perceptic-core-client 0.12.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

perceptic_core_client/models/__init__.py

@@ -24,16 +24,21 @@ from perceptic_core_client.models.create_connection_response import CreateConnec
 from perceptic_core_client.models.create_file_system_response import CreateFileSystemResponse
 from perceptic_core_client.models.create_folder_request import CreateFolderRequest
 from perceptic_core_client.models.create_folder_response import CreateFolderResponse
+from perceptic_core_client.models.create_indexing_schedule_request import CreateIndexingScheduleRequest
+from perceptic_core_client.models.create_indexing_schedule_response import CreateIndexingScheduleResponse
 from perceptic_core_client.models.create_indexing_task_request import CreateIndexingTaskRequest
 from perceptic_core_client.models.create_indexing_task_response import CreateIndexingTaskResponse
 from perceptic_core_client.models.create_managed_file_system_request import CreateManagedFileSystemRequest
 from perceptic_core_client.models.create_remote_file_system_request import CreateRemoteFileSystemRequest
 from perceptic_core_client.models.create_tag_request import CreateTagRequest
 from perceptic_core_client.models.create_tag_response import CreateTagResponse
+from perceptic_core_client.models.cron_trigger import CronTrigger
+from perceptic_core_client.models.execution_trigger_reason import ExecutionTriggerReason
 from perceptic_core_client.models.file_system_api_dto import FileSystemApiDto
 from perceptic_core_client.models.file_system_root_metadata_api_dto import FileSystemRootMetadataApiDto
 from perceptic_core_client.models.get_connection_response import GetConnectionResponse
 from perceptic_core_client.models.get_indexer_response import GetIndexerResponse
+from perceptic_core_client.models.get_indexing_schedule_response import GetIndexingScheduleResponse
 from perceptic_core_client.models.get_indexing_task_response import GetIndexingTaskResponse
 from perceptic_core_client.models.get_metadata_response import GetMetadataResponse
 from perceptic_core_client.models.get_parent_response import GetParentResponse
@@ -46,18 +51,23 @@ from perceptic_core_client.models.get_workers_response import GetWorkersResponse
 from perceptic_core_client.models.indexer_dto import IndexerDto
 from perceptic_core_client.models.indexing_action_dto import IndexingActionDto
 from perceptic_core_client.models.indexing_action_status import IndexingActionStatus
+from perceptic_core_client.models.indexing_schedule_dto import IndexingScheduleDto
 from perceptic_core_client.models.indexing_task_dto import IndexingTaskDto
 from perceptic_core_client.models.indexing_task_status import IndexingTaskStatus
 from perceptic_core_client.models.info_event import InfoEvent
+from perceptic_core_client.models.interval_trigger import IntervalTrigger
 from perceptic_core_client.models.json_node import JsonNode
 from perceptic_core_client.models.json_node_type import JsonNodeType
 from perceptic_core_client.models.list_all_file_systems_response import ListAllFileSystemsResponse
 from perceptic_core_client.models.list_file_system_response import ListFileSystemResponse
 from perceptic_core_client.models.list_indexers_response import ListIndexersResponse
 from perceptic_core_client.models.list_indexing_actions_response import ListIndexingActionsResponse
+from perceptic_core_client.models.list_indexing_schedules_response import ListIndexingSchedulesResponse
+from perceptic_core_client.models.list_schedule_executions_response import ListScheduleExecutionsResponse
 from perceptic_core_client.models.managed_file_system_api_dto import ManagedFileSystemApiDto
 from perceptic_core_client.models.me_response import MeResponse
 from perceptic_core_client.models.model_schema import ModelSchema
+from perceptic_core_client.models.on_upload_trigger import OnUploadTrigger
 from perceptic_core_client.models.paged_list_file_system_response import PagedListFileSystemResponse
 from perceptic_core_client.models.post_worker_run_request import PostWorkerRunRequest
 from perceptic_core_client.models.post_worker_run_response import PostWorkerRunResponse
@@ -71,8 +81,12 @@ from perceptic_core_client.models.resource_type_dto import ResourceTypeDto
 from perceptic_core_client.models.run_status_dto import RunStatusDto
 from perceptic_core_client.models.s3_connection_settings_api_dto import S3ConnectionSettingsApiDto
 from perceptic_core_client.models.s3_file_system_root_metadata_api_dto import S3FileSystemRootMetadataApiDto
