pulumi-oci 2.29.0a1744186202__py3-none-any.whl → 2.30.0__py3-none-any.whl

pulumi_oci/goldengate/outputs.py

@@ -32,6 +32,7 @@ __all__ = [
     'DeploymentOggDataGroupToRolesMapping',
     'PipelineLock',
     'PipelineMappingRule',
+    'PipelinePipelineDiagnosticData',
     'PipelineProcessOptions',
     'PipelineProcessOptionsInitialDataLoad',
     'PipelineProcessOptionsReplicateSchemaChange',
@@ -100,6 +101,7 @@ __all__ = [
     'GetMessagesFilterResult',
     'GetPipelineLockResult',
     'GetPipelineMappingRuleResult',
+    'GetPipelinePipelineDiagnosticDataResult',
     'GetPipelineProcessOptionResult',
     'GetPipelineProcessOptionInitialDataLoadResult',
     'GetPipelineProcessOptionReplicateSchemaChangeResult',
@@ -119,6 +121,7 @@ __all__ = [
     'GetPipelinesPipelineCollectionItemResult',
     'GetPipelinesPipelineCollectionItemLockResult',
     'GetPipelinesPipelineCollectionItemMappingRuleResult',
+    'GetPipelinesPipelineCollectionItemPipelineDiagnosticDataResult',
     'GetPipelinesPipelineCollectionItemProcessOptionResult',
     'GetPipelinesPipelineCollectionItemProcessOptionInitialDataLoadResult',
     'GetPipelinesPipelineCollectionItemProcessOptionReplicateSchemaChangeResult',
@@ -1181,6 +1184,92 @@ class PipelineMappingRule(dict):
         return pulumi.get(self, "target")
 
 
+@pulumi.output_type
+class PipelinePipelineDiagnosticData(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "diagnosticState":
+            suggest = "diagnostic_state"
+        elif key == "timeLastCollected":
+            suggest = "time_last_collected"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PipelinePipelineDiagnosticData. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PipelinePipelineDiagnosticData.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PipelinePipelineDiagnosticData.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bucket: Optional[builtins.str] = None,
+                 diagnostic_state: Optional[builtins.str] = None,
+                 namespace: Optional[builtins.str] = None,
+                 object: Optional[builtins.str] = None,
+                 time_last_collected: Optional[builtins.str] = None):
+        """
+        :param builtins.str bucket: Name of the bucket where the object is to be uploaded in the object storage
+        :param builtins.str diagnostic_state: The state of the pipeline diagnostics collection.
+        :param builtins.str namespace: Name of namespace that serves as a container for all of your buckets
+        :param builtins.str object: Name of the diagnostic collected and uploaded to object storage
+        :param builtins.str time_last_collected: The date and time the diagnostic data was last collected for the pipeline. The format is defined by  [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2024-07-25T21:10:29.600Z`.
+        """
+        if bucket is not None:
+            pulumi.set(__self__, "bucket", bucket)
+        if diagnostic_state is not None:
+            pulumi.set(__self__, "diagnostic_state", diagnostic_state)
+        if namespace is not None:
+            pulumi.set(__self__, "namespace", namespace)
+        if object is not None:
+            pulumi.set(__self__, "object", object)
+        if time_last_collected is not None:
+            pulumi.set(__self__, "time_last_collected", time_last_collected)
+
+    @property
+    @pulumi.getter
+    def bucket(self) -> Optional[builtins.str]:
+        """
+        Name of the bucket where the object is to be uploaded in the object storage
+        """
+        return pulumi.get(self, "bucket")
+
+    @property
+    @pulumi.getter(name="diagnosticState")
+    def diagnostic_state(self) -> Optional[builtins.str]:
+        """
+        The state of the pipeline diagnostics collection.
+        """
+        return pulumi.get(self, "diagnostic_state")
+
+    @property
+    @pulumi.getter
+    def namespace(self) -> Optional[builtins.str]:
+        """
+        Name of namespace that serves as a container for all of your buckets
+        """
+        return pulumi.get(self, "namespace")
+
+    @property
+    @pulumi.getter
+    def object(self) -> Optional[builtins.str]:
+        """
+        Name of the diagnostic collected and uploaded to object storage
+        """
+        return pulumi.get(self, "object")
+
+    @property
+    @pulumi.getter(name="timeLastCollected")
+    def time_last_collected(self) -> Optional[builtins.str]:
+        """
+        The date and time the diagnostic data was last collected for the pipeline. The format is defined by  [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2024-07-25T21:10:29.600Z`.
+        """
+        return pulumi.get(self, "time_last_collected")
+
+
 @pulumi.output_type
 class PipelineProcessOptions(dict):
     @staticmethod
@@ -1192,6 +1281,8 @@ class PipelineProcessOptions(dict):
             suggest = "replicate_schema_change"
         elif key == "shouldRestartOnFailure":
             suggest = "should_restart_on_failure"
+        elif key == "startUsingDefaultMapping":
+            suggest = "start_using_default_mapping"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in PipelineProcessOptions. Access the value via the '{suggest}' property getter instead.")
@@ -1207,15 +1298,19 @@ class PipelineProcessOptions(dict):
     def __init__(__self__, *,
                  initial_data_load: 'outputs.PipelineProcessOptionsInitialDataLoad',
                  replicate_schema_change: 'outputs.PipelineProcessOptionsReplicateSchemaChange',
-                 should_restart_on_failure: builtins.str):
+                 should_restart_on_failure: builtins.str,
+                 start_using_default_mapping: Optional[builtins.str] = None):
         """
         :param 'PipelineProcessOptionsInitialDataLoadArgs' initial_data_load: (Updatable) Options required for the pipeline Initial Data Load. If enabled, copies existing data from source to target before replication.
         :param 'PipelineProcessOptionsReplicateSchemaChangeArgs' replicate_schema_change: (Updatable) Options required for pipeline Initial Data Load. If enabled, copies existing data from source to target before replication.
         :param builtins.str should_restart_on_failure: (Updatable) If ENABLED, then the replication process restarts itself upon failure. This option applies when creating or updating a pipeline.
+        :param builtins.str start_using_default_mapping: (Updatable) If ENABLED, then the pipeline is started as part of pipeline creation. It uses default mapping. This option applies when creating or updating a pipeline.
         """
         pulumi.set(__self__, "initial_data_load", initial_data_load)
         pulumi.set(__self__, "replicate_schema_change", replicate_schema_change)
         pulumi.set(__self__, "should_restart_on_failure", should_restart_on_failure)
+        if start_using_default_mapping is not None:
+            pulumi.set(__self__, "start_using_default_mapping", start_using_default_mapping)
 
     @property
     @pulumi.getter(name="initialDataLoad")
@@ -1241,6 +1336,14 @@ class PipelineProcessOptions(dict):
         """
         return pulumi.get(self, "should_restart_on_failure")
 
+    @property
+    @pulumi.getter(name="startUsingDefaultMapping")
+    def start_using_default_mapping(self) -> Optional[builtins.str]:
+        """
+        (Updatable) If ENABLED, then the pipeline is started as part of pipeline creation. It uses default mapping. This option applies when creating or updating a pipeline.
+        """
+        return pulumi.get(self, "start_using_default_mapping")
+
 
 @pulumi.output_type
 class PipelineProcessOptionsInitialDataLoad(dict):
@@ -6645,20 +6748,85 @@ class GetPipelineMappingRuleResult(dict):
         return pulumi.get(self, "target")
 
 
+@pulumi.output_type
+class GetPipelinePipelineDiagnosticDataResult(dict):
+    def __init__(__self__, *,
+                 bucket: builtins.str,
+                 diagnostic_state: builtins.str,
+                 namespace: builtins.str,
+                 object: builtins.str,
+                 time_last_collected: builtins.str):
+        """
+        :param builtins.str bucket: Name of the bucket where the object is to be uploaded in the object storage
+        :param builtins.str diagnostic_state: The state of the pipeline diagnostics collection.
+        :param builtins.str namespace: Name of namespace that serves as a container for all of your buckets
+        :param builtins.str object: Name of the diagnostic collected and uploaded to object storage
+        :param builtins.str time_last_collected: The date and time the diagnostic data was last collected for the pipeline. The format is defined by  [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2024-07-25T21:10:29.600Z`.
+        """
+        pulumi.set(__self__, "bucket", bucket)
+        pulumi.set(__self__, "diagnostic_state", diagnostic_state)
+        pulumi.set(__self__, "namespace", namespace)
+        pulumi.set(__self__, "object", object)
+        pulumi.set(__self__, "time_last_collected", time_last_collected)
+
+    @property
+    @pulumi.getter
+    def bucket(self) -> builtins.str:
+        """
+        Name of the bucket where the object is to be uploaded in the object storage
+        """
+        return pulumi.get(self, "bucket")
+
+    @property
+    @pulumi.getter(name="diagnosticState")
+    def diagnostic_state(self) -> builtins.str:
+        """
+        The state of the pipeline diagnostics collection.
+        """
+        return pulumi.get(self, "diagnostic_state")
+
+    @property
+    @pulumi.getter
+    def namespace(self) -> builtins.str:
+        """
+        Name of namespace that serves as a container for all of your buckets
+        """
+        return pulumi.get(self, "namespace")
+
+    @property
+    @pulumi.getter
+    def object(self) -> builtins.str:
+        """
+        Name of the diagnostic collected and uploaded to object storage
+        """
+        return pulumi.get(self, "object")
+
+    @property
+    @pulumi.getter(name="timeLastCollected")
+    def time_last_collected(self) -> builtins.str:
+        """
+        The date and time the diagnostic data was last collected for the pipeline. The format is defined by  [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2024-07-25T21:10:29.600Z`.
+        """
+        return pulumi.get(self, "time_last_collected")
+
+
 @pulumi.output_type
 class GetPipelineProcessOptionResult(dict):
     def __init__(__self__, *,
                  initial_data_loads: Sequence['outputs.GetPipelineProcessOptionInitialDataLoadResult'],
                  replicate_schema_changes: Sequence['outputs.GetPipelineProcessOptionReplicateSchemaChangeResult'],
-                 should_restart_on_failure: builtins.str):
+                 should_restart_on_failure: builtins.str,
+                 start_using_default_mapping: builtins.str):
         """
         :param Sequence['GetPipelineProcessOptionInitialDataLoadArgs'] initial_data_loads: Options required for the pipeline Initial Data Load. If enabled, copies existing data from source to target before replication.
         :param Sequence['GetPipelineProcessOptionReplicateSchemaChangeArgs'] replicate_schema_changes: Options required for pipeline Initial Data Load. If enabled, copies existing data from source to target before replication.
         :param builtins.str should_restart_on_failure: If ENABLED, then the replication process restarts itself upon failure. This option applies when creating or updating a pipeline.
+        :param builtins.str start_using_default_mapping: If ENABLED, then the pipeline is started as part of pipeline creation. It uses default mapping. This option applies when creating or updating a pipeline.
         """
         pulumi.set(__self__, "initial_data_loads", initial_data_loads)
         pulumi.set(__self__, "replicate_schema_changes", replicate_schema_changes)
         pulumi.set(__self__, "should_restart_on_failure", should_restart_on_failure)
+        pulumi.set(__self__, "start_using_default_mapping", start_using_default_mapping)
 
     @property
     @pulumi.getter(name="initialDataLoads")
@@ -6684,6 +6852,14 @@ class GetPipelineProcessOptionResult(dict):
         """
         return pulumi.get(self, "should_restart_on_failure")
 
+    @property
+    @pulumi.getter(name="startUsingDefaultMapping")
+    def start_using_default_mapping(self) -> builtins.str:
+        """
+        If ENABLED, then the pipeline is started as part of pipeline creation. It uses default mapping. This option applies when creating or updating a pipeline.
+        """
+        return pulumi.get(self, "start_using_default_mapping")
+
 
 @pulumi.output_type
 class GetPipelineProcessOptionInitialDataLoadResult(dict):
@@ -7128,6 +7304,7 @@ class GetPipelinesPipelineCollectionItemResult(dict):
                  lifecycle_sub_state: builtins.str,
                  locks: Sequence['outputs.GetPipelinesPipelineCollectionItemLockResult'],
                  mapping_rules: Sequence['outputs.GetPipelinesPipelineCollectionItemMappingRuleResult'],
+                 pipeline_diagnostic_datas: Sequence['outputs.GetPipelinesPipelineCollectionItemPipelineDiagnosticDataResult'],
                  process_options: Sequence['outputs.GetPipelinesPipelineCollectionItemProcessOptionResult'],
                  recipe_type: builtins.str,
                  source_connection_details: Sequence['outputs.GetPipelinesPipelineCollectionItemSourceConnectionDetailResult'],
@@ -7151,6 +7328,7 @@ class GetPipelinesPipelineCollectionItemResult(dict):
         :param builtins.str lifecycle_sub_state: A filtered list of pipelines to return for a given lifecycleSubState.
         :param Sequence['GetPipelinesPipelineCollectionItemLockArgs'] locks: Locks associated with this resource.
         :param Sequence['GetPipelinesPipelineCollectionItemMappingRuleArgs'] mapping_rules: Mapping for source/target schema/tables for the pipeline data replication.
+        :param Sequence['GetPipelinesPipelineCollectionItemPipelineDiagnosticDataArgs'] pipeline_diagnostic_datas: Information regarding the pipeline diagnostic collection
         :param Sequence['GetPipelinesPipelineCollectionItemProcessOptionArgs'] process_options: Required pipeline options to configure the replication process (Extract or Replicat).
         :param builtins.str recipe_type: The type of the recipe
         :param Sequence['GetPipelinesPipelineCollectionItemSourceConnectionDetailArgs'] source_connection_details: The source connection details for creating a pipeline.
@@ -7174,6 +7352,7 @@ class GetPipelinesPipelineCollectionItemResult(dict):
         pulumi.set(__self__, "lifecycle_sub_state", lifecycle_sub_state)
         pulumi.set(__self__, "locks", locks)
         pulumi.set(__self__, "mapping_rules", mapping_rules)
+        pulumi.set(__self__, "pipeline_diagnostic_datas", pipeline_diagnostic_datas)
         pulumi.set(__self__, "process_options", process_options)
         pulumi.set(__self__, "recipe_type", recipe_type)
         pulumi.set(__self__, "source_connection_details", source_connection_details)
@@ -7288,6 +7467,14 @@ class GetPipelinesPipelineCollectionItemResult(dict):
         """
         return pulumi.get(self, "mapping_rules")
 
+    @property
+    @pulumi.getter(name="pipelineDiagnosticDatas")
+    def pipeline_diagnostic_datas(self) -> Sequence['outputs.GetPipelinesPipelineCollectionItemPipelineDiagnosticDataResult']:
+        """
+        Information regarding the pipeline diagnostic collection
+        """
+        return pulumi.get(self, "pipeline_diagnostic_datas")
+
     @property
     @pulumi.getter(name="processOptions")
     def process_options(self) -> Sequence['outputs.GetPipelinesPipelineCollectionItemProcessOptionResult']:
@@ -7430,20 +7617,85 @@ class GetPipelinesPipelineCollectionItemMappingRuleResult(dict):
         return pulumi.get(self, "target")
 
 
+@pulumi.output_type
+class GetPipelinesPipelineCollectionItemPipelineDiagnosticDataResult(dict):
+    def __init__(__self__, *,
+                 bucket: builtins.str,
+                 diagnostic_state: builtins.str,
+                 namespace: builtins.str,
+                 object: builtins.str,
+                 time_last_collected: builtins.str):
+        """
+        :param builtins.str bucket: Name of the bucket where the object is to be uploaded in the object storage
+        :param builtins.str diagnostic_state: The state of the pipeline diagnostics collection.
+        :param builtins.str namespace: Name of namespace that serves as a container for all of your buckets
+        :param builtins.str object: Name of the diagnostic collected and uploaded to object storage
+        :param builtins.str time_last_collected: The date and time the diagnostic data was last collected for the pipeline. The format is defined by  [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2024-07-25T21:10:29.600Z`.
+        """
+        pulumi.set(__self__, "bucket", bucket)
+        pulumi.set(__self__, "diagnostic_state", diagnostic_state)
+        pulumi.set(__self__, "namespace", namespace)
+        pulumi.set(__self__, "object", object)
+        pulumi.set(__self__, "time_last_collected", time_last_collected)
+
+    @property
+    @pulumi.getter
+    def bucket(self) -> builtins.str:
+        """
+        Name of the bucket where the object is to be uploaded in the object storage
+        """
+        return pulumi.get(self, "bucket")
+
+    @property
+    @pulumi.getter(name="diagnosticState")
+    def diagnostic_state(self) -> builtins.str:
+        """
+        The state of the pipeline diagnostics collection.
+        """
+        return pulumi.get(self, "diagnostic_state")
+
+    @property
+    @pulumi.getter
+    def namespace(self) -> builtins.str:
+        """
+        Name of namespace that serves as a container for all of your buckets
+        """
+        return pulumi.get(self, "namespace")
+
+    @property
+    @pulumi.getter
+    def object(self) -> builtins.str:
+        """
+        Name of the diagnostic collected and uploaded to object storage
+        """
+        return pulumi.get(self, "object")
+
+    @property
+    @pulumi.getter(name="timeLastCollected")
+    def time_last_collected(self) -> builtins.str:
+        """
+        The date and time the diagnostic data was last collected for the pipeline. The format is defined by  [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2024-07-25T21:10:29.600Z`.
+        """
+        return pulumi.get(self, "time_last_collected")
+
+
 @pulumi.output_type
 class GetPipelinesPipelineCollectionItemProcessOptionResult(dict):
     def __init__(__self__, *,
                  initial_data_loads: Sequence['outputs.GetPipelinesPipelineCollectionItemProcessOptionInitialDataLoadResult'],
                  replicate_schema_changes: Sequence['outputs.GetPipelinesPipelineCollectionItemProcessOptionReplicateSchemaChangeResult'],
-                 should_restart_on_failure: builtins.str):
+                 should_restart_on_failure: builtins.str,
+                 start_using_default_mapping: builtins.str):
         """
         :param Sequence['GetPipelinesPipelineCollectionItemProcessOptionInitialDataLoadArgs'] initial_data_loads: Options required for the pipeline Initial Data Load. If enabled, copies existing data from source to target before replication.
         :param Sequence['GetPipelinesPipelineCollectionItemProcessOptionReplicateSchemaChangeArgs'] replicate_schema_changes: Options required for pipeline Initial Data Load. If enabled, copies existing data from source to target before replication.
         :param builtins.str should_restart_on_failure: If ENABLED, then the replication process restarts itself upon failure. This option applies when creating or updating a pipeline.
+        :param builtins.str start_using_default_mapping: If ENABLED, then the pipeline is started as part of pipeline creation. It uses default mapping. This option applies when creating or updating a pipeline.
         """
         pulumi.set(__self__, "initial_data_loads", initial_data_loads)
         pulumi.set(__self__, "replicate_schema_changes", replicate_schema_changes)
         pulumi.set(__self__, "should_restart_on_failure", should_restart_on_failure)
+        pulumi.set(__self__, "start_using_default_mapping", start_using_default_mapping)
 
     @property
     @pulumi.getter(name="initialDataLoads")
@@ -7469,6 +7721,14 @@ class GetPipelinesPipelineCollectionItemProcessOptionResult(dict):
         """
         return pulumi.get(self, "should_restart_on_failure")
 
+    @property
+    @pulumi.getter(name="startUsingDefaultMapping")
+    def start_using_default_mapping(self) -> builtins.str:
+        """
+        If ENABLED, then the pipeline is started as part of pipeline creation. It uses default mapping. This option applies when creating or updating a pipeline.
+        """
+        return pulumi.get(self, "start_using_default_mapping")
+
 
 @pulumi.output_type
 class GetPipelinesPipelineCollectionItemProcessOptionInitialDataLoadResult(dict):

pulumi_oci/goldengate/pipeline.py

@@ -212,6 +212,7 @@ class _PipelineState:
                  lifecycle_sub_state: Optional[pulumi.Input[builtins.str]] = None,
                  locks: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineLockArgs']]]] = None,
                  mapping_rules: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineMappingRuleArgs']]]] = None,
+                 pipeline_diagnostic_datas: Optional[pulumi.Input[Sequence[pulumi.Input['PipelinePipelineDiagnosticDataArgs']]]] = None,
                  process_options: Optional[pulumi.Input['PipelineProcessOptionsArgs']] = None,
                  recipe_type: Optional[pulumi.Input[builtins.str]] = None,
                  source_connection_details: Optional[pulumi.Input['PipelineSourceConnectionDetailsArgs']] = None,
@@ -235,6 +236,7 @@ class _PipelineState:
         :param pulumi.Input[builtins.str] lifecycle_sub_state: Possible lifecycle substates when retrieving a pipeline.
         :param pulumi.Input[Sequence[pulumi.Input['PipelineLockArgs']]] locks: Locks associated with this resource.
         :param pulumi.Input[Sequence[pulumi.Input['PipelineMappingRuleArgs']]] mapping_rules: Mapping for source/target schema/tables for the pipeline data replication.
+        :param pulumi.Input[Sequence[pulumi.Input['PipelinePipelineDiagnosticDataArgs']]] pipeline_diagnostic_datas: Information regarding the pipeline diagnostic collection
         :param pulumi.Input['PipelineProcessOptionsArgs'] process_options: (Updatable) Required pipeline options to configure the replication process (Extract or Replicat).
         :param pulumi.Input[builtins.str] recipe_type: (Updatable) The type of the recipe
         :param pulumi.Input['PipelineSourceConnectionDetailsArgs'] source_connection_details: The source connection details for creating a pipeline.
@@ -269,6 +271,8 @@ class _PipelineState:
             pulumi.set(__self__, "locks", locks)
         if mapping_rules is not None:
             pulumi.set(__self__, "mapping_rules", mapping_rules)
+        if pipeline_diagnostic_datas is not None:
+            pulumi.set(__self__, "pipeline_diagnostic_datas", pipeline_diagnostic_datas)
         if process_options is not None:
             pulumi.set(__self__, "process_options", process_options)
         if recipe_type is not None:
@@ -432,6 +436,18 @@ class _PipelineState:
     def mapping_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineMappingRuleArgs']]]]):
         pulumi.set(self, "mapping_rules", value)
 
+    @property
+    @pulumi.getter(name="pipelineDiagnosticDatas")
+    def pipeline_diagnostic_datas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PipelinePipelineDiagnosticDataArgs']]]]:
+        """
+        Information regarding the pipeline diagnostic collection
+        """
+        return pulumi.get(self, "pipeline_diagnostic_datas")
+
+    @pipeline_diagnostic_datas.setter
+    def pipeline_diagnostic_datas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PipelinePipelineDiagnosticDataArgs']]]]):
+        pulumi.set(self, "pipeline_diagnostic_datas", value)
+
     @property
     @pulumi.getter(name="processOptions")
     def process_options(self) -> Optional[pulumi.Input['PipelineProcessOptionsArgs']]:
@@ -667,6 +683,7 @@ class Pipeline(pulumi.CustomResource):
             __props__.__dict__["lifecycle_details"] = None
             __props__.__dict__["lifecycle_sub_state"] = None
             __props__.__dict__["mapping_rules"] = None
+            __props__.__dict__["pipeline_diagnostic_datas"] = None
             __props__.__dict__["state"] = None
             __props__.__dict__["system_tags"] = None
             __props__.__dict__["time_created"] = None
@@ -694,6 +711,7 @@ class Pipeline(pulumi.CustomResource):
             lifecycle_sub_state: Optional[pulumi.Input[builtins.str]] = None,
             locks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['PipelineLockArgs', 'PipelineLockArgsDict']]]]] = None,
             mapping_rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['PipelineMappingRuleArgs', 'PipelineMappingRuleArgsDict']]]]] = None,
