# coding=utf-8
# *** WARNING: this file was generated by pulumi-language-python. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins
import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'ServerCustomizationsArgs',
    'ServerCustomizationsArgsDict',
    'ServerIamArgs',
    'ServerIamArgsDict',
    'ServerNetworkingInterfaceArgs',
    'ServerNetworkingInterfaceArgsDict',
    'ServerOrderArgs',
    'ServerOrderArgsDict',
    'ServerOrderDetailArgs',
    'ServerOrderDetailArgsDict',
    'ServerPlanArgs',
    'ServerPlanArgsDict',
    'ServerPlanConfigurationArgs',
    'ServerPlanConfigurationArgsDict',
    'ServerPlanOptionArgs',
    'ServerPlanOptionArgsDict',
    'ServerPlanOptionConfigurationArgs',
    'ServerPlanOptionConfigurationArgsDict',
    'ServerReinstallTaskCustomizationsArgs',
    'ServerReinstallTaskCustomizationsArgsDict',
    'ServerReinstallTaskStorageArgs',
    'ServerReinstallTaskStorageArgsDict',
    'ServerReinstallTaskStorageHardwareRaidArgs',
    'ServerReinstallTaskStorageHardwareRaidArgsDict',
    'ServerReinstallTaskStoragePartitioningArgs',
    'ServerReinstallTaskStoragePartitioningArgsDict',
    'ServerReinstallTaskStoragePartitioningLayoutArgs',
    'ServerReinstallTaskStoragePartitioningLayoutArgsDict',
    'ServerReinstallTaskStoragePartitioningLayoutExtraArgs',
    'ServerReinstallTaskStoragePartitioningLayoutExtraArgsDict',
    'ServerReinstallTaskStoragePartitioningLayoutExtraLvArgs',
    'ServerReinstallTaskStoragePartitioningLayoutExtraLvArgsDict',
    'ServerReinstallTaskStoragePartitioningLayoutExtraZpArgs',
    'ServerReinstallTaskStoragePartitioningLayoutExtraZpArgsDict',
    'ServerStorageArgs',
    'ServerStorageArgsDict',
    'ServerStorageHardwareRaidArgs',
    'ServerStorageHardwareRaidArgsDict',
    'ServerStoragePartitioningArgs',
    'ServerStoragePartitioningArgsDict',
    'ServerStoragePartitioningLayoutArgs',
    'ServerStoragePartitioningLayoutArgsDict',
    'ServerStoragePartitioningLayoutExtrasArgs',
    'ServerStoragePartitioningLayoutExtrasArgsDict',
    'ServerStoragePartitioningLayoutExtrasLvArgs',
    'ServerStoragePartitioningLayoutExtrasLvArgsDict',
    'ServerStoragePartitioningLayoutExtrasZpArgs',
    'ServerStoragePartitioningLayoutExtrasZpArgsDict',
]

MYPY = False

if not MYPY:
    class ServerCustomizationsArgsDict(TypedDict):
        config_drive_user_data: NotRequired[pulumi.Input[builtins.str]]
        """
        Config Drive UserData
        """
        efi_bootloader_path: NotRequired[pulumi.Input[builtins.str]]
        """
        Path of the EFI bootloader
        """
        hostname: NotRequired[pulumi.Input[builtins.str]]
        """
        Custom hostname
        """
        http_headers: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
        """
        Image HTTP Headers
        """
        image_check_sum: NotRequired[pulumi.Input[builtins.str]]
        """
        Image checksum
        """
        image_check_sum_type: NotRequired[pulumi.Input[builtins.str]]
        """
        Checksum type
        """
        image_type: NotRequired[pulumi.Input[builtins.str]]
        """
        Image Type
        """
        image_url: NotRequired[pulumi.Input[builtins.str]]
        """
        Image URL
        """
        language: NotRequired[pulumi.Input[builtins.str]]
        """
        Display Language
        """
        post_installation_script: NotRequired[pulumi.Input[builtins.str]]
        """
        Post-Installation Script
        """
        post_installation_script_extension: NotRequired[pulumi.Input[builtins.str]]
        """
        Post-Installation Script File Extension
        """
        ssh_key: NotRequired[pulumi.Input[builtins.str]]
        """
        SSH Public Key
        """
