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

office365/sharepoint/lists/list.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 import os
+from collections.abc import Mapping, Sequence
 from datetime import datetime
-from typing import IO, TYPE_CHECKING, AnyStr, Callable, Dict, Optional, Union
+from typing import IO, TYPE_CHECKING, Any, AnyStr, Callable, Dict, Optional, Union, cast
+from uuid import UUID
 
 from typing_extensions import Self
 
@@ -10,7 +12,9 @@ from office365.runtime.client_result import ClientResult
 from office365.runtime.client_value_collection import ClientValueCollection
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.paths.service_operation import ServiceOperationPath
+from office365.runtime.queries.function import FunctionQuery
 from office365.runtime.queries.service_operation import ServiceOperationQuery
+from office365.runtime.types.collections import GuidCollection
 from office365.runtime.types.odata_property import odata
 from office365.sharepoint.changes.collection import ChangeCollection
 from office365.sharepoint.changes.log_item_query import ChangeLogItemQuery
@@ -21,6 +25,7 @@ from office365.sharepoint.contenttypes.collection import ContentTypeCollection
 from office365.sharepoint.customactions.element_collection import (
     CustomActionElementCollection,
 )
+from office365.sharepoint.entity_collection import EntityCollection
 from office365.sharepoint.eventreceivers.definition_collection import (
     EventReceiverDefinitionCollection,
 )
@@ -37,8 +42,12 @@ from office365.sharepoint.flows.connector_result import ConnectorResult
 from office365.sharepoint.flows.synchronization_result import FlowSynchronizationResult
 from office365.sharepoint.folders.folder import Folder
 from office365.sharepoint.forms.collection import FormCollection
+from office365.sharepoint.listitems.caml.guard import warn_if_unpaged
 from office365.sharepoint.listitems.caml.query import CamlQuery
 from office365.sharepoint.listitems.collection import ListItemCollection
+from office365.sharepoint.listitems.collection_position import (
+    ListItemCollectionPosition,
+)
 from office365.sharepoint.listitems.creation_information import (
     ListItemCreationInformation,
 )
@@ -65,6 +74,12 @@ from office365.sharepoint.permissions.securable_object import SecurableObject
 from office365.sharepoint.principal.users.user import User
 from office365.sharepoint.sharing.object_sharing_settings import ObjectSharingSettings
 from office365.sharepoint.sitescripts.utility import SiteScriptUtility
+from office365.sharepoint.thresholds import (
+    LIST_VIEW_THRESHOLD,
+    SAFE_PAGE_SIZE,
+    Limits,
+    limit,
+)
 from office365.sharepoint.translation.user_resource import UserResource
 from office365.sharepoint.types.resource_path import ResourcePath as SPResPath
 from office365.sharepoint.usercustomactions.collection import UserCustomActionCollection
@@ -74,10 +89,65 @@ from office365.sharepoint.views.view import View
 from office365.sharepoint.webhooks.subscription_collection import SubscriptionCollection
 
 if TYPE_CHECKING:
+    from office365.runtime.converters.dataframe import DataFrameResult
+    from office365.runtime.imports import (
+        CheckpointStore,
+        ImportCheckpoint,
+        ImportResult,
+    )
     from office365.runtime.operations import ProgressCallback
+    from office365.runtime.record_collection import VerificationResult
     from office365.sharepoint.client_context import ClientContext
     from office365.sharepoint.documentmanagement.document_set import DocumentSet
+    from office365.sharepoint.documents.contentassemblyfileinfo import (
+        ContentAssemblyFileInfo,
+    )
+    from office365.sharepoint.documents.contentassemblyformanswer import (
+        ContentAssemblyFormAnswer,
+    )
+    from office365.sharepoint.documents.contentassemblymoderntemplatecolumnsmappinginfo import (
+        ContentAssemblyModernTemplateColumnsMappingInfo,
+    )
+    from office365.sharepoint.documents.createhvcsitemapprovalrequestparameters import (
+        CreateHVCSItemApprovalRequestParameters,
+    )
+    from office365.sharepoint.documents.documentgenerationinfo import (
+        DocumentGenerationInfo,
+    )
+    from office365.sharepoint.documents.fieldvalueswithurl import FieldValuesWithUrl
+    from office365.sharepoint.documents.itemorderupdatevalue import ItemOrderUpdateValue
+    from office365.sharepoint.documents.lockfiledata import LockFileData
+    from office365.sharepoint.documents.placeholderv2 import PlaceholderV2
+    from office365.sharepoint.documents.publishmoderntemplatepayload import (
+        PublishModernTemplatePayload,
+    )
+    from office365.sharepoint.documents.publishsnippetpayload import (
+        PublishSnippetPayload,
+    )
+    from office365.sharepoint.documents.publishtemplatev2payload import (
+        PublishTemplateV2Payload,
+    )
+    from office365.sharepoint.documents.templatemetadata import TemplateMetaData
+    from office365.sharepoint.documents.updatetemplateinfo import UpdateTemplateInfo
+    from office365.sharepoint.documents.updatetemplateinfov2 import UpdateTemplateInfoV2
+    from office365.sharepoint.files.versionbatchdeleteparameters import (
+        FileVersionBatchDeleteParameters,
+    )
+    from office365.sharepoint.lists.extended_share_point_permission_settings import (
+        ExtendedSharePointPermissionSettings,
+    )
+    from office365.sharepoint.lists.listform import ListForm
+    from office365.sharepoint.lists.rules.action import SPRuleAction
+    from office365.sharepoint.lists.templatization_metadata import (
+        TemplatizationMetaData,
+    )
+    from office365.sharepoint.permissions.irm.settings import (
+        InformationRightsManagementSettings,
+    )
     from office365.sharepoint.webs.web import Web
+    from office365.sharepoint.workflow.associations.association import (
+        WorkflowAssociation,
+    )
 
 
 class List(SecurableObject):
@@ -95,7 +165,9 @@ class List(SecurableObject):
         """Create an alert on this list for the current user."""
 
         def _add_alert(url: str | None) -> None:
-            from office365.sharepoint.alerts.creation_information import AlertCreationInformation
+            from office365.sharepoint.alerts.creation_information import (
+                AlertCreationInformation,
+            )
 
             assert url is not None
             params = AlertCreationInformation(
@@ -117,10 +189,18 @@ class List(SecurableObject):
         include_content: bool = False,
         item_exported: Optional[Callable[[ExportListProgress], None]] = None,
     ) -> Self:
-        """Exports SharePoint List"""
+        """Export the list as a **package** (``.zip``): per-item JSON + optional content.
+
+        This is the package exporter (``ListExporter``), distinct from the record
+        export on :meth:`export_to`/``list.items.export_to``. Run with
+        ``execute_query()``:
+
+            >>> with open("Orders.zip", "wb") as f:
+            ...     lst.export(f, include_content=True).execute_query()
+        """
         from office365.sharepoint.lists.exporter import ListExporter
 
-        return ListExporter.export(self, local_file, include_content, item_exported)  # type: ignore[override]
+        return cast(Self, ListExporter.export(self, local_file, include_content, item_exported))
 
     def can_customize_forms(self) -> ConnectorResult:
         """"""
@@ -144,13 +224,7 @@ class List(SecurableObject):
 
             >>> 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)
+        self.items.select(["Id"]).get_all().execute_query().delete_all()
         return self
 
     def create_document_set(self, name: str) -> DocumentSet:
@@ -424,11 +498,17 @@ class List(SecurableObject):
         self.context.add_query(qry)
         return return_type
 
-    def recycle(self) -> ClientResult[str]:
-        """Moves the list to the Recycle Bin and returns the identifier of the new Recycle Bin item."""
+    def recycle(self, ignore_missing: bool = False) -> ClientResult[str]:
+        """Moves the list to the Recycle Bin and returns the identifier of the new Recycle Bin item.
+
+        Args:
+            ignore_missing (bool): When True, recycling a list that no longer
+                exists (HTTP 404) succeeds instead of raising.
+        """
         return_type = ClientResult[str](self.context)
         qry = ServiceOperationQuery(self, "Recycle", None, None, None, return_type)
         self.context.add_query(qry)