+from perceptic_core_client.models.schedule_execution_dto import ScheduleExecutionDto
+from perceptic_core_client.models.schedule_trigger import ScheduleTrigger
 from perceptic_core_client.models.schema_location import SchemaLocation
 from perceptic_core_client.models.start_execution_response import StartExecutionResponse
+from perceptic_core_client.models.update_indexing_schedule_request import UpdateIndexingScheduleRequest
+from perceptic_core_client.models.update_indexing_schedule_response import UpdateIndexingScheduleResponse
 from perceptic_core_client.models.upload_file_to_managed_file_system_response import UploadFileToManagedFileSystemResponse
 from perceptic_core_client.models.worker_event import WorkerEvent
 from perceptic_core_client.models.worker_metadata_dto import WorkerMetadataDto

perceptic_core_client/models/create_indexing_schedule_request.py

@@ -0,0 +1,122 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from perceptic_core_client.models.schedule_trigger import ScheduleTrigger
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CreateIndexingScheduleRequest(BaseModel):
+    """
+    CreateIndexingScheduleRequest
+    """ # noqa: E501
+    name: Annotated[str, Field(strict=True, max_length=255)] = Field(description="Display name for the schedule")
+    description: Optional[Annotated[str, Field(strict=True, max_length=1000)]] = Field(default=None, description="Optional description of the schedule's purpose")
+    indexer_rid: StrictStr = Field(description="RID of the indexer to use", alias="indexerRid")
+    target_uri: StrictStr = Field(description="URI of folder or filesystem to index", alias="targetUri")
+    namespace: Annotated[str, Field(strict=True)] = Field(description="Namespace for indexing")
+    target_minimum_version: Optional[StrictInt] = Field(default=None, description="Minimum indexer version required", alias="targetMinimumVersion")
+    indexing_settings: Optional[Dict[str, Any]] = Field(default=None, description="Indexer-specific settings", alias="indexingSettings")
+    trigger: ScheduleTrigger
+    enabled: Optional[StrictBool] = Field(default=None, description="Whether the schedule is enabled")
+    __properties: ClassVar[List[str]] = ["name", "description", "indexerRid", "targetUri", "namespace", "targetMinimumVersion", "indexingSettings", "trigger", "enabled"]
+
+    @field_validator('name')
+    def name_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"\S", value):
+            raise ValueError(r"must validate the regular expression /\S/")
+        return value
+
+    @field_validator('namespace')
+    def namespace_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"\S", value):
+            raise ValueError(r"must validate the regular expression /\S/")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CreateIndexingScheduleRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of trigger
+        if self.trigger:
+            _dict['trigger'] = self.trigger.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CreateIndexingScheduleRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "description": obj.get("description"),
+            "indexerRid": obj.get("indexerRid"),
+            "targetUri": obj.get("targetUri"),
+            "namespace": obj.get("namespace"),
+            "targetMinimumVersion": obj.get("targetMinimumVersion"),
+            "indexingSettings": obj.get("indexingSettings"),
+            "trigger": ScheduleTrigger.from_dict(obj["trigger"]) if obj.get("trigger") is not None else None,
+            "enabled": obj.get("enabled")
+        })
+        return _obj
+
+

perceptic_core_client/models/create_indexing_schedule_response.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from perceptic_core_client.models.indexing_schedule_dto import IndexingScheduleDto
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CreateIndexingScheduleResponse(BaseModel):
+    """
+    CreateIndexingScheduleResponse
+    """ # noqa: E501
+    schedule_rid: Optional[StrictStr] = Field(default=None, alias="scheduleRid")
+    schedule: Optional[IndexingScheduleDto] = None
+    __properties: ClassVar[List[str]] = ["scheduleRid", "schedule"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CreateIndexingScheduleResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of schedule
+        if self.schedule:
+            _dict['schedule'] = self.schedule.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CreateIndexingScheduleResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "scheduleRid": obj.get("scheduleRid"),
+            "schedule": IndexingScheduleDto.from_dict(obj["schedule"]) if obj.get("schedule") is not None else None
+        })
+        return _obj
+
+

