pulumi-oci 2.14.0a1730182164__py3-none-any.whl → 2.15.0__py3-none-any.whl

pulumi_oci/datascience/_inputs.py

@@ -41,6 +41,10 @@ __all__ = [
     'JobRunJobStorageMountConfigurationDetailsListArgsDict',
     'JobRunLogDetailArgs',
     'JobRunLogDetailArgsDict',
+    'ModelBackupOperationDetailArgs',
+    'ModelBackupOperationDetailArgsDict',
+    'ModelBackupSettingArgs',
+    'ModelBackupSettingArgsDict',
     'ModelCustomMetadataListArgs',
     'ModelCustomMetadataListArgsDict',
     'ModelDefinedMetadataListArgs',
@@ -73,6 +77,10 @@ __all__ = [
     'ModelDeploymentModelDeploymentConfigurationDetailsModelConfigurationDetailsScalingPolicyAutoScalingPolicyRuleScaleOutConfigurationArgsDict',
     'ModelDeploymentModelDeploymentSystemDataArgs',
     'ModelDeploymentModelDeploymentSystemDataArgsDict',
+    'ModelRetentionOperationDetailArgs',
+    'ModelRetentionOperationDetailArgsDict',
+    'ModelRetentionSettingArgs',
+    'ModelRetentionSettingArgsDict',
     'NotebookSessionNotebookSessionConfigDetailsArgs',
     'NotebookSessionNotebookSessionConfigDetailsArgsDict',
     'NotebookSessionNotebookSessionConfigDetailsNotebookSessionShapeConfigDetailsArgs',
@@ -1502,6 +1510,148 @@ class JobRunLogDetailArgs:
         pulumi.set(self, "log_id", value)
 
 
+if not MYPY:
+    class ModelBackupOperationDetailArgsDict(TypedDict):
+        backup_state: NotRequired[pulumi.Input[str]]
+        """
+        The backup status of the model.
+        """
+        backup_state_details: NotRequired[pulumi.Input[str]]
+        """
+        The backup execution status details of the model.
+        """
+        time_last_backup: NotRequired[pulumi.Input[str]]
+        """
+        The last backup execution time of the model.
+        """
+elif False:
+    ModelBackupOperationDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ModelBackupOperationDetailArgs:
+    def __init__(__self__, *,
+                 backup_state: Optional[pulumi.Input[str]] = None,
+                 backup_state_details: Optional[pulumi.Input[str]] = None,
+                 time_last_backup: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] backup_state: The backup status of the model.
+        :param pulumi.Input[str] backup_state_details: The backup execution status details of the model.
+        :param pulumi.Input[str] time_last_backup: The last backup execution time of the model.
+        """
+        if backup_state is not None:
+            pulumi.set(__self__, "backup_state", backup_state)
+        if backup_state_details is not None:
+            pulumi.set(__self__, "backup_state_details", backup_state_details)
+        if time_last_backup is not None:
+            pulumi.set(__self__, "time_last_backup", time_last_backup)
+
+    @property
+    @pulumi.getter(name="backupState")
+    def backup_state(self) -> Optional[pulumi.Input[str]]:
+        """
+        The backup status of the model.
+        """
+        return pulumi.get(self, "backup_state")
+
+    @backup_state.setter
+    def backup_state(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "backup_state", value)
+
+    @property
+    @pulumi.getter(name="backupStateDetails")
+    def backup_state_details(self) -> Optional[pulumi.Input[str]]:
+        """
+        The backup execution status details of the model.
+        """
+        return pulumi.get(self, "backup_state_details")
+
+    @backup_state_details.setter
+    def backup_state_details(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "backup_state_details", value)
+
+    @property
+    @pulumi.getter(name="timeLastBackup")
+    def time_last_backup(self) -> Optional[pulumi.Input[str]]:
+        """
+        The last backup execution time of the model.
+        """
+        return pulumi.get(self, "time_last_backup")
+
+    @time_last_backup.setter
+    def time_last_backup(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_last_backup", value)
+
+
+if not MYPY:
+    class ModelBackupSettingArgsDict(TypedDict):
+        backup_region: pulumi.Input[str]
+        """
+        (Updatable) Oracle Cloud Infrastructure backup region for the model.
+        """
+        is_backup_enabled: pulumi.Input[bool]
+        """
+        (Updatable) Boolean flag representing whether backup needs to be enabled/disabled for the model.
+        """
+        customer_notification_type: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Customer notification on backup success/failure events.
+        """
+elif False:
+    ModelBackupSettingArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ModelBackupSettingArgs:
+    def __init__(__self__, *,
+                 backup_region: pulumi.Input[str],
+                 is_backup_enabled: pulumi.Input[bool],
+                 customer_notification_type: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] backup_region: (Updatable) Oracle Cloud Infrastructure backup region for the model.
+        :param pulumi.Input[bool] is_backup_enabled: (Updatable) Boolean flag representing whether backup needs to be enabled/disabled for the model.
+        :param pulumi.Input[str] customer_notification_type: (Updatable) Customer notification on backup success/failure events.
+        """
+        pulumi.set(__self__, "backup_region", backup_region)
+        pulumi.set(__self__, "is_backup_enabled", is_backup_enabled)
+        if customer_notification_type is not None:
+            pulumi.set(__self__, "customer_notification_type", customer_notification_type)
+
+    @property
+    @pulumi.getter(name="backupRegion")
+    def backup_region(self) -> pulumi.Input[str]:
+        """
+        (Updatable) Oracle Cloud Infrastructure backup region for the model.
+        """
+        return pulumi.get(self, "backup_region")
+
+    @backup_region.setter
+    def backup_region(self, value: pulumi.Input[str]):
+        pulumi.set(self, "backup_region", value)
+
+    @property
+    @pulumi.getter(name="isBackupEnabled")
+    def is_backup_enabled(self) -> pulumi.Input[bool]:
+        """
+        (Updatable) Boolean flag representing whether backup needs to be enabled/disabled for the model.
+        """
+        return pulumi.get(self, "is_backup_enabled")
+
+    @is_backup_enabled.setter
+    def is_backup_enabled(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "is_backup_enabled", value)
+
+    @property
+    @pulumi.getter(name="customerNotificationType")
+    def customer_notification_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) Customer notification on backup success/failure events.
+        """
+        return pulumi.get(self, "customer_notification_type")
+
+    @customer_notification_type.setter
+    def customer_notification_type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "customer_notification_type", value)
+
+
 if not MYPY:
     class ModelCustomMetadataListArgsDict(TypedDict):
         category: NotRequired[pulumi.Input[str]]
@@ -3035,6 +3185,209 @@ class ModelDeploymentModelDeploymentSystemDataArgs:
         pulumi.set(self, "system_infra_type", value)
 
 
+if not MYPY:
+    class ModelRetentionOperationDetailArgsDict(TypedDict):
+        archive_state: NotRequired[pulumi.Input[str]]
+        """
+        The archival status of model.
+        """
+        archive_state_details: NotRequired[pulumi.Input[str]]
+        """
+        The archival state details of the model.
+        """
+        delete_state: NotRequired[pulumi.Input[str]]
+        """
+        The deletion status of the archived model.
+        """
+        delete_state_details: NotRequired[pulumi.Input[str]]
+        """
+        The deletion status details of the archived model.
+        """
+        time_archival_scheduled: NotRequired[pulumi.Input[str]]
+        """
+        The estimated archival time of the model based on the provided retention setting.
+        """
+        time_deletion_scheduled: NotRequired[pulumi.Input[str]]
+        """
+        The estimated deletion time of the model based on the provided retention setting.
+        """
+elif False:
+    ModelRetentionOperationDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ModelRetentionOperationDetailArgs:
+    def __init__(__self__, *,
+                 archive_state: Optional[pulumi.Input[str]] = None,
+                 archive_state_details: Optional[pulumi.Input[str]] = None,
+                 delete_state: Optional[pulumi.Input[str]] = None,
+                 delete_state_details: Optional[pulumi.Input[str]] = None,
+                 time_archival_scheduled: Optional[pulumi.Input[str]] = None,
+                 time_deletion_scheduled: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] archive_state: The archival status of model.
+        :param pulumi.Input[str] archive_state_details: The archival state details of the model.
+        :param pulumi.Input[str] delete_state: The deletion status of the archived model.
+        :param pulumi.Input[str] delete_state_details: The deletion status details of the archived model.
+        :param pulumi.Input[str] time_archival_scheduled: The estimated archival time of the model based on the provided retention setting.
+        :param pulumi.Input[str] time_deletion_scheduled: The estimated deletion time of the model based on the provided retention setting.
+        """
+        if archive_state is not None:
+            pulumi.set(__self__, "archive_state", archive_state)
+        if archive_state_details is not None:
+            pulumi.set(__self__, "archive_state_details", archive_state_details)
+        if delete_state is not None:
+            pulumi.set(__self__, "delete_state", delete_state)
+        if delete_state_details is not None:
+            pulumi.set(__self__, "delete_state_details", delete_state_details)
+        if time_archival_scheduled is not None:
+            pulumi.set(__self__, "time_archival_scheduled", time_archival_scheduled)
+        if time_deletion_scheduled is not None:
+            pulumi.set(__self__, "time_deletion_scheduled", time_deletion_scheduled)
+
+    @property
+    @pulumi.getter(name="archiveState")
+    def archive_state(self) -> Optional[pulumi.Input[str]]:
+        """
+        The archival status of model.
+        """
+        return pulumi.get(self, "archive_state")
+
+    @archive_state.setter
+    def archive_state(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "archive_state", value)
+
+    @property
+    @pulumi.getter(name="archiveStateDetails")
+    def archive_state_details(self) -> Optional[pulumi.Input[str]]:
+        """
+        The archival state details of the model.
+        """
+        return pulumi.get(self, "archive_state_details")
+
+    @archive_state_details.setter
+    def archive_state_details(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "archive_state_details", value)
+
+    @property
+    @pulumi.getter(name="deleteState")
+    def delete_state(self) -> Optional[pulumi.Input[str]]:
+        """
+        The deletion status of the archived model.
+        """
+        return pulumi.get(self, "delete_state")
+
+    @delete_state.setter
+    def delete_state(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "delete_state", value)
+
+    @property
+    @pulumi.getter(name="deleteStateDetails")
+    def delete_state_details(self) -> Optional[pulumi.Input[str]]:
+        """
+        The deletion status details of the archived model.
+        """
+        return pulumi.get(self, "delete_state_details")
+
+    @delete_state_details.setter
+    def delete_state_details(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "delete_state_details", value)
+
+    @property
+    @pulumi.getter(name="timeArchivalScheduled")
+    def time_archival_scheduled(self) -> Optional[pulumi.Input[str]]:
+        """
+        The estimated archival time of the model based on the provided retention setting.
+        """
+        return pulumi.get(self, "time_archival_scheduled")
+
+    @time_archival_scheduled.setter
+    def time_archival_scheduled(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_archival_scheduled", value)
+
+    @property
+    @pulumi.getter(name="timeDeletionScheduled")
+    def time_deletion_scheduled(self) -> Optional[pulumi.Input[str]]:
+        """
+        The estimated deletion time of the model based on the provided retention setting.
+        """
+        return pulumi.get(self, "time_deletion_scheduled")
+
+    @time_deletion_scheduled.setter
+    def time_deletion_scheduled(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_deletion_scheduled", value)
+
+
+if not MYPY:
+    class ModelRetentionSettingArgsDict(TypedDict):
+        archive_after_days: pulumi.Input[int]
+        """
+        (Updatable) Number of days after which the model will be archived.
+        """
+        customer_notification_type: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Customer notification options on success/failure of archival, deletion events.
+        """
+        delete_after_days: NotRequired[pulumi.Input[int]]
+        """
+        (Updatable) Number of days after which the archived model will be deleted.
+        """
+elif False:
+    ModelRetentionSettingArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ModelRetentionSettingArgs:
+    def __init__(__self__, *,
+                 archive_after_days: pulumi.Input[int],
+                 customer_notification_type: Optional[pulumi.Input[str]] = None,
+                 delete_after_days: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[int] archive_after_days: (Updatable) Number of days after which the model will be archived.
+        :param pulumi.Input[str] customer_notification_type: (Updatable) Customer notification options on success/failure of archival, deletion events.
+        :param pulumi.Input[int] delete_after_days: (Updatable) Number of days after which the archived model will be deleted.
+        """
+        pulumi.set(__self__, "archive_after_days", archive_after_days)
+        if customer_notification_type is not None:
+            pulumi.set(__self__, "customer_notification_type", customer_notification_type)
+        if delete_after_days is not None:
+            pulumi.set(__self__, "delete_after_days", delete_after_days)
+
+    @property
+    @pulumi.getter(name="archiveAfterDays")
+    def archive_after_days(self) -> pulumi.Input[int]:
+        """
+        (Updatable) Number of days after which the model will be archived.
+        """
+        return pulumi.get(self, "archive_after_days")
+
+    @archive_after_days.setter
+    def archive_after_days(self, value: pulumi.Input[int]):
+        pulumi.set(self, "archive_after_days", value)
+
+    @property
+    @pulumi.getter(name="customerNotificationType")
+    def customer_notification_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) Customer notification options on success/failure of archival, deletion events.
+        """
+        return pulumi.get(self, "customer_notification_type")
+
+    @customer_notification_type.setter
+    def customer_notification_type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "customer_notification_type", value)
+
+    @property
+    @pulumi.getter(name="deleteAfterDays")
+    def delete_after_days(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Updatable) Number of days after which the archived model will be deleted.
+        """
+        return pulumi.get(self, "delete_after_days")
+
+    @delete_after_days.setter
+    def delete_after_days(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "delete_after_days", value)
+
+
 if not MYPY:
     class NotebookSessionNotebookSessionConfigDetailsArgsDict(TypedDict):
         shape: pulumi.Input[str]

pulumi_oci/datascience/get_model.py

@@ -27,7 +27,7 @@ class GetModelResult:
     """
     A collection of values returned by getModel.
     """
-    def __init__(__self__, artifact_content_disposition=None, artifact_content_length=None, artifact_content_md5=None, artifact_last_modified=None, compartment_id=None, created_by=None, custom_metadata_lists=None, defined_metadata_lists=None, defined_tags=None, description=None, display_name=None, empty_model=None, freeform_tags=None, id=None, input_schema=None, model_artifact=None, model_id=None, output_schema=None, project_id=None, state=None, time_created=None):
+    def __init__(__self__, artifact_content_disposition=None, artifact_content_length=None, artifact_content_md5=None, artifact_last_modified=None, backup_operation_details=None, backup_settings=None, compartment_id=None, created_by=None, custom_metadata_lists=None, defined_metadata_lists=None, defined_tags=None, description=None, display_name=None, empty_model=None, freeform_tags=None, id=None, input_schema=None, lifecycle_details=None, model_artifact=None, model_id=None, model_version_set_id=None, model_version_set_name=None, output_schema=None, project_id=None, retention_operation_details=None, retention_settings=None, state=None, time_created=None, version_label=None):
         if artifact_content_disposition and not isinstance(artifact_content_disposition, str):
             raise TypeError("Expected argument 'artifact_content_disposition' to be a str")
         pulumi.set(__self__, "artifact_content_disposition", artifact_content_disposition)
@@ -40,6 +40,12 @@ class GetModelResult:
         if artifact_last_modified and not isinstance(artifact_last_modified, str):
             raise TypeError("Expected argument 'artifact_last_modified' to be a str")
         pulumi.set(__self__, "artifact_last_modified", artifact_last_modified)
+        if backup_operation_details and not isinstance(backup_operation_details, list):
+            raise TypeError("Expected argument 'backup_operation_details' to be a list")
+        pulumi.set(__self__, "backup_operation_details", backup_operation_details)
+        if backup_settings and not isinstance(backup_settings, list):
+            raise TypeError("Expected argument 'backup_settings' to be a list")
+        pulumi.set(__self__, "backup_settings", backup_settings)
         if compartment_id and not isinstance(compartment_id, str):
             raise TypeError("Expected argument 'compartment_id' to be a str")
         pulumi.set(__self__, "compartment_id", compartment_id)
@@ -73,24 +79,42 @@ class GetModelResult:
         if input_schema and not isinstance(input_schema, str):
             raise TypeError("Expected argument 'input_schema' to be a str")
         pulumi.set(__self__, "input_schema", input_schema)
+        if lifecycle_details and not isinstance(lifecycle_details, str):
+            raise TypeError("Expected argument 'lifecycle_details' to be a str")
+        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
         if model_artifact and not isinstance(model_artifact, str):
             raise TypeError("Expected argument 'model_artifact' to be a str")
         pulumi.set(__self__, "model_artifact", model_artifact)
         if model_id and not isinstance(model_id, str):
             raise TypeError("Expected argument 'model_id' to be a str")
         pulumi.set(__self__, "model_id", model_id)
+        if model_version_set_id and not isinstance(model_version_set_id, str):
+            raise TypeError("Expected argument 'model_version_set_id' to be a str")
+        pulumi.set(__self__, "model_version_set_id", model_version_set_id)
+        if model_version_set_name and not isinstance(model_version_set_name, str):
+            raise TypeError("Expected argument 'model_version_set_name' to be a str")
+        pulumi.set(__self__, "model_version_set_name", model_version_set_name)
         if output_schema and not isinstance(output_schema, str):
             raise TypeError("Expected argument 'output_schema' to be a str")
         pulumi.set(__self__, "output_schema", output_schema)
         if project_id and not isinstance(project_id, str):
             raise TypeError("Expected argument 'project_id' to be a str")
         pulumi.set(__self__, "project_id", project_id)
+        if retention_operation_details and not isinstance(retention_operation_details, list):
+            raise TypeError("Expected argument 'retention_operation_details' to be a list")
+        pulumi.set(__self__, "retention_operation_details", retention_operation_details)
+        if retention_settings and not isinstance(retention_settings, list):
+            raise TypeError("Expected argument 'retention_settings' to be a list")
+        pulumi.set(__self__, "retention_settings", retention_settings)
         if state and not isinstance(state, str):
             raise TypeError("Expected argument 'state' to be a str")
         pulumi.set(__self__, "state", state)
         if time_created and not isinstance(time_created, str):
             raise TypeError("Expected argument 'time_created' to be a str")
         pulumi.set(__self__, "time_created", time_created)
+        if version_label and not isinstance(version_label, str):
+            raise TypeError("Expected argument 'version_label' to be a str")
+        pulumi.set(__self__, "version_label", version_label)
 
     @property
     @pulumi.getter(name="artifactContentDisposition")
@@ -112,6 +136,22 @@ class GetModelResult:
     def artifact_last_modified(self) -> str:
         return pulumi.get(self, "artifact_last_modified")
 
+    @property
+    @pulumi.getter(name="backupOperationDetails")
+    def backup_operation_details(self) -> Sequence['outputs.GetModelBackupOperationDetailResult']:
+        """
+        Backup operation details of the model.
+        """
+        return pulumi.get(self, "backup_operation_details")
+
+    @property
+    @pulumi.getter(name="backupSettings")
+    def backup_settings(self) -> Sequence['outputs.GetModelBackupSettingResult']:
+        """
+        Back up setting details of the model.
+        """
+        return pulumi.get(self, "backup_settings")
+
     @property
     @pulumi.getter(name="compartmentId")
     def compartment_id(self) -> str:
@@ -197,6 +237,14 @@ class GetModelResult:
         """
         return pulumi.get(self, "input_schema")
 
+    @property
+    @pulumi.getter(name="lifecycleDetails")
+    def lifecycle_details(self) -> str:
+        """
+        Details about the lifecycle state of the model.
+        """
+        return pulumi.get(self, "lifecycle_details")
+
     @property
     @pulumi.getter(name="modelArtifact")
     def model_artifact(self) -> str:
@@ -207,6 +255,22 @@ class GetModelResult:
     def model_id(self) -> str:
         return pulumi.get(self, "model_id")
 
+    @property
+    @pulumi.getter(name="modelVersionSetId")
+    def model_version_set_id(self) -> str:
+        """
+        The OCID of the model version set that the model is associated to.
+        """
+        return pulumi.get(self, "model_version_set_id")
+
+    @property
+    @pulumi.getter(name="modelVersionSetName")
+    def model_version_set_name(self) -> str:
+        """
+        The name of the model version set that the model is associated to.
+        """
+        return pulumi.get(self, "model_version_set_name")
+
     @property
     @pulumi.getter(name="outputSchema")
     def output_schema(self) -> str:
@@ -223,6 +287,22 @@ class GetModelResult:
         """
         return pulumi.get(self, "project_id")
 
+    @property
+    @pulumi.getter(name="retentionOperationDetails")
+    def retention_operation_details(self) -> Sequence['outputs.GetModelRetentionOperationDetailResult']:
+        """
+        Retention operation details for the model.
+        """
+        return pulumi.get(self, "retention_operation_details")
+
+    @property
+    @pulumi.getter(name="retentionSettings")
+    def retention_settings(self) -> Sequence['outputs.GetModelRetentionSettingResult']:
+        """
+        Retention setting details of the model.
+        """
+        return pulumi.get(self, "retention_settings")
+
     @property
     @pulumi.getter
     def state(self) -> str:
@@ -239,6 +319,11 @@ class GetModelResult:
         """
         return pulumi.get(self, "time_created")
 
+    @property
+    @pulumi.getter(name="versionLabel")
+    def version_label(self) -> str:
+        return pulumi.get(self, "version_label")
+
 
 class AwaitableGetModelResult(GetModelResult):
     # pylint: disable=using-constant-test
@@ -250,6 +335,8 @@ class AwaitableGetModelResult(GetModelResult):
             artifact_content_length=self.artifact_content_length,
             artifact_content_md5=self.artifact_content_md5,
             artifact_last_modified=self.artifact_last_modified,
+            backup_operation_details=self.backup_operation_details,
+            backup_settings=self.backup_settings,
             compartment_id=self.compartment_id,
             created_by=self.created_by,
             custom_metadata_lists=self.custom_metadata_lists,
@@ -261,12 +348,18 @@ class AwaitableGetModelResult(GetModelResult):
             freeform_tags=self.freeform_tags,
             id=self.id,
             input_schema=self.input_schema,
+            lifecycle_details=self.lifecycle_details,
             model_artifact=self.model_artifact,
             model_id=self.model_id,
+            model_version_set_id=self.model_version_set_id,
+            model_version_set_name=self.model_version_set_name,
             output_schema=self.output_schema,
             project_id=self.project_id,
+            retention_operation_details=self.retention_operation_details,
+            retention_settings=self.retention_settings,
             state=self.state,
-            time_created=self.time_created)
+            time_created=self.time_created,
+            version_label=self.version_label)
 
 
 def get_model(model_id: Optional[str] = None,
@@ -298,6 +391,8 @@ def get_model(model_id: Optional[str] = None,
         artifact_content_length=pulumi.get(__ret__, 'artifact_content_length'),
         artifact_content_md5=pulumi.get(__ret__, 'artifact_content_md5'),
         artifact_last_modified=pulumi.get(__ret__, 'artifact_last_modified'),
+        backup_operation_details=pulumi.get(__ret__, 'backup_operation_details'),
+        backup_settings=pulumi.get(__ret__, 'backup_settings'),
         compartment_id=pulumi.get(__ret__, 'compartment_id'),
         created_by=pulumi.get(__ret__, 'created_by'),
         custom_metadata_lists=pulumi.get(__ret__, 'custom_metadata_lists'),
@@ -309,12 +404,18 @@ def get_model(model_id: Optional[str] = None,
         freeform_tags=pulumi.get(__ret__, 'freeform_tags'),
         id=pulumi.get(__ret__, 'id'),
         input_schema=pulumi.get(__ret__, 'input_schema'),
+        lifecycle_details=pulumi.get(__ret__, 'lifecycle_details'),
         model_artifact=pulumi.get(__ret__, 'model_artifact'),
         model_id=pulumi.get(__ret__, 'model_id'),
+        model_version_set_id=pulumi.get(__ret__, 'model_version_set_id'),
+        model_version_set_name=pulumi.get(__ret__, 'model_version_set_name'),
         output_schema=pulumi.get(__ret__, 'output_schema'),
         project_id=pulumi.get(__ret__, 'project_id'),
+        retention_operation_details=pulumi.get(__ret__, 'retention_operation_details'),
+        retention_settings=pulumi.get(__ret__, 'retention_settings'),
         state=pulumi.get(__ret__, 'state'),
-        time_created=pulumi.get(__ret__, 'time_created'))
+        time_created=pulumi.get(__ret__, 'time_created'),
+        version_label=pulumi.get(__ret__, 'version_label'))
 def get_model_output(model_id: Optional[pulumi.Input[str]] = None,
                      opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetModelResult]:
     """
@@ -343,6 +444,8 @@ def get_model_output(model_id: Optional[pulumi.Input[str]] = None,
         artifact_content_length=pulumi.get(__response__, 'artifact_content_length'),
         artifact_content_md5=pulumi.get(__response__, 'artifact_content_md5'),
         artifact_last_modified=pulumi.get(__response__, 'artifact_last_modified'),
+        backup_operation_details=pulumi.get(__response__, 'backup_operation_details'),
+        backup_settings=pulumi.get(__response__, 'backup_settings'),
         compartment_id=pulumi.get(__response__, 'compartment_id'),
         created_by=pulumi.get(__response__, 'created_by'),
         custom_metadata_lists=pulumi.get(__response__, 'custom_metadata_lists'),
@@ -354,9 +457,15 @@ def get_model_output(model_id: Optional[pulumi.Input[str]] = None,
         freeform_tags=pulumi.get(__response__, 'freeform_tags'),
         id=pulumi.get(__response__, 'id'),
         input_schema=pulumi.get(__response__, 'input_schema'),
+        lifecycle_details=pulumi.get(__response__, 'lifecycle_details'),
         model_artifact=pulumi.get(__response__, 'model_artifact'),
         model_id=pulumi.get(__response__, 'model_id'),
+        model_version_set_id=pulumi.get(__response__, 'model_version_set_id'),
+        model_version_set_name=pulumi.get(__response__, 'model_version_set_name'),
         output_schema=pulumi.get(__response__, 'output_schema'),
         project_id=pulumi.get(__response__, 'project_id'),
+        retention_operation_details=pulumi.get(__response__, 'retention_operation_details'),
+        retention_settings=pulumi.get(__response__, 'retention_settings'),
         state=pulumi.get(__response__, 'state'),
-        time_created=pulumi.get(__response__, 'time_created')))
+        time_created=pulumi.get(__response__, 'time_created'),
+        version_label=pulumi.get(__response__, 'version_label')))