+        self._tolerate_missing(ignore_missing)
         return return_type
 
     def start_recycle(self) -> ClientResult[str]:
@@ -656,82 +736,464 @@ class List(SecurableObject):
     #    """Clears the broken taxonomy values"""
     #    raise NotImplementedError("validate_broken_taxonomy_values")
 
-    def get_items(self, caml_query: Optional[CamlQuery] = None) -> ListItemCollection:
-        """Returns a collection of items from the list based on the specified query."""
+    def index_candidates(self, caml_query: CamlQuery) -> list[str]:
+        """The columns a CAML query filters/sorts on that are worth indexing (``ID`` excluded).
+
+        A starting point for :meth:`ensure_indexed` — indexing is explicit and the
+        build runs in the background. Shorthand for ``caml_query.index_candidates``.
+        """
+        return caml_query.index_candidates
+
+    def check_query(self, caml_query: CamlQuery, *, item_count: Optional[int] = None) -> None:
+        """Pre-flight a CAML query against the SharePoint list view threshold.
+
+        Loads the list's item count (unless ``item_count`` is given) and the
+        ``Indexed`` status of the columns the query filters/sorts on, and raises
+        :class:`~office365.sharepoint.exceptions.SPQueryThrottledException` — with
+        the exact columns to index — when the query would be throttled, instead of
+        letting the server return an opaque 500. Performs 1-2 requests.
+
+        Args:
+            caml_query: The query to check.
+            item_count: The list size, when already known (avoids a request).
+        """
+        from office365.sharepoint.exceptions import SPQueryThrottledException
+
+        if item_count is None:
+            self.ensure_property("ItemCount").execute_query()
+            item_count = self.item_count or 0
+        if item_count <= LIST_VIEW_THRESHOLD:
+            return
+        candidates = set(caml_query.index_candidates)
+        if not candidates:
+            return
+
+        fields = self.fields
+        fields.select(["InternalName", "Title", "Indexed"]).get().execute_query()
+        not_indexed = sorted(
+            str(f.internal_name or f.title or "")
+            for f in fields
+            if (f.internal_name in candidates or f.title in candidates) and f.indexed is not True
+        )
+        if not_indexed:
+            names = ", ".join(repr(name) for name in not_indexed)
+            raise SPQueryThrottledException(
+                f"This CAML query filters/sorts on non-indexed column(s) {names} and the list has "
+                f"{item_count:,} items (over the {LIST_VIEW_THRESHOLD:,}-item list view threshold), so it "
+                f"would be throttled. Index them first, e.g. "
+                f"lst.ensure_indexed({not_indexed[0]!r}).execute_query(), or filter on ID (always indexed)."
+            )
+
+    @limit(Limits.LIST_VIEW, arg="page_size")
+    def get_items(
+        self,
+        caml_query: Optional[CamlQuery] = None,
+        page_size: Optional[int] = None,
+        check: bool = False,
+    ) -> ListItemCollection:
+        """Returns a collection of items from the list based on the specified query.
+
+        Pass ``page_size`` to page the results (continues from the last item via
+        ``ListItemCollectionPosition``), so a query over more than the 5,000-item
+        list view threshold can be read in full:
+
+            >>> for item in list.get_items(query, page_size=2000).execute_query():
+            ...     ...
+
+        Pass ``check=True`` to pre-flight the query with :meth:`check_query` first
+        (raises actionable guidance instead of an opaque server 500). It performs
+        1-2 requests immediately, so it is off by default.
+        """
         if not caml_query:
             caml_query = CamlQuery.create_all_items_query()
+        if check:
+            self.check_query(caml_query)
+        if page_size is None:
+            warn_if_unpaged(caml_query, item_count=self.item_count)
         return_type = ListItemCollection(self.context, self.items.resource_path)
         payload = {"query": caml_query}
         qry = ServiceOperationQuery(self, "GetItems", None, payload, None, return_type)
         self.context.add_query(qry)
+        if page_size:
+            return_type.paged(page_size)
+
+            def _next_page() -> None:
+                # CAML paging: continue from the last item via its collection position,
+                # carrying the sort columns (then ID) so the next page starts where
+                # the previous one stopped.
+                last = return_type[-1]
+                parts = ["Paged=TRUE"]
+                parts.extend(
+                    f"p_{name}={last.properties.get(name)}"
+                    for name in caml_query.order_by_fields
+                    if name.upper() != "ID"
+                )
+                parts.append(f"p_ID={last.id}")
+                caml_query.ListItemCollectionPosition = ListItemCollectionPosition(PagingInfo="&".join(parts))
+                next_qry = ServiceOperationQuery(self, "GetItems", None, {"query": caml_query}, None, return_type)
+                self.context.add_query(next_qry)
+
+            return_type._next_page = _next_page
         return return_type
 
-    def ensure_field(self, name: str, field_type: FieldType = FieldType.Text, description: str | None = None) -> Self:
+    def ensure_field(
+        self,
+        name: "str | FieldCreationInformation",
+        field_type: FieldType = FieldType.Text,
+        description: str | None = None,
+        *,
+        on_conflict: str = "skip",
+    ) -> Field:
         """Ensure a single column exists on the list, creating it if missing.
 
+        Pass a column ``name`` for a basic column — with an optional ``field_type``
+        and ``description`` — or a populated :class:`FieldCreationInformation` for
+        a rich one (``Choices`` for Choice/MultiChoice, ``Formula`` for Calculated,
+        ``Required``, ``LookupListId``/``LookupFieldName`` for Lookup, ...)::
+
+            lst.ensure_field("Status", FieldType.Choice)
+            lst.ensure_field(
+                FieldCreationInformation(Title="Status", FieldTypeKind=FieldType.Choice, Choices=["A", "B"])
+            )
+
         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()``).
+        With ``on_conflict="update"`` an existing column's type/description and rich
+        settings (choices, formula, required) are reconciled.
 
         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
+            name: The column title, or a ``FieldCreationInformation`` describing it.
+            field_type: The field type to create it with if missing (Text by default).
+            description: The description of the column.
+            on_conflict: ``"skip"`` (default) or ``"update"``.
+
+        Returns:
+            Field: The existing or newly created field.
         """
-        self.fields.ensure(FieldCreationInformation(Title=name, FieldTypeKind=field_type, Description=description))
-        return self
+        if isinstance(name, FieldCreationInformation):
+            info = name
+        else:
+            info = FieldCreationInformation(Title=name, FieldTypeKind=field_type, Description=description)
+        return self.fields.ensure(info, on_conflict=on_conflict)
 
-    def ensure_fields(self, columns: "Dict[str, FieldType] | list[str]") -> Self:
+    def ensure_fields(
+        self,
+        columns: "Mapping[str, FieldType] | Sequence[str | FieldCreationInformation]",
+        *,
+        on_conflict: str = "skip",
+    ) -> list[Field]:
         """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()``).
+        Reconciles the source schema with the target list before data import:
+        existing fields are kept (or reconciled with ``on_conflict="update"``),
+        missing ones are created (Text by default). Deferred — execute the query
+        after.
 
         Args:
-            columns: Either a list of field names (created as Text) or a mapping
-                of field name -> FieldType
+            columns: A mapping of field name -> :class:`FieldType` (basic columns),
+                or a sequence of names (created as Text) and/or
+                :class:`FieldCreationInformation` specs for rich columns
+                (choice/lookup/calculated/...).
+            on_conflict: ``"skip"`` (default) or ``"update"``.
+
+        Returns:
+            list[Field]: The existing or newly created fields.
         """
-        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
+        if isinstance(columns, Mapping):
+            return [self.ensure_field(name, field_type, on_conflict=on_conflict) for name, field_type in columns.items()]
+        return [self.ensure_field(column, on_conflict=on_conflict) for column in columns]
 
-    def from_dataframe(self, df, progress: "ProgressCallback | None" = None) -> Self:
-        """Import a pandas DataFrame into this list.
+    def ensure_indexed(self, name: str) -> Field:
+        """Enable the index on an existing column (idempotent, deferred).
 
