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

office365/sharepoint/listitems/caml/query.py

@@ -1,14 +1,22 @@
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Iterator, Tuple
 
 from office365.runtime.client_value import ClientValue
+from office365.sharepoint.fields.builtin_field_name import SPBuiltInFieldName
 from office365.sharepoint.listitems.collection_position import (
     ListItemCollectionPosition,
 )
 from office365.sharepoint.types.resource_path import ResourcePath
 from office365.sharepoint.views.scope import ViewScope
 
+if TYPE_CHECKING:
+    from office365.sharepoint.listitems.caml.builder import QueryBuilder
+
+_FIELD_REF_RE = re.compile(r"<FieldRef\s+Name=['\"]([^'\"]+)['\"]", re.IGNORECASE)
+
 
 @dataclass
 class CamlQuery(ClientValue):
@@ -31,6 +39,23 @@ class CamlQuery(ClientValue):
     AllowIncrementalResults: bool = True
     FolderServerRelativePath: ResourcePath | None = None
 
+    def __post_init__(self) -> None:
+        # The expression AST (set by QueryBuilder.build()); not serialized.
+        self._expr: "QueryBuilder | None" = None
+
+    @staticmethod
+    def builder() -> "QueryBuilder":
+        """A fluent builder for this query (``ViewFields``/``Where``/``OrderBy``/...)."""
+        from office365.sharepoint.listitems.caml.builder import QueryBuilder
+
+        return QueryBuilder()
+
+    def __iter__(self) -> Iterator[Tuple[str, Any]]:
+        """Yield serializable properties (skips private attrs such as the AST)."""
+        for name, value in vars(self).items():
+            if not name.startswith("_"):
+                yield name, value
+
     @staticmethod
     def parse(query_expr: str, scope: ViewScope = ViewScope.DefaultValue) -> CamlQuery:
         """Creates a CamlQuery object from a query expression
@@ -51,15 +76,59 @@ class CamlQuery(ClientValue):
     @staticmethod
     def create_all_folders_query() -> CamlQuery:
         """Constructs a query to return folder objects"""
-        qry_text = '<Where><Eq><FieldRef Name="FSObjType" /><Value Type="Integer">1</Value></Eq></Where>'
+        qry_text = (
+            f'<Where><Eq><FieldRef Name="{SPBuiltInFieldName.FSObjType}" /><Value Type="Integer">1</Value></Eq></Where>'
+        )
         return CamlQuery.parse(qry_text, ViewScope.DefaultValue)
 
     @staticmethod
     def create_all_files_query() -> CamlQuery:
         """Constructs a query to return file objects"""
-        qry_text = '<Where><Eq><FieldRef Name="FSObjType" /><Value Type="Integer">0</Value></Eq></Where>'
+        qry_text = (
+            f'<Where><Eq><FieldRef Name="{SPBuiltInFieldName.FSObjType}" /><Value Type="Integer">0</Value></Eq></Where>'
+        )
         return CamlQuery.parse(qry_text, ViewScope.DefaultValue)
 
+    @property
+    def is_paged(self) -> bool:
+        """Whether the query uses server-driven paging (``RowLimit Paged='TRUE'``)."""
+        if self._expr is not None:
+            return self._expr.is_paged
+        xml = self.ViewXml or ""
+        return "Paged='TRUE'" in xml or 'Paged="TRUE"' in xml
+
+    @property
+    def order_by_fields(self) -> list[str]:
+        """The field names in ``<OrderBy>``, in order (empty when unsorted).
+
+        Used to build the ``ListItemCollectionPosition`` paging token so a
+        multi-page CAML query continues where the previous page stopped.
+        """
+        if self._expr is not None:
+            return [ref.name for ref in self._expr._order_by]
+        match = re.search(r"<OrderBy>(.*?)</OrderBy>", self.ViewXml or "", re.DOTALL | re.IGNORECASE)
+        return _FIELD_REF_RE.findall(match.group(1)) if match else []
+
+    @property
+    def field_refs(self) -> set[str]:
+        """The field names referenced by the query.
+
+        Uses the expression AST when the query was produced by the builder, else
+        falls back to scanning the raw ``ViewXml``.
+        """
+        if self._expr is not None:
+            return self._expr.field_refs
+        return {match.group(1) for match in _FIELD_REF_RE.finditer(self.ViewXml or "")}
+
+    @property
+    def index_candidates(self) -> list[str]:
+        """Fields the query filters/sorts on that are worth indexing (``ID`` excluded).
+
+        Feed these to :meth:`~office365.sharepoint.lists.list.List.ensure_indexed`
+        so a large-list query on them is not throttled by the list view threshold.
+        """
+        return sorted(self.field_refs - {"ID"})
+
     def __repr__(self):
         return self.ViewXml or ""
 

office365/sharepoint/listitems/caml/values.py

@@ -0,0 +1,113 @@
+"""Typed CAML ``<Value>`` nodes.
+
+A :class:`Value` renders a ``<Value Type='...'>...</Value>`` element, inferring
+the OData value type from the Python value (``str`` -> ``Text``, ``int`` ->
+``Integer``, ``bool`` -> ``Boolean``, ``datetime`` -> ``DateTime``) unless an
+explicit type is given. Special values (``Now``/``Today``/``Month``/``UserID``/
+``ListProperty``) render a child element instead of literal text.
+"""
+
+from __future__ import annotations
+
+from datetime import date, datetime
+from enum import Enum
+from typing import Any, Optional
+from xml.sax.saxutils import escape, quoteattr
+
+
+class ValueType(str, Enum):
+    """The ``Type`` attribute of a CAML ``<Value>`` element."""
+
+    Text = "Text"
+    Note = "Note"
+    Integer = "Integer"
+    Counter = "Counter"
+    Number = "Number"
+    Currency = "Currency"
+    DateTime = "DateTime"
+    Boolean = "Boolean"
+    Lookup = "Lookup"
+    User = "User"
+    Choice = "Choice"
+    URL = "URL"
+    Guid = "Guid"
+    Calculated = "Calculated"
+
+
+def infer_value_type(value: Any) -> ValueType:
+    """Infer the CAML ``ValueType`` from a Python value."""
+    if isinstance(value, bool):  # bool before int (bool is an int subclass)
+        return ValueType.Boolean
+    if isinstance(value, int):
+        return ValueType.Integer
+    if isinstance(value, float):
+        return ValueType.Number
+    if isinstance(value, (datetime, date)):
+        return ValueType.DateTime
+    return ValueType.Text
+
+
+class Value:
+    """A CAML ``<Value>`` element."""
+
+    def __init__(
+        self,
+        value: Any = None,
+        *,
+        type: Optional[ValueType | str] = None,  # noqa: A002
+        include_time_value: bool = False,
+        lookup_id: bool = False,
+        child: Optional[str] = None,
+    ) -> None:
+        self._value = value
+        self._type = ValueType(type) if isinstance(type, str) else type
+        self._include_time_value = include_time_value
+        self._lookup_id = lookup_id
+        self._child = child  # raw child XML (e.g. "<Now/>")
+
+    @property
+    def value_type(self) -> ValueType:
+        """The resolved ``ValueType`` (explicit type, else inferred)."""
+        return self._type or infer_value_type(self._value)
+
+    def to_xml(self) -> str:
+        attrs = [f"Type={quoteattr(self.value_type.value)}"]
+        if self._include_time_value:
+            attrs.append('IncludeTimeValue="TRUE"')
+        if self._lookup_id:
+            attrs.append('LookupId="TRUE"')
+        inner = self._child if self._child is not None else escape(self._format(self._value))
+        return f"<Value {' '.join(attrs)}>{inner}</Value>"
+
+    @staticmethod
+    def _format(value: Any) -> str:
+        if isinstance(value, bool):
+            return "1" if value else "0"
+        if isinstance(value, (datetime, date)):
+            return value.isoformat()
+        return str(value)
+
+
+def now() -> Value:
+    """A ``<Value Type='DateTime'><Now/></Value>`` node."""
+    return Value(type=ValueType.DateTime, child="<Now/>")
+
+
+def today() -> Value:
+    """A ``<Value Type='DateTime'><Today/></Value>`` node."""
+    return Value(type=ValueType.DateTime, child="<Today/>")
+
+
+def month() -> Value:
+    """A ``<Value Type='Integer'><Month/></Value>`` node."""
+    return Value(type=ValueType.Integer, child="<Month/>")
+
+
+def user_id() -> Value:
+    """A ``<Value Type='Integer'><UserID/></Value>`` node."""
+    return Value(type=ValueType.Integer, child="<UserID/>")
+
+
+def list_property(name: str) -> Value:
+    """A ``<Value><ListProperty Name='...'/></Value>`` node."""
+    return Value(child=f"<ListProperty Name={quoteattr(name)}/>")

office365/sharepoint/listitems/collection.py

@@ -1,29 +1,58 @@
+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
+from office365.sharepoint.thresholds import LIST_VIEW_THRESHOLD
+
+if TYPE_CHECKING:
+    from office365.runtime.converters.upsert import UpsertTarget
+    from office365.runtime.operations import ProgressCallback
 
 
 class ListItemCollection(EntityCollection[ListItem]):
     """List Item collection"""
 
-    def __init__(self, context, resource_path=None):
-        super().__init__(context, ListItem, resource_path)
+    _list_view_threshold = LIST_VIEW_THRESHOLD
+    _truncation_hint = "page it with List.get_items(query, page_size=2000) or items.get_all(page_size=2000)"
 
-    def get_by_id(self, item_id: int) -> ListItem:
-        """Returns the list item with the specified list item identifier.
+    def __init__(self, context, resource_path=None, parent=None):
+        super().__init__(context, ListItem, resource_path, parent)
+
+    def queue_records(self, records, progress: "ProgressCallback | None" = None) -> Self:
+        """Queue an item create per record.
 
-        Args:
-            item_id (int): The list item identifier.
+        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()``.
         """