elif False:
    ServerCustomizationsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerCustomizationsArgs:
    def __init__(__self__, *,
                 config_drive_user_data: Optional[pulumi.Input[builtins.str]] = None,
                 efi_bootloader_path: Optional[pulumi.Input[builtins.str]] = None,
                 hostname: Optional[pulumi.Input[builtins.str]] = None,
                 http_headers: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
                 image_check_sum: Optional[pulumi.Input[builtins.str]] = None,
                 image_check_sum_type: Optional[pulumi.Input[builtins.str]] = None,
                 image_type: Optional[pulumi.Input[builtins.str]] = None,
                 image_url: Optional[pulumi.Input[builtins.str]] = None,
                 language: Optional[pulumi.Input[builtins.str]] = None,
                 post_installation_script: Optional[pulumi.Input[builtins.str]] = None,
                 post_installation_script_extension: Optional[pulumi.Input[builtins.str]] = None,
                 ssh_key: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] config_drive_user_data: Config Drive UserData
        :param pulumi.Input[builtins.str] efi_bootloader_path: Path of the EFI bootloader
        :param pulumi.Input[builtins.str] hostname: Custom hostname
        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] http_headers: Image HTTP Headers
        :param pulumi.Input[builtins.str] image_check_sum: Image checksum
        :param pulumi.Input[builtins.str] image_check_sum_type: Checksum type
        :param pulumi.Input[builtins.str] image_type: Image Type
        :param pulumi.Input[builtins.str] image_url: Image URL
        :param pulumi.Input[builtins.str] language: Display Language
        :param pulumi.Input[builtins.str] post_installation_script: Post-Installation Script
        :param pulumi.Input[builtins.str] post_installation_script_extension: Post-Installation Script File Extension
        :param pulumi.Input[builtins.str] ssh_key: SSH Public Key
        """
        if config_drive_user_data is not None:
            pulumi.set(__self__, "config_drive_user_data", config_drive_user_data)
        if efi_bootloader_path is not None:
            pulumi.set(__self__, "efi_bootloader_path", efi_bootloader_path)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if http_headers is not None:
            pulumi.set(__self__, "http_headers", http_headers)
        if image_check_sum is not None:
            pulumi.set(__self__, "image_check_sum", image_check_sum)
        if image_check_sum_type is not None:
            pulumi.set(__self__, "image_check_sum_type", image_check_sum_type)
        if image_type is not None:
            pulumi.set(__self__, "image_type", image_type)
        if image_url is not None:
            pulumi.set(__self__, "image_url", image_url)
        if language is not None:
            pulumi.set(__self__, "language", language)
        if post_installation_script is not None:
            pulumi.set(__self__, "post_installation_script", post_installation_script)
        if post_installation_script_extension is not None:
            pulumi.set(__self__, "post_installation_script_extension", post_installation_script_extension)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)

    @property
    @pulumi.getter(name="configDriveUserData")
    def config_drive_user_data(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Config Drive UserData
        """
        return pulumi.get(self, "config_drive_user_data")

    @config_drive_user_data.setter
    def config_drive_user_data(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "config_drive_user_data", value)

    @property
    @pulumi.getter(name="efiBootloaderPath")
    def efi_bootloader_path(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Path of the EFI bootloader
        """
        return pulumi.get(self, "efi_bootloader_path")

    @efi_bootloader_path.setter
    def efi_bootloader_path(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "efi_bootloader_path", value)

    @property
    @pulumi.getter
    def hostname(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Custom hostname
        """
        return pulumi.get(self, "hostname")

    @hostname.setter
    def hostname(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "hostname", value)

    @property
    @pulumi.getter(name="httpHeaders")
    def http_headers(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
        """
        Image HTTP Headers
        """
        return pulumi.get(self, "http_headers")

    @http_headers.setter
    def http_headers(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "http_headers", value)

    @property
    @pulumi.getter(name="imageCheckSum")
    def image_check_sum(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Image checksum
        """
        return pulumi.get(self, "image_check_sum")

    @image_check_sum.setter
    def image_check_sum(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "image_check_sum", value)

    @property
    @pulumi.getter(name="imageCheckSumType")
    def image_check_sum_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Checksum type
        """
        return pulumi.get(self, "image_check_sum_type")

    @image_check_sum_type.setter
    def image_check_sum_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "image_check_sum_type", value)

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Image Type
        """
        return pulumi.get(self, "image_type")

    @image_type.setter
    def image_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "image_type", value)

    @property
    @pulumi.getter(name="imageUrl")
    def image_url(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Image URL
        """
        return pulumi.get(self, "image_url")

    @image_url.setter
    def image_url(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "image_url", value)

    @property
    @pulumi.getter
    def language(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Display Language
        """
        return pulumi.get(self, "language")

    @language.setter
    def language(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "language", value)

    @property
    @pulumi.getter(name="postInstallationScript")
    def post_installation_script(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Post-Installation Script
        """
        return pulumi.get(self, "post_installation_script")

    @post_installation_script.setter
    def post_installation_script(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "post_installation_script", value)

    @property
    @pulumi.getter(name="postInstallationScriptExtension")
    def post_installation_script_extension(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Post-Installation Script File Extension
        """
        return pulumi.get(self, "post_installation_script_extension")

    @post_installation_script_extension.setter
    def post_installation_script_extension(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "post_installation_script_extension", value)

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        SSH Public Key
        """
        return pulumi.get(self, "ssh_key")

    @ssh_key.setter
    def ssh_key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "ssh_key", value)


if not MYPY:
    class ServerIamArgsDict(TypedDict):
        display_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Resource display name
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        Unique identifier of the resource in the IAM
        """
        tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
        """
        Resource tags. Tags that were internally computed are prefixed with `ovh:`
        """
        urn: NotRequired[pulumi.Input[builtins.str]]
        """
        URN of the private database, used when writing IAM policies
        """
elif False:
    ServerIamArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerIamArgs:
    def __init__(__self__, *,
                 display_name: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
                 urn: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] display_name: Resource display name
        :param pulumi.Input[builtins.str] id: Unique identifier of the resource in the IAM
        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] tags: Resource tags. Tags that were internally computed are prefixed with `ovh:`
        :param pulumi.Input[builtins.str] urn: URN of the private database, used when writing IAM policies
        """
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if urn is not None:
            pulumi.set(__self__, "urn", urn)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Resource display name
        """
        return pulumi.get(self, "display_name")

    @display_name.setter
    def display_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "display_name", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Unique identifier of the resource in the IAM
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
        """
        Resource tags. Tags that were internally computed are prefixed with `ovh:`
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter
    def urn(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        URN of the private database, used when writing IAM policies
        """
        return pulumi.get(self, "urn")

    @urn.setter
    def urn(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "urn", value)


if not MYPY:
    class ServerNetworkingInterfaceArgsDict(TypedDict):
        macs: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
        """
        Interface Mac address
        """
        type: pulumi.Input[builtins.str]
        """
        Interface type
        """
elif False:
    ServerNetworkingInterfaceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerNetworkingInterfaceArgs:
    def __init__(__self__, *,
                 macs: pulumi.Input[Sequence[pulumi.Input[builtins.str]]],
                 type: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] macs: Interface Mac address
        :param pulumi.Input[builtins.str] type: Interface type
        """
        pulumi.set(__self__, "macs", macs)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def macs(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
        """
        Interface Mac address
        """
        return pulumi.get(self, "macs")

    @macs.setter
    def macs(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
        pulumi.set(self, "macs", value)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[builtins.str]:
        """
        Interface type
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "type", value)


if not MYPY:
    class ServerOrderArgsDict(TypedDict):
        date: NotRequired[pulumi.Input[builtins.str]]
        details: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServerOrderDetailArgsDict']]]]
        expiration_date: NotRequired[pulumi.Input[builtins.str]]
        order_id: NotRequired[pulumi.Input[builtins.float]]
elif False:
    ServerOrderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerOrderArgs:
    def __init__(__self__, *,
                 date: Optional[pulumi.Input[builtins.str]] = None,
                 details: Optional[pulumi.Input[Sequence[pulumi.Input['ServerOrderDetailArgs']]]] = None,
                 expiration_date: Optional[pulumi.Input[builtins.str]] = None,
                 order_id: Optional[pulumi.Input[builtins.float]] = None):
        if date is not None:
            pulumi.set(__self__, "date", date)
        if details is not None:
            pulumi.set(__self__, "details", details)
        if expiration_date is not None:
            pulumi.set(__self__, "expiration_date", expiration_date)
        if order_id is not None:
            pulumi.set(__self__, "order_id", order_id)

    @property
    @pulumi.getter
    def date(self) -> Optional[pulumi.Input[builtins.str]]:
        return pulumi.get(self, "date")

    @date.setter
    def date(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "date", value)

    @property
    @pulumi.getter
    def details(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServerOrderDetailArgs']]]]:
        return pulumi.get(self, "details")

    @details.setter
    def details(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServerOrderDetailArgs']]]]):
        pulumi.set(self, "details", value)

    @property
    @pulumi.getter(name="expirationDate")
    def expiration_date(self) -> Optional[pulumi.Input[builtins.str]]:
        return pulumi.get(self, "expiration_date")

    @expiration_date.setter
    def expiration_date(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "expiration_date", value)

    @property
    @pulumi.getter(name="orderId")
    def order_id(self) -> Optional[pulumi.Input[builtins.float]]:
        return pulumi.get(self, "order_id")

    @order_id.setter
    def order_id(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "order_id", value)


if not MYPY:
    class ServerOrderDetailArgsDict(TypedDict):
        description: NotRequired[pulumi.Input[builtins.str]]
        detail_type: NotRequired[pulumi.Input[builtins.str]]
        """
        Product type of item in order
        """
        domain: NotRequired[pulumi.Input[builtins.str]]
        order_detail_id: NotRequired[pulumi.Input[builtins.float]]
        quantity: NotRequired[pulumi.Input[builtins.str]]
elif False:
    ServerOrderDetailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerOrderDetailArgs:
    def __init__(__self__, *,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 detail_type: Optional[pulumi.Input[builtins.str]] = None,
                 domain: Optional[pulumi.Input[builtins.str]] = None,
                 order_detail_id: Optional[pulumi.Input[builtins.float]] = None,
                 quantity: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] detail_type: Product type of item in order
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if detail_type is not None:
            pulumi.set(__self__, "detail_type", detail_type)
        if domain is not None:
            pulumi.set(__self__, "domain", domain)
        if order_detail_id is not None:
            pulumi.set(__self__, "order_detail_id", order_detail_id)
        if quantity is not None:
            pulumi.set(__self__, "quantity", quantity)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter(name="detailType")
    def detail_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Product type of item in order
        """
        return pulumi.get(self, "detail_type")

    @detail_type.setter
    def detail_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "detail_type", value)

    @property
    @pulumi.getter
    def domain(self) -> Optional[pulumi.Input[builtins.str]]:
        return pulumi.get(self, "domain")

    @domain.setter
    def domain(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "domain", value)

    @property
    @pulumi.getter(name="orderDetailId")
    def order_detail_id(self) -> Optional[pulumi.Input[builtins.float]]:
        return pulumi.get(self, "order_detail_id")

    @order_detail_id.setter
    def order_detail_id(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "order_detail_id", value)

    @property
    @pulumi.getter
    def quantity(self) -> Optional[pulumi.Input[builtins.str]]:
        return pulumi.get(self, "quantity")

    @quantity.setter
    def quantity(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "quantity", value)


if not MYPY:
    class ServerPlanArgsDict(TypedDict):
        duration: pulumi.Input[builtins.str]
        """
        Duration selected for the purchase of the product
        """
        plan_code: pulumi.Input[builtins.str]
        """
        Identifier of the option offer
        """
        pricing_mode: pulumi.Input[builtins.str]
        """
        Pricing mode selected for the purchase of the product
        """
        configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServerPlanConfigurationArgsDict']]]]
        item_id: NotRequired[pulumi.Input[builtins.float]]
        """
        Cart item to be linked
        """
        quantity: NotRequired[pulumi.Input[builtins.float]]
        """
        Quantity of product desired
        """
elif False:
    ServerPlanArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerPlanArgs:
    def __init__(__self__, *,
                 duration: pulumi.Input[builtins.str],
                 plan_code: pulumi.Input[builtins.str],
                 pricing_mode: pulumi.Input[builtins.str],
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['ServerPlanConfigurationArgs']]]] = None,
                 item_id: Optional[pulumi.Input[builtins.float]] = None,
                 quantity: Optional[pulumi.Input[builtins.float]] = None):
        """
        :param pulumi.Input[builtins.str] duration: Duration selected for the purchase of the product
        :param pulumi.Input[builtins.str] plan_code: Identifier of the option offer
        :param pulumi.Input[builtins.str] pricing_mode: Pricing mode selected for the purchase of the product
        :param pulumi.Input[builtins.float] item_id: Cart item to be linked
        :param pulumi.Input[builtins.float] quantity: Quantity of product desired
        """
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "plan_code", plan_code)
        pulumi.set(__self__, "pricing_mode", pricing_mode)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)
        if item_id is not None:
            pulumi.set(__self__, "item_id", item_id)
        if quantity is not None:
            pulumi.set(__self__, "quantity", quantity)

    @property
    @pulumi.getter
    def duration(self) -> pulumi.Input[builtins.str]:
        """
        Duration selected for the purchase of the product
        """
        return pulumi.get(self, "duration")

    @duration.setter
    def duration(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "duration", value)

    @property
    @pulumi.getter(name="planCode")
    def plan_code(self) -> pulumi.Input[builtins.str]:
        """
        Identifier of the option offer
        """
        return pulumi.get(self, "plan_code")

    @plan_code.setter
    def plan_code(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "plan_code", value)

    @property
    @pulumi.getter(name="pricingMode")
    def pricing_mode(self) -> pulumi.Input[builtins.str]:
        """
        Pricing mode selected for the purchase of the product
        """
        return pulumi.get(self, "pricing_mode")

    @pricing_mode.setter
    def pricing_mode(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "pricing_mode", value)

    @property
    @pulumi.getter
    def configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServerPlanConfigurationArgs']]]]:
        return pulumi.get(self, "configurations")

    @configurations.setter
    def configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServerPlanConfigurationArgs']]]]):
        pulumi.set(self, "configurations", value)

    @property
    @pulumi.getter(name="itemId")
    def item_id(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        Cart item to be linked
        """
        return pulumi.get(self, "item_id")

    @item_id.setter
    def item_id(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "item_id", value)

    @property
    @pulumi.getter
    def quantity(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        Quantity of product desired
        """
        return pulumi.get(self, "quantity")

    @quantity.setter
    def quantity(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "quantity", value)


if not MYPY:
    class ServerPlanConfigurationArgsDict(TypedDict):
        label: pulumi.Input[builtins.str]
        """
        Label for your configuration item
        """
        value: pulumi.Input[builtins.str]
        """
        Value or resource URL on API.OVH.COM of your configuration item
        """
elif False:
    ServerPlanConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerPlanConfigurationArgs:
    def __init__(__self__, *,
                 label: pulumi.Input[builtins.str],
                 value: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] label: Label for your configuration item
        :param pulumi.Input[builtins.str] value: Value or resource URL on API.OVH.COM of your configuration item
        """
        pulumi.set(__self__, "label", label)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def label(self) -> pulumi.Input[builtins.str]:
        """
        Label for your configuration item
        """
        return pulumi.get(self, "label")

    @label.setter
    def label(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "label", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[builtins.str]:
        """
        Value or resource URL on API.OVH.COM of your configuration item
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class ServerPlanOptionArgsDict(TypedDict):
        duration: pulumi.Input[builtins.str]
        """
        Duration selected for the purchase of the product
        """
        plan_code: pulumi.Input[builtins.str]
        """
        Identifier of the option offer
        """
        pricing_mode: pulumi.Input[builtins.str]
        """
        Pricing mode selected for the purchase of the product
        """
        quantity: pulumi.Input[builtins.float]
        """
        Quantity of product desired
        """
        configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServerPlanOptionConfigurationArgsDict']]]]
elif False:
    ServerPlanOptionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerPlanOptionArgs:
    def __init__(__self__, *,
                 duration: pulumi.Input[builtins.str],
                 plan_code: pulumi.Input[builtins.str],
                 pricing_mode: pulumi.Input[builtins.str],
                 quantity: pulumi.Input[builtins.float],
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['ServerPlanOptionConfigurationArgs']]]] = None):
        """
        :param pulumi.Input[builtins.str] duration: Duration selected for the purchase of the product
        :param pulumi.Input[builtins.str] plan_code: Identifier of the option offer
        :param pulumi.Input[builtins.str] pricing_mode: Pricing mode selected for the purchase of the product
        :param pulumi.Input[builtins.float] quantity: Quantity of product desired
        """
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "plan_code", plan_code)
        pulumi.set(__self__, "pricing_mode", pricing_mode)
        pulumi.set(__self__, "quantity", quantity)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)

    @property
    @pulumi.getter
    def duration(self) -> pulumi.Input[builtins.str]:
        """
        Duration selected for the purchase of the product
        """
        return pulumi.get(self, "duration")

    @duration.setter
    def duration(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "duration", value)

    @property
    @pulumi.getter(name="planCode")
    def plan_code(self) -> pulumi.Input[builtins.str]:
        """
        Identifier of the option offer
        """
        return pulumi.get(self, "plan_code")

    @plan_code.setter
    def plan_code(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "plan_code", value)

    @property
    @pulumi.getter(name="pricingMode")
    def pricing_mode(self) -> pulumi.Input[builtins.str]:
        """
        Pricing mode selected for the purchase of the product
        """
        return pulumi.get(self, "pricing_mode")

    @pricing_mode.setter
    def pricing_mode(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "pricing_mode", value)

    @property
    @pulumi.getter
    def quantity(self) -> pulumi.Input[builtins.float]:
        """
        Quantity of product desired
        """
        return pulumi.get(self, "quantity")

    @quantity.setter
    def quantity(self, value: pulumi.Input[builtins.float]):
        pulumi.set(self, "quantity", value)

    @property
    @pulumi.getter
    def configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServerPlanOptionConfigurationArgs']]]]:
        return pulumi.get(self, "configurations")

    @configurations.setter
    def configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServerPlanOptionConfigurationArgs']]]]):
        pulumi.set(self, "configurations", value)