-        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()``:
+        Indexing the columns used in a CAML/``$filter``/``$orderby`` lets queries
+        filter and sort past the 5,000-item list view threshold. The column must
+        already exist. Run 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()
+            >>> lst.ensure_indexed("Status").execute_query()
+        """
+        return self.fields.get_by_internal_name_or_title(name).ensure_indexed()
 
-        Column names are sanitized into SharePoint field internal names
-        (spaces/punctuation -> ``_``); NaN cells are skipped.
+    def from_records(
+        self,
+        source,
+        *,
+        format: str = "records",  # noqa: A002
+        schema: "Dict[str, FieldType] | None" = None,
+        chunksize: int = SAFE_PAGE_SIZE,
+        progress: "ProgressCallback | None" = None,
+        total: "int | None" = None,
+        checkpoint: "ImportCheckpoint | CheckpointStore | str | None" = None,
+        on_error: str = "raise",
+        key: "str | list[str] | None" = None,
+        key_field: str = "MigrationKey",
+        on_conflict: str = "skip",
+        enforce_unique: bool = False,
+        dry_run: bool = False,
+        on_schema_change: str = "evolve",
+        dead_letter: "str | None" = None,
+        mapping: "Dict[str, str] | None" = None,
+    ) -> "ImportResult":
+        """Stream a source into this list's items, memory-bounded (streaming entry).
+
+        Returns an :class:`~office365.runtime.imports.ImportResult`; run it with
+        ``execute_query()`` (sequential) or ``execute_batch(...)`` (batched):
+
+            >>> lst.from_dataframe(pd.read_csv(url, chunksize=2000)).execute_batch(concurrency=5)
+
+        Fields are provisioned from the first chunk (or ``schema``) for the
+        ``dataframe``/``csv`` formats; columns that first appear in a later chunk
+        are added (``on_schema_change="evolve"``, the default) or rejected
+        (``"fail"``). Column names are sanitized into field internal names; NaN
+        cells are skipped. ``checkpoint`` resumes; ``key`` makes it idempotent.
 
         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()``.
+            source: A DataFrame / chunk iterable / CSV path (``dataframe``/``csv``),
+                record batches (``records``), or a reader source for other formats.
+            format: Source format (default ``"records"``).
+            schema: Optional explicit ``{column: FieldType}``; inferred from dtypes.
+                A ``FieldType`` also drives typed value coercion (multi-choice,
+                lookup, user, URL, geolocation, ...).
+            chunksize: Rows per chunk for a DataFrame/CSV source.
+            progress: Optional hook fired live (initial, per chunk, per batch).
+            total: Total rows when known upfront (drives the progress percentage).
+            checkpoint: Optional resumable-run checkpoint (object or path).
+            on_error: ``"raise"`` (default) or ``"collect"``.
+            key: Natural-key source column(s) for idempotency; ``None`` disables it.
+            key_field: Target column storing the derived key hash.
+            on_conflict: ``"skip"`` (default) or ``"update"``.
+            enforce_unique: Mark the key column unique (guards a create race).
+            dry_run: Plan the create/update/skip counts without writing.
+            on_schema_change: ``"evolve"`` (default) or ``"fail"``.
+            mapping: Optional ``{source_column: target_name}`` rename map.
+            dead_letter: Optional JSONL path for collected chunk failures.
 
         Returns:
-            Self: The list, for method chaining.
+            ImportResult: The deferred streaming import driver.
+        """
+        from functools import partial
+
+        from office365.runtime.converters.dataframe import records_from_dataframe
+        from office365.sharepoint.fields.coercion import coerce_field_value
+        from office365.sharepoint.fields.name import internal_field_name
+
+        if on_schema_change not in ("evolve", "fail"):
+            raise ValueError(f"on_schema_change must be 'evolve' or 'fail', got {on_schema_change!r}")
+        provisioned: set[str] = set()
+        coercions: "Dict[str, Any] | None" = None
+        if isinstance(schema, dict):
+            coercions = {
+                internal_field_name(str(column)): partial(coerce_field_value, field_type)
+                for column, field_type in schema.items()
+            }
+
+        def _mapped(chunk: Any) -> Any:
+            if mapping and hasattr(chunk, "rename"):
+                return chunk.rename(columns=mapping)
+            return chunk
+
+        def _ensure_new_fields(chunk: Any) -> None:
+            chunk = _mapped(chunk)
+            if not hasattr(chunk, "columns"):  # only DataFrame/CSV chunks carry a schema
+                return
+            new = [c for c in chunk.columns if internal_field_name(str(c)) not in provisioned]
+            if not new:
+                return
+            if on_schema_change == "fail" and provisioned:
+                raise ValueError(f"source schema changed: new column(s) {new}")
+            self.fields.ensure_from_dataframe(chunk[new])
+            provisioned.update(internal_field_name(str(c)) for c in new)
+            self.context.execute_query()
+
+        def _prepare(first_chunk: Any) -> None:
+            if schema is not None:
+                self.ensure_fields(schema)
+                names = schema.keys() if isinstance(schema, dict) else schema
+                provisioned.update(internal_field_name(str(k)) for k in names)
+            else:
+                _ensure_new_fields(first_chunk)
+
+        def _to_records(chunk: Any) -> list[dict]:
+            return records_from_dataframe(_mapped(chunk), key_fn=internal_field_name)
+
+        to_records = _to_records if format in ("dataframe", "csv") else None
+
+        return self.items.from_records(
+            source,
+            format=format,
+            chunksize=chunksize,
+            total=total,
+            key=key,
+            key_field=key_field,
+            on_conflict=on_conflict,
+            enforce_unique=enforce_unique,
+            checkpoint=checkpoint,
+            on_error=on_error,
+            progress=progress,
+            prepare=_prepare,
+            before_chunk=_ensure_new_fields,
+            to_records=to_records,
+            dry_run=dry_run,
+            dead_letter=dead_letter,
+            mapping=mapping if to_records is None else None,
+            coerce=coercions,
+        )
+
+    def from_dataframe(self, source, **opts) -> "ImportResult":
+        """Stream a DataFrame / chunked CSV into this list (see :meth:`from_records`)."""
+        return self.from_records(source, format="dataframe", **opts)
+
+    def from_csv(self, source, **opts) -> "ImportResult":
+        """Stream a CSV source into this list (see :meth:`from_records`)."""
+        return self.from_records(source, format="csv", **opts)
+
+    def from_json(self, source, **opts) -> "ImportResult":
+        """Stream a JSON-array file into this list (see :meth:`from_records`)."""
+        return self.from_records(source, format="json", **opts)
+
+    def from_ndjson(self, source, **opts) -> "ImportResult":
+        """Stream an NDJSON source into this list (see :meth:`from_records`)."""
+        return self.from_records(source, format="ndjson", **opts)
+
+    def from_excel(self, source, **opts) -> "ImportResult":
+        """Stream an Excel (.xlsx) worksheet into this list (see :meth:`from_records`)."""
+        return self.from_records(source, format="excel", **opts)
+
+    def from_parquet(self, source, **opts) -> "ImportResult":
+        """Stream a Parquet file into this list (see :meth:`from_records`)."""
+        return self.from_records(source, format="parquet", **opts)
+
+    def from_orc(self, source, **opts) -> "ImportResult":
+        """Stream an ORC file into this list (see :meth:`from_records`)."""
+        return self.from_records(source, format="orc", **opts)
+
+    def from_feather(self, source, **opts) -> "ImportResult":
+        """Stream a Feather file into this list (see :meth:`from_records`)."""
+        return self.from_records(source, format="feather", **opts)
+
+    def from_file(
+        self,
+        server_relative_url: str,
+        *,
+        format: str = "csv",  # noqa: A002
+        chunksize: int = SAFE_PAGE_SIZE,
+        **opts,
+    ) -> "ImportResult":
+        """Stream a SharePoint-hosted file (CSV/XLSX) into this list's items.
+
+        Downloads the file from this site (honoring auth) and streams it through
+        :meth:`from_records` — bounded memory, resumable and idempotent with
+        ``key=...``. ``format`` is ``"csv"`` (default) or ``"xlsx"``/``"excel"``.
+
+            >>> lst.from_file("Shared Documents/stocks.csv", key=["Name", "date"]) \\
+            ...    .execute_batch(concurrency=5)
+        """
+        import io
+
+        file = self.context.web.get_file_by_server_relative_url(server_relative_url)
+        content = file.read()
+        if format in ("xlsx", "excel"):
+            from office365.runtime.converters.dataframe import require_pandas
+
+            df = require_pandas().read_excel(io.BytesIO(content))
+            return self.from_dataframe(df, chunksize=chunksize, **opts)
+        return self.from_csv(io.BytesIO(content), chunksize=chunksize, **opts)
+
+    def queue_dataframe(
+        self,
+        df,
+        schema: "Dict[str, FieldType] | None" = None,
+        progress: "ProgressCallback | None" = None,
+    ) -> Self:
+        """Queue a DataFrame into this list **deferred** (queue-all).
+
+        Provisions the columns (from the dtypes, or ``schema``) and queues an item
+        create per row; run with ``execute_query()``. For large frames use the
+        streaming :meth:`from_dataframe` (bounded memory + idempotency).
+        """
+        if schema is not None:
+            self.ensure_fields(schema)
+        else:
+            self.fields.ensure_from_dataframe(df)
+        self.items.queue_dataframe(df, progress=progress)
+        return self
+
+    def queue_records(self, records, progress: "ProgressCallback | None" = None) -> Self:
+        """Queue record dicts into this list's items (deferred)."""
+        self.items.queue_records(records, progress=progress)
+        return self
+
+    def verify(
+        self,
+        source,
+        *,
+        key: "str | list[str]",
+        format: str = "dataframe",  # noqa: A002
+        key_field: str = "MigrationKey",
+    ) -> "VerificationResult":
+        """Reconcile a source's natural keys against this list (bounded).
+
+        Streams the source, hashes each row's natural key and checks it against the
+        list's existing keys. ``format`` is ``"dataframe"`` (default), ``"csv"`` or
+        any registered format.
         """
         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)