+        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 upsert_target(self, *, key_field: str = "MigrationKey", enforce_unique: bool = False) -> "UpsertTarget":
+        """The keyed skip/upsert target for this list (see ``from_records(key=...)``)."""
+        from office365.sharepoint.listitems.upsert import ListItemUpsertTarget
+
+        return ListItemUpsertTarget(self, key_field=key_field, enforce_unique=enforce_unique)
+
+    def _key_column(self, column: str) -> str:
+        """List-item record keys are field internal names (``Name`` -> ``Name_``)."""
+        from office365.sharepoint.fields.name import internal_field_name
+
+        return internal_field_name(column)
+
+    def get_by_id(self, item_id: int) -> ListItem:
+        """Returns the list item with the specified list item identifier."""
         return ListItem(self.context, ServiceOperationPath("GetById", [item_id], self.resource_path))
 
     def get_by_string_id(self, s_id: str) -> ListItem:
         """Returns the list item with either the specified list item identifier or the specified identifier
         for an instance of an external content type.
-
-        Args:
-            s_id (str): Specifies the list item identifier, or if the list is an external list, specifies the identifier
-                for an instance of an external content type as specified in[MS-ECTPWPS] section 3.1.4.1.2.1.
         """
         return ListItem(
             self.context,

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/upsert.py

@@ -0,0 +1,75 @@
+"""SharePoint list-item :class:`UpsertTarget` — the destination side of keyed imports.
+
+Keeps the SharePoint-specific pieces (ensure the key column, load existing keys,
+create/update items) out of the runtime upsert core, so the same
+:func:`~office365.runtime.converters.upsert.keyed_queue` drives list imports and
+the migration toolkit.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Mapping, cast
+
+from office365.runtime.paths.v3.entity import EntityPath
+from office365.sharepoint.fields.type import FieldType
+from office365.sharepoint.listitems.listitem import ListItem
+
+if TYPE_CHECKING:
+    from office365.sharepoint.listitems.collection import ListItemCollection
+    from office365.sharepoint.lists.list import List
+
+
+class ListItemUpsertTarget:
+    """Keyed skip/upsert target backed by a :class:`ListItemCollection`."""
+
+    def __init__(
+        self,
+        collection: "ListItemCollection",
+        *,
+        key_field: str = "MigrationKey",
+        enforce_unique: bool = False,
+    ) -> None:
+        self._collection = collection
+        self._key_field = key_field
+        self._enforce_unique = enforce_unique
+
+    @property
+    def key_field(self) -> str:
+        return self._key_field
+
+    def ensure_key_field(self) -> None:
+        """Queue the key column (Text, optionally unique+indexed) if missing."""
+        from office365.sharepoint.fields.creation_information import FieldCreationInformation
+
+        parent = cast("List", self._collection.parent)
+        if parent is None:
+            return
+        field = parent.fields.ensure(FieldCreationInformation(Title=self._key_field, FieldTypeKind=FieldType.Text))
+        if self._enforce_unique:
+            field.set_property("EnforceUniqueValues", True)
+            field.set_property("Indexed", True)
+            field.update()
+
+    def load_keys(self) -> Mapping[str, Any]:
+        """Return the existing ``{key: item_id}`` map (paged; key + ``Id`` only)."""
+        loaded = self._collection.select([self._key_field, "Id"]).get_all().execute_query()
+        keys: dict[str, Any] = {}
+        for item in loaded:
+            value = item.properties.get(self._key_field)
+            item_id = item.id
+            if value is not None and item_id is not None:
+                keys[str(value)] = item_id
+        return keys
+
+    def create_records(self, records: list[dict]) -> None:
+        self._collection.queue_records(records)
+
+    def update_record(self, item_id: Any, record: dict) -> None:
+        item = ListItem(
+            self._collection.context,
+            EntityPath(item_id, self._collection.resource_path),
+            parent_list=self._collection.parent,
+        )
+        for name, value in record.items():
+            item.set_property(name, value, persist_changes=True)
+        item.update()

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

@@ -71,6 +71,49 @@ class ListCollection(EntityCollection[List]):
             self,
         )
 
+    def ensure_list(
+        self,
+        title: str,
+        description: str | None = None,
+        template_type: ListTemplateType = ListTemplateType.GenericList,
+        allow_content_types: bool = False,
+        *,
+        on_conflict: str = "skip",
+    ) -> List:
+        """Gets the list with the given title, or creates it if it does not exist.
+
+        Idempotent (deferred — resolve with ``execute_query()``). With
+        ``on_conflict="update"`` the existing list's description is reconciled.
+
+        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
+            allow_content_types: Whether to enable content types
+            on_conflict: ``"skip"`` (default) or ``"update"``.
+
+        Returns:
+            List: The existing or newly created list
+        """
+        from office365.runtime.queries.get_or_create import create_or_get
+
+        def _reconcile(lst: List) -> None:
+            if description is not None and lst.properties.get("Description") != description:
+                lst.set_property("Description", description)
+                lst.update()
+
+        return create_or_get(
+            create=lambda: self.add_list(
+                title=title,
+                description=description,
+                template_type=template_type,
+                allow_content_types=allow_content_types,
+            ),
+            find=lambda: self.get_by_title(title).get(),
+            on_conflict=on_conflict,
+            reconcile=_reconcile,
+        )
+
     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/exporter.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from typing import IO, TYPE_CHECKING, Callable, Optional, Union
 
 from office365.runtime.client_result import ClientResult
+from office365.sharepoint.fields.builtin_field_name import SPBuiltInFieldName
 from office365.sharepoint.files.system_object_type import FileSystemObjectType
 from office365.sharepoint.listitems.collection import ListItemCollection
 from office365.sharepoint.listitems.listitem import ListItem
@@ -72,9 +73,9 @@ class ListExporter:
                     [
                         "*",
                         "Id",
-                        "FileRef",
-                        "FileDirRef",
-                        "FileLeafRef",
+                        SPBuiltInFieldName.FileRef,
+                        SPBuiltInFieldName.FileDirRef,
+                        SPBuiltInFieldName.FileLeafRef,
                         "FileSystemObjectType",
                     ]
                 )

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)