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

pulumi_databricks/get_external_location.py

@@ -28,7 +28,7 @@ class GetExternalLocationResult:
     """
     A collection of values returned by getExternalLocation.
     """
-    def __init__(__self__, external_location_info=None, id=None, name=None):
+    def __init__(__self__, external_location_info=None, id=None, name=None, provider_config=None):
         if external_location_info and not isinstance(external_location_info, dict):
             raise TypeError("Expected argument 'external_location_info' to be a dict")
         pulumi.set(__self__, "external_location_info", external_location_info)
@@ -38,6 +38,9 @@ class GetExternalLocationResult:
         if name and not isinstance(name, str):
             raise TypeError("Expected argument 'name' to be a str")
         pulumi.set(__self__, "name", name)
+        if provider_config and not isinstance(provider_config, dict):
+            raise TypeError("Expected argument 'provider_config' to be a dict")
+        pulumi.set(__self__, "provider_config", provider_config)
 
     @_builtins.property
     @pulumi.getter(name="externalLocationInfo")
@@ -60,6 +63,11 @@ class GetExternalLocationResult:
     def name(self) -> _builtins.str:
         return pulumi.get(self, "name")
 
+    @_builtins.property
+    @pulumi.getter(name="providerConfig")
+    def provider_config(self) -> Optional['outputs.GetExternalLocationProviderConfigResult']:
+        return pulumi.get(self, "provider_config")
+
 
 class AwaitableGetExternalLocationResult(GetExternalLocationResult):
     # pylint: disable=using-constant-test
@@ -69,12 +77,14 @@ class AwaitableGetExternalLocationResult(GetExternalLocationResult):
         return GetExternalLocationResult(
             external_location_info=self.external_location_info,
             id=self.id,
-            name=self.name)
+            name=self.name,
+            provider_config=self.provider_config)
 
 
 def get_external_location(external_location_info: Optional[Union['GetExternalLocationExternalLocationInfoArgs', 'GetExternalLocationExternalLocationInfoArgsDict']] = None,
                           id: Optional[_builtins.str] = None,
                           name: Optional[_builtins.str] = None,
+                          provider_config: Optional[Union['GetExternalLocationProviderConfigArgs', 'GetExternalLocationProviderConfigArgsDict']] = None,
                           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetExternalLocationResult:
     """
     Retrieves details about a ExternalLocation that were created by Pulumi or manually.
@@ -104,21 +114,25 @@ def get_external_location(external_location_info: Optional[Union['GetExternalLoc
     :param Union['GetExternalLocationExternalLocationInfoArgs', 'GetExternalLocationExternalLocationInfoArgsDict'] external_location_info: array of objects with information about external location:
     :param _builtins.str id: external location ID - same as name.
     :param _builtins.str name: The name of the external location
+    :param Union['GetExternalLocationProviderConfigArgs', 'GetExternalLocationProviderConfigArgsDict'] provider_config: Configure the provider for management through account provider. This block consists of the following fields:
     """
     __args__ = dict()
     __args__['externalLocationInfo'] = external_location_info
     __args__['id'] = id
     __args__['name'] = name
+    __args__['providerConfig'] = provider_config
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('databricks:index/getExternalLocation:getExternalLocation', __args__, opts=opts, typ=GetExternalLocationResult).value
 
     return AwaitableGetExternalLocationResult(
         external_location_info=pulumi.get(__ret__, 'external_location_info'),
         id=pulumi.get(__ret__, 'id'),
-        name=pulumi.get(__ret__, 'name'))
+        name=pulumi.get(__ret__, 'name'),
+        provider_config=pulumi.get(__ret__, 'provider_config'))
 def get_external_location_output(external_location_info: Optional[pulumi.Input[Optional[Union['GetExternalLocationExternalLocationInfoArgs', 'GetExternalLocationExternalLocationInfoArgsDict']]]] = None,
                                  id: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                                  name: Optional[pulumi.Input[_builtins.str]] = None,
+                                 provider_config: Optional[pulumi.Input[Optional[Union['GetExternalLocationProviderConfigArgs', 'GetExternalLocationProviderConfigArgsDict']]]] = None,
                                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetExternalLocationResult]:
     """
     Retrieves details about a ExternalLocation that were created by Pulumi or manually.
@@ -148,14 +162,17 @@ def get_external_location_output(external_location_info: Optional[pulumi.Input[O
     :param Union['GetExternalLocationExternalLocationInfoArgs', 'GetExternalLocationExternalLocationInfoArgsDict'] external_location_info: array of objects with information about external location:
     :param _builtins.str id: external location ID - same as name.
     :param _builtins.str name: The name of the external location
+    :param Union['GetExternalLocationProviderConfigArgs', 'GetExternalLocationProviderConfigArgsDict'] provider_config: Configure the provider for management through account provider. This block consists of the following fields:
     """
     __args__ = dict()
     __args__['externalLocationInfo'] = external_location_info
     __args__['id'] = id
     __args__['name'] = name