+        def _to_records(chunk):
+            return records_from_dataframe(chunk, key_fn=internal_field_name)
+
+        to_records = _to_records if format in ("dataframe", "csv") else None
+        return self.items.verify(source, key=key, format=format, key_field=key_field, to_records=to_records)
+
+    def export_to(self, target, *, format: str = "csv", page_size=None, **opts) -> Self:  # noqa: A002
+        """Export this list's items to ``target`` in ``format`` (deferred).
+
+        The record exporter (CSV/NDJSON/JSON/Excel); pass ``page_size`` to stream
+        an appendable format page by page (bounded memory). For the ``.zip``
+        package export use :meth:`export`. Run with ``execute_query()``.
+        """
+        if page_size:
+            self.items.export_to(target, format=format, page_size=page_size, **opts)
+        else:
+            self.items.get_all().export_to(target, format=format, **opts)
+        return self
+
+    async def export_to_async(self, target, *, format: str = "csv", page_size=None, **opts) -> Self:  # noqa: A002
+        """Async twin of :meth:`export_to`.
+
+        The list's items are paged and written on the worker pool, so the event
+        loop stays free; pass ``page_size`` to stream an appendable format page by
+        page (bounded memory) or omit it to load and write the whole collection.
+
+            >>> await lst.export_to_async("items.csv", page_size=2000)
+        """
+        items = self.items
+        if page_size:
+            await items.export_to_async(target, format=format, page_size=page_size, **opts)
+        else:
+            # `List.items` builds a new collection per access, so keep one
+            # reference: load it, then export the loaded items.
+            await items.get_all_async()
+            await items.export_to_async(target, format=format, **opts)
         return self
 
