pulumi-databricks 1.75.0a1756323569__py3-none-any.whl → 1.77.0__py3-none-any.whl

pulumi_databricks/get_database_instance.py

@@ -14,7 +14,6 @@ else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 from . import outputs
-from ._inputs import *
 
 __all__ = [
     'GetDatabaseInstanceResult',
@@ -28,7 +27,7 @@ class GetDatabaseInstanceResult:
     """
     A collection of values returned by getDatabaseInstance.
     """
-    def __init__(__self__, capacity=None, child_instance_refs=None, creation_time=None, creator=None, effective_enable_readable_secondaries=None, effective_node_count=None, effective_retention_window_in_days=None, effective_stopped=None, enable_readable_secondaries=None, id=None, name=None, node_count=None, parent_instance_ref=None, pg_version=None, read_only_dns=None, read_write_dns=None, retention_window_in_days=None, state=None, stopped=None, uid=None):
+    def __init__(__self__, capacity=None, child_instance_refs=None, creation_time=None, creator=None, custom_tags=None, effective_capacity=None, effective_custom_tags=None, effective_enable_pg_native_login=None, effective_enable_readable_secondaries=None, effective_node_count=None, effective_retention_window_in_days=None, effective_stopped=None, effective_usage_policy_id=None, enable_pg_native_login=None, enable_readable_secondaries=None, id=None, name=None, node_count=None, parent_instance_ref=None, pg_version=None, read_only_dns=None, read_write_dns=None, retention_window_in_days=None, state=None, stopped=None, uid=None, usage_policy_id=None):
         if capacity and not isinstance(capacity, str):
             raise TypeError("Expected argument 'capacity' to be a str")
         pulumi.set(__self__, "capacity", capacity)
@@ -41,6 +40,18 @@ class GetDatabaseInstanceResult:
         if creator and not isinstance(creator, str):
             raise TypeError("Expected argument 'creator' to be a str")
         pulumi.set(__self__, "creator", creator)
+        if custom_tags and not isinstance(custom_tags, list):
+            raise TypeError("Expected argument 'custom_tags' to be a list")
+        pulumi.set(__self__, "custom_tags", custom_tags)
+        if effective_capacity and not isinstance(effective_capacity, str):
+            raise TypeError("Expected argument 'effective_capacity' to be a str")
+        pulumi.set(__self__, "effective_capacity", effective_capacity)
+        if effective_custom_tags and not isinstance(effective_custom_tags, list):
+            raise TypeError("Expected argument 'effective_custom_tags' to be a list")
+        pulumi.set(__self__, "effective_custom_tags", effective_custom_tags)
+        if effective_enable_pg_native_login and not isinstance(effective_enable_pg_native_login, bool):
+            raise TypeError("Expected argument 'effective_enable_pg_native_login' to be a bool")
+        pulumi.set(__self__, "effective_enable_pg_native_login", effective_enable_pg_native_login)
         if effective_enable_readable_secondaries and not isinstance(effective_enable_readable_secondaries, bool):
             raise TypeError("Expected argument 'effective_enable_readable_secondaries' to be a bool")
         pulumi.set(__self__, "effective_enable_readable_secondaries", effective_enable_readable_secondaries)
@@ -53,6 +64,12 @@ class GetDatabaseInstanceResult:
         if effective_stopped and not isinstance(effective_stopped, bool):
             raise TypeError("Expected argument 'effective_stopped' to be a bool")
         pulumi.set(__self__, "effective_stopped", effective_stopped)
+        if effective_usage_policy_id and not isinstance(effective_usage_policy_id, str):
+            raise TypeError("Expected argument 'effective_usage_policy_id' to be a str")
+        pulumi.set(__self__, "effective_usage_policy_id", effective_usage_policy_id)
+        if enable_pg_native_login and not isinstance(enable_pg_native_login, bool):
+            raise TypeError("Expected argument 'enable_pg_native_login' to be a bool")
+        pulumi.set(__self__, "enable_pg_native_login", enable_pg_native_login)
         if enable_readable_secondaries and not isinstance(enable_readable_secondaries, bool):
             raise TypeError("Expected argument 'enable_readable_secondaries' to be a bool")
         pulumi.set(__self__, "enable_readable_secondaries", enable_readable_secondaries)
@@ -89,10 +106,13 @@ class GetDatabaseInstanceResult:
         if uid and not isinstance(uid, str):
             raise TypeError("Expected argument 'uid' to be a str")
         pulumi.set(__self__, "uid", uid)
+        if usage_policy_id and not isinstance(usage_policy_id, str):
+            raise TypeError("Expected argument 'usage_policy_id' to be a str")
+        pulumi.set(__self__, "usage_policy_id", usage_policy_id)
 
     @_builtins.property
     @pulumi.getter
-    def capacity(self) -> Optional[_builtins.str]:
+    def capacity(self) -> _builtins.str:
         """
         (string) - The sku of the instance. Valid values are "CU_1", "CU_2", "CU_4", "CU_8"
         """
@@ -123,13 +143,43 @@ class GetDatabaseInstanceResult:
         """
         return pulumi.get(self, "creator")
 
+    @_builtins.property
+    @pulumi.getter(name="customTags")
+    def custom_tags(self) -> Sequence['outputs.GetDatabaseInstanceCustomTagResult']:
+        """
+        (list of CustomTag) - Custom tags associated with the instance. This field is only included on create and update responses
+        """
+        return pulumi.get(self, "custom_tags")
+
+    @_builtins.property
+    @pulumi.getter(name="effectiveCapacity")
+    def effective_capacity(self) -> _builtins.str:
+        """
+        (string, deprecated) - Deprecated. The sku of the instance; this field will always match the value of capacity
+        """
+        return pulumi.get(self, "effective_capacity")
+
+    @_builtins.property
+    @pulumi.getter(name="effectiveCustomTags")
+    def effective_custom_tags(self) -> Sequence['outputs.GetDatabaseInstanceEffectiveCustomTagResult']:
+        """
+        (list of CustomTag) - The recorded custom tags associated with the instance
+        """
+        return pulumi.get(self, "effective_custom_tags")
+
+    @_builtins.property
+    @pulumi.getter(name="effectiveEnablePgNativeLogin")
+    def effective_enable_pg_native_login(self) -> _builtins.bool:
+        """
+        (boolean) - Whether the instance has PG native password login enabled
+        """
+        return pulumi.get(self, "effective_enable_pg_native_login")
+
     @_builtins.property
     @pulumi.getter(name="effectiveEnableReadableSecondaries")
     def effective_enable_readable_secondaries(self) -> _builtins.bool:
         """
-        (boolean) - xref AIP-129. `enable_readable_secondaries` is owned by the client, while `effective_enable_readable_secondaries` is owned by the server.
-        `enable_readable_secondaries` will only be set in Create/Update response messages if and only if the user provides the field via the request.
-        `effective_enable_readable_secondaries` on the other hand will always bet set in all response messages (Create/Update/Get/List)
+        (boolean) - Whether secondaries serving read-only traffic are enabled. Defaults to false
         """
         return pulumi.get(self, "effective_enable_readable_secondaries")
 
@@ -137,9 +187,8 @@ class GetDatabaseInstanceResult:
     @pulumi.getter(name="effectiveNodeCount")
     def effective_node_count(self) -> _builtins.int:
         """
-        (integer) - xref AIP-129. `node_count` is owned by the client, while `effective_node_count` is owned by the server.
-        `node_count` will only be set in Create/Update response messages if and only if the user provides the field via the request.
-        `effective_node_count` on the other hand will always bet set in all response messages (Create/Update/Get/List)
+        (integer) - The number of nodes in the instance, composed of 1 primary and 0 or more secondaries. Defaults to
+        1 primary and 0 secondaries
         """
         return pulumi.get(self, "effective_node_count")
 
@@ -147,9 +196,8 @@ class GetDatabaseInstanceResult:
     @pulumi.getter(name="effectiveRetentionWindowInDays")
     def effective_retention_window_in_days(self) -> _builtins.int:
         """
-        (integer) - xref AIP-129. `retention_window_in_days` is owned by the client, while `effective_retention_window_in_days` is owned by the server.
-        `retention_window_in_days` will only be set in Create/Update response messages if and only if the user provides the field via the request.
-        `effective_retention_window_in_days` on the other hand will always bet set in all response messages (Create/Update/Get/List)
+        (integer) - The retention window for the instance. This is the time window in days
+        for which the historical data is retained
         """
         return pulumi.get(self, "effective_retention_window_in_days")
 
@@ -157,15 +205,29 @@ class GetDatabaseInstanceResult:
     @pulumi.getter(name="effectiveStopped")
     def effective_stopped(self) -> _builtins.bool:
         """
-        (boolean) - xref AIP-129. `stopped` is owned by the client, while `effective_stopped` is owned by the server.
-        `stopped` will only be set in Create/Update response messages if and only if the user provides the field via the request.
-        `effective_stopped` on the other hand will always bet set in all response messages (Create/Update/Get/List)
+        (boolean) - Whether the instance is stopped
         """
         return pulumi.get(self, "effective_stopped")
 
+    @_builtins.property
+    @pulumi.getter(name="effectiveUsagePolicyId")
+    def effective_usage_policy_id(self) -> _builtins.str:
+        """
+        (string) - The policy that is applied to the instance
+        """
+        return pulumi.get(self, "effective_usage_policy_id")
+
+    @_builtins.property
+    @pulumi.getter(name="enablePgNativeLogin")
+    def enable_pg_native_login(self) -> _builtins.bool:
+        """
+        (boolean) - Whether to enable PG native password login on the instance. Defaults to false
+        """
+        return pulumi.get(self, "enable_pg_native_login")
+
     @_builtins.property
     @pulumi.getter(name="enableReadableSecondaries")
-    def enable_readable_secondaries(self) -> Optional[_builtins.bool]:
+    def enable_readable_secondaries(self) -> _builtins.bool:
         """
         (boolean) - Whether to enable secondaries to serve read-only traffic. Defaults to false
         """
@@ -189,16 +251,16 @@ class GetDatabaseInstanceResult:
 
     @_builtins.property
     @pulumi.getter(name="nodeCount")
-    def node_count(self) -> Optional[_builtins.int]:
+    def node_count(self) -> _builtins.int:
         """
         (integer) - The number of nodes in the instance, composed of 1 primary and 0 or more secondaries. Defaults to
-        1 primary and 0 secondaries
+        1 primary and 0 secondaries. This field is input only, see effective_node_count for the output
         """
         return pulumi.get(self, "node_count")
 
     @_builtins.property
     @pulumi.getter(name="parentInstanceRef")
-    def parent_instance_ref(self) -> Optional['outputs.GetDatabaseInstanceParentInstanceRefResult']:
+    def parent_instance_ref(self) -> 'outputs.GetDatabaseInstanceParentInstanceRefResult':
         """
         (DatabaseInstanceRef) - The ref of the parent instance. This is only available if the instance is
         child instance.
@@ -234,7 +296,7 @@ class GetDatabaseInstanceResult:
 
     @_builtins.property
     @pulumi.getter(name="retentionWindowInDays")
-    def retention_window_in_days(self) -> Optional[_builtins.int]:
+    def retention_window_in_days(self) -> _builtins.int:
         """
         (integer) - The retention window for the instance. This is the time window in days
         for which the historical data is retained. The default value is 7 days.
@@ -252,9 +314,9 @@ class GetDatabaseInstanceResult:
 
     @_builtins.property
     @pulumi.getter
-    def stopped(self) -> Optional[_builtins.bool]:
+    def stopped(self) -> _builtins.bool:
         """
-        (boolean) - Whether the instance is stopped
+        (boolean) - Whether to stop the instance. An input only param, see effective_stopped for the output
         """
         return pulumi.get(self, "stopped")
 
@@ -266,6 +328,14 @@ class GetDatabaseInstanceResult:
         """
         return pulumi.get(self, "uid")
 
+    @_builtins.property
+    @pulumi.getter(name="usagePolicyId")
+    def usage_policy_id(self) -> _builtins.str:
+        """
+        (string) - The desired usage policy to associate with the instance
+        """
+        return pulumi.get(self, "usage_policy_id")
+
 
 class AwaitableGetDatabaseInstanceResult(GetDatabaseInstanceResult):
     # pylint: disable=using-constant-test
@@ -277,10 +347,16 @@ class AwaitableGetDatabaseInstanceResult(GetDatabaseInstanceResult):
             child_instance_refs=self.child_instance_refs,
             creation_time=self.creation_time,
             creator=self.creator,
+            custom_tags=self.custom_tags,
+            effective_capacity=self.effective_capacity,
+            effective_custom_tags=self.effective_custom_tags,
+            effective_enable_pg_native_login=self.effective_enable_pg_native_login,
             effective_enable_readable_secondaries=self.effective_enable_readable_secondaries,
             effective_node_count=self.effective_node_count,
             effective_retention_window_in_days=self.effective_retention_window_in_days,
             effective_stopped=self.effective_stopped,
+            effective_usage_policy_id=self.effective_usage_policy_id,
+            enable_pg_native_login=self.enable_pg_native_login,
             enable_readable_secondaries=self.enable_readable_secondaries,
             id=self.id,
             name=self.name,
@@ -292,18 +368,15 @@ class AwaitableGetDatabaseInstanceResult(GetDatabaseInstanceResult):
             retention_window_in_days=self.retention_window_in_days,
             state=self.state,
             stopped=self.stopped,
-            uid=self.uid)
+            uid=self.uid,
+            usage_policy_id=self.usage_policy_id)
 
 
-def get_database_instance(capacity: Optional[_builtins.str] = None,
-                          enable_readable_secondaries: Optional[_builtins.bool] = None,
-                          name: Optional[_builtins.str] = None,
-                          node_count: Optional[_builtins.int] = None,
-                          parent_instance_ref: Optional[Union['GetDatabaseInstanceParentInstanceRefArgs', 'GetDatabaseInstanceParentInstanceRefArgsDict']] = None,
-                          retention_window_in_days: Optional[_builtins.int] = None,
-                          stopped: Optional[_builtins.bool] = None,
+def get_database_instance(name: Optional[_builtins.str] = None,
                           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDatabaseInstanceResult:
     """
+    [![Public Preview](https://img.shields.io/badge/Release_Stage-Public_Preview-yellowgreen)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
     This data source can be used to get a single Database Instance.
 
     ## Example Usage
@@ -318,28 +391,10 @@ def get_database_instance(capacity: Optional[_builtins.str] = None,
     ```
 
 
-    :param _builtins.str capacity: (string) - The sku of the instance. Valid values are "CU_1", "CU_2", "CU_4", "CU_8"
-    :param _builtins.bool enable_readable_secondaries: (boolean) - Whether to enable secondaries to serve read-only traffic. Defaults to false
     :param _builtins.str name: The name of the instance. This is the unique identifier for the instance
-    :param _builtins.int node_count: (integer) - The number of nodes in the instance, composed of 1 primary and 0 or more secondaries. Defaults to
-           1 primary and 0 secondaries
-    :param Union['GetDatabaseInstanceParentInstanceRefArgs', 'GetDatabaseInstanceParentInstanceRefArgsDict'] parent_instance_ref: (DatabaseInstanceRef) - The ref of the parent instance. This is only available if the instance is
-           child instance.
-           Input: For specifying the parent instance to create a child instance. Optional.
-           Output: Only populated if provided as input to create a child instance
-    :param _builtins.int retention_window_in_days: (integer) - The retention window for the instance. This is the time window in days
-           for which the historical data is retained. The default value is 7 days.
-           Valid values are 2 to 35 days
-    :param _builtins.bool stopped: (boolean) - Whether the instance is stopped
     """
     __args__ = dict()
-    __args__['capacity'] = capacity
-    __args__['enableReadableSecondaries'] = enable_readable_secondaries
     __args__['name'] = name
-    __args__['nodeCount'] = node_count
-    __args__['parentInstanceRef'] = parent_instance_ref
-    __args__['retentionWindowInDays'] = retention_window_in_days
-    __args__['stopped'] = stopped
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('databricks:index/getDatabaseInstance:getDatabaseInstance', __args__, opts=opts, typ=GetDatabaseInstanceResult).value
 
@@ -348,10 +403,16 @@ def get_database_instance(capacity: Optional[_builtins.str] = None,
         child_instance_refs=pulumi.get(__ret__, 'child_instance_refs'),
         creation_time=pulumi.get(__ret__, 'creation_time'),
         creator=pulumi.get(__ret__, 'creator'),
+        custom_tags=pulumi.get(__ret__, 'custom_tags'),
+        effective_capacity=pulumi.get(__ret__, 'effective_capacity'),
+        effective_custom_tags=pulumi.get(__ret__, 'effective_custom_tags'),
+        effective_enable_pg_native_login=pulumi.get(__ret__, 'effective_enable_pg_native_login'),
         effective_enable_readable_secondaries=pulumi.get(__ret__, 'effective_enable_readable_secondaries'),
         effective_node_count=pulumi.get(__ret__, 'effective_node_count'),
         effective_retention_window_in_days=pulumi.get(__ret__, 'effective_retention_window_in_days'),
         effective_stopped=pulumi.get(__ret__, 'effective_stopped'),
+        effective_usage_policy_id=pulumi.get(__ret__, 'effective_usage_policy_id'),
+        enable_pg_native_login=pulumi.get(__ret__, 'enable_pg_native_login'),
         enable_readable_secondaries=pulumi.get(__ret__, 'enable_readable_secondaries'),
         id=pulumi.get(__ret__, 'id'),
         name=pulumi.get(__ret__, 'name'),
@@ -363,16 +424,13 @@ def get_database_instance(capacity: Optional[_builtins.str] = None,
         retention_window_in_days=pulumi.get(__ret__, 'retention_window_in_days'),
         state=pulumi.get(__ret__, 'state'),
         stopped=pulumi.get(__ret__, 'stopped'),
-        uid=pulumi.get(__ret__, 'uid'))
-def get_database_instance_output(capacity: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
-                                 enable_readable_secondaries: Optional[pulumi.Input[Optional[_builtins.bool]]] = None,
-                                 name: Optional[pulumi.Input[_builtins.str]] = None,
-                                 node_count: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
-                                 parent_instance_ref: Optional[pulumi.Input[Optional[Union['GetDatabaseInstanceParentInstanceRefArgs', 'GetDatabaseInstanceParentInstanceRefArgsDict']]]] = None,
-                                 retention_window_in_days: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
-                                 stopped: Optional[pulumi.Input[Optional[_builtins.bool]]] = None,
+        uid=pulumi.get(__ret__, 'uid'),
+        usage_policy_id=pulumi.get(__ret__, 'usage_policy_id'))
+def get_database_instance_output(name: Optional[pulumi.Input[_builtins.str]] = None,
                                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDatabaseInstanceResult]:
     """
+    [![Public Preview](https://img.shields.io/badge/Release_Stage-Public_Preview-yellowgreen)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
     This data source can be used to get a single Database Instance.
 
     ## Example Usage
@@ -387,28 +445,10 @@ def get_database_instance_output(capacity: Optional[pulumi.Input[Optional[_built
     ```
 
 
-    :param _builtins.str capacity: (string) - The sku of the instance. Valid values are "CU_1", "CU_2", "CU_4", "CU_8"
-    :param _builtins.bool enable_readable_secondaries: (boolean) - Whether to enable secondaries to serve read-only traffic. Defaults to false
     :param _builtins.str name: The name of the instance. This is the unique identifier for the instance
-    :param _builtins.int node_count: (integer) - The number of nodes in the instance, composed of 1 primary and 0 or more secondaries. Defaults to
-           1 primary and 0 secondaries
-    :param Union['GetDatabaseInstanceParentInstanceRefArgs', 'GetDatabaseInstanceParentInstanceRefArgsDict'] parent_instance_ref: (DatabaseInstanceRef) - The ref of the parent instance. This is only available if the instance is
-           child instance.
-           Input: For specifying the parent instance to create a child instance. Optional.
-           Output: Only populated if provided as input to create a child instance
-    :param _builtins.int retention_window_in_days: (integer) - The retention window for the instance. This is the time window in days
-           for which the historical data is retained. The default value is 7 days.
-           Valid values are 2 to 35 days
-    :param _builtins.bool stopped: (boolean) - Whether the instance is stopped
     """
     __args__ = dict()
-    __args__['capacity'] = capacity
-    __args__['enableReadableSecondaries'] = enable_readable_secondaries
     __args__['name'] = name
-    __args__['nodeCount'] = node_count
-    __args__['parentInstanceRef'] = parent_instance_ref
-    __args__['retentionWindowInDays'] = retention_window_in_days
-    __args__['stopped'] = stopped
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('databricks:index/getDatabaseInstance:getDatabaseInstance', __args__, opts=opts, typ=GetDatabaseInstanceResult)
     return __ret__.apply(lambda __response__: GetDatabaseInstanceResult(
@@ -416,10 +456,16 @@ def get_database_instance_output(capacity: Optional[pulumi.Input[Optional[_built
         child_instance_refs=pulumi.get(__response__, 'child_instance_refs'),
         creation_time=pulumi.get(__response__, 'creation_time'),
         creator=pulumi.get(__response__, 'creator'),
+        custom_tags=pulumi.get(__response__, 'custom_tags'),
+        effective_capacity=pulumi.get(__response__, 'effective_capacity'),
+        effective_custom_tags=pulumi.get(__response__, 'effective_custom_tags'),
+        effective_enable_pg_native_login=pulumi.get(__response__, 'effective_enable_pg_native_login'),
         effective_enable_readable_secondaries=pulumi.get(__response__, 'effective_enable_readable_secondaries'),
         effective_node_count=pulumi.get(__response__, 'effective_node_count'),
         effective_retention_window_in_days=pulumi.get(__response__, 'effective_retention_window_in_days'),
         effective_stopped=pulumi.get(__response__, 'effective_stopped'),
+        effective_usage_policy_id=pulumi.get(__response__, 'effective_usage_policy_id'),
+        enable_pg_native_login=pulumi.get(__response__, 'enable_pg_native_login'),
         enable_readable_secondaries=pulumi.get(__response__, 'enable_readable_secondaries'),
         id=pulumi.get(__response__, 'id'),
         name=pulumi.get(__response__, 'name'),
@@ -431,4 +477,5 @@ def get_database_instance_output(capacity: Optional[pulumi.Input[Optional[_built
         retention_window_in_days=pulumi.get(__response__, 'retention_window_in_days'),
         state=pulumi.get(__response__, 'state'),
         stopped=pulumi.get(__response__, 'stopped'),
-        uid=pulumi.get(__response__, 'uid')))
+        uid=pulumi.get(__response__, 'uid'),
+        usage_policy_id=pulumi.get(__response__, 'usage_policy_id')))

pulumi_databricks/get_database_instances.py

@@ -27,13 +27,16 @@ class GetDatabaseInstancesResult:
     """
     A collection of values returned by getDatabaseInstances.
     """
-    def __init__(__self__, database_instances=None, id=None):
+    def __init__(__self__, database_instances=None, id=None, page_size=None):
         if database_instances and not isinstance(database_instances, list):
             raise TypeError("Expected argument 'database_instances' to be a list")
         pulumi.set(__self__, "database_instances", database_instances)
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
+        if page_size and not isinstance(page_size, int):
+            raise TypeError("Expected argument 'page_size' to be a int")
+        pulumi.set(__self__, "page_size", page_size)
 
     @_builtins.property
     @pulumi.getter(name="databaseInstances")
@@ -48,6 +51,11 @@ class GetDatabaseInstancesResult:
         """
         return pulumi.get(self, "id")
 
+    @_builtins.property
+    @pulumi.getter(name="pageSize")
+    def page_size(self) -> Optional[_builtins.int]:
+        return pulumi.get(self, "page_size")
+
 
 class AwaitableGetDatabaseInstancesResult(GetDatabaseInstancesResult):
     # pylint: disable=using-constant-test
@@ -56,11 +64,15 @@ class AwaitableGetDatabaseInstancesResult(GetDatabaseInstancesResult):
             yield self
         return GetDatabaseInstancesResult(
             database_instances=self.database_instances,
-            id=self.id)
+            id=self.id,
+            page_size=self.page_size)
 
 
-def get_database_instances(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDatabaseInstancesResult:
+def get_database_instances(page_size: Optional[_builtins.int] = None,
+                           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDatabaseInstancesResult:
     """
+    [![Public Preview](https://img.shields.io/badge/Release_Stage-Public_Preview-yellowgreen)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
     This data source can be used to fetch the list of Database Instances within the workspace.
     The list can then be accessed via the data object's `database_instances` field.
 
@@ -75,16 +87,24 @@ def get_database_instances(opts: Optional[pulumi.InvokeOptions] = None) -> Await
     all = databricks.get_database_instances()
     pulumi.export("allDatabaseInstances", all.database_instances)
     ```
+
+
+    :param _builtins.int page_size: Upper bound for items returned
     """
     __args__ = dict()
+    __args__['pageSize'] = page_size
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('databricks:index/getDatabaseInstances:getDatabaseInstances', __args__, opts=opts, typ=GetDatabaseInstancesResult).value
 
     return AwaitableGetDatabaseInstancesResult(
         database_instances=pulumi.get(__ret__, 'database_instances'),
-        id=pulumi.get(__ret__, 'id'))
-def get_database_instances_output(opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDatabaseInstancesResult]:
+        id=pulumi.get(__ret__, 'id'),
+        page_size=pulumi.get(__ret__, 'page_size'))
+def get_database_instances_output(page_size: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
+                                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDatabaseInstancesResult]:
     """
+    [![Public Preview](https://img.shields.io/badge/Release_Stage-Public_Preview-yellowgreen)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
     This data source can be used to fetch the list of Database Instances within the workspace.
     The list can then be accessed via the data object's `database_instances` field.
 
@@ -99,10 +119,15 @@ def get_database_instances_output(opts: Optional[Union[pulumi.InvokeOptions, pul
     all = databricks.get_database_instances()
     pulumi.export("allDatabaseInstances", all.database_instances)
     ```
+
+
+    :param _builtins.int page_size: Upper bound for items returned
     """
     __args__ = dict()
+    __args__['pageSize'] = page_size
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('databricks:index/getDatabaseInstances:getDatabaseInstances', __args__, opts=opts, typ=GetDatabaseInstancesResult)
     return __ret__.apply(lambda __response__: GetDatabaseInstancesResult(
         database_instances=pulumi.get(__response__, 'database_instances'),
-        id=pulumi.get(__response__, 'id')))
+        id=pulumi.get(__response__, 'id'),
+        page_size=pulumi.get(__response__, 'page_size')))

pulumi_databricks/get_database_synced_database_table.py

@@ -14,7 +14,6 @@ else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 from . import outputs
-from ._inputs import *
 
 __all__ = [
     'GetDatabaseSyncedDatabaseTableResult',
@@ -119,7 +118,7 @@ class GetDatabaseSyncedDatabaseTableResult:
 
     @_builtins.property
     @pulumi.getter
-    def spec(self) -> Optional['outputs.GetDatabaseSyncedDatabaseTableSpecResult']:
+    def spec(self) -> 'outputs.GetDatabaseSyncedDatabaseTableSpecResult':
         """
         (SyncedTableSpec)
         """
@@ -153,12 +152,11 @@ class AwaitableGetDatabaseSyncedDatabaseTableResult(GetDatabaseSyncedDatabaseTab
             unity_catalog_provisioning_state=self.unity_catalog_provisioning_state)
 
 
-def get_database_synced_database_table(database_instance_name: Optional[_builtins.str] = None,
-                                       logical_database_name: Optional[_builtins.str] = None,
-                                       name: Optional[_builtins.str] = None,
-                                       spec: Optional[Union['GetDatabaseSyncedDatabaseTableSpecArgs', 'GetDatabaseSyncedDatabaseTableSpecArgsDict']] = None,
+def get_database_synced_database_table(name: Optional[_builtins.str] = None,
                                        opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDatabaseSyncedDatabaseTableResult:
     """
+    [![Private Preview](https://img.shields.io/badge/Release_Stage-Private_Preview-blueviolet)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
     This data source can be used to get a single Synced Database Table.
 
     ## Example Usage
@@ -173,19 +171,10 @@ def get_database_synced_database_table(database_instance_name: Optional[_builtin
     ```
 
 
-    :param _builtins.str database_instance_name: (string) - Name of the target database instance. This is required when creating synced database tables in standard catalogs.
-           This is optional when creating synced database tables in registered catalogs. If this field is specified
-           when creating synced database tables in registered catalogs, the database instance name MUST
-           match that of the registered catalog (or the request will be rejected)
-    :param _builtins.str logical_database_name: (string) - Target Postgres database object (logical database) name for this table.
     :param _builtins.str name: Full three-part (catalog, schema, table) name of the table
-    :param Union['GetDatabaseSyncedDatabaseTableSpecArgs', 'GetDatabaseSyncedDatabaseTableSpecArgsDict'] spec: (SyncedTableSpec)
     """
     __args__ = dict()
-    __args__['databaseInstanceName'] = database_instance_name
-    __args__['logicalDatabaseName'] = logical_database_name
     __args__['name'] = name
-    __args__['spec'] = spec
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('databricks:index/getDatabaseSyncedDatabaseTable:getDatabaseSyncedDatabaseTable', __args__, opts=opts, typ=GetDatabaseSyncedDatabaseTableResult).value
 
@@ -199,12 +188,11 @@ def get_database_synced_database_table(database_instance_name: Optional[_builtin
         name=pulumi.get(__ret__, 'name'),
         spec=pulumi.get(__ret__, 'spec'),
         unity_catalog_provisioning_state=pulumi.get(__ret__, 'unity_catalog_provisioning_state'))
-def get_database_synced_database_table_output(database_instance_name: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
-                                              logical_database_name: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
-                                              name: Optional[pulumi.Input[_builtins.str]] = None,
-                                              spec: Optional[pulumi.Input[Optional[Union['GetDatabaseSyncedDatabaseTableSpecArgs', 'GetDatabaseSyncedDatabaseTableSpecArgsDict']]]] = None,
+def get_database_synced_database_table_output(name: Optional[pulumi.Input[_builtins.str]] = None,
                                               opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDatabaseSyncedDatabaseTableResult]:
     """
+    [![Private Preview](https://img.shields.io/badge/Release_Stage-Private_Preview-blueviolet)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
     This data source can be used to get a single Synced Database Table.
 
     ## Example Usage
@@ -219,19 +207,10 @@ def get_database_synced_database_table_output(database_instance_name: Optional[p
     ```
 
 
-    :param _builtins.str database_instance_name: (string) - Name of the target database instance. This is required when creating synced database tables in standard catalogs.
-           This is optional when creating synced database tables in registered catalogs. If this field is specified
-           when creating synced database tables in registered catalogs, the database instance name MUST
-           match that of the registered catalog (or the request will be rejected)
-    :param _builtins.str logical_database_name: (string) - Target Postgres database object (logical database) name for this table.
     :param _builtins.str name: Full three-part (catalog, schema, table) name of the table
-    :param Union['GetDatabaseSyncedDatabaseTableSpecArgs', 'GetDatabaseSyncedDatabaseTableSpecArgsDict'] spec: (SyncedTableSpec)
     """
     __args__ = dict()
-    __args__['databaseInstanceName'] = database_instance_name
-    __args__['logicalDatabaseName'] = logical_database_name
     __args__['name'] = name
-    __args__['spec'] = spec
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('databricks:index/getDatabaseSyncedDatabaseTable:getDatabaseSyncedDatabaseTable', __args__, opts=opts, typ=GetDatabaseSyncedDatabaseTableResult)
     return __ret__.apply(lambda __response__: GetDatabaseSyncedDatabaseTableResult(