Office365-REST-Python-Client 3.0.0__py3-none-any.whl → 3.1.0__py3-none-any.whl

office365/sharepoint/internal/paths/web.py

@@ -1,5 +1,7 @@
+from urllib.parse import urlparse
+
+from office365.runtime.http.url import is_absolute_url
 from office365.runtime.paths.resource_path import ResourcePath
-from office365.runtime.utilities import is_absolute_url, urlparse
 
 
 class WebPath(ResourcePath):

office365/sharepoint/internal/sticky_routing_options.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from office365.runtime.client_value import ClientValue
+
+
+class StickyRoutingOptions(ClientValue):
+    InteractionId: str | None = None
+    SessionId: str | None = None
+    SessionTicket: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "Microsoft.SharePoint.Internal.StickyRoutingOptions"

office365/sharepoint/likes/liked_by_information.py

@@ -1,6 +1,7 @@
 from typing import Optional
 
 from office365.runtime.paths.resource_path import ResourcePath
+from office365.runtime.types.odata_property import odata
 from office365.sharepoint.entity import Entity
 from office365.sharepoint.entity_collection import EntityCollection
 from office365.sharepoint.likes.user_entity import UserEntity
@@ -19,6 +20,7 @@ class LikedByInformation(Entity):
         """MUST be TRUE if the current user has liked the list item."""
         return self.properties.get("isLikedByUser", None)
 
+    @odata(name="likedBy")
     @property
     def liked_by(self) -> EntityCollection[UserEntity]:
         """
@@ -29,12 +31,6 @@ class LikedByInformation(Entity):
             "likedBy", EntityCollection(self.context, UserEntity, ResourcePath("likedBy", self.resource_path))
         )
 
-    def get_property(self, name, default_value=None):
-        if default_value is None:
-            property_mapping = {"likedBy": self.liked_by}
-            default_value = property_mapping.get(name, None)
-        return super().get_property(name, default_value)
-
     @property
     def entity_type_name(self):
         return "Microsoft.SharePoint.Likes.LikedByInformation"

office365/sharepoint/listitems/collection.py

@@ -1,7 +1,16 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import Self
+
 from office365.runtime.paths.service_operation import ServiceOperationPath
 from office365.sharepoint.entity_collection import EntityCollection
 from office365.sharepoint.listitems.listitem import ListItem
 
+if TYPE_CHECKING:
+    from office365.runtime.operations import ProgressCallback
+
 
 class ListItemCollection(EntityCollection[ListItem]):
     """List Item collection"""
@@ -9,6 +18,25 @@ class ListItemCollection(EntityCollection[ListItem]):
     def __init__(self, context, resource_path=None):
         super().__init__(context, ListItem, resource_path)
 
+    def from_records(self, records, progress: "ProgressCallback | None" = None) -> Self:
+        """Queue an item create per record.
+
+        List item columns are defined per list at runtime, not on the ``ListItem``
+        class, so every record key is forwarded to the server (no unknown-column
+        filtering). Deferred — run the creates with ``execute_query()``.
+
+        Args:
+            records: Plain dict records to import.
+            progress: Optional hook invoked per queued create as it completes
+              during ``execute_query()``.
+
+        Returns:
+            Self: The item collection, for method chaining.
+        """
+        from office365.runtime.converters.csv_reader import coerce_records
+
+        return self._import_records(coerce_records(self._item_type, records, allow_unknown=True), progress=progress)
+
     def get_by_id(self, item_id: int) -> ListItem:
         """Returns the list item with the specified list item identifier.
 

office365/sharepoint/listitems/compliance_info.py

@@ -18,3 +18,4 @@ class ListItemComplianceInfo(ClientValue):
     TagPolicyEventBased: bool | None = None
     TagPolicyHold: bool | None = None
     TagPolicyRecord: bool | None = None
+    DoNotEnforceTagPolicyHoldForVersions: bool | None = None

office365/sharepoint/listitems/form_update_value.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from datetime import datetime
+from typing import Dict, cast
 
 from office365.runtime.client_value import ClientValue
 from office365.sharepoint.fields.lookup_value import FieldLookupValue