+            pipeline_diagnostic_datas: Optional[pulumi.Input[Sequence[pulumi.Input[Union['PipelinePipelineDiagnosticDataArgs', 'PipelinePipelineDiagnosticDataArgsDict']]]]] = None,
             process_options: Optional[pulumi.Input[Union['PipelineProcessOptionsArgs', 'PipelineProcessOptionsArgsDict']]] = None,
             recipe_type: Optional[pulumi.Input[builtins.str]] = None,
             source_connection_details: Optional[pulumi.Input[Union['PipelineSourceConnectionDetailsArgs', 'PipelineSourceConnectionDetailsArgsDict']]] = None,
@@ -722,6 +740,7 @@ class Pipeline(pulumi.CustomResource):
         :param pulumi.Input[builtins.str] lifecycle_sub_state: Possible lifecycle substates when retrieving a pipeline.
         :param pulumi.Input[Sequence[pulumi.Input[Union['PipelineLockArgs', 'PipelineLockArgsDict']]]] locks: Locks associated with this resource.
         :param pulumi.Input[Sequence[pulumi.Input[Union['PipelineMappingRuleArgs', 'PipelineMappingRuleArgsDict']]]] mapping_rules: Mapping for source/target schema/tables for the pipeline data replication.
+        :param pulumi.Input[Sequence[pulumi.Input[Union['PipelinePipelineDiagnosticDataArgs', 'PipelinePipelineDiagnosticDataArgsDict']]]] pipeline_diagnostic_datas: Information regarding the pipeline diagnostic collection
         :param pulumi.Input[Union['PipelineProcessOptionsArgs', 'PipelineProcessOptionsArgsDict']] process_options: (Updatable) Required pipeline options to configure the replication process (Extract or Replicat).
         :param pulumi.Input[builtins.str] recipe_type: (Updatable) The type of the recipe
         :param pulumi.Input[Union['PipelineSourceConnectionDetailsArgs', 'PipelineSourceConnectionDetailsArgsDict']] source_connection_details: The source connection details for creating a pipeline.