+    __args__['providerConfig'] = provider_config
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('databricks:index/getExternalLocation:getExternalLocation', __args__, opts=opts, typ=GetExternalLocationResult)
     return __ret__.apply(lambda __response__: GetExternalLocationResult(
         external_location_info=pulumi.get(__response__, 'external_location_info'),
         id=pulumi.get(__response__, 'id'),
-        name=pulumi.get(__response__, 'name')))
+        name=pulumi.get(__response__, 'name'),
+        provider_config=pulumi.get(__response__, 'provider_config')))

pulumi_databricks/get_external_locations.py

@@ -13,6 +13,8 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
+from . import outputs
+from ._inputs import *
 
 __all__ = [
     'GetExternalLocationsResult',
@@ -26,13 +28,16 @@ class GetExternalLocationsResult:
     """
     A collection of values returned by getExternalLocations.
     """
-    def __init__(__self__, id=None, names=None):
+    def __init__(__self__, id=None, names=None, provider_config=None):
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
         if names and not isinstance(names, list):
             raise TypeError("Expected argument 'names' to be a list")
         pulumi.set(__self__, "names", names)
+        if provider_config and not isinstance(provider_config, dict):
+            raise TypeError("Expected argument 'provider_config' to be a dict")
+        pulumi.set(__self__, "provider_config", provider_config)
 
     @_builtins.property
     @pulumi.getter
@@ -50,6 +55,11 @@ class GetExternalLocationsResult:
         """
         return pulumi.get(self, "names")
 
+    @_builtins.property
+    @pulumi.getter(name="providerConfig")
+    def provider_config(self) -> Optional['outputs.GetExternalLocationsProviderConfigResult']:
+        return pulumi.get(self, "provider_config")
+
 
 class AwaitableGetExternalLocationsResult(GetExternalLocationsResult):
     # pylint: disable=using-constant-test
@@ -58,10 +68,12 @@ class AwaitableGetExternalLocationsResult(GetExternalLocationsResult):
             yield self
         return GetExternalLocationsResult(
             id=self.id,
-            names=self.names)
+            names=self.names,
+            provider_config=self.provider_config)
 
 
 def get_external_locations(names: Optional[Sequence[_builtins.str]] = None,
+                           provider_config: Optional[Union['GetExternalLocationsProviderConfigArgs', 'GetExternalLocationsProviderConfigArgsDict']] = None,
                            opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetExternalLocationsResult:
     """
     Retrieves a list of ExternalLocation objects, that were created by Pulumi or manually, so that special handling could be applied.
@@ -89,16 +101,20 @@ def get_external_locations(names: Optional[Sequence[_builtins.str]] = None,
 
 
     :param Sequence[_builtins.str] names: List of names of ExternalLocation in the metastore
+    :param Union['GetExternalLocationsProviderConfigArgs', 'GetExternalLocationsProviderConfigArgsDict'] provider_config: Configure the provider for management through account provider. This block consists of the following fields:
     """
     __args__ = dict()
     __args__['names'] = names
+    __args__['providerConfig'] = provider_config
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('databricks:index/getExternalLocations:getExternalLocations', __args__, opts=opts, typ=GetExternalLocationsResult).value
 
     return AwaitableGetExternalLocationsResult(
         id=pulumi.get(__ret__, 'id'),
-        names=pulumi.get(__ret__, 'names'))
+        names=pulumi.get(__ret__, 'names'),
+        provider_config=pulumi.get(__ret__, 'provider_config'))
 def get_external_locations_output(names: Optional[pulumi.Input[Optional[Sequence[_builtins.str]]]] = None,
+                                  provider_config: Optional[pulumi.Input[Optional[Union['GetExternalLocationsProviderConfigArgs', 'GetExternalLocationsProviderConfigArgsDict']]]] = None,
                                   opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetExternalLocationsResult]:
     """
     Retrieves a list of ExternalLocation objects, that were created by Pulumi or manually, so that special handling could be applied.
@@ -126,11 +142,14 @@ def get_external_locations_output(names: Optional[pulumi.Input[Optional[Sequence
 
 
     :param Sequence[_builtins.str] names: List of names of ExternalLocation in the metastore
+    :param Union['GetExternalLocationsProviderConfigArgs', 'GetExternalLocationsProviderConfigArgsDict'] provider_config: Configure the provider for management through account provider. This block consists of the following fields:
     """
     __args__ = dict()
     __args__['names'] = names
+    __args__['providerConfig'] = provider_config
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('databricks:index/getExternalLocations:getExternalLocations', __args__, opts=opts, typ=GetExternalLocationsResult)
     return __ret__.apply(lambda __response__: GetExternalLocationsResult(
         id=pulumi.get(__response__, 'id'),
-        names=pulumi.get(__response__, 'names')))
+        names=pulumi.get(__response__, 'names'),
+        provider_config=pulumi.get(__response__, 'provider_config')))

pulumi_databricks/get_external_metadata.py

@@ -72,7 +72,7 @@ class GetExternalMetadataResult:
 
     @_builtins.property
     @pulumi.getter
-    def columns(self) -> Optional[Sequence[_builtins.str]]:
+    def columns(self) -> Sequence[_builtins.str]:
         """
         (list of string) - List of columns associated with the external metadata object
         """
@@ -96,7 +96,7 @@ class GetExternalMetadataResult:
 
     @_builtins.property
     @pulumi.getter
-    def description(self) -> Optional[_builtins.str]:
+    def description(self) -> _builtins.str:
         """
         (string) - User-provided free-form text description
         """
@@ -136,7 +136,7 @@ class GetExternalMetadataResult:
 
     @_builtins.property
     @pulumi.getter
-    def owner(self) -> Optional[_builtins.str]:
+    def owner(self) -> _builtins.str:
         """
         (string) - Owner of the external metadata object
         """
@@ -144,7 +144,7 @@ class GetExternalMetadataResult:
 
     @_builtins.property
     @pulumi.getter
-    def properties(self) -> Optional[Mapping[str, _builtins.str]]:
+    def properties(self) -> Mapping[str, _builtins.str]:
         """
         (object) - A map of key-value properties attached to the external metadata object
         """
@@ -154,7 +154,7 @@ class GetExternalMetadataResult:
     @pulumi.getter(name="systemType")
     def system_type(self) -> _builtins.str:
         """
-        (string) - Type of external system. Possible values are: `AMAZON_REDSHIFT`, `AZURE_SYNAPSE`, `CONFLUENT`, `DATABRICKS`, `GOOGLE_BIGQUERY`, `KAFKA`, `LOOKER`, `MICROSOFT_FABRIC`, `MICROSOFT_SQL_SERVER`, `MONGODB`, `MYSQL`, `ORACLE`, `OTHER`, `POSTGRESQL`, `POWER_BI`, `SALESFORCE`, `SAP`, `SERVICENOW`, `SNOWFLAKE`, `TABLEAU`, `TERADATA`, `WORKDAY`
+        (string) - Type of external system. Possible values are: `AMAZON_REDSHIFT`, `AZURE_SYNAPSE`, `CONFLUENT`, `DATABRICKS`, `GOOGLE_BIGQUERY`, `KAFKA`, `LOOKER`, `MICROSOFT_FABRIC`, `MICROSOFT_SQL_SERVER`, `MONGODB`, `MYSQL`, `ORACLE`, `OTHER`, `POSTGRESQL`, `POWER_BI`, `SALESFORCE`, `SAP`, `SERVICENOW`, `SNOWFLAKE`, `STREAM_NATIVE`, `TABLEAU`, `TERADATA`, `WORKDAY`
         """
         return pulumi.get(self, "system_type")
 
@@ -176,7 +176,7 @@ class GetExternalMetadataResult:
 
     @_builtins.property
     @pulumi.getter
-    def url(self) -> Optional[_builtins.str]:
+    def url(self) -> _builtins.str:
         """
         (string) - URL associated with the external metadata object
         """
@@ -205,16 +205,11 @@ class AwaitableGetExternalMetadataResult(GetExternalMetadataResult):
             url=self.url)
 
 
-def get_external_metadata(columns: Optional[Sequence[_builtins.str]] = None,
-                          description: Optional[_builtins.str] = None,
-                          entity_type: Optional[_builtins.str] = None,
-                          name: Optional[_builtins.str] = None,
-                          owner: Optional[_builtins.str] = None,
-                          properties: Optional[Mapping[str, _builtins.str]] = None,
-                          system_type: Optional[_builtins.str] = None,
-                          url: Optional[_builtins.str] = None,
+def get_external_metadata(name: Optional[_builtins.str] = None,
                           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetExternalMetadataResult:
     """
+    [![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 external metadata object.
 
     > **Note** This resource can only be used with an workspace-level provider!
@@ -231,24 +226,10 @@ def get_external_metadata(columns: Optional[Sequence[_builtins.str]] = None,
     ```
 
 
-    :param Sequence[_builtins.str] columns: (list of string) - List of columns associated with the external metadata object
-    :param _builtins.str description: (string) - User-provided free-form text description
-    :param _builtins.str entity_type: (string) - Type of entity within the external system
     :param _builtins.str name: Name of the external metadata object
-    :param _builtins.str owner: (string) - Owner of the external metadata object
-    :param Mapping[str, _builtins.str] properties: (object) - A map of key-value properties attached to the external metadata object
-    :param _builtins.str system_type: (string) - Type of external system. Possible values are: `AMAZON_REDSHIFT`, `AZURE_SYNAPSE`, `CONFLUENT`, `DATABRICKS`, `GOOGLE_BIGQUERY`, `KAFKA`, `LOOKER`, `MICROSOFT_FABRIC`, `MICROSOFT_SQL_SERVER`, `MONGODB`, `MYSQL`, `ORACLE`, `OTHER`, `POSTGRESQL`, `POWER_BI`, `SALESFORCE`, `SAP`, `SERVICENOW`, `SNOWFLAKE`, `TABLEAU`, `TERADATA`, `WORKDAY`
-    :param _builtins.str url: (string) - URL associated with the external metadata object
     """
     __args__ = dict()
-    __args__['columns'] = columns
-    __args__['description'] = description
-    __args__['entityType'] = entity_type
     __args__['name'] = name
-    __args__['owner'] = owner
-    __args__['properties'] = properties
-    __args__['systemType'] = system_type
-    __args__['url'] = url
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('databricks:index/getExternalMetadata:getExternalMetadata', __args__, opts=opts, typ=GetExternalMetadataResult).value
 
@@ -267,16 +248,11 @@ def get_external_metadata(columns: Optional[Sequence[_builtins.str]] = None,
         update_time=pulumi.get(__ret__, 'update_time'),
         updated_by=pulumi.get(__ret__, 'updated_by'),
         url=pulumi.get(__ret__, 'url'))
-def get_external_metadata_output(columns: Optional[pulumi.Input[Optional[Sequence[_builtins.str]]]] = None,
-                                 description: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
-                                 entity_type: Optional[pulumi.Input[_builtins.str]] = None,
-                                 name: Optional[pulumi.Input[_builtins.str]] = None,
-                                 owner: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
-                                 properties: Optional[pulumi.Input[Optional[Mapping[str, _builtins.str]]]] = None,
-                                 system_type: Optional[pulumi.Input[_builtins.str]] = None,
-                                 url: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+def get_external_metadata_output(name: Optional[pulumi.Input[_builtins.str]] = None,
                                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetExternalMetadataResult]:
     """
+    [![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 external metadata object.
 
     > **Note** This resource can only be used with an workspace-level provider!
@@ -293,24 +269,10 @@ def get_external_metadata_output(columns: Optional[pulumi.Input[Optional[Sequenc
     ```
 
 
-    :param Sequence[_builtins.str] columns: (list of string) - List of columns associated with the external metadata object
-    :param _builtins.str description: (string) - User-provided free-form text description
-    :param _builtins.str entity_type: (string) - Type of entity within the external system
     :param _builtins.str name: Name of the external metadata object
-    :param _builtins.str owner: (string) - Owner of the external metadata object
-    :param Mapping[str, _builtins.str] properties: (object) - A map of key-value properties attached to the external metadata object
-    :param _builtins.str system_type: (string) - Type of external system. Possible values are: `AMAZON_REDSHIFT`, `AZURE_SYNAPSE`, `CONFLUENT`, `DATABRICKS`, `GOOGLE_BIGQUERY`, `KAFKA`, `LOOKER`, `MICROSOFT_FABRIC`, `MICROSOFT_SQL_SERVER`, `MONGODB`, `MYSQL`, `ORACLE`, `OTHER`, `POSTGRESQL`, `POWER_BI`, `SALESFORCE`, `SAP`, `SERVICENOW`, `SNOWFLAKE`, `TABLEAU`, `TERADATA`, `WORKDAY`
-    :param _builtins.str url: (string) - URL associated with the external metadata object
     """
     __args__ = dict()
-    __args__['columns'] = columns
-    __args__['description'] = description
-    __args__['entityType'] = entity_type
     __args__['name'] = name
-    __args__['owner'] = owner
-    __args__['properties'] = properties
-    __args__['systemType'] = system_type
-    __args__['url'] = url
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('databricks:index/getExternalMetadata:getExternalMetadata', __args__, opts=opts, typ=GetExternalMetadataResult)
     return __ret__.apply(lambda __response__: GetExternalMetadataResult(

pulumi_databricks/get_external_metadatas.py

@@ -27,13 +27,16 @@ class GetExternalMetadatasResult:
     """
     A collection of values returned by getExternalMetadatas.
     """
-    def __init__(__self__, external_metadatas=None, id=None):
+    def __init__(__self__, external_metadatas=None, id=None, page_size=None):
         if external_metadatas and not isinstance(external_metadatas, list):
             raise TypeError("Expected argument 'external_metadatas' to be a list")
         pulumi.set(__self__, "external_metadatas", external_metadatas)
         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="externalMetadatas")
@@ -48,6 +51,11 @@ class GetExternalMetadatasResult:
         """
         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 AwaitableGetExternalMetadatasResult(GetExternalMetadatasResult):
     # pylint: disable=using-constant-test
@@ -56,31 +64,72 @@ class AwaitableGetExternalMetadatasResult(GetExternalMetadatasResult):
             yield self
         return GetExternalMetadatasResult(
             external_metadatas=self.external_metadatas,
-            id=self.id)
+            id=self.id,
+            page_size=self.page_size)
 
 
-def get_external_metadatas(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetExternalMetadatasResult:
+def get_external_metadatas(page_size: Optional[_builtins.int] = None,
+                           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetExternalMetadatasResult:
     """
+    [![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 external metadata objects.
 
     > **Note** This resource can only be used with an workspace-level provider!
+
+    ## Example Usage
+
+    Getting a list of all external metadata objects:
+
+    ```python
+    import pulumi
+    import pulumi_databricks as databricks
+
+    all = databricks.get_external_metadatas()
+    ```
+
+
+    :param _builtins.int page_size: Specifies the maximum number of external metadata objects to return in a single response.
+           The value must be less than or equal to 1000
     """
     __args__ = dict()
+    __args__['pageSize'] = page_size
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('databricks:index/getExternalMetadatas:getExternalMetadatas', __args__, opts=opts, typ=GetExternalMetadatasResult).value
 
     return AwaitableGetExternalMetadatasResult(
         external_metadatas=pulumi.get(__ret__, 'external_metadatas'),
-        id=pulumi.get(__ret__, 'id'))
-def get_external_metadatas_output(opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetExternalMetadatasResult]:
+        id=pulumi.get(__ret__, 'id'),
+        page_size=pulumi.get(__ret__, 'page_size'))
+def get_external_metadatas_output(page_size: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
+                                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetExternalMetadatasResult]:
     """
+    [![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 external metadata objects.
 
     > **Note** This resource can only be used with an workspace-level provider!
+
+    ## Example Usage
+
+    Getting a list of all external metadata objects:
+
+    ```python
+    import pulumi
+    import pulumi_databricks as databricks
+
+    all = databricks.get_external_metadatas()
+    ```
+
+
+    :param _builtins.int page_size: Specifies the maximum number of external metadata objects to return in a single response.
+           The value must be less than or equal to 1000
     """
     __args__ = dict()
+    __args__['pageSize'] = page_size
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('databricks:index/getExternalMetadatas:getExternalMetadatas', __args__, opts=opts, typ=GetExternalMetadatasResult)
     return __ret__.apply(lambda __response__: GetExternalMetadatasResult(
         external_metadatas=pulumi.get(__response__, 'external_metadatas'),
-        id=pulumi.get(__response__, 'id')))
+        id=pulumi.get(__response__, 'id'),
+        page_size=pulumi.get(__response__, 'page_size')))

pulumi_databricks/get_feature_engineering_feature.py

@@ -0,0 +1,179 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+from . import outputs
+
+__all__ = [
+    'GetFeatureEngineeringFeatureResult',
+    'AwaitableGetFeatureEngineeringFeatureResult',
+    'get_feature_engineering_feature',
+    'get_feature_engineering_feature_output',
+]
+
+@pulumi.output_type
+class GetFeatureEngineeringFeatureResult:
+    """
+    A collection of values returned by getFeatureEngineeringFeature.
+    """
+    def __init__(__self__, description=None, filter_condition=None, full_name=None, function=None, id=None, inputs=None, source=None, time_window=None):
+        if description and not isinstance(description, str):
+            raise TypeError("Expected argument 'description' to be a str")
+        pulumi.set(__self__, "description", description)
+        if filter_condition and not isinstance(filter_condition, str):
+            raise TypeError("Expected argument 'filter_condition' to be a str")
+        pulumi.set(__self__, "filter_condition", filter_condition)
+        if full_name and not isinstance(full_name, str):
+            raise TypeError("Expected argument 'full_name' to be a str")
+        pulumi.set(__self__, "full_name", full_name)
+        if function and not isinstance(function, dict):
+            raise TypeError("Expected argument 'function' to be a dict")
+        pulumi.set(__self__, "function", function)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if inputs and not isinstance(inputs, list):
+            raise TypeError("Expected argument 'inputs' to be a list")
+        pulumi.set(__self__, "inputs", inputs)
+        if source and not isinstance(source, dict):
+            raise TypeError("Expected argument 'source' to be a dict")
+        pulumi.set(__self__, "source", source)
+        if time_window and not isinstance(time_window, dict):
+            raise TypeError("Expected argument 'time_window' to be a dict")
+        pulumi.set(__self__, "time_window", time_window)
+
+    @_builtins.property
+    @pulumi.getter
+    def description(self) -> _builtins.str:
+        """
+        (string) - The description of the feature
+        """
+        return pulumi.get(self, "description")
+
+    @_builtins.property
+    @pulumi.getter(name="filterCondition")
+    def filter_condition(self) -> _builtins.str:
+        """
+        (string) - The filter condition applied to the source data before aggregation
+        """
+        return pulumi.get(self, "filter_condition")
+
+    @_builtins.property
+    @pulumi.getter(name="fullName")
+    def full_name(self) -> _builtins.str:
+        """
+        (string) - The full three-part (catalog, schema, table) name of the Delta table
+        """
+        return pulumi.get(self, "full_name")
+
+    @_builtins.property
+    @pulumi.getter
+    def function(self) -> 'outputs.GetFeatureEngineeringFeatureFunctionResult':
+        """
+        (Function) - The function by which the feature is computed
+        """
+        return pulumi.get(self, "function")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter
+    def inputs(self) -> Sequence[_builtins.str]:
+        """
+        (list of string) - The input columns from which the feature is computed
+        """
+        return pulumi.get(self, "inputs")
+
+    @_builtins.property
+    @pulumi.getter
+    def source(self) -> 'outputs.GetFeatureEngineeringFeatureSourceResult':
+        """
+        (DataSource) - The data source of the feature
+        """
+        return pulumi.get(self, "source")
+
+    @_builtins.property
+    @pulumi.getter(name="timeWindow")
+    def time_window(self) -> 'outputs.GetFeatureEngineeringFeatureTimeWindowResult':
+        """
+        (TimeWindow) - The time window in which the feature is computed
+        """
+        return pulumi.get(self, "time_window")
+
+
+class AwaitableGetFeatureEngineeringFeatureResult(GetFeatureEngineeringFeatureResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetFeatureEngineeringFeatureResult(
+            description=self.description,
+            filter_condition=self.filter_condition,
+            full_name=self.full_name,
+            function=self.function,
+            id=self.id,
+            inputs=self.inputs,
+            source=self.source,
+            time_window=self.time_window)
+
+
+def get_feature_engineering_feature(full_name: Optional[_builtins.str] = None,
+                                    opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetFeatureEngineeringFeatureResult:
+    """
+    [![Private Preview](https://img.shields.io/badge/Release_Stage-Private_Preview-blueviolet)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
+
+    :param _builtins.str full_name: The full three-part name (catalog, schema, name) of the feature
+    """
+    __args__ = dict()
+    __args__['fullName'] = full_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('databricks:index/getFeatureEngineeringFeature:getFeatureEngineeringFeature', __args__, opts=opts, typ=GetFeatureEngineeringFeatureResult).value
+
+    return AwaitableGetFeatureEngineeringFeatureResult(
+        description=pulumi.get(__ret__, 'description'),
+        filter_condition=pulumi.get(__ret__, 'filter_condition'),
+        full_name=pulumi.get(__ret__, 'full_name'),
+        function=pulumi.get(__ret__, 'function'),
+        id=pulumi.get(__ret__, 'id'),
+        inputs=pulumi.get(__ret__, 'inputs'),
+        source=pulumi.get(__ret__, 'source'),
+        time_window=pulumi.get(__ret__, 'time_window'))
+def get_feature_engineering_feature_output(full_name: Optional[pulumi.Input[_builtins.str]] = None,
+                                           opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetFeatureEngineeringFeatureResult]:
+    """
+    [![Private Preview](https://img.shields.io/badge/Release_Stage-Private_Preview-blueviolet)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
+
+    :param _builtins.str full_name: The full three-part name (catalog, schema, name) of the feature
+    """
+    __args__ = dict()
+    __args__['fullName'] = full_name
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('databricks:index/getFeatureEngineeringFeature:getFeatureEngineeringFeature', __args__, opts=opts, typ=GetFeatureEngineeringFeatureResult)
+    return __ret__.apply(lambda __response__: GetFeatureEngineeringFeatureResult(
+        description=pulumi.get(__response__, 'description'),
+        filter_condition=pulumi.get(__response__, 'filter_condition'),
+        full_name=pulumi.get(__response__, 'full_name'),
+        function=pulumi.get(__response__, 'function'),
+        id=pulumi.get(__response__, 'id'),
+        inputs=pulumi.get(__response__, 'inputs'),
+        source=pulumi.get(__response__, 'source'),
+        time_window=pulumi.get(__response__, 'time_window')))