# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

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__ = [
    'AccessPointPosixUserArgs',
    'AccessPointPosixUserArgsDict',
    'AccessPointRootPathPermissionArgs',
    'AccessPointRootPathPermissionArgsDict',
    'FileSystemNfsAclArgs',
    'FileSystemNfsAclArgsDict',
    'FileSystemRecycleBinArgs',
    'FileSystemRecycleBinArgsDict',
]

MYPY = False

if not MYPY:
    class AccessPointPosixUserArgsDict(TypedDict):
        posix_group_id: NotRequired[pulumi.Input[int]]
        """
        The ID of the Posix user group.
        """
        posix_secondary_group_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
        """
        The ID of the second user group.
        """
        posix_user_id: NotRequired[pulumi.Input[int]]
        """
        The Posix user ID.
        """
elif False:
    AccessPointPosixUserArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccessPointPosixUserArgs:
    def __init__(__self__, *,
                 posix_group_id: Optional[pulumi.Input[int]] = None,
                 posix_secondary_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
                 posix_user_id: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] posix_group_id: The ID of the Posix user group.
        :param pulumi.Input[Sequence[pulumi.Input[int]]] posix_secondary_group_ids: The ID of the second user group.
        :param pulumi.Input[int] posix_user_id: The Posix user ID.
        """
        if posix_group_id is not None:
            pulumi.set(__self__, "posix_group_id", posix_group_id)
        if posix_secondary_group_ids is not None:
            pulumi.set(__self__, "posix_secondary_group_ids", posix_secondary_group_ids)
        if posix_user_id is not None:
            pulumi.set(__self__, "posix_user_id", posix_user_id)

    @property
    @pulumi.getter(name="posixGroupId")
    def posix_group_id(self) -> Optional[pulumi.Input[int]]:
        """
        The ID of the Posix user group.
        """
        return pulumi.get(self, "posix_group_id")

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

    @property
    @pulumi.getter(name="posixSecondaryGroupIds")
    def posix_secondary_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
        """
        The ID of the second user group.
        """
        return pulumi.get(self, "posix_secondary_group_ids")

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

    @property
    @pulumi.getter(name="posixUserId")
    def posix_user_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Posix user ID.
        """
        return pulumi.get(self, "posix_user_id")

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


if not MYPY:
    class AccessPointRootPathPermissionArgsDict(TypedDict):
        owner_group_id: NotRequired[pulumi.Input[int]]
        """
        The ID of the primary user group.
        """
        owner_user_id: NotRequired[pulumi.Input[int]]
        """
        The owner user ID.
        """
        permission: NotRequired[pulumi.Input[str]]
        """
        POSIX permission.
        """
elif False:
    AccessPointRootPathPermissionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccessPointRootPathPermissionArgs:
    def __init__(__self__, *,
                 owner_group_id: Optional[pulumi.Input[int]] = None,
                 owner_user_id: Optional[pulumi.Input[int]] = None,
                 permission: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] owner_group_id: The ID of the primary user group.
        :param pulumi.Input[int] owner_user_id: The owner user ID.
        :param pulumi.Input[str] permission: POSIX permission.
        """
        if owner_group_id is not None:
            pulumi.set(__self__, "owner_group_id", owner_group_id)
        if owner_user_id is not None:
            pulumi.set(__self__, "owner_user_id", owner_user_id)
        if permission is not None:
            pulumi.set(__self__, "permission", permission)

    @property
    @pulumi.getter(name="ownerGroupId")
    def owner_group_id(self) -> Optional[pulumi.Input[int]]:
        """
        The ID of the primary user group.
        """
        return pulumi.get(self, "owner_group_id")

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

    @property
    @pulumi.getter(name="ownerUserId")
    def owner_user_id(self) -> Optional[pulumi.Input[int]]:
        """
        The owner user ID.
        """
        return pulumi.get(self, "owner_user_id")

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

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

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


if not MYPY:
    class FileSystemNfsAclArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[bool]]
        """
        Specifies whether to enable the NFS ACL feature. Default value: `false`. Valid values:
        """
elif False:
    FileSystemNfsAclArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FileSystemNfsAclArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enabled: Specifies whether to enable the NFS ACL feature. Default value: `false`. Valid values:
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether to enable the NFS ACL feature. Default value: `false`. Valid values:
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


if not MYPY:
    class FileSystemRecycleBinArgsDict(TypedDict):
        enable_time: NotRequired[pulumi.Input[str]]
        """
        The time at which the recycle bin was enabled.
        """
        reserved_days: NotRequired[pulumi.Input[int]]
        """
        The retention period of the files in the recycle bin. Unit: days. Default value: `3`. Valid values: `1` to `180`. **NOTE:** `reserved_days` takes effect only if `status` is set to `Enable`.
        """
        secondary_size: NotRequired[pulumi.Input[int]]
        """
        The size of the Infrequent Access (IA) data that is dumped to the recycle bin.
        """
        size: NotRequired[pulumi.Input[int]]
        """
        The size of the files that are dumped to the recycle bin.
        """
        status: NotRequired[pulumi.Input[str]]
        """
        Specifies whether to enable the recycle bin feature. Default value: `Disable`. Valid values: `Enable`, `Disable`.
        """
elif False:
    FileSystemRecycleBinArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FileSystemRecycleBinArgs:
    def __init__(__self__, *,
                 enable_time: Optional[pulumi.Input[str]] = None,
                 reserved_days: Optional[pulumi.Input[int]] = None,
                 secondary_size: Optional[pulumi.Input[int]] = None,
                 size: Optional[pulumi.Input[int]] = None,
                 status: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] enable_time: The time at which the recycle bin was enabled.
        :param pulumi.Input[int] reserved_days: The retention period of the files in the recycle bin. Unit: days. Default value: `3`. Valid values: `1` to `180`. **NOTE:** `reserved_days` takes effect only if `status` is set to `Enable`.
        :param pulumi.Input[int] secondary_size: The size of the Infrequent Access (IA) data that is dumped to the recycle bin.
        :param pulumi.Input[int] size: The size of the files that are dumped to the recycle bin.
        :param pulumi.Input[str] status: Specifies whether to enable the recycle bin feature. Default value: `Disable`. Valid values: `Enable`, `Disable`.
        """
        if enable_time is not None:
            pulumi.set(__self__, "enable_time", enable_time)
        if reserved_days is not None:
            pulumi.set(__self__, "reserved_days", reserved_days)
        if secondary_size is not None:
            pulumi.set(__self__, "secondary_size", secondary_size)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="enableTime")
    def enable_time(self) -> Optional[pulumi.Input[str]]:
        """
        The time at which the recycle bin was enabled.
        """
        return pulumi.get(self, "enable_time")

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

    @property
    @pulumi.getter(name="reservedDays")
    def reserved_days(self) -> Optional[pulumi.Input[int]]:
        """
        The retention period of the files in the recycle bin. Unit: days. Default value: `3`. Valid values: `1` to `180`. **NOTE:** `reserved_days` takes effect only if `status` is set to `Enable`.
        """
        return pulumi.get(self, "reserved_days")

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

    @property
    @pulumi.getter(name="secondarySize")
    def secondary_size(self) -> Optional[pulumi.Input[int]]:
        """
        The size of the Infrequent Access (IA) data that is dumped to the recycle bin.
        """
        return pulumi.get(self, "secondary_size")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[int]]:
        """
        The size of the files that are dumped to the recycle bin.
        """
        return pulumi.get(self, "size")

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

    @property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies whether to enable the recycle bin feature. Default value: `Disable`. Valid values: `Enable`, `Disable`.
        """
        return pulumi.get(self, "status")

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