perceptic_core_client/models/cron_trigger.py

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CronTrigger(BaseModel):
+    """
+    CronTrigger
+    """ # noqa: E501
+    expression: Annotated[str, Field(strict=True)] = Field(description="Cron expression")
+    timezone: Annotated[str, Field(strict=True)] = Field(description="Timezone for cron expression")
+    type: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["expression", "timezone", "type"]
+
+    @field_validator('expression')
+    def expression_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"\S", value):
+            raise ValueError(r"must validate the regular expression /\S/")
+        return value
+
+    @field_validator('timezone')
+    def timezone_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[A-Za-z]+\/[A-Za-z_]+$", value):
+            raise ValueError(r"must validate the regular expression /^[A-Za-z]+\/[A-Za-z_]+$/")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CronTrigger from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CronTrigger from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "expression": obj.get("expression"),
+            "timezone": obj.get("timezone"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

perceptic_core_client/models/execution_trigger_reason.py

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class ExecutionTriggerReason(str, Enum):
+    """
+    ExecutionTriggerReason
+    """
+
+    """
+    allowed enum values
+    """
+    SCHEDULED = 'SCHEDULED'
+    FILE_UPLOAD = 'FILE_UPLOAD'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of ExecutionTriggerReason from a JSON string"""
+        return cls(json.loads(json_str))
+
+

perceptic_core_client/models/get_indexing_schedule_response.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from perceptic_core_client.models.indexing_schedule_dto import IndexingScheduleDto
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetIndexingScheduleResponse(BaseModel):
+    """
+    GetIndexingScheduleResponse
+    """ # noqa: E501
+    schedule: Optional[IndexingScheduleDto] = None
+    __properties: ClassVar[List[str]] = ["schedule"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of GetIndexingScheduleResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of schedule
+        if self.schedule:
+            _dict['schedule'] = self.schedule.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetIndexingScheduleResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "schedule": IndexingScheduleDto.from_dict(obj["schedule"]) if obj.get("schedule") is not None else None
+        })
+        return _obj
+
+

perceptic_core_client/models/indexing_schedule_dto.py

@@ -0,0 +1,118 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from perceptic_core_client.models.schedule_trigger import ScheduleTrigger
+from typing import Optional, Set
+from typing_extensions import Self
+
+class IndexingScheduleDto(BaseModel):
+    """
+    IndexingScheduleDto
+    """ # noqa: E501
+    schedule_rid: Optional[StrictStr] = Field(default=None, alias="scheduleRid")
+    name: Optional[StrictStr] = None
+    description: Optional[StrictStr] = None
+    indexer_rid: Optional[StrictStr] = Field(default=None, alias="indexerRid")
+    target_uri: Optional[StrictStr] = Field(default=None, alias="targetUri")
+    namespace: Optional[StrictStr] = None
+    target_minimum_version: Optional[StrictInt] = Field(default=None, alias="targetMinimumVersion")
+    indexing_settings: Optional[Dict[str, Any]] = Field(default=None, alias="indexingSettings")
+    trigger: Optional[ScheduleTrigger] = None
+    enabled: Optional[StrictBool] = None
+    created_at: Optional[datetime] = Field(default=None, alias="createdAt")
+    updated_at: Optional[datetime] = Field(default=None, alias="updatedAt")
+    last_executed_at: Optional[datetime] = Field(default=None, alias="lastExecutedAt")
+    next_execution_at: Optional[datetime] = Field(default=None, alias="nextExecutionAt")
+    __properties: ClassVar[List[str]] = ["scheduleRid", "name", "description", "indexerRid", "targetUri", "namespace", "targetMinimumVersion", "indexingSettings", "trigger", "enabled", "createdAt", "updatedAt", "lastExecutedAt", "nextExecutionAt"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of IndexingScheduleDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of trigger
+        if self.trigger:
+            _dict['trigger'] = self.trigger.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of IndexingScheduleDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "scheduleRid": obj.get("scheduleRid"),
+            "name": obj.get("name"),
+            "description": obj.get("description"),
+            "indexerRid": obj.get("indexerRid"),
+            "targetUri": obj.get("targetUri"),
+            "namespace": obj.get("namespace"),
+            "targetMinimumVersion": obj.get("targetMinimumVersion"),
+            "indexingSettings": obj.get("indexingSettings"),
+            "trigger": ScheduleTrigger.from_dict(obj["trigger"]) if obj.get("trigger") is not None else None,
+            "enabled": obj.get("enabled"),
+            "createdAt": obj.get("createdAt"),
+            "updatedAt": obj.get("updatedAt"),
+            "lastExecutedAt": obj.get("lastExecutedAt"),
+            "nextExecutionAt": obj.get("nextExecutionAt")
+        })
+        return _obj
+
+