+    def to_dataframe(self) -> "DataFrameResult":
+        """Export this list's items to a pandas DataFrame (deferred result)."""
+        return self.items.get_all().to_dataframe()
+
+    def to_parquet(self, target) -> Self:
+        """Export this list's items to Parquet (deferred; requires the ``[parquet]`` extra)."""
+        return self.export_to(target, format="parquet")
+
+    def to_orc(self, target) -> Self:
+        """Export this list's items to ORC (deferred; requires the ``[parquet]`` extra)."""
+        return self.export_to(target, format="orc")
+
+    def to_feather(self, target) -> Self:
+        """Export this list's items to Feather (deferred; requires the ``[parquet]`` extra)."""
+        return self.export_to(target, format="feather")
+
     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."""
@@ -1247,7 +1709,7 @@ class List(SecurableObject):
         """Get list items"""
         return self.properties.get(
             "Items",
-            ListItemCollection(self.context, ResourcePath("items", self.resource_path)),
+            ListItemCollection(self.context, ResourcePath("items", self.resource_path), parent=self),
         )
 
     @odata(name="RootFolder")
@@ -1586,3 +2048,1123 @@ class List(SecurableObject):
             if name == "Url":
                 self._resource_path = ServiceOperationPath("getList", [value], self.context.web.resource_path)
         return self
+
+    @property
+    def color(self) -> Optional[str]:
+        """Gets the Color property"""
+        return self.properties.get("Color", None)
+
+    @property
+    def default_new_form_url(self) -> Optional[str]:
+        """Gets the DefaultNewFormUrl property"""
+        return self.properties.get("DefaultNewFormUrl", None)
+
+    @property
+    def direction(self) -> Optional[str]:
+        """Gets the Direction property"""
+        return self.properties.get("Direction", None)
+
+    @property
+    def document_read_security(self) -> Optional[bool]:
+        """Gets the DocumentReadSecurity property"""
+        return self.properties.get("DocumentReadSecurity", None)
+
+    @property
+    def draft_version_visibility(self) -> Optional[int]:
+        """Gets the DraftVersionVisibility property"""
+        return self.properties.get("DraftVersionVisibility", None)
+
+    @property
+    def enabled_queryable_columns_datetime(self) -> Optional[datetime]:
+        """Gets the EnabledQueryableColumnsDateTime property"""
+        return self.properties.get("EnabledQueryableColumnsDateTime", datetime.min)
+
+    @property
+    def exclude_from_offline_mode(self) -> Optional[bool]:
+        """Gets the ExcludeFromOfflineMode property"""
+        return self.properties.get("ExcludeFromOfflineMode", None)
+
+    @property
+    def extended_sharepoint_permission_offline_days_for_library(self) -> Optional[int]:
+        """Gets the ExtendedSharePointPermissionOfflineDaysForLibrary property"""
+        return self.properties.get("ExtendedSharePointPermissionOfflineDaysForLibrary", None)
+
+    @property
+    def has_copy_move_rules(self) -> Optional[bool]:
+        """Gets the HasCopyMoveRules property"""
+        return self.properties.get("HasCopyMoveRules", None)
+
+    @property
+    def has_list_bound_content_assembly_templates(self) -> Optional[bool]:
+        """Gets the HasListBoundContentAssemblyTemplates property"""
+        return self.properties.get("HasListBoundContentAssemblyTemplates", None)
+
+    @property
+    def high_priority_media_processing(self) -> Optional[bool]:
+        """Gets the HighPriorityMediaProcessing property"""
+        return self.properties.get("HighPriorityMediaProcessing", None)
+
+    @property
+    def icon(self) -> Optional[str]:
+        """Gets the Icon property"""
+        return self.properties.get("Icon", None)
+
+    @property
+    def image_path(self) -> ResourcePath:
+        """Gets the ImagePath property"""
+        from office365.sharepoint.types.resource_path import ResourcePath
+
+        return self.properties.get("ImagePath", ResourcePath())
+
+    @property
+    def image_url(self) -> Optional[str]:
+        """Gets the ImageUrl property"""
+        return self.properties.get("ImageUrl", None)
+
+    @property
+    def default_sensitivity_label_for_library(self) -> Optional[str]:
+        """Gets the DefaultSensitivityLabelForLibrary property"""
+        return self.properties.get("DefaultSensitivityLabelForLibrary", None)
+
+    @property
+    def sensitivity_label_to_encrypt_on_download_for_library(self) -> Optional[str]:
+        """Gets the SensitivityLabelToEncryptOnDownloadForLibrary property"""
+        return self.properties.get("SensitivityLabelToEncryptOnDownloadForLibrary", None)
+
+    @property
+    def irm_reject(self) -> Optional[bool]:
+        """Gets the IrmReject property"""
+        return self.properties.get("IrmReject", None)
+
+    @property
+    def is_application_list(self) -> Optional[bool]:
+        """Gets the IsApplicationList property"""
+        return self.properties.get("IsApplicationList", None)
+
+    @property
+    def is_catalog(self) -> Optional[bool]:
+        """Gets the IsCatalog property"""
+        return self.properties.get("IsCatalog", None)
+
+    @property
+    def is_contributor_owner_enabled(self) -> Optional[bool]:
+        """Gets the IsContributorOwnerEnabled property"""
+        return self.properties.get("IsContributorOwnerEnabled", None)
+
+    @property
+    def is_default_document_library(self) -> Optional[bool]:
+        """Gets the IsDefaultDocumentLibrary property"""
+        return self.properties.get("IsDefaultDocumentLibrary", None)
+
+    @property
+    def is_enterprise_gallery_library(self) -> Optional[bool]:
+        """Gets the IsEnterpriseGalleryLibrary property"""
+        return self.properties.get("IsEnterpriseGalleryLibrary", None)
+
+    @property
+    def is_prediction_model_applied(self) -> Optional[bool]:
+        """Gets the IsPredictionModelApplied property"""
+        return self.properties.get("IsPredictionModelApplied", None)
+
+    @property
+    def multiple_data_list(self) -> Optional[bool]:
+        """Gets the MultipleDataList property"""
+        return self.properties.get("MultipleDataList", None)
+
+    @property
+    def show_one_tab_only(self) -> Optional[bool]:
+        """Gets the ShowOneTabOnly property"""
+        return self.properties.get("ShowOneTabOnly", None)
+
+    @property
+    def template_type_id(self) -> Optional[str]:
+        """Gets the TemplateTypeId property"""
+        return self.properties.get("TemplateTypeId", None)
+
+    @property
+    def validation_message(self) -> Optional[str]:
+        """Gets the ValidationMessage property"""
+        return self.properties.get("ValidationMessage", None)
+
+    @property
+    def write_security(self) -> Optional[int]:
+        """Gets the WriteSecurity property"""
+        return self.properties.get("WriteSecurity", None)
+
+    @property
+    def extended_sharepoint_permission_settings(self) -> ExtendedSharePointPermissionSettings:
+        """Gets the ExtendedSharePointPermissionSettings property"""
+        from office365.sharepoint.lists.extended_share_point_permission_settings import (
+            ExtendedSharePointPermissionSettings,
+        )
+
+        return self.properties.get(
+            "ExtendedSharePointPermissionSettings",
+            ExtendedSharePointPermissionSettings(
+                self.context, ResourcePath("ExtendedSharePointPermissionSettings", self.resource_path)
+            ),
+        )
+
+    @property
+    def information_rights_management_settings(self) -> InformationRightsManagementSettings:
+        """Gets the InformationRightsManagementSettings property"""
+        from office365.sharepoint.permissions.irm.settings import (
+            InformationRightsManagementSettings,
+        )
+
+        return self.properties.get(
+            "InformationRightsManagementSettings",
+            InformationRightsManagementSettings(
+                self.context, ResourcePath("InformationRightsManagementSettings", self.resource_path)
+            ),
+        )
+
+    @property
+    def workflow_associations(self) -> EntityCollection[WorkflowAssociation]:
+        """Gets the WorkflowAssociations property"""
+        from office365.sharepoint.workflow.associations.association import (
+            WorkflowAssociation,
+        )
+
+        return self.properties.get(
+            "WorkflowAssociations",
+            EntityCollection[WorkflowAssociation](
+                self.context, WorkflowAssociation, ResourcePath("WorkflowAssociations", self.resource_path)
+            ),
+        )
+
+    def add_validate_update_item_using_path(
+        self,
+        list_item_create_info: ListItemCreationInformationUsingPath,
+        form_values: ClientValueCollection[ListItemFormUpdateValue],
+        bnew_document_update: bool,
+        check_in_comment: str,
+        dates_in_utc: bool,
+        number_in_invariant_culture: bool,
+    ) -> ClientResult[ClientValueCollection[ListItemFormUpdateValue]]:
+        """AddValidateUpdateItemUsingPath operation.
+
+        Args:
+            list_item_create_info (ListItemCreationInformationUsingPath):
+                listItemCreateInfo parameter
+            form_values (ClientValueCollection[ListItemFormUpdateValue]):
+                formValues parameter
+            bnew_document_update (bool):
+                bNewDocumentUpdate parameter
+            check_in_comment (str):
+                checkInComment parameter
+            dates_in_utc (bool):
+                datesInUTC parameter
+            number_in_invariant_culture (bool):
+                numberInInvariantCulture parameter
+        """
+        from office365.sharepoint.listitems.form_update_value import (
+            ListItemFormUpdateValue,
+        )
+
+        return_type = ClientResult(self.context, ClientValueCollection[ListItemFormUpdateValue]())
+        qry = ServiceOperationQuery(
+            self,
+            "AddValidateUpdateItemUsingPath",
+            None,
+            {
+                "listItemCreateInfo": list_item_create_info,
+                "formValues": form_values,
+                "bNewDocumentUpdate": bnew_document_update,
+                "checkInComment": check_in_comment,
+                "datesInUTC": dates_in_utc,
+                "numberInInvariantCulture": number_in_invariant_culture,
+            },
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def caae_create_temp_folder(self) -> ClientResult[str]:
+        """CAAECreateTempFolder operation."""
+        return_type = ClientResult(self.context, str())
+        qry = ServiceOperationQuery(self, "CAAECreateTempFolder", None, {}, None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def caae_rename_file_in_temporary_folder(self, path: str, updated_name: str) -> ClientResult[str]:
+        """CAAERenameFileInTemporaryFolder operation.
+
+        Args:
+            path (str):
+                Path parameter
+            updated_name (str):
+                UpdatedName parameter
+        """
+        return_type = ClientResult(self.context, str())
+        qry = ServiceOperationQuery(
+            self, "CAAERenameFileInTemporaryFolder", None, {"Path": path, "UpdatedName": updated_name}, None, return_type
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def cancel_delete_file_versions(self) -> Self:
+        """CancelDeleteFileVersions operation."""
+        qry = ServiceOperationQuery(self, "CancelDeleteFileVersions", None, {}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def clear_business_app_migration_interactive_data(self) -> Self:
+        """ClearBusinessAppMigrationInteractiveData operation."""
+        qry = ServiceOperationQuery(self, "ClearBusinessAppMigrationInteractiveData", None, {}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def copy_template_and_get_metadata(self, id_: str) -> ClientResult[TemplatizationMetaData]:
+        """CopyTemplateAndGetMetadata operation.
+
+        Args:
+            id_ (str):
+                Id parameter
+        """
+        from office365.sharepoint.lists.templatization_metadata import (
+            TemplatizationMetaData,
+        )
+
+        return_type = ClientResult(self.context, TemplatizationMetaData())
+        qry = ServiceOperationQuery(self, "CopyTemplateAndGetMetadata", None, {"Id": id_}, None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def create_document_from_caae_template(
+        self, content_type_name: str, document_generation_info: DocumentGenerationInfo
+    ) -> ClientResult[ContentAssemblyFileInfo]:
+        """CreateDocumentFromCAAETemplate operation.
+
+        Args:
+            content_type_name (str):
+                ContentTypeName parameter
+            document_generation_info (DocumentGenerationInfo):
+                documentGenerationInfo parameter
+        """
+        from office365.sharepoint.documents.contentassemblyfileinfo import (
+            ContentAssemblyFileInfo,
+        )
+
+        return_type = ClientResult(self.context, ContentAssemblyFileInfo())
+        qry = ServiceOperationQuery(
+            self,
+            "CreateDocumentFromCAAETemplate",
+            None,
+            {"ContentTypeName": content_type_name, "documentGenerationInfo": document_generation_info},
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def create_document_from_caae_template_v2(
+        self, id_: str, document_generation_info: DocumentGenerationInfo
+    ) -> ClientResult[ContentAssemblyFileInfo]:
+        """CreateDocumentFromCAAETemplateV2 operation.
+
+        Args:
+            id_ (str):
+                Id parameter
+            document_generation_info (DocumentGenerationInfo):
+                documentGenerationInfo parameter
+        """
+        from office365.sharepoint.documents.contentassemblyfileinfo import (
+            ContentAssemblyFileInfo,
+        )
+
+        return_type = ClientResult(self.context, ContentAssemblyFileInfo())
+        qry = ServiceOperationQuery(
+            self,
+            "CreateDocumentFromCAAETemplateV2",
+            None,
+            {"Id": id_, "documentGenerationInfo": document_generation_info},
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def create_document_from_content_assembly_template(
+        self, template_url: str, document_generation_info: DocumentGenerationInfo
+    ) -> ClientResult[ContentAssemblyFileInfo]:
+        """CreateDocumentFromContentAssemblyTemplate operation.
+
+        Args:
+            template_url (str):
+                TemplateUrl parameter
+            document_generation_info (DocumentGenerationInfo):
+                documentGenerationInfo parameter
+        """
+        from office365.sharepoint.documents.contentassemblyfileinfo import (
+            ContentAssemblyFileInfo,
+        )
+
+        return_type = ClientResult(self.context, ContentAssemblyFileInfo())
+        qry = ServiceOperationQuery(
+            self,
+            "CreateDocumentFromContentAssemblyTemplate",
+            None,
+            {"TemplateUrl": template_url, "documentGenerationInfo": document_generation_info},
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def create_hvcs_item_approval_request(
+        self, create_item_request_payload: CreateHVCSItemApprovalRequestParameters
+    ) -> ClientResult[str]:
+        """CreateHVCSItemApprovalRequest operation.
+
+        Args:
+            create_item_request_payload (CreateHVCSItemApprovalRequestParameters):
+                createItemRequestPayload parameter
+        """
+        return_type = ClientResult(self.context, str())
+        qry = ServiceOperationQuery(
+            self,
+            "CreateHVCSItemApprovalRequest",
+            None,
+            {"createItemRequestPayload": create_item_request_payload},
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def create_list_form(self, parameters: ListForm) -> ClientResult[ListForm]:
+        """CreateListForm operation.
+
+        Args:
+            parameters (ListForm):
+                parameters parameter
+        """
+        from office365.sharepoint.lists.listform import ListForm
+
+        return_type = ClientResult(self.context, ListForm())
+        qry = ServiceOperationQuery(self, "CreateListForm", None, {"parameters": parameters}, None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def create_rule_ex(
+        self, condition: str, title: str, trigger_type: int, action: SPRuleAction, rule_template_id: str
+    ) -> ClientResult[UUID]:
+        """CreateRuleEx operation.
+
+        Args:
+            condition (str):
+                condition parameter
+            title (str):
+                title parameter
+            trigger_type (int):
+                triggerType parameter
+            action (SPRuleAction):
+                action parameter
+            rule_template_id (str):
+                ruleTemplateId parameter
+        """
+        return_type = ClientResult(self.context, UUID(int=0))
+        qry = ServiceOperationQuery(
+            self,
+            "CreateRuleEx",
+            None,
+            {
+                "condition": condition,
+                "title": title,
+                "triggerType": trigger_type,
+                "action": action,
+                "ruleTemplateId": rule_template_id,
+            },
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def enable_queryable_columns(self) -> Self:
+        """EnableQueryableColumns operation."""
+        qry = ServiceOperationQuery(self, "EnableQueryableColumns", None, {}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def get_async_action_task_ids(self) -> ClientResult[GuidCollection]:
+        """GetAsyncActionTaskIds operation."""
+        return_type = ClientResult(self.context, GuidCollection())
+        qry = ServiceOperationQuery(self, "GetAsyncActionTaskIds", None, {}, None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def get_business_app_migration_interactive_data(self) -> ClientResult[str]:
+        """GetBusinessAppMigrationInteractiveData operation."""
+        return_type = ClientResult(self.context, str())
+        qry = FunctionQuery(self, "GetBusinessAppMigrationInteractiveData", [], return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def get_caae_template_metadata(self, name: str, published: bool) -> ClientResult[TemplateMetaData]:
+        """GetCAAETemplateMetadata operation.
+
+        Args:
+            name (str):
+                Name parameter
+            published (bool):
+                Published parameter
+        """
+        from office365.sharepoint.documents.templatemetadata import TemplateMetaData
+
+        return_type = ClientResult(self.context, TemplateMetaData())
+        qry = FunctionQuery(self, "GetCAAETemplateMetadata", [name, published], return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def get_caae_template_metadata_v2(self, id_: str) -> ClientResult[ClientValueCollection[PlaceholderV2]]:
+        """GetCAAETemplateMetadataV2 operation.
+
+        Args:
+            id_ (str):
+                Id parameter
+        """
+        from office365.sharepoint.documents.placeholderv2 import PlaceholderV2
+
+        return_type = ClientResult(self.context, ClientValueCollection[PlaceholderV2]())
+        qry = FunctionQuery(self, "GetCAAETemplateMetadataV2", [id_], return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def get_content_assembly_document_field_values(self, document_url: str) -> ClientResult[FieldValuesWithUrl]:
+        """GetContentAssemblyDocumentFieldValues operation.
+
+        Args:
+            document_url (str):
+                DocumentUrl parameter
+        """
+        from office365.sharepoint.documents.fieldvalueswithurl import FieldValuesWithUrl
+
+        return_type = ClientResult(self.context, FieldValuesWithUrl())
+        qry = FunctionQuery(self, "GetContentAssemblyDocumentFieldValues", [document_url], return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def get_content_assembly_template_fields(
+        self, template_url: str
+    ) -> ClientResult[ClientValueCollection[PlaceholderV2]]:
+        """GetContentAssemblyTemplateFields operation.
+
+        Args:
+            template_url (str):
+                TemplateUrl parameter
+        """
+        from office365.sharepoint.documents.placeholderv2 import PlaceholderV2
+
+        return_type = ClientResult(self.context, ClientValueCollection[PlaceholderV2]())
+        qry = FunctionQuery(self, "GetContentAssemblyTemplateFields", [template_url], return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def get_list_forms(self, bsanitize: bool) -> ClientResult[ClientValueCollection[ListForm]]:
+        """GetListForms operation.
+
+        Args:
+            bsanitize (bool):
+                bSanitize parameter
+        """
+        from office365.sharepoint.lists.listform import ListForm
+
+        return_type = ClientResult(self.context, ClientValueCollection[ListForm]())
+        qry = FunctionQuery(self, "GetListForms", [bsanitize], return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def get_progress_for_delete_file_versions(self) -> ClientResult[str]:
+        """GetProgressForDeleteFileVersions operation."""
+        return_type = ClientResult(self.context, str())
+        qry = ServiceOperationQuery(self, "GetProgressForDeleteFileVersions", None, {}, None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def get_progress_for_file_version_expiration_report(self, report_file_url: str) -> ClientResult[str]:
+        """GetProgressForFileVersionExpirationReport operation.
+
+        Args:
+            report_file_url (str):
+                reportFileUrl parameter
+        """
+        return_type = ClientResult(self.context, str())
+        qry = ServiceOperationQuery(
+            self,
+            "GetProgressForFileVersionExpirationReport",
+            None,
+            {"reportFileUrl": report_file_url},
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def is_syntex_ai_features_flight_enabled(self) -> ClientResult[bool]:
+        """IsSyntexAIFeaturesFlightEnabled operation."""
+        return_type = ClientResult(self.context, bool())
+        qry = FunctionQuery(self, "IsSyntexAIFeaturesFlightEnabled", [], return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def lock_smart_template(self, id_: str) -> ClientResult[LockFileData]:
+        """LockSmartTemplate operation.
+
+        Args:
+            id_ (str):
+                Id parameter
+        """
+        from office365.sharepoint.documents.lockfiledata import LockFileData
+
+        return_type = ClientResult(self.context, LockFileData())
+        qry = ServiceOperationQuery(self, "LockSmartTemplate", None, {"Id": id_}, None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def map_fields_to_columns_for_modern_temlate(
+        self, payload: PublishModernTemplatePayload
+    ) -> ClientResult[ContentAssemblyModernTemplateColumnsMappingInfo]:
+        """MapFieldsToColumnsForModernTemlate operation.
+
+        Args:
+            payload (PublishModernTemplatePayload):
+                payload parameter
+        """
+        from office365.sharepoint.documents.contentassemblymoderntemplatecolumnsmappinginfo import (
+            ContentAssemblyModernTemplateColumnsMappingInfo,
+        )
+
+        return_type = ClientResult(self.context, ContentAssemblyModernTemplateColumnsMappingInfo())
+        qry = ServiceOperationQuery(
+            self, "MapFieldsToColumnsForModernTemlate", None, {"payload": payload}, None, return_type
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def map_fields_to_columns_for_modern_template(
+        self, template_payload: PublishModernTemplatePayload
+    ) -> ClientResult[ContentAssemblyModernTemplateColumnsMappingInfo]:
+        """MapFieldsToColumnsForModernTemplate operation.
+
+        Args:
+            template_payload (PublishModernTemplatePayload):
+                templatePayload parameter
+        """
+        from office365.sharepoint.documents.contentassemblymoderntemplatecolumnsmappinginfo import (
+            ContentAssemblyModernTemplateColumnsMappingInfo,
+        )
+
+        return_type = ClientResult(self.context, ContentAssemblyModernTemplateColumnsMappingInfo())
+        qry = ServiceOperationQuery(
+            self, "MapFieldsToColumnsForModernTemplate", None, {"templatePayload": template_payload}, None, return_type
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def parse_document_template(self, name: str) -> ClientResult[str]:
+        """ParseDocumentTemplate operation.
+
+        Args:
+            name (str):
+                Name parameter
+        """
+        return_type = ClientResult(self.context, str())
+        qry = ServiceOperationQuery(self, "ParseDocumentTemplate", None, {"Name": name}, None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def publish_snippet(self, publish_snippet_payload: PublishSnippetPayload) -> Self:
+        """PublishSnippet operation.
+
+        Args:
+            publish_snippet_payload (PublishSnippetPayload):
+                publishSnippetPayload parameter
+        """
+        qry = ServiceOperationQuery(
+            self, "PublishSnippet", None, {"publishSnippetPayload": publish_snippet_payload}, None, None
+        )
+        self.context.add_query(qry)
+        return self
+
+    def publish_template_v2(self, payload: PublishTemplateV2Payload) -> Self:
+        """PublishTemplateV2 operation.
+
+        Args:
+            payload (PublishTemplateV2Payload):
+                payload parameter
+        """
+        qry = ServiceOperationQuery(self, "PublishTemplateV2", None, {"payload": payload}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def refresh_lock_smart_template(self, id_: str, lock_id: str) -> ClientResult[LockFileData]:
+        """RefreshLockSmartTemplate operation.
+
+        Args:
+            id_ (str):
+                Id parameter
+            lock_id (str):
+                LockId parameter
+        """
+        from office365.sharepoint.documents.lockfiledata import LockFileData
+
+        return_type = ClientResult(self.context, LockFileData())
+        qry = ServiceOperationQuery(
+            self, "RefreshLockSmartTemplate", None, {"Id": id_, "LockId": lock_id}, None, return_type
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def render_extended_list_form_data(
+        self, item_id: int, form_id: str, mode: int, options: int, cutoff_version: int
+    ) -> ClientResult[str]:
+        """RenderExtendedListFormData operation.
+
+        Args:
+            item_id (int):
+                itemId parameter
+            form_id (str):
+                formId parameter
+            mode (int):
+                mode parameter
+            options (int):
+                options parameter
+            cutoff_version (int):
+                cutoffVersion parameter
+        """
+        return_type = ClientResult(self.context, str())
+        qry = ServiceOperationQuery(
+            self,
+            "RenderExtendedListFormData",
+            None,
+            {"itemId": item_id, "formId": form_id, "mode": mode, "options": options, "cutoffVersion": cutoff_version},
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def render_list_context_menu_data(
+        self,
+        casc_del_warn_message: str,
+        custom_action: str,
+        field: str,
+        id_: str,
+        inplace_full_list_search: str,
+        inplace_search_query: str,
+        is_csr: str,
+        is_xsl_view: str,
+        item_id: str,
+        list_view_page_url: str,
+        override_scope: str,
+        root_folder: str,
+        view: str,
+        view_count: str,
+    ) -> ClientResult[bytes]:
+        """RenderListContextMenuData operation.
+
+        Args:
+            casc_del_warn_message (str):
+                CascDelWarnMessage parameter
+            custom_action (str):
+                CustomAction parameter
+            field (str):
+                Field parameter
+            id_ (str):
+                ID parameter
+            inplace_full_list_search (str):
+                InplaceFullListSearch parameter
+            inplace_search_query (str):
+                InplaceSearchQuery parameter
+            is_csr (str):
+                IsCSR parameter
+            is_xsl_view (str):
+                IsXslView parameter
+            item_id (str):
+                ItemId parameter
+            list_view_page_url (str):
+                ListViewPageUrl parameter
+            override_scope (str):
+                OverrideScope parameter
+            root_folder (str):
+                RootFolder parameter
+            view (str):
+                View parameter
+            view_count (str):
+                ViewCount parameter
+        """
+        return_type = ClientResult(self.context, bytes())
+        qry = ServiceOperationQuery(
+            self,
+            "RenderListContextMenuData",
+            None,
+            {
+                "CascDelWarnMessage": casc_del_warn_message,
+                "CustomAction": custom_action,
+                "Field": field,
+                "ID": id_,
+                "InplaceFullListSearch": inplace_full_list_search,
+                "InplaceSearchQuery": inplace_search_query,
+                "IsCSR": is_csr,
+                "IsXslView": is_xsl_view,
+                "ItemId": item_id,
+                "ListViewPageUrl": list_view_page_url,
+                "OverrideScope": override_scope,
+                "RootFolder": root_folder,
+                "View": view,
+                "ViewCount": view_count,
+            },
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def render_list_filter_data(
+        self,
+        exclude_field_filtering_html: bool,
+        field_internal_name: str,
+        override_scope: str,
+        process_q_string_to_caml: str,
+        view_id: str,
+        view_xml: str,
+    ) -> ClientResult[bytes]:
+        """RenderListFilterData operation.
+
+        Args:
+            exclude_field_filtering_html (bool):
+                ExcludeFieldFilteringHtml parameter
+            field_internal_name (str):
+                FieldInternalName parameter
+            override_scope (str):
+                OverrideScope parameter
+            process_q_string_to_caml (str):
+                ProcessQStringToCAML parameter
+            view_id (str):
+                ViewId parameter
+            view_xml (str):
+                ViewXml parameter
+        """
+        return_type = ClientResult(self.context, bytes())
+        qry = ServiceOperationQuery(
+            self,
+            "RenderListFilterData",
+            None,
+            {
+                "ExcludeFieldFilteringHtml": exclude_field_filtering_html,
+                "FieldInternalName": field_internal_name,
+                "OverrideScope": override_scope,
+                "ProcessQStringToCAML": process_q_string_to_caml,
+                "ViewId": view_id,
+                "ViewXml": view_xml,
+            },
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def render_list_form_data(self, item_id: int, form_id: str, mode: int) -> ClientResult[str]:
+        """RenderListFormData operation.
+
+        Args:
+            item_id (int):
+                itemId parameter
+            form_id (str):
+                formId parameter
+            mode (int):
+                mode parameter
+        """
+        return_type = ClientResult(self.context, str())
+        qry = ServiceOperationQuery(
+            self, "RenderListFormData", None, {"itemId": item_id, "formId": form_id, "mode": mode}, None, return_type
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def set_column_mapping(self, column_mapping: str) -> Self:
+        """SetColumnMapping operation.
+
+        Args:
+            column_mapping (str):
+                columnMapping parameter
+        """
+        qry = ServiceOperationQuery(self, "SetColumnMapping", None, {"columnMapping": column_mapping}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def set_content_assembly_template_read_only(self, id_: str) -> Self:
+        """SetContentAssemblyTemplateReadOnly operation.
+
+        Args:
+            id_ (str):
+                Id parameter
+        """
+        qry = ServiceOperationQuery(self, "SetContentAssemblyTemplateReadOnly", None, {"Id": id_}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def set_items_order(
+        self, item_ids: list[int], lower_order_item_id: int, higher_order_item_id: int, use_provided_order_item_id: bool
+    ) -> ClientResult[ClientValueCollection[ItemOrderUpdateValue]]:
+        """SetItemsOrder operation.
+
+        Args:
+            item_ids (list[int]):
+                itemIds parameter
+            lower_order_item_id (int):
+                lowerOrderItemId parameter
+            higher_order_item_id (int):
+                higherOrderItemId parameter
+            use_provided_order_item_id (bool):
+                useProvidedOrderItemId parameter
+        """
+        from office365.sharepoint.documents.itemorderupdatevalue import (
+            ItemOrderUpdateValue,
+        )
+
+        return_type = ClientResult(self.context, ClientValueCollection[ItemOrderUpdateValue]())
+        qry = ServiceOperationQuery(
+            self,
+            "SetItemsOrder",
+            None,
+            {
+                "itemIds": ClientValueCollection(int, item_ids),
+                "lowerOrderItemId": lower_order_item_id,
+                "higherOrderItemId": higher_order_item_id,
+                "useProvidedOrderItemId": use_provided_order_item_id,
+            },
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def set_list_custom_order_flag(self, value: bool) -> Self:
+        """SetListCustomOrderFlag operation.
+
+        Args:
+            value (bool):
+                value parameter
+        """
+        qry = ServiceOperationQuery(self, "SetListCustomOrderFlag", None, {"value": value}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def set_quickstep_ordering(self, quickstep_ids: str) -> Self:
+        """SetQuickstepOrdering operation.
+
+        Args:
+            quickstep_ids (str):
+                quickstepIds parameter
+        """
+        qry = ServiceOperationQuery(self, "SetQuickstepOrdering", None, {"quickstepIds": quickstep_ids}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def start_delete_file_versions(self, delete_older_than_days: int) -> Self:
+        """StartDeleteFileVersions operation.
+
+        Args:
+            delete_older_than_days (int):
+                deleteOlderThanDays parameter
+        """
+        qry = ServiceOperationQuery(
+            self, "StartDeleteFileVersions", None, {"deleteOlderThanDays": delete_older_than_days}, None, None
+        )
+        self.context.add_query(qry)
+        return self
+
+    def start_delete_file_versions_by_mode(self, batch_delete_parameters: FileVersionBatchDeleteParameters) -> Self:
+        """StartDeleteFileVersionsByMode operation.
+
+        Args:
+            batch_delete_parameters (FileVersionBatchDeleteParameters):
+                batchDeleteParameters parameter
+        """
+        qry = ServiceOperationQuery(
+            self, "StartDeleteFileVersionsByMode", None, {"batchDeleteParameters": batch_delete_parameters}, None, None
+        )
+        self.context.add_query(qry)
+        return self
+
+    def start_file_version_expiration_report(self, report_file_url: str) -> Self:
+        """StartFileVersionExpirationReport operation.
+
+        Args:
+            report_file_url (str):
+                reportFileUrl parameter
+        """
+        qry = ServiceOperationQuery(
+            self, "StartFileVersionExpirationReport", None, {"reportFileUrl": report_file_url}, None, None
+        )
+        self.context.add_query(qry)
+        return self
+
+    def unlock_smart_template(self, id_: str, lock_id: str) -> Self:
+        """UnlockSmartTemplate operation.
+
+        Args:
+            id_ (str):
+                Id parameter
+            lock_id (str):
+                LockId parameter
+        """
+        qry = ServiceOperationQuery(self, "UnlockSmartTemplate", None, {"Id": id_, "LockId": lock_id}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def unset_content_assembly_template_read_only(self, id_: str) -> Self:
+        """UnsetContentAssemblyTemplateReadOnly operation.
+
+        Args:
+            id_ (str):
+                Id parameter
+        """
+        qry = ServiceOperationQuery(self, "UnsetContentAssemblyTemplateReadOnly", None, {"Id": id_}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def update_caae_template(self, name: str, update_template_info: UpdateTemplateInfo) -> Self:
+        """UpdateCAAETemplate operation.
+
+        Args:
+            name (str):
+                Name parameter
+            update_template_info (UpdateTemplateInfo):
+                updateTemplateInfo parameter
+        """
+        qry = ServiceOperationQuery(
+            self, "UpdateCAAETemplate", None, {"Name": name, "updateTemplateInfo": update_template_info}, None, None
+        )
+        self.context.add_query(qry)
+        return self
+
+    def update_caae_template_v2(self, id_: str, update_template_info: UpdateTemplateInfoV2) -> Self:
+        """UpdateCAAETemplateV2 operation.
+
+        Args:
+            id_ (str):
+                Id parameter
+            update_template_info (UpdateTemplateInfoV2):
+                updateTemplateInfo parameter
+        """
+        qry = ServiceOperationQuery(
+            self, "UpdateCAAETemplateV2", None, {"Id": id_, "updateTemplateInfo": update_template_info}, None, None
+        )
+        self.context.add_query(qry)
+        return self
+
+    def update_content_assembly_document(
+        self, template_url: str, content_assembly_form_answers: ClientValueCollection[ContentAssemblyFormAnswer]
+    ) -> ClientResult[ContentAssemblyFileInfo]:
+        """UpdateContentAssemblyDocument operation.
+
+        Args:
+            template_url (str):
+                TemplateUrl parameter
+            content_assembly_form_answers (ClientValueCollection[ContentAssemblyFormAnswer]):
+                contentAssemblyFormAnswers parameter
+        """
+        from office365.sharepoint.documents.contentassemblyfileinfo import (
+            ContentAssemblyFileInfo,
+        )
+
+        return_type = ClientResult(self.context, ContentAssemblyFileInfo())
+        qry = ServiceOperationQuery(
+            self,
+            "UpdateContentAssemblyDocument",
+            None,
+            {"TemplateUrl": template_url, "contentAssemblyFormAnswers": content_assembly_form_answers},
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def update_form_processing_model_retention_label(self, retention_label: str) -> Self:
+        """UpdateFormProcessingModelRetentionLabel operation.
+
+        Args:
+            retention_label (str):
+                retentionLabel parameter
+        """
+        qry = ServiceOperationQuery(
+            self, "UpdateFormProcessingModelRetentionLabel", None, {"retentionLabel": retention_label}, None, None
+        )
+        self.context.add_query(qry)
+        return self
+
+    def update_form_processing_model_settings(self, retention_label: str, linked_list: str) -> Self:
+        """UpdateFormProcessingModelSettings operation.
+
+        Args:
+            retention_label (str):
+                retentionLabel parameter
+            linked_list (str):
+                linkedList parameter
+        """
+        qry = ServiceOperationQuery(
+            self,
+            "UpdateFormProcessingModelSettings",
+            None,
+            {"retentionLabel": retention_label, "linkedList": linked_list},
+            None,
+            None,
+        )
+        self.context.add_query(qry)
+        return self
+
+    def update_list_form(self, parameters: ListForm) -> ClientResult[ListForm]:
+        """UpdateListForm operation.
+
+        Args:
+            parameters (ListForm):
+                parameters parameter
+        """
+        from office365.sharepoint.lists.listform import ListForm
+
+        return_type = ClientResult(self.context, ListForm())
+        qry = ServiceOperationQuery(self, "UpdateListForm", None, {"parameters": parameters}, None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def update_rule_ex(
+        self, rule_id: str, condition: str, title: str, status: int, action: SPRuleAction, trigger_type: int
+    ) -> Self:
+        """UpdateRuleEx operation.
+
+        Args:
+            rule_id (str):
+                ruleId parameter
+            condition (str):
+                condition parameter
+            title (str):
+                title parameter
+            status (int):
+                status parameter
+            action (SPRuleAction):
+                action parameter
+            trigger_type (int):
+                triggerType parameter
+        """
+        qry = ServiceOperationQuery(
+            self,
+            "UpdateRuleEx",
+            None,
+            {
+                "ruleId": rule_id,
+                "condition": condition,
+                "title": title,
+                "status": status,
+                "action": action,
+                "triggerType": trigger_type,
+            },
+            None,
+            None,
+        )
+        self.context.add_query(qry)
+        return self