if not MYPY:
    class ServerPlanOptionConfigurationArgsDict(TypedDict):
        label: pulumi.Input[builtins.str]
        """
        Label for your configuration item
        """
        value: pulumi.Input[builtins.str]
        """
        Value or resource URL on API.OVH.COM of your configuration item
        """
elif False:
    ServerPlanOptionConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerPlanOptionConfigurationArgs:
    def __init__(__self__, *,
                 label: pulumi.Input[builtins.str],
                 value: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] label: Label for your configuration item
        :param pulumi.Input[builtins.str] value: Value or resource URL on API.OVH.COM of your configuration item
        """
        pulumi.set(__self__, "label", label)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def label(self) -> pulumi.Input[builtins.str]:
        """
        Label for your configuration item
        """
        return pulumi.get(self, "label")

    @label.setter
    def label(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "label", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[builtins.str]:
        """
        Value or resource URL on API.OVH.COM of your configuration item
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class ServerReinstallTaskCustomizationsArgsDict(TypedDict):
        config_drive_user_data: NotRequired[pulumi.Input[builtins.str]]
        """
        Config Drive UserData
        """
        efi_bootloader_path: NotRequired[pulumi.Input[builtins.str]]
        """
        EFI bootloader path
        """
        hostname: NotRequired[pulumi.Input[builtins.str]]
        """
        Custom hostname
        """
        http_headers: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
        """
        Image HTTP Headers
        """
        image_check_sum: NotRequired[pulumi.Input[builtins.str]]
        """
        Image checksum
        """
        image_check_sum_type: NotRequired[pulumi.Input[builtins.str]]
        """
        Checksum type
        """
        image_type: NotRequired[pulumi.Input[builtins.str]]
        """
        Image Type
        """
        image_url: NotRequired[pulumi.Input[builtins.str]]
        """
        Image URL
        """
        language: NotRequired[pulumi.Input[builtins.str]]
        """
        Display Language
        """
        post_installation_script: NotRequired[pulumi.Input[builtins.str]]
        """
        Post-Installation Script
        """
        post_installation_script_extension: NotRequired[pulumi.Input[builtins.str]]
        """
        Post-Installation Script File Extension
        """
        ssh_key: NotRequired[pulumi.Input[builtins.str]]
        """
        SSH Public Key
        """