@@ -748,6 +767,7 @@ class Pipeline(pulumi.CustomResource):
         __props__.__dict__["lifecycle_sub_state"] = lifecycle_sub_state
         __props__.__dict__["locks"] = locks
         __props__.__dict__["mapping_rules"] = mapping_rules
+        __props__.__dict__["pipeline_diagnostic_datas"] = pipeline_diagnostic_datas
         __props__.__dict__["process_options"] = process_options
         __props__.__dict__["recipe_type"] = recipe_type
         __props__.__dict__["source_connection_details"] = source_connection_details
@@ -855,6 +875,14 @@ class Pipeline(pulumi.CustomResource):
         """
         return pulumi.get(self, "mapping_rules")
 
+    @property
+    @pulumi.getter(name="pipelineDiagnosticDatas")
+    def pipeline_diagnostic_datas(self) -> pulumi.Output[Sequence['outputs.PipelinePipelineDiagnosticData']]:
+        """
+        Information regarding the pipeline diagnostic collection
+        """
+        return pulumi.get(self, "pipeline_diagnostic_datas")
+
     @property
     @pulumi.getter(name="processOptions")
     def process_options(self) -> pulumi.Output['outputs.PipelineProcessOptions']:

pulumi_oci/kms/_inputs.py

@@ -50,6 +50,8 @@ __all__ = [
     'VaultRestoreFromFileArgsDict',
     'VaultRestoreFromObjectStoreArgs',
     'VaultRestoreFromObjectStoreArgsDict',
+    'VaultVerificationReplicaVaultMetadataArgs',
+    'VaultVerificationReplicaVaultMetadataArgsDict',
     'GetEkmsPrivateEndpointsFilterArgs',
     'GetEkmsPrivateEndpointsFilterArgsDict',
     'GetKeyVersionsFilterArgs',
@@ -1229,6 +1231,52 @@ class VaultRestoreFromObjectStoreArgs:
         pulumi.set(self, "uri", value)
 
 
+if not MYPY:
+    class VaultVerificationReplicaVaultMetadataArgsDict(TypedDict):
+        idcs_account_name_url: pulumi.Input[builtins.str]
+        private_endpoint_id: pulumi.Input[builtins.str]
+        vault_type: pulumi.Input[builtins.str]
+elif False:
+    VaultVerificationReplicaVaultMetadataArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class VaultVerificationReplicaVaultMetadataArgs:
+    def __init__(__self__, *,
+                 idcs_account_name_url: pulumi.Input[builtins.str],
+                 private_endpoint_id: pulumi.Input[builtins.str],
+                 vault_type: pulumi.Input[builtins.str]):
+        pulumi.set(__self__, "idcs_account_name_url", idcs_account_name_url)
+        pulumi.set(__self__, "private_endpoint_id", private_endpoint_id)
+        pulumi.set(__self__, "vault_type", vault_type)
+
+    @property
+    @pulumi.getter(name="idcsAccountNameUrl")
+    def idcs_account_name_url(self) -> pulumi.Input[builtins.str]:
+        return pulumi.get(self, "idcs_account_name_url")
+
+    @idcs_account_name_url.setter
+    def idcs_account_name_url(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "idcs_account_name_url", value)
+
+    @property
+    @pulumi.getter(name="privateEndpointId")
+    def private_endpoint_id(self) -> pulumi.Input[builtins.str]:
+        return pulumi.get(self, "private_endpoint_id")
+
+    @private_endpoint_id.setter
+    def private_endpoint_id(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "private_endpoint_id", value)
+
+    @property
+    @pulumi.getter(name="vaultType")
+    def vault_type(self) -> pulumi.Input[builtins.str]:
+        return pulumi.get(self, "vault_type")
+
+    @vault_type.setter
+    def vault_type(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "vault_type", value)
+
+
 if not MYPY:
     class GetEkmsPrivateEndpointsFilterArgsDict(TypedDict):
         name: builtins.str

pulumi_oci/kms/outputs.py

@@ -34,6 +34,7 @@ __all__ = [
     'VaultReplicaDetail',
     'VaultRestoreFromFile',
     'VaultRestoreFromObjectStore',
+    'VaultVerificationReplicaVaultMetadata',
     'GetEkmsPrivateEndpointsEkmsPrivateEndpointResult',
     'GetEkmsPrivateEndpointsFilterResult',
     'GetKeyAutoKeyRotationDetailResult',
@@ -1060,6 +1061,53 @@ class VaultRestoreFromObjectStore(dict):
         return pulumi.get(self, "uri")
 
 
+@pulumi.output_type
+class VaultVerificationReplicaVaultMetadata(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "idcsAccountNameUrl":
+            suggest = "idcs_account_name_url"
+        elif key == "privateEndpointId":
+            suggest = "private_endpoint_id"
+        elif key == "vaultType":
+            suggest = "vault_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in VaultVerificationReplicaVaultMetadata. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        VaultVerificationReplicaVaultMetadata.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        VaultVerificationReplicaVaultMetadata.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 idcs_account_name_url: builtins.str,
+                 private_endpoint_id: builtins.str,
+                 vault_type: builtins.str):
+        pulumi.set(__self__, "idcs_account_name_url", idcs_account_name_url)
+        pulumi.set(__self__, "private_endpoint_id", private_endpoint_id)
+        pulumi.set(__self__, "vault_type", vault_type)
+
+    @property
+    @pulumi.getter(name="idcsAccountNameUrl")
+    def idcs_account_name_url(self) -> builtins.str:
+        return pulumi.get(self, "idcs_account_name_url")
+
+    @property
+    @pulumi.getter(name="privateEndpointId")
+    def private_endpoint_id(self) -> builtins.str:
+        return pulumi.get(self, "private_endpoint_id")
+
+    @property
+    @pulumi.getter(name="vaultType")
+    def vault_type(self) -> builtins.str:
+        return pulumi.get(self, "vault_type")
+
+
 @pulumi.output_type
 class GetEkmsPrivateEndpointsEkmsPrivateEndpointResult(dict):
     def __init__(__self__, *,