@@ -32,7 +33,7 @@ class ListItemFormUpdateValue(ClientValue):
             return f"{self.FieldName} update succeeded"
 
     def to_json(self, json_format=None):
-        json = super().to_json(json_format)
+        json = cast(Dict, super().to_json(json_format))
         if isinstance(self.FieldValue, FieldLookupValue):
             json["FieldValue"] = "[{" + f"'Key':'{self.FieldValue.LookupValue}'" + "}]"
         elif isinstance(self.FieldValue, datetime):

office365/sharepoint/listitems/listdata_validation_exception_value.py

@@ -13,5 +13,7 @@ class ListDataValidationExceptionValue(ClientValue):
     Specifies failure information for a failed field or list item data validation.
     """
 
-    FieldFailures: ClientValueCollection[ListDataValidationFailure] | None = None
+    FieldFailures: ClientValueCollection[ListDataValidationFailure] = field(
+        default_factory=lambda: ClientValueCollection(ListDataValidationFailure)
+    )
     ItemFailure: ListDataValidationFailure = field(default_factory=ListDataValidationFailure)

office365/sharepoint/listitems/listitem.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict
 
 from typing_extensions import Self
 
@@ -243,14 +243,14 @@ class ListItem(SecurableObject):
             value (int): An integer value for the rating to be submitted.
                 The rating value SHOULD be between 1 and 5; otherwise, the server SHOULD return an exception.
         """
-        return_value = ClientResult(self.context)
+        return_value = ClientResult[float](self.context)
 
-        def _list_item_loaded():
+        def _set_rating():
             assert self.parent_list.id is not None
             assert self.id is not None
             Reputation.set_rating(self.context, self.parent_list.id, self.id, value, return_value)
 
-        self.parent_list.ensure_properties(["Id", "ParentList"]).after_execute(lambda _: _list_item_loaded())
+        self.parent_list.ensure_properties(["Id", "ParentList"]).after_execute(lambda _: _set_rating())
         return return_value
 
     def set_like(self, value: bool) -> ClientResult[int]:
@@ -716,7 +716,7 @@ class ListItem(SecurableObject):
         """Document ID fora document"""
         return self.properties.get("OData__dlc_DocIdUrl", FieldUrlValue())
 
-    def get_property(self, name, default_value=None):
+    def get_property(self, name, default_value=None) -> Any:
         if default_value is None:
             property_mapping = {
                 "AttachmentFiles": self.attachment_files,

office365/sharepoint/listitems/versions/version.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Optional, cast
 
 from office365.runtime.client_value_collection import ClientValueCollection
 from office365.runtime.paths.resource_path import ResourcePath
+from office365.runtime.types.odata_property import odata
 from office365.sharepoint.entity import Entity
 from office365.sharepoint.listitems.versions.change import SPListItemVersionChange
 
@@ -50,6 +51,7 @@ class ListItemVersion(Entity):
         """Gets the modified date and time for the item version."""
         return self.properties.get("Modified", datetime.min)
 
+    @odata(name="FileVersion")
     @property
     def created_by(self):
         """Gets the user that created the item version."""
@@ -70,6 +72,7 @@ class ListItemVersion(Entity):
             FieldCollection(self.context, ResourcePath("Fields", self.resource_path)),
         )
 
+    @odata(name="FileVersion")
     @property
     def file_version(self):
         """"""
@@ -91,18 +94,3 @@ class ListItemVersion(Entity):
         )
 
         return cast(ListItemVersionCollection, self._parent_collection)
-
-    def get_property(self, name, default_value=None):
-        if default_value is None:
-            property_mapping = {
-                "CreatedBy": self.created_by,
-                "FileVersion": self.file_version,
-            }
-            default_value = property_mapping.get(name, None)
-        return super().get_property(name, default_value)
-
-    def set_property(self, name, value, persist_changes=True):
-        if self._resource_path is None:
-            if name == "VersionId":
-                self._resource_path = self.parent_collection.get_by_id(value).resource_path
-        return super().set_property(name, value, persist_changes)

