msgraph-sdk 1.51.0__py3-none-any.whl → 1.53.0__py3-none-any.whl

msgraph/generated/models/file_storage_container_type.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+from uuid import UUID
+
+if TYPE_CHECKING:
+    from .entity import Entity
+    from .file_storage_container_billing_classification import FileStorageContainerBillingClassification
+    from .file_storage_container_billing_status import FileStorageContainerBillingStatus
+    from .file_storage_container_type_settings import FileStorageContainerTypeSettings
+
+from .entity import Entity
+
+@dataclass
+class FileStorageContainerType(Entity, Parsable):
+    # The billingClassification property
+    billing_classification: Optional[FileStorageContainerBillingClassification] = None
+    # The billingStatus property
+    billing_status: Optional[FileStorageContainerBillingStatus] = None
+    # The creation date. The timestamp type represents date and time information using ISO 8601 format and is always in UTC. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z. Read-only.
+    created_date_time: Optional[datetime.datetime] = None
+    # Used in update scenarios for optimistic concurrency control. Read-only.
+    etag: Optional[str] = None
+    # The expiration date. The timestamp type represents date and time information using ISO 8601 format and is always in UTC. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z. Read-only.
+    expiration_date_time: Optional[datetime.datetime] = None
+    # The name of the fileStorageContainerType.
+    name: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # ID of the application that owns the fileStorageContainerType.
+    owning_app_id: Optional[UUID] = None
+    # The settings property
+    settings: Optional[FileStorageContainerTypeSettings] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FileStorageContainerType:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: FileStorageContainerType
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FileStorageContainerType()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .entity import Entity
+        from .file_storage_container_billing_classification import FileStorageContainerBillingClassification
+        from .file_storage_container_billing_status import FileStorageContainerBillingStatus
+        from .file_storage_container_type_settings import FileStorageContainerTypeSettings
+
+        from .entity import Entity
+        from .file_storage_container_billing_classification import FileStorageContainerBillingClassification
+        from .file_storage_container_billing_status import FileStorageContainerBillingStatus
+        from .file_storage_container_type_settings import FileStorageContainerTypeSettings
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "billingClassification": lambda n : setattr(self, 'billing_classification', n.get_enum_value(FileStorageContainerBillingClassification)),
+            "billingStatus": lambda n : setattr(self, 'billing_status', n.get_enum_value(FileStorageContainerBillingStatus)),
+            "createdDateTime": lambda n : setattr(self, 'created_date_time', n.get_datetime_value()),
+            "etag": lambda n : setattr(self, 'etag', n.get_str_value()),
+            "expirationDateTime": lambda n : setattr(self, 'expiration_date_time', n.get_datetime_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "owningAppId": lambda n : setattr(self, 'owning_app_id', n.get_uuid_value()),
+            "settings": lambda n : setattr(self, 'settings', n.get_object_value(FileStorageContainerTypeSettings)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_enum_value("billingClassification", self.billing_classification)
+        writer.write_enum_value("billingStatus", self.billing_status)
+        writer.write_datetime_value("createdDateTime", self.created_date_time)
+        writer.write_str_value("etag", self.etag)
+        writer.write_datetime_value("expirationDateTime", self.expiration_date_time)
+        writer.write_str_value("name", self.name)
+        writer.write_uuid_value("owningAppId", self.owning_app_id)
+        writer.write_object_value("settings", self.settings)
+    
+

msgraph/generated/models/file_storage_container_type_app_permission.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+class FileStorageContainerTypeAppPermission(str, Enum):
+    None_ = "none",
+    ReadContent = "readContent",
+    WriteContent = "writeContent",
+    ManageContent = "manageContent",
+    Create = "create",
+    Delete = "delete",
+    Read = "read",
+    Write = "write",
+    EnumeratePermissions = "enumeratePermissions",
+    AddPermissions = "addPermissions",
+    UpdatePermissions = "updatePermissions",
+    DeletePermissions = "deletePermissions",
+    DeleteOwnPermission = "deleteOwnPermission",
+    ManagePermissions = "managePermissions",
+    Full = "full",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/file_storage_container_type_app_permission_grant.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFactorySingleton
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .file_storage_container_type_app_permission import FileStorageContainerTypeAppPermission
+
+@dataclass
+class FileStorageContainerTypeAppPermissionGrant(AdditionalDataHolder, BackedModel, Parsable):
+    # Stores model information.
+    backing_store: BackingStore = field(default_factory=BackingStoreFactorySingleton(backing_store_factory=None).backing_store_factory.create_backing_store, repr=False)
+
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+    # Application ID to which to set permissions.
+    app_id: Optional[str] = None
+    # Allowed permissions when you use delegated tokens. The possible values are: none, readContent, writeContent, manageContent, create, delete, read, write, enumeratePermissions, addPermissions, updatePermissions, deletePermissions, deleteOwnPermission, managePermissions, full, unknownFutureValue.
+    application_permissions: Optional[list[FileStorageContainerTypeAppPermission]] = None
+    # Allowed permissions when you use application tokens. The possible values are: none, readContent, writeContent, manageContent, create, delete, read, write, enumeratePermissions, addPermissions, updatePermissions, deletePermissions, deleteOwnPermission, managePermissions, full, unknownFutureValue.
+    delegated_permissions: Optional[list[FileStorageContainerTypeAppPermission]] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FileStorageContainerTypeAppPermissionGrant:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: FileStorageContainerTypeAppPermissionGrant
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FileStorageContainerTypeAppPermissionGrant()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .file_storage_container_type_app_permission import FileStorageContainerTypeAppPermission
+
+        from .file_storage_container_type_app_permission import FileStorageContainerTypeAppPermission
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "appId": lambda n : setattr(self, 'app_id', n.get_str_value()),
+            "applicationPermissions": lambda n : setattr(self, 'application_permissions', n.get_collection_of_enum_values(FileStorageContainerTypeAppPermission)),
+            "delegatedPermissions": lambda n : setattr(self, 'delegated_permissions', n.get_collection_of_enum_values(FileStorageContainerTypeAppPermission)),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("appId", self.app_id)
+        writer.write_collection_of_enum_values("applicationPermissions", self.application_permissions)
+        writer.write_collection_of_enum_values("delegatedPermissions", self.delegated_permissions)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/file_storage_container_type_app_permission_grant_collection_response.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+    from .file_storage_container_type_app_permission_grant import FileStorageContainerTypeAppPermissionGrant
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class FileStorageContainerTypeAppPermissionGrantCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[FileStorageContainerTypeAppPermissionGrant]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FileStorageContainerTypeAppPermissionGrantCollectionResponse:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: FileStorageContainerTypeAppPermissionGrantCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FileStorageContainerTypeAppPermissionGrantCollectionResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .file_storage_container_type_app_permission_grant import FileStorageContainerTypeAppPermissionGrant
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .file_storage_container_type_app_permission_grant import FileStorageContainerTypeAppPermissionGrant
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(FileStorageContainerTypeAppPermissionGrant)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_collection_of_object_values("value", self.value)
+    
+

msgraph/generated/models/file_storage_container_type_collection_response.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+    from .file_storage_container_type import FileStorageContainerType
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class FileStorageContainerTypeCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[FileStorageContainerType]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FileStorageContainerTypeCollectionResponse:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: FileStorageContainerTypeCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FileStorageContainerTypeCollectionResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .file_storage_container_type import FileStorageContainerType
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .file_storage_container_type import FileStorageContainerType
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(FileStorageContainerType)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_collection_of_object_values("value", self.value)
+    
+

msgraph/generated/models/file_storage_container_type_registration.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+from uuid import UUID
+
+if TYPE_CHECKING:
+    from .entity import Entity
+    from .file_storage_container_billing_classification import FileStorageContainerBillingClassification
+    from .file_storage_container_billing_status import FileStorageContainerBillingStatus
+    from .file_storage_container_type_app_permission_grant import FileStorageContainerTypeAppPermissionGrant
+    from .file_storage_container_type_registration_settings import FileStorageContainerTypeRegistrationSettings
+
+from .entity import Entity
+
+@dataclass
+class FileStorageContainerTypeRegistration(Entity, Parsable):
+    # Access privileges of applications on containers.
+    application_permission_grants: Optional[list[FileStorageContainerTypeAppPermissionGrant]] = None
+    # The billingClassification property
+    billing_classification: Optional[FileStorageContainerBillingClassification] = None
+    # The billingStatus property
+    billing_status: Optional[FileStorageContainerBillingStatus] = None
+    # Used in update scenarios for optimistic concurrency control. Read-only.
+    etag: Optional[str] = None
+    # The expiration date. The timestamp type represents date and time information using ISO 8601 format and is always in UTC. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z. Read-only.
+    expiration_date_time: Optional[datetime.datetime] = None
+    # The name of the fileStorageContainerTypeRegistration. Read-only.
+    name: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # ID of the application that owns the fileStorageContainerType. Read-only.
+    owning_app_id: Optional[UUID] = None
+    # The registration date. The timestamp type represents date and time information using ISO 8601 format and is always in UTC. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z. Read-only.
+    registered_date_time: Optional[datetime.datetime] = None
+    # The settings property
+    settings: Optional[FileStorageContainerTypeRegistrationSettings] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FileStorageContainerTypeRegistration:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: FileStorageContainerTypeRegistration
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FileStorageContainerTypeRegistration()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .entity import Entity
+        from .file_storage_container_billing_classification import FileStorageContainerBillingClassification
+        from .file_storage_container_billing_status import FileStorageContainerBillingStatus
+        from .file_storage_container_type_app_permission_grant import FileStorageContainerTypeAppPermissionGrant
+        from .file_storage_container_type_registration_settings import FileStorageContainerTypeRegistrationSettings
+
+        from .entity import Entity
+        from .file_storage_container_billing_classification import FileStorageContainerBillingClassification
+        from .file_storage_container_billing_status import FileStorageContainerBillingStatus
+        from .file_storage_container_type_app_permission_grant import FileStorageContainerTypeAppPermissionGrant
+        from .file_storage_container_type_registration_settings import FileStorageContainerTypeRegistrationSettings
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "applicationPermissionGrants": lambda n : setattr(self, 'application_permission_grants', n.get_collection_of_object_values(FileStorageContainerTypeAppPermissionGrant)),
+            "billingClassification": lambda n : setattr(self, 'billing_classification', n.get_enum_value(FileStorageContainerBillingClassification)),
+            "billingStatus": lambda n : setattr(self, 'billing_status', n.get_enum_value(FileStorageContainerBillingStatus)),
+            "etag": lambda n : setattr(self, 'etag', n.get_str_value()),
+            "expirationDateTime": lambda n : setattr(self, 'expiration_date_time', n.get_datetime_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "owningAppId": lambda n : setattr(self, 'owning_app_id', n.get_uuid_value()),
+            "registeredDateTime": lambda n : setattr(self, 'registered_date_time', n.get_datetime_value()),
+            "settings": lambda n : setattr(self, 'settings', n.get_object_value(FileStorageContainerTypeRegistrationSettings)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_collection_of_object_values("applicationPermissionGrants", self.application_permission_grants)
+        writer.write_enum_value("billingClassification", self.billing_classification)
+        writer.write_enum_value("billingStatus", self.billing_status)
+        writer.write_str_value("etag", self.etag)
+        writer.write_datetime_value("expirationDateTime", self.expiration_date_time)
+        writer.write_str_value("name", self.name)
+        writer.write_uuid_value("owningAppId", self.owning_app_id)
+        writer.write_datetime_value("registeredDateTime", self.registered_date_time)
+        writer.write_object_value("settings", self.settings)
+    
+

msgraph/generated/models/file_storage_container_type_registration_collection_response.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+    from .file_storage_container_type_registration import FileStorageContainerTypeRegistration
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class FileStorageContainerTypeRegistrationCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[FileStorageContainerTypeRegistration]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FileStorageContainerTypeRegistrationCollectionResponse:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: FileStorageContainerTypeRegistrationCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FileStorageContainerTypeRegistrationCollectionResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .file_storage_container_type_registration import FileStorageContainerTypeRegistration
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .file_storage_container_type_registration import FileStorageContainerTypeRegistration
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(FileStorageContainerTypeRegistration)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_collection_of_object_values("value", self.value)
+    
+

msgraph/generated/models/file_storage_container_type_registration_settings.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFactorySingleton
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .sharing_capabilities import SharingCapabilities
+
+@dataclass
+class FileStorageContainerTypeRegistrationSettings(AdditionalDataHolder, BackedModel, Parsable):
+    # Stores model information.
+    backing_store: BackingStore = field(default_factory=BackingStoreFactorySingleton(backing_store_factory=None).backing_store_factory.create_backing_store, repr=False)
+
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+    # Indicates whether items from containers are surfaced in experiences such as My Activity or Microsoft 365.
+    is_discoverability_enabled: Optional[bool] = None
+    # Indicates whether item versioning is enabled.
+    is_item_versioning_enabled: Optional[bool] = None
+    # Indicates whether search is enabled.
+    is_search_enabled: Optional[bool] = None
+    # Only the manager and owner can share files in the container if restricted sharing is enabled.
+    is_sharing_restricted: Optional[bool] = None
+    # Maximum number of versions. Versioning must be enabled ('isItemVersioningEnabled'=true).
+    item_major_version_limit: Optional[int] = None
+    # Controls maximum storage in bytes.
+    max_storage_per_container_in_bytes: Optional[int] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Sharing capabilities permitted for containers. The possible values are: disabled, externalUserSharingOnly, externalUserAndGuestSharing, existingExternalUserSharingOnly, unknownFutureValue. Can always be updated.
+    sharing_capability: Optional[SharingCapabilities] = None
+    # Pattern used to redirect files.
+    url_template: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FileStorageContainerTypeRegistrationSettings:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: FileStorageContainerTypeRegistrationSettings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FileStorageContainerTypeRegistrationSettings()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .sharing_capabilities import SharingCapabilities
+
+        from .sharing_capabilities import SharingCapabilities
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "isDiscoverabilityEnabled": lambda n : setattr(self, 'is_discoverability_enabled', n.get_bool_value()),
+            "isItemVersioningEnabled": lambda n : setattr(self, 'is_item_versioning_enabled', n.get_bool_value()),
+            "isSearchEnabled": lambda n : setattr(self, 'is_search_enabled', n.get_bool_value()),
+            "isSharingRestricted": lambda n : setattr(self, 'is_sharing_restricted', n.get_bool_value()),
+            "itemMajorVersionLimit": lambda n : setattr(self, 'item_major_version_limit', n.get_int_value()),
+            "maxStoragePerContainerInBytes": lambda n : setattr(self, 'max_storage_per_container_in_bytes', n.get_int_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "sharingCapability": lambda n : setattr(self, 'sharing_capability', n.get_enum_value(SharingCapabilities)),
+            "urlTemplate": lambda n : setattr(self, 'url_template', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_bool_value("isDiscoverabilityEnabled", self.is_discoverability_enabled)
+        writer.write_bool_value("isItemVersioningEnabled", self.is_item_versioning_enabled)
+        writer.write_bool_value("isSearchEnabled", self.is_search_enabled)
+        writer.write_bool_value("isSharingRestricted", self.is_sharing_restricted)
+        writer.write_int_value("itemMajorVersionLimit", self.item_major_version_limit)
+        writer.write_int_value("maxStoragePerContainerInBytes", self.max_storage_per_container_in_bytes)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_enum_value("sharingCapability", self.sharing_capability)
+        writer.write_str_value("urlTemplate", self.url_template)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/file_storage_container_type_settings.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFactorySingleton
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .file_storage_container_type_settings_override import FileStorageContainerTypeSettingsOverride
+    from .sharing_capabilities import SharingCapabilities
+
+@dataclass
+class FileStorageContainerTypeSettings(AdditionalDataHolder, BackedModel, Parsable):
+    # Stores model information.
+    backing_store: BackingStore = field(default_factory=BackingStoreFactorySingleton(backing_store_factory=None).backing_store_factory.create_backing_store, repr=False)
+
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+    # A comma-separated list of settings that can be overridden in the consuming tenant. The possible values are: urlTemplate, isDiscoverabilityEnabled, isSearchEnabled, isItemVersioningEnabled, itemMajorVersionLimit, maxStoragePerContainerInBytes, unknownFutureValue.
+    consuming_tenant_overridables: Optional[FileStorageContainerTypeSettingsOverride] = None
+    # Indicates whether items from containers are surfaced in experiences such as My Activity or Microsoft 365.
+    is_discoverability_enabled: Optional[bool] = None
+    # Indicates whether item versioning is enabled.
+    is_item_versioning_enabled: Optional[bool] = None
+    # Indicates whether search is enabled.
+    is_search_enabled: Optional[bool] = None
+    # Only the manager and owner can share files in the container if restricted sharing is enabled.
+    is_sharing_restricted: Optional[bool] = None
+    # Maximum number of versions. Versioning must be enabled ('isItemVersioningEnabled'=true).
+    item_major_version_limit: Optional[int] = None
+    # Controls maximum storage in bytes.
+    max_storage_per_container_in_bytes: Optional[int] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Sharing capabilities permitted for containers. This value can always be overridden during registration if needed. The possible values are: disabled, externalUserSharingOnly, externalUserAndGuestSharing, existingExternalUserSharingOnly, unknownFutureValue.
+    sharing_capability: Optional[SharingCapabilities] = None
+    # Pattern used to redirect files.
+    url_template: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FileStorageContainerTypeSettings:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: FileStorageContainerTypeSettings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FileStorageContainerTypeSettings()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .file_storage_container_type_settings_override import FileStorageContainerTypeSettingsOverride
+        from .sharing_capabilities import SharingCapabilities
+
+        from .file_storage_container_type_settings_override import FileStorageContainerTypeSettingsOverride
+        from .sharing_capabilities import SharingCapabilities
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "consumingTenantOverridables": lambda n : setattr(self, 'consuming_tenant_overridables', n.get_collection_of_enum_values(FileStorageContainerTypeSettingsOverride)),
+            "isDiscoverabilityEnabled": lambda n : setattr(self, 'is_discoverability_enabled', n.get_bool_value()),
+            "isItemVersioningEnabled": lambda n : setattr(self, 'is_item_versioning_enabled', n.get_bool_value()),
+            "isSearchEnabled": lambda n : setattr(self, 'is_search_enabled', n.get_bool_value()),
+            "isSharingRestricted": lambda n : setattr(self, 'is_sharing_restricted', n.get_bool_value()),
+            "itemMajorVersionLimit": lambda n : setattr(self, 'item_major_version_limit', n.get_int_value()),
+            "maxStoragePerContainerInBytes": lambda n : setattr(self, 'max_storage_per_container_in_bytes', n.get_int_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "sharingCapability": lambda n : setattr(self, 'sharing_capability', n.get_enum_value(SharingCapabilities)),
+            "urlTemplate": lambda n : setattr(self, 'url_template', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_enum_value("consumingTenantOverridables", self.consuming_tenant_overridables)
+        writer.write_bool_value("isDiscoverabilityEnabled", self.is_discoverability_enabled)
+        writer.write_bool_value("isItemVersioningEnabled", self.is_item_versioning_enabled)
+        writer.write_bool_value("isSearchEnabled", self.is_search_enabled)
+        writer.write_bool_value("isSharingRestricted", self.is_sharing_restricted)
+        writer.write_int_value("itemMajorVersionLimit", self.item_major_version_limit)
+        writer.write_int_value("maxStoragePerContainerInBytes", self.max_storage_per_container_in_bytes)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_enum_value("sharingCapability", self.sharing_capability)
+        writer.write_str_value("urlTemplate", self.url_template)
+        writer.write_additional_data_value(self.additional_data)
+    
+