elif False:
    ServerReinstallTaskCustomizationsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerReinstallTaskCustomizationsArgs:
    def __init__(__self__, *,
                 config_drive_user_data: Optional[pulumi.Input[builtins.str]] = None,
                 efi_bootloader_path: Optional[pulumi.Input[builtins.str]] = None,
                 hostname: Optional[pulumi.Input[builtins.str]] = None,
                 http_headers: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
                 image_check_sum: Optional[pulumi.Input[builtins.str]] = None,
                 image_check_sum_type: Optional[pulumi.Input[builtins.str]] = None,
                 image_type: Optional[pulumi.Input[builtins.str]] = None,
                 image_url: Optional[pulumi.Input[builtins.str]] = None,
                 language: Optional[pulumi.Input[builtins.str]] = None,
                 post_installation_script: Optional[pulumi.Input[builtins.str]] = None,
                 post_installation_script_extension: Optional[pulumi.Input[builtins.str]] = None,
                 ssh_key: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] config_drive_user_data: Config Drive UserData
        :param pulumi.Input[builtins.str] efi_bootloader_path: EFI bootloader path
        :param pulumi.Input[builtins.str] hostname: Custom hostname
        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] http_headers: Image HTTP Headers
        :param pulumi.Input[builtins.str] image_check_sum: Image checksum
        :param pulumi.Input[builtins.str] image_check_sum_type: Checksum type
        :param pulumi.Input[builtins.str] image_type: Image Type
        :param pulumi.Input[builtins.str] image_url: Image URL
        :param pulumi.Input[builtins.str] language: Display Language
        :param pulumi.Input[builtins.str] post_installation_script: Post-Installation Script
        :param pulumi.Input[builtins.str] post_installation_script_extension: Post-Installation Script File Extension
        :param pulumi.Input[builtins.str] ssh_key: SSH Public Key
        """
        if config_drive_user_data is not None:
            pulumi.set(__self__, "config_drive_user_data", config_drive_user_data)
        if efi_bootloader_path is not None:
            pulumi.set(__self__, "efi_bootloader_path", efi_bootloader_path)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if http_headers is not None:
            pulumi.set(__self__, "http_headers", http_headers)
        if image_check_sum is not None:
            pulumi.set(__self__, "image_check_sum", image_check_sum)
        if image_check_sum_type is not None:
            pulumi.set(__self__, "image_check_sum_type", image_check_sum_type)
        if image_type is not None:
            pulumi.set(__self__, "image_type", image_type)
        if image_url is not None:
            pulumi.set(__self__, "image_url", image_url)
        if language is not None:
            pulumi.set(__self__, "language", language)
        if post_installation_script is not None:
            pulumi.set(__self__, "post_installation_script", post_installation_script)
        if post_installation_script_extension is not None:
            pulumi.set(__self__, "post_installation_script_extension", post_installation_script_extension)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)

    @property
    @pulumi.getter(name="configDriveUserData")
    def config_drive_user_data(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Config Drive UserData
        """
        return pulumi.get(self, "config_drive_user_data")

    @config_drive_user_data.setter
    def config_drive_user_data(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "config_drive_user_data", value)

    @property
    @pulumi.getter(name="efiBootloaderPath")
    def efi_bootloader_path(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        EFI bootloader path
        """
        return pulumi.get(self, "efi_bootloader_path")

    @efi_bootloader_path.setter
    def efi_bootloader_path(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "efi_bootloader_path", value)

    @property
    @pulumi.getter
    def hostname(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Custom hostname
        """
        return pulumi.get(self, "hostname")

    @hostname.setter
    def hostname(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "hostname", value)

    @property
    @pulumi.getter(name="httpHeaders")
    def http_headers(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
        """
        Image HTTP Headers
        """
        return pulumi.get(self, "http_headers")

    @http_headers.setter
    def http_headers(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "http_headers", value)

    @property
    @pulumi.getter(name="imageCheckSum")
    def image_check_sum(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Image checksum
        """
        return pulumi.get(self, "image_check_sum")

    @image_check_sum.setter
    def image_check_sum(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "image_check_sum", value)

    @property
    @pulumi.getter(name="imageCheckSumType")
    def image_check_sum_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Checksum type
        """
        return pulumi.get(self, "image_check_sum_type")

    @image_check_sum_type.setter
    def image_check_sum_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "image_check_sum_type", value)

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Image Type
        """
        return pulumi.get(self, "image_type")

    @image_type.setter
    def image_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "image_type", value)

    @property
    @pulumi.getter(name="imageUrl")
    def image_url(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Image URL
        """
        return pulumi.get(self, "image_url")

    @image_url.setter
    def image_url(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "image_url", value)

    @property
    @pulumi.getter
    def language(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Display Language
        """
        return pulumi.get(self, "language")

    @language.setter
    def language(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "language", value)

    @property
    @pulumi.getter(name="postInstallationScript")
    def post_installation_script(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Post-Installation Script
        """
        return pulumi.get(self, "post_installation_script")

    @post_installation_script.setter
    def post_installation_script(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "post_installation_script", value)

    @property
    @pulumi.getter(name="postInstallationScriptExtension")
    def post_installation_script_extension(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Post-Installation Script File Extension
        """
        return pulumi.get(self, "post_installation_script_extension")

    @post_installation_script_extension.setter
    def post_installation_script_extension(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "post_installation_script_extension", value)

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        SSH Public Key
        """
        return pulumi.get(self, "ssh_key")

    @ssh_key.setter
    def ssh_key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "ssh_key", value)


if not MYPY:
    class ServerReinstallTaskStorageArgsDict(TypedDict):
        disk_group_id: NotRequired[pulumi.Input[builtins.int]]
        """
        Disk group id to install the OS to (default is 0, meaning automatic).
        """
        hardware_raids: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStorageHardwareRaidArgsDict']]]]
        """
        Hardware Raid configurations (if not specified, all disks of the chosen disk group id will be configured in JBOD mode).
        """
        partitionings: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningArgsDict']]]]
        """
        Partitioning configuration
        """
elif False:
    ServerReinstallTaskStorageArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerReinstallTaskStorageArgs:
    def __init__(__self__, *,
                 disk_group_id: Optional[pulumi.Input[builtins.int]] = None,
                 hardware_raids: Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStorageHardwareRaidArgs']]]] = None,
                 partitionings: Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningArgs']]]] = None):
        """
        :param pulumi.Input[builtins.int] disk_group_id: Disk group id to install the OS to (default is 0, meaning automatic).
        :param pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStorageHardwareRaidArgs']]] hardware_raids: Hardware Raid configurations (if not specified, all disks of the chosen disk group id will be configured in JBOD mode).
        :param pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningArgs']]] partitionings: Partitioning configuration
        """
        if disk_group_id is not None:
            pulumi.set(__self__, "disk_group_id", disk_group_id)
        if hardware_raids is not None:
            pulumi.set(__self__, "hardware_raids", hardware_raids)
        if partitionings is not None:
            pulumi.set(__self__, "partitionings", partitionings)

    @property
    @pulumi.getter(name="diskGroupId")
    def disk_group_id(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Disk group id to install the OS to (default is 0, meaning automatic).
        """
        return pulumi.get(self, "disk_group_id")

    @disk_group_id.setter
    def disk_group_id(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "disk_group_id", value)

    @property
    @pulumi.getter(name="hardwareRaids")
    def hardware_raids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStorageHardwareRaidArgs']]]]:
        """
        Hardware Raid configurations (if not specified, all disks of the chosen disk group id will be configured in JBOD mode).
        """
        return pulumi.get(self, "hardware_raids")

    @hardware_raids.setter
    def hardware_raids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStorageHardwareRaidArgs']]]]):
        pulumi.set(self, "hardware_raids", value)

    @property
    @pulumi.getter
    def partitionings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningArgs']]]]:
        """
        Partitioning configuration
        """
        return pulumi.get(self, "partitionings")

    @partitionings.setter
    def partitionings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningArgs']]]]):
        pulumi.set(self, "partitionings", value)


if not MYPY:
    class ServerReinstallTaskStorageHardwareRaidArgsDict(TypedDict):
        arrays: NotRequired[pulumi.Input[builtins.int]]
        """
        Number of arrays (default is 1)
        """
        disks: NotRequired[pulumi.Input[builtins.int]]
        """
        Total number of disks in the disk group involved in the hardware raid configuration (all disks of the disk group by default)
        """
        raid_level: NotRequired[pulumi.Input[builtins.int]]
        """
        Hardware raid type (default is 1)
        """
        spares: NotRequired[pulumi.Input[builtins.int]]
        """
        Number of disks in the disk group involved in the spare (default is 0)
        """
elif False:
    ServerReinstallTaskStorageHardwareRaidArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerReinstallTaskStorageHardwareRaidArgs:
    def __init__(__self__, *,
                 arrays: Optional[pulumi.Input[builtins.int]] = None,
                 disks: Optional[pulumi.Input[builtins.int]] = None,
                 raid_level: Optional[pulumi.Input[builtins.int]] = None,
                 spares: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] arrays: Number of arrays (default is 1)
        :param pulumi.Input[builtins.int] disks: Total number of disks in the disk group involved in the hardware raid configuration (all disks of the disk group by default)
        :param pulumi.Input[builtins.int] raid_level: Hardware raid type (default is 1)
        :param pulumi.Input[builtins.int] spares: Number of disks in the disk group involved in the spare (default is 0)
        """
        if arrays is not None:
            pulumi.set(__self__, "arrays", arrays)
        if disks is not None:
            pulumi.set(__self__, "disks", disks)
        if raid_level is not None:
            pulumi.set(__self__, "raid_level", raid_level)
        if spares is not None:
            pulumi.set(__self__, "spares", spares)

    @property
    @pulumi.getter
    def arrays(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Number of arrays (default is 1)
        """
        return pulumi.get(self, "arrays")

    @arrays.setter
    def arrays(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "arrays", value)

    @property
    @pulumi.getter
    def disks(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Total number of disks in the disk group involved in the hardware raid configuration (all disks of the disk group by default)
        """
        return pulumi.get(self, "disks")

    @disks.setter
    def disks(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "disks", value)

    @property
    @pulumi.getter(name="raidLevel")
    def raid_level(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Hardware raid type (default is 1)
        """
        return pulumi.get(self, "raid_level")

    @raid_level.setter
    def raid_level(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "raid_level", value)

    @property
    @pulumi.getter
    def spares(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Number of disks in the disk group involved in the spare (default is 0)
        """
        return pulumi.get(self, "spares")

    @spares.setter
    def spares(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "spares", value)


if not MYPY:
    class ServerReinstallTaskStoragePartitioningArgsDict(TypedDict):
        disks: NotRequired[pulumi.Input[builtins.int]]
        """
        Total number of disks in the disk group involved in the partitioning configuration (all disks of the disk group by default)
        """
        layouts: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutArgsDict']]]]
        """
        Custom partitioning layout (default is the default layout of the operating system's default partitioning scheme). Accept multiple values (multiple partitions):
        """
        scheme_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Partitioning scheme (if applicable with selected operating system)
        """
elif False:
    ServerReinstallTaskStoragePartitioningArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerReinstallTaskStoragePartitioningArgs:
    def __init__(__self__, *,
                 disks: Optional[pulumi.Input[builtins.int]] = None,
                 layouts: Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutArgs']]]] = None,
                 scheme_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] disks: Total number of disks in the disk group involved in the partitioning configuration (all disks of the disk group by default)
        :param pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutArgs']]] layouts: Custom partitioning layout (default is the default layout of the operating system's default partitioning scheme). Accept multiple values (multiple partitions):
        :param pulumi.Input[builtins.str] scheme_name: Partitioning scheme (if applicable with selected operating system)
        """
        if disks is not None:
            pulumi.set(__self__, "disks", disks)
        if layouts is not None:
            pulumi.set(__self__, "layouts", layouts)
        if scheme_name is not None:
            pulumi.set(__self__, "scheme_name", scheme_name)

    @property
    @pulumi.getter
    def disks(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Total number of disks in the disk group involved in the partitioning configuration (all disks of the disk group by default)
        """
        return pulumi.get(self, "disks")

    @disks.setter
    def disks(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "disks", value)

    @property
    @pulumi.getter
    def layouts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutArgs']]]]:
        """
        Custom partitioning layout (default is the default layout of the operating system's default partitioning scheme). Accept multiple values (multiple partitions):
        """
        return pulumi.get(self, "layouts")

    @layouts.setter
    def layouts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutArgs']]]]):
        pulumi.set(self, "layouts", value)

    @property
    @pulumi.getter(name="schemeName")
    def scheme_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Partitioning scheme (if applicable with selected operating system)
        """
        return pulumi.get(self, "scheme_name")

    @scheme_name.setter
    def scheme_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "scheme_name", value)


if not MYPY:
    class ServerReinstallTaskStoragePartitioningLayoutArgsDict(TypedDict):
        file_system: pulumi.Input[builtins.str]
        """
        File system type
        """
        mount_point: pulumi.Input[builtins.str]
        """
        Mount point
        """
        extras: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraArgsDict']]]]
        """
        Partition extras parameters (when applicable)
        """
        raid_level: NotRequired[pulumi.Input[builtins.int]]
        """
        Software raid type (default is 1)
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        Partition size in MiB (default value is 0 which means to fill the disk with that partition)
        """
elif False:
    ServerReinstallTaskStoragePartitioningLayoutArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerReinstallTaskStoragePartitioningLayoutArgs:
    def __init__(__self__, *,
                 file_system: pulumi.Input[builtins.str],
                 mount_point: pulumi.Input[builtins.str],
                 extras: Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraArgs']]]] = None,
                 raid_level: Optional[pulumi.Input[builtins.int]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] file_system: File system type
        :param pulumi.Input[builtins.str] mount_point: Mount point
        :param pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraArgs']]] extras: Partition extras parameters (when applicable)
        :param pulumi.Input[builtins.int] raid_level: Software raid type (default is 1)
        :param pulumi.Input[builtins.int] size: Partition size in MiB (default value is 0 which means to fill the disk with that partition)
        """
        pulumi.set(__self__, "file_system", file_system)
        pulumi.set(__self__, "mount_point", mount_point)
        if extras is not None:
            pulumi.set(__self__, "extras", extras)
        if raid_level is not None:
            pulumi.set(__self__, "raid_level", raid_level)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter(name="fileSystem")
    def file_system(self) -> pulumi.Input[builtins.str]:
        """
        File system type
        """
        return pulumi.get(self, "file_system")

    @file_system.setter
    def file_system(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "file_system", value)

    @property
    @pulumi.getter(name="mountPoint")
    def mount_point(self) -> pulumi.Input[builtins.str]:
        """
        Mount point
        """
        return pulumi.get(self, "mount_point")

    @mount_point.setter
    def mount_point(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "mount_point", value)

    @property
    @pulumi.getter
    def extras(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraArgs']]]]:
        """
        Partition extras parameters (when applicable)
        """
        return pulumi.get(self, "extras")

    @extras.setter
    def extras(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraArgs']]]]):
        pulumi.set(self, "extras", value)

    @property
    @pulumi.getter(name="raidLevel")
    def raid_level(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Software raid type (default is 1)
        """
        return pulumi.get(self, "raid_level")

    @raid_level.setter
    def raid_level(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "raid_level", value)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Partition size in MiB (default value is 0 which means to fill the disk with that partition)
        """
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "size", value)


if not MYPY:
    class ServerReinstallTaskStoragePartitioningLayoutExtraArgsDict(TypedDict):
        lvs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraLvArgsDict']]]]
        """
        LVM-specific parameters (when applicable)
        """
        zps: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraZpArgsDict']]]]
        """
        ZFS-specific parameters (when applicable)
        """
elif False:
    ServerReinstallTaskStoragePartitioningLayoutExtraArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerReinstallTaskStoragePartitioningLayoutExtraArgs:
    def __init__(__self__, *,
                 lvs: Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraLvArgs']]]] = None,
                 zps: Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraZpArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraLvArgs']]] lvs: LVM-specific parameters (when applicable)
        :param pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraZpArgs']]] zps: ZFS-specific parameters (when applicable)
        """
        if lvs is not None:
            pulumi.set(__self__, "lvs", lvs)
        if zps is not None:
            pulumi.set(__self__, "zps", zps)

    @property
    @pulumi.getter
    def lvs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraLvArgs']]]]:
        """
        LVM-specific parameters (when applicable)
        """
        return pulumi.get(self, "lvs")

    @lvs.setter
    def lvs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraLvArgs']]]]):
        pulumi.set(self, "lvs", value)

    @property
    @pulumi.getter
    def zps(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraZpArgs']]]]:
        """
        ZFS-specific parameters (when applicable)
        """
        return pulumi.get(self, "zps")

    @zps.setter
    def zps(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServerReinstallTaskStoragePartitioningLayoutExtraZpArgs']]]]):
        pulumi.set(self, "zps", value)


if not MYPY:
    class ServerReinstallTaskStoragePartitioningLayoutExtraLvArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        Logical volume name
        """
elif False:
    ServerReinstallTaskStoragePartitioningLayoutExtraLvArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerReinstallTaskStoragePartitioningLayoutExtraLvArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] name: Logical volume name
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Logical volume name
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)


if not MYPY:
    class ServerReinstallTaskStoragePartitioningLayoutExtraZpArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        zpool name (generated automatically if not specified, note that multiple ZFS partitions with same zpool names will be configured as multiple datasets belonging to the same zpool if compatible)
        """
elif False:
    ServerReinstallTaskStoragePartitioningLayoutExtraZpArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerReinstallTaskStoragePartitioningLayoutExtraZpArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] name: zpool name (generated automatically if not specified, note that multiple ZFS partitions with same zpool names will be configured as multiple datasets belonging to the same zpool if compatible)
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        zpool name (generated automatically if not specified, note that multiple ZFS partitions with same zpool names will be configured as multiple datasets belonging to the same zpool if compatible)
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)


if not MYPY:
    class ServerStorageArgsDict(TypedDict):
        disk_group_id: NotRequired[pulumi.Input[builtins.float]]
        """
        Disk group id (default is 0, meaning automatic)
        """
        hardware_raids: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServerStorageHardwareRaidArgsDict']]]]
        """
        Hardware Raid configurations (if not specified, all disks of the chosen disk group id will be configured in JBOD mode)
        """
        partitioning: NotRequired[pulumi.Input['ServerStoragePartitioningArgsDict']]
        """
        Partitioning configuration
        """
elif False:
    ServerStorageArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerStorageArgs:
    def __init__(__self__, *,
                 disk_group_id: Optional[pulumi.Input[builtins.float]] = None,
                 hardware_raids: Optional[pulumi.Input[Sequence[pulumi.Input['ServerStorageHardwareRaidArgs']]]] = None,
                 partitioning: Optional[pulumi.Input['ServerStoragePartitioningArgs']] = None):
        """
        :param pulumi.Input[builtins.float] disk_group_id: Disk group id (default is 0, meaning automatic)
        :param pulumi.Input[Sequence[pulumi.Input['ServerStorageHardwareRaidArgs']]] hardware_raids: Hardware Raid configurations (if not specified, all disks of the chosen disk group id will be configured in JBOD mode)
        :param pulumi.Input['ServerStoragePartitioningArgs'] partitioning: Partitioning configuration
        """
        if disk_group_id is not None:
            pulumi.set(__self__, "disk_group_id", disk_group_id)
        if hardware_raids is not None:
            pulumi.set(__self__, "hardware_raids", hardware_raids)
        if partitioning is not None:
            pulumi.set(__self__, "partitioning", partitioning)

    @property
    @pulumi.getter(name="diskGroupId")
    def disk_group_id(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        Disk group id (default is 0, meaning automatic)
        """
        return pulumi.get(self, "disk_group_id")

    @disk_group_id.setter
    def disk_group_id(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "disk_group_id", value)

    @property
    @pulumi.getter(name="hardwareRaids")
    def hardware_raids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServerStorageHardwareRaidArgs']]]]:
        """
        Hardware Raid configurations (if not specified, all disks of the chosen disk group id will be configured in JBOD mode)
        """
        return pulumi.get(self, "hardware_raids")

    @hardware_raids.setter
    def hardware_raids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServerStorageHardwareRaidArgs']]]]):
        pulumi.set(self, "hardware_raids", value)

    @property
    @pulumi.getter
    def partitioning(self) -> Optional[pulumi.Input['ServerStoragePartitioningArgs']]:
        """
        Partitioning configuration
        """
        return pulumi.get(self, "partitioning")

    @partitioning.setter
    def partitioning(self, value: Optional[pulumi.Input['ServerStoragePartitioningArgs']]):
        pulumi.set(self, "partitioning", value)


if not MYPY:
    class ServerStorageHardwareRaidArgsDict(TypedDict):
        arrays: NotRequired[pulumi.Input[builtins.float]]
        """
        Number of arrays (default is 1)
        """
        disks: NotRequired[pulumi.Input[builtins.float]]
        """
        Total number of disks in the disk group involved in the hardware raid configuration (all disks of the disk group by default)
        """
        raid_level: NotRequired[pulumi.Input[builtins.float]]
        """
        Hardware raid type (default is 1)
        """
        spares: NotRequired[pulumi.Input[builtins.float]]
        """
        Number of disks in the disk group involved in the spare (default is 0)
        """
elif False:
    ServerStorageHardwareRaidArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerStorageHardwareRaidArgs:
    def __init__(__self__, *,
                 arrays: Optional[pulumi.Input[builtins.float]] = None,
                 disks: Optional[pulumi.Input[builtins.float]] = None,
                 raid_level: Optional[pulumi.Input[builtins.float]] = None,
                 spares: Optional[pulumi.Input[builtins.float]] = None):
        """
        :param pulumi.Input[builtins.float] arrays: Number of arrays (default is 1)
        :param pulumi.Input[builtins.float] disks: Total number of disks in the disk group involved in the hardware raid configuration (all disks of the disk group by default)
        :param pulumi.Input[builtins.float] raid_level: Hardware raid type (default is 1)
        :param pulumi.Input[builtins.float] spares: Number of disks in the disk group involved in the spare (default is 0)
        """
        if arrays is not None:
            pulumi.set(__self__, "arrays", arrays)
        if disks is not None:
            pulumi.set(__self__, "disks", disks)
        if raid_level is not None:
            pulumi.set(__self__, "raid_level", raid_level)
        if spares is not None:
            pulumi.set(__self__, "spares", spares)

    @property
    @pulumi.getter
    def arrays(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        Number of arrays (default is 1)
        """
        return pulumi.get(self, "arrays")

    @arrays.setter
    def arrays(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "arrays", value)

    @property
    @pulumi.getter
    def disks(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        Total number of disks in the disk group involved in the hardware raid configuration (all disks of the disk group by default)
        """
        return pulumi.get(self, "disks")

    @disks.setter
    def disks(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "disks", value)

    @property
    @pulumi.getter(name="raidLevel")
    def raid_level(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        Hardware raid type (default is 1)
        """
        return pulumi.get(self, "raid_level")

    @raid_level.setter
    def raid_level(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "raid_level", value)

    @property
    @pulumi.getter
    def spares(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        Number of disks in the disk group involved in the spare (default is 0)
        """
        return pulumi.get(self, "spares")

    @spares.setter
    def spares(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "spares", value)


if not MYPY:
    class ServerStoragePartitioningArgsDict(TypedDict):
        disks: NotRequired[pulumi.Input[builtins.float]]
        """
        Total number of disks in the disk group involved in the partitioning configuration (all disks of the disk group by default)
        """
        layouts: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServerStoragePartitioningLayoutArgsDict']]]]
        """
        Custom partitioning layout (default is the default layout of the operating system's default partitioning scheme)
        """
        scheme_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Partitioning scheme (if applicable with selected operating system)
        """
elif False:
    ServerStoragePartitioningArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerStoragePartitioningArgs:
    def __init__(__self__, *,
                 disks: Optional[pulumi.Input[builtins.float]] = None,
                 layouts: Optional[pulumi.Input[Sequence[pulumi.Input['ServerStoragePartitioningLayoutArgs']]]] = None,
                 scheme_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.float] disks: Total number of disks in the disk group involved in the partitioning configuration (all disks of the disk group by default)
        :param pulumi.Input[Sequence[pulumi.Input['ServerStoragePartitioningLayoutArgs']]] layouts: Custom partitioning layout (default is the default layout of the operating system's default partitioning scheme)
        :param pulumi.Input[builtins.str] scheme_name: Partitioning scheme (if applicable with selected operating system)
        """
        if disks is not None:
            pulumi.set(__self__, "disks", disks)
        if layouts is not None:
            pulumi.set(__self__, "layouts", layouts)
        if scheme_name is not None:
            pulumi.set(__self__, "scheme_name", scheme_name)

    @property
    @pulumi.getter
    def disks(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        Total number of disks in the disk group involved in the partitioning configuration (all disks of the disk group by default)
        """
        return pulumi.get(self, "disks")

    @disks.setter
    def disks(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "disks", value)

    @property
    @pulumi.getter
    def layouts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServerStoragePartitioningLayoutArgs']]]]:
        """
        Custom partitioning layout (default is the default layout of the operating system's default partitioning scheme)
        """
        return pulumi.get(self, "layouts")

    @layouts.setter
    def layouts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServerStoragePartitioningLayoutArgs']]]]):
        pulumi.set(self, "layouts", value)

    @property
    @pulumi.getter(name="schemeName")
    def scheme_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Partitioning scheme (if applicable with selected operating system)
        """
        return pulumi.get(self, "scheme_name")

    @scheme_name.setter
    def scheme_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "scheme_name", value)


if not MYPY:
    class ServerStoragePartitioningLayoutArgsDict(TypedDict):
        file_system: pulumi.Input[builtins.str]
        """
        File system type
        """
        mount_point: pulumi.Input[builtins.str]
        """
        Mount point
        """
        extras: NotRequired[pulumi.Input['ServerStoragePartitioningLayoutExtrasArgsDict']]
        """
        Partition extras parameters
        """
        raid_level: NotRequired[pulumi.Input[builtins.float]]
        """
        Software raid type (default is 1)
        """
        size: NotRequired[pulumi.Input[builtins.float]]
        """
        Partition size in MiB (default value is 0 which means to fill the disk with that partition)
        """
elif False:
    ServerStoragePartitioningLayoutArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerStoragePartitioningLayoutArgs:
    def __init__(__self__, *,
                 file_system: pulumi.Input[builtins.str],
                 mount_point: pulumi.Input[builtins.str],
                 extras: Optional[pulumi.Input['ServerStoragePartitioningLayoutExtrasArgs']] = None,
                 raid_level: Optional[pulumi.Input[builtins.float]] = None,
                 size: Optional[pulumi.Input[builtins.float]] = None):
        """
        :param pulumi.Input[builtins.str] file_system: File system type
        :param pulumi.Input[builtins.str] mount_point: Mount point
        :param pulumi.Input['ServerStoragePartitioningLayoutExtrasArgs'] extras: Partition extras parameters
        :param pulumi.Input[builtins.float] raid_level: Software raid type (default is 1)
        :param pulumi.Input[builtins.float] size: Partition size in MiB (default value is 0 which means to fill the disk with that partition)
        """
        pulumi.set(__self__, "file_system", file_system)
        pulumi.set(__self__, "mount_point", mount_point)
        if extras is not None:
            pulumi.set(__self__, "extras", extras)
        if raid_level is not None:
            pulumi.set(__self__, "raid_level", raid_level)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter(name="fileSystem")
    def file_system(self) -> pulumi.Input[builtins.str]:
        """
        File system type
        """
        return pulumi.get(self, "file_system")

    @file_system.setter
    def file_system(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "file_system", value)

    @property
    @pulumi.getter(name="mountPoint")
    def mount_point(self) -> pulumi.Input[builtins.str]:
        """
        Mount point
        """
        return pulumi.get(self, "mount_point")

    @mount_point.setter
    def mount_point(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "mount_point", value)

    @property
    @pulumi.getter
    def extras(self) -> Optional[pulumi.Input['ServerStoragePartitioningLayoutExtrasArgs']]:
        """
        Partition extras parameters
        """
        return pulumi.get(self, "extras")

    @extras.setter
    def extras(self, value: Optional[pulumi.Input['ServerStoragePartitioningLayoutExtrasArgs']]):
        pulumi.set(self, "extras", value)

    @property
    @pulumi.getter(name="raidLevel")
    def raid_level(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        Software raid type (default is 1)
        """
        return pulumi.get(self, "raid_level")

    @raid_level.setter
    def raid_level(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "raid_level", value)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        Partition size in MiB (default value is 0 which means to fill the disk with that partition)
        """
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "size", value)


if not MYPY:
    class ServerStoragePartitioningLayoutExtrasArgsDict(TypedDict):
        lv: NotRequired[pulumi.Input['ServerStoragePartitioningLayoutExtrasLvArgsDict']]
        """
        LVM-specific parameters
        """
        zp: NotRequired[pulumi.Input['ServerStoragePartitioningLayoutExtrasZpArgsDict']]
        """
        ZFS-specific parameters
        """
elif False:
    ServerStoragePartitioningLayoutExtrasArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerStoragePartitioningLayoutExtrasArgs:
    def __init__(__self__, *,
                 lv: Optional[pulumi.Input['ServerStoragePartitioningLayoutExtrasLvArgs']] = None,
                 zp: Optional[pulumi.Input['ServerStoragePartitioningLayoutExtrasZpArgs']] = None):
        """
        :param pulumi.Input['ServerStoragePartitioningLayoutExtrasLvArgs'] lv: LVM-specific parameters
        :param pulumi.Input['ServerStoragePartitioningLayoutExtrasZpArgs'] zp: ZFS-specific parameters
        """
        if lv is not None:
            pulumi.set(__self__, "lv", lv)
        if zp is not None:
            pulumi.set(__self__, "zp", zp)

    @property
    @pulumi.getter
    def lv(self) -> Optional[pulumi.Input['ServerStoragePartitioningLayoutExtrasLvArgs']]:
        """
        LVM-specific parameters
        """
        return pulumi.get(self, "lv")

    @lv.setter
    def lv(self, value: Optional[pulumi.Input['ServerStoragePartitioningLayoutExtrasLvArgs']]):
        pulumi.set(self, "lv", value)

    @property
    @pulumi.getter
    def zp(self) -> Optional[pulumi.Input['ServerStoragePartitioningLayoutExtrasZpArgs']]:
        """
        ZFS-specific parameters
        """
        return pulumi.get(self, "zp")

    @zp.setter
    def zp(self, value: Optional[pulumi.Input['ServerStoragePartitioningLayoutExtrasZpArgs']]):
        pulumi.set(self, "zp", value)


if not MYPY:
    class ServerStoragePartitioningLayoutExtrasLvArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dedicated server name
        """
elif False:
    ServerStoragePartitioningLayoutExtrasLvArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerStoragePartitioningLayoutExtrasLvArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] name: Dedicated server name
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dedicated server name
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)


if not MYPY:
    class ServerStoragePartitioningLayoutExtrasZpArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dedicated server name
        """
elif False:
    ServerStoragePartitioningLayoutExtrasZpArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerStoragePartitioningLayoutExtrasZpArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] name: Dedicated server name
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dedicated server name
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)