office365/sharepoint/lists/batch_convert_item_result.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from dataclasses import field
+
+from office365.runtime.client_value import ClientValue
+from office365.sharepoint.lists.conversion_loss_report import ConversionLossReport
+
+
+class BatchConvertItemResult(ClientValue):
+    errorCode: str | None = None
+    errorMessage: str | None = None
+    lossy: ConversionLossReport = field(default_factory=ConversionLossReport)
+    sourceItemId: int | None = None
+    succeeded: bool | None = None
+    viewerUrl: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "Microsoft.SharePoint.SmartWikiLibrary.BatchConvertItemResult"

office365/sharepoint/lists/batch_convert_result.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from dataclasses import field
+
+from office365.runtime.client_value import ClientValue
+from office365.runtime.client_value_collection import ClientValueCollection
+from office365.sharepoint.lists.batch_convert_item_result import BatchConvertItemResult
+
+
+class BatchConvertResult(ClientValue):
+    results: ClientValueCollection[BatchConvertItemResult] = field(
+        default_factory=lambda: ClientValueCollection(BatchConvertItemResult)
+    )
+
+    @property
+    def entity_type_name(self) -> str:
+        return "Microsoft.SharePoint.SmartWikiLibrary.BatchConvertResult"

office365/sharepoint/lists/collection.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Optional
 
+from office365.runtime.client_request_exception import ClientRequestException, DuplicatedObjectException
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.paths.service_operation import ServiceOperationPath
 from office365.runtime.paths.v3.entity import EntityPath
@@ -71,6 +72,41 @@ class ListCollection(EntityCollection[List]):
             self,
         )
 
+    def ensure_list(
+        self, title: str, description: str | None = None, template_type: ListTemplateType = ListTemplateType.GenericList
+    ) -> List:
+        """Gets the list with the given title, or creates it if it does not exist.
+
+        Attempts to create the list via ``add_list``; if the server reports that
+        a list with the title already exists (``DuplicatedObjectException``), the
+        existing list is loaded instead and its properties are copied into the
+        returned object. All other errors propagate.
+
+        The result is deferred: resolve it with ``execute_query()`` before use,
+        e.g.::
+
+            >>> lst = ctx.web.lists.ensure_list("My List").execute_query()
+
+        Args:
+            title: Title of the list to get or create
+            description: Description of the list to get or create
+            template_type: Type of list to get or create
+
+        Returns:
+            List: The existing or newly created list
+        """
+        return_type = self.add_list(title=title, description=description, template_type=template_type)
+
+        def _on_name_exists(error: ClientRequestException):
+            if not isinstance(error, DuplicatedObjectException):
+                raise error
+            self.get_by_title(title).get().after_execute(
+                lambda existing: return_type.copy_from(existing), execute_first=True
+            )
+
+        return_type.on_error(_on_name_exists)
+        return return_type
+
     def ensure_client_rendered_site_pages_library(self) -> List:
         """
         Gets or creates the default client-rendered site pages library.

office365/sharepoint/lists/conversion_loss_item.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from office365.runtime.client_value import ClientValue
+
+
+class ConversionLossItem(ClientValue):
+    count: int | None = None
+    detail: str | None = None
+    kind: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "Microsoft.SharePoint.SmartWikiLibrary.ConversionLossItem"

office365/sharepoint/lists/conversion_loss_report.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from dataclasses import field
+
+from office365.runtime.client_value import ClientValue
+from office365.runtime.client_value_collection import ClientValueCollection
+from office365.sharepoint.lists.conversion_loss_item import ConversionLossItem
+
+
+class ConversionLossReport(ClientValue):
+    isClean: bool | None = None
+    items: ClientValueCollection[ConversionLossItem] = field(
+        default_factory=lambda: ClientValueCollection(ConversionLossItem)
+    )
+
+    @property
+    def entity_type_name(self) -> str:
+        return "Microsoft.SharePoint.SmartWikiLibrary.ConversionLossReport"

office365/sharepoint/lists/extended_share_point_permission_settings.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from office365.sharepoint.entity import Entity
+
+
+class ExtendedSharePointPermissionSettings(Entity):
+    @property
+    def enabled(self) -> Optional[bool]:
+        """Gets the Enabled property"""
+        return self.properties.get("Enabled", None)
+
+    @property
+    def offline_days(self) -> Optional[int]:
+        """Gets the OfflineDays property"""
+        return self.properties.get("OfflineDays", None)

office365/sharepoint/lists/list.py

@@ -25,8 +25,10 @@ from office365.sharepoint.eventreceivers.definition_collection import (
     EventReceiverDefinitionCollection,
 )
 from office365.sharepoint.fields.collection import FieldCollection
+from office365.sharepoint.fields.creation_information import FieldCreationInformation
 from office365.sharepoint.fields.field import Field
 from office365.sharepoint.fields.related_field_collection import RelatedFieldCollection
+from office365.sharepoint.fields.type import FieldType
 from office365.sharepoint.files.checked_out_file_collection import (
     CheckedOutFileCollection,
 )
@@ -72,6 +74,7 @@ from office365.sharepoint.views.view import View
 from office365.sharepoint.webhooks.subscription_collection import SubscriptionCollection
 
 if TYPE_CHECKING:
+    from office365.runtime.operations import ProgressCallback
     from office365.sharepoint.client_context import ClientContext
     from office365.sharepoint.documentmanagement.document_set import DocumentSet
     from office365.sharepoint.webs.web import Web
@@ -133,13 +136,21 @@ class List(SecurableObject):
         self.ensure_property("Title").after_execute(lambda _: _can_customize_forms())
         return return_type
 
-    def clear(self):
-        """Clears the list."""
+    def clear(self) -> Self:
+        """Clears the list (deletes all items).
 
-        def _clear(items):
-            [item.delete_object() for item in items]
+        Loads only the item IDs (paged) and queues a delete per item, so large
+        lists are cleared in full. The deletions run on ``execute_batch``:
 
-        self.items.get().after_execute(_clear, execute_first=True)
+            >>> target_list.clear().execute_batch()
+        """
+
+        def _delete_all(items) -> None:
+            # snapshot: delete_object removes items from the collection while iterating
+            [item.delete_object() for item in list(items)]
+
+        items = self.items.select(["Id"]).get_all().execute_query()
+        _delete_all(items)
         return self
 
     def create_document_set(self, name: str) -> DocumentSet:
@@ -279,11 +290,11 @@ class List(SecurableObject):
 
         return_type = ConnectorResult(self.context)
 
-        def _loaded():
-            assert self.title is not None
-            FlowPermissions.get_flow_permission_level_on_list(self.context, self.title, return_type)
+        def _get_flow_permission_level(title: str | None):
+            assert title is not None
+            FlowPermissions.get_flow_permission_level_on_list(self.context, title, return_type)
 
-        self.ensure_property("Title").after_execute(lambda _: _loaded())
+        self.ensure_property("Title").after_execute(lambda _: _get_flow_permission_level(self.title))
         return return_type
 
     def get_sharing_settings(self) -> ObjectSharingSettings:
@@ -655,6 +666,72 @@ class List(SecurableObject):
         self.context.add_query(qry)
         return return_type
 
+    def ensure_field(self, name: str, field_type: FieldType = FieldType.Text, description: str | None = None) -> Self:
+        """Ensure a single column exists on the list, creating it if missing.
+
+        The check is deferred — the column is looked up and created when the
+        caller executes the query (e.g. ``list.ensure_field("Status").execute_query()``).
+
+        Args:
+            name: The column title
+            field_type: The field type to create it with if missing (Text by default)
+            description: The description of the column
+        """
+        self.fields.ensure(FieldCreationInformation(Title=name, FieldTypeKind=field_type, Description=description))
+        return self
+
+    def ensure_fields(self, columns: "Dict[str, FieldType] | list[str]") -> Self:
+        """Ensure the specified columns exist on the list, creating missing ones.
+
+        Reconciles the source schema with the target list before data import,
+        like migration tools do: existing fields are kept, missing ones are
+        created with the given type (Text by default).
+
+        The check is deferred — the fields are read and missing ones created
+        when the caller executes the query (e.g.
+        ``list.ensure_fields(...).execute_query()``).
+
+        Args:
+            columns: Either a list of field names (created as Text) or a mapping
+                of field name -> FieldType
+        """
+        spec = columns.items() if isinstance(columns, dict) else ((c, FieldType.Text) for c in columns)
+        for name, field_type in spec:
+            self.ensure_field(name, field_type)
+        return self
+
+    def from_dataframe(self, df, progress: "ProgressCallback | None" = None) -> Self:
+        """Import a pandas DataFrame into this list.
+
+        Defines a column per DataFrame column via ``fields.from_dataframe``
+        (type inferred from the dtype, created idempotently), then queues an
+        item create per row — fully deferred, run the whole import with
+        ``execute_query()``:
+
+            >>> lst = ctx.web.lists.ensure_list("My List").execute_query()
+            >>> lst.from_dataframe(df).execute_query()
+            >>> lst.from_dataframe(df, progress=my_callback).execute_query()
+
+        Column names are sanitized into SharePoint field internal names
+        (spaces/punctuation -> ``_``); NaN cells are skipped.
+
+        Args:
+            df: A pandas DataFrame (requires ``pip install
+                office365-rest-python-client[pandas]``).
+            progress: Optional hook invoked per row as its item create completes
+              during ``execute_query()``.
+
+        Returns:
+            Self: The list, for method chaining.
+        """
+        from office365.runtime.converters.dataframe import records_from_dataframe
+        from office365.sharepoint.fields.name import internal_field_name
+
+        records = records_from_dataframe(df, key_fn=internal_field_name)
+        self.fields.from_dataframe(df)
+        self.items.from_records(records, progress=progress)
+        return self
+
     def add_item(self, creation_information: Union[ListItemCreationInformation, Dict]) -> ListItem:
         """The recommended way to add a list item is to send a POST request to the ListItemCollection resource endpoint,
         as shown in ListItemCollection request examples."""
@@ -755,7 +832,7 @@ class List(SecurableObject):
         self.items.add_child(return_type)
 
         def _after_loaded(item):
-            [return_type.set_property(k, v, False) for k, v in item.properties.items()]
+            return_type.copy_from(item)
 
         def _get_item_by_url():
             assert self.root_folder.server_relative_url is not None
@@ -1185,7 +1262,7 @@ class List(SecurableObject):
     @property
     def fields(self) -> FieldCollection:
         """Gets a value that specifies the collection of all fields in the list."""
-        return self.properties.get(
+        return self.properties.setdefault(
             "Fields",
             FieldCollection(self.context, ResourcePath("Fields", self.resource_path), self),
         )
@@ -1312,31 +1389,29 @@ class List(SecurableObject):
 
     @odata(name="LastItemDeletedDate")
     @property
-    def last_item_deleted_date(self) -> datetime:
+    def last_item_deleted_date(self) -> Optional[datetime]:
         """
         Specifies the last time a list item was deleted from the list. It MUST return Created if no list item has
         been deleted from the list yet.
         """
-        return self.properties.get("LastItemDeletedDate", datetime.min)
+        return self.properties.get("LastItemDeletedDate", None)
 
     @odata(name="LastItemModifiedDate")
     @property
-    def last_item_modified_date(self) -> datetime:
+    def last_item_modified_date(self) -> Optional[datetime]:
         """
         Specifies the last time a list item, field, or property of the list was modified.
         It MUST return Created if the list has not been modified.
         """
-        return self.properties.get("LastItemModifiedDate", datetime.min)
+        return self.properties.get("LastItemModifiedDate", None)
 
     @odata(name="LastItemUserModifiedDate")
     @property
-    def last_item_user_modified_date(self) -> datetime:
+    def last_item_user_modified_date(self) -> Optional[datetime]:
         """
-        Specifies when an item of the list was last modified by a non-system update. A non-system update is a change
-        to a list item that is visible to end users. If no item has been created in the list, the list creation time
-        is returned.
+        Specifies the last time a list item was modified by a user.
         """
-        return self.properties.get("LastItemUserModifiedDate", datetime.min)
+        return self.properties.get("LastItemUserModifiedDate", None)
 
     @property
     def list_experience_options(self) -> Optional[int]:

office365/sharepoint/lists/list_forms_api.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from office365.sharepoint.entity import Entity
+
+
+class ListFormsAPI(Entity):
+    pass

office365/sharepoint/logger/activityrequest.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Optional
 
@@ -8,6 +10,7 @@ from office365.runtime.client_value import ClientValue
 class LogActivityRequest(ClientValue):
     LastAccessTime: Optional[str] = None
     ListItemUniqueId: Optional[str] = None
+    IsAdjusted: bool | None = None
 
     @property
     def entity_type_name(self):

office365/sharepoint/marketplace/corporatecuratedgallery/addins/permission_response.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from office365.runtime.client_value import ClientValue
 from office365.runtime.client_value_collection import ClientValueCollection
@@ -14,8 +14,12 @@ from office365.sharepoint.marketplace.corporatecuratedgallery.addins.permission_
 
 @dataclass
 class SPAddinPermissionResponse(ClientValue):
-    addinPermissions: ClientValueCollection[SPAddinPermissionInfo] | None = None
-    failedAddins: ClientValueCollection[SPAddinPermissionFailedInfo] | None = None
+    addinPermissions: ClientValueCollection[SPAddinPermissionInfo] = field(
+        default_factory=lambda: ClientValueCollection(SPAddinPermissionInfo)
+    )
+    failedAddins: ClientValueCollection[SPAddinPermissionFailedInfo] = field(
+        default_factory=lambda: ClientValueCollection(SPAddinPermissionFailedInfo)
+    )
 
     @property
     def entity_type_name(self):

office365/sharepoint/marketplace/corporatecuratedgallery/available_addins_response.py

@@ -14,7 +14,9 @@ from office365.sharepoint.marketplace.corporatecuratedgallery.sperrorwithserverr
 
 @dataclass
 class SPAvailableAddinsResponse(ClientValue):
-    addins: ClientValueCollection[SPAddinInstanceInfo] | None = None
+    addins: ClientValueCollection[SPAddinInstanceInfo] = field(
+        default_factory=lambda: ClientValueCollection(SPAddinInstanceInfo)
+    )
     errorsWithServerRelativeUrl: ClientValueCollection[SPErrorWithServerRelativeUrl] = field(
         default_factory=lambda: ClientValueCollection(SPErrorWithServerRelativeUrl)
     )

office365/sharepoint/marketplace/tenant/appcatalog/accessor.py

@@ -7,6 +7,7 @@ from office365.runtime.client_result import ClientResult
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.paths.service_operation import ServiceOperationPath
 from office365.runtime.queries.service_operation import ServiceOperationQuery
+from office365.runtime.types.odata_property import odata
 from office365.sharepoint.entity import Entity
 from office365.sharepoint.files.file import File
 from office365.sharepoint.marketplace.app_metadata import CorporateCatalogAppMetadata
@@ -121,6 +122,7 @@ class TenantCorporateCatalogAccessor(Entity):
         self.context.add_query(qry)
         return self
 
+    @odata(name="AvailableApps")
     @property
     def available_apps(self) -> CorporateCatalogAppMetadataCollection:
         """Returns the apps available in this corporate catalog."""
@@ -129,6 +131,7 @@ class TenantCorporateCatalogAccessor(Entity):
             CorporateCatalogAppMetadataCollection(self.context, ResourcePath("AvailableApps", self.resource_path)),
         )
 
+    @odata(name="CardDesigns")
     @property
     def card_designs(self) -> CardDesigns:
         """Returns the card designs available in this corporate catalog."""
@@ -137,6 +140,7 @@ class TenantCorporateCatalogAccessor(Entity):
             CardDesigns(self.context, ResourcePath("CardDesigns", self.resource_path)),
         )
 
+    @odata(name="SiteCollectionAppCatalogsSites")
     @property
     def site_collection_app_catalogs_sites(
         self,
@@ -154,13 +158,3 @@ class TenantCorporateCatalogAccessor(Entity):
     @property
     def entity_type_name(self):
         return "Microsoft.SharePoint.Marketplace.CorporateCuratedGallery.TenantCorporateCatalogAccessor"
-
-    def get_property(self, name, default_value=None):
-        if default_value is None:
-            property_mapping = {
-                "AvailableApps": self.available_apps,
-                "CardDesigns": self.card_designs,
-                "SiteCollectionAppCatalogsSites": self.site_collection_app_catalogs_sites,
-            }
-            default_value = property_mapping.get(name, None)
-        return super().get_property(name, default_value)