pulumi-gcp 8.33.0a1749001887__py3-none-any.whl → 8.34.0__py3-none-any.whl

pulumi_gcp/apihub/outputs.py

@@ -14,9 +14,13 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
+from . import outputs
 
 __all__ = [
     'ApiHubInstanceConfig',
+    'CurationEndpoint',
+    'CurationEndpointApplicationIntegrationEndpointDetails',
+    'CurationPluginInstanceAction',
 ]
 
 @pulumi.output_type
@@ -123,3 +127,164 @@ class ApiHubInstanceConfig(dict):
         return pulumi.get(self, "vertex_location")
 
 
+@pulumi.output_type
+class CurationEndpoint(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "applicationIntegrationEndpointDetails":
+            suggest = "application_integration_endpoint_details"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CurationEndpoint. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CurationEndpoint.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CurationEndpoint.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 application_integration_endpoint_details: 'outputs.CurationEndpointApplicationIntegrationEndpointDetails'):
+        """
+        :param 'CurationEndpointApplicationIntegrationEndpointDetailsArgs' application_integration_endpoint_details: The details of the Application Integration endpoint to be triggered for
+               curation.
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "application_integration_endpoint_details", application_integration_endpoint_details)
+
+    @property
+    @pulumi.getter(name="applicationIntegrationEndpointDetails")
+    def application_integration_endpoint_details(self) -> 'outputs.CurationEndpointApplicationIntegrationEndpointDetails':
+        """
+        The details of the Application Integration endpoint to be triggered for
+        curation.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "application_integration_endpoint_details")
+
+
+@pulumi.output_type
+class CurationEndpointApplicationIntegrationEndpointDetails(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "triggerId":
+            suggest = "trigger_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CurationEndpointApplicationIntegrationEndpointDetails. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CurationEndpointApplicationIntegrationEndpointDetails.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CurationEndpointApplicationIntegrationEndpointDetails.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 trigger_id: builtins.str,
+                 uri: builtins.str):
+        """
+        :param builtins.str trigger_id: The API trigger ID of the Application Integration workflow.
+        :param builtins.str uri: The endpoint URI should be a valid REST URI for triggering an Application
+               Integration.
+               Format:
+               `https://integrations.googleapis.com/v1/{name=projects/*/locations/*/integrations/*}:execute`
+               or
+               `https://{location}-integrations.googleapis.com/v1/{name=projects/*/locations/*/integrations/*}:execute`
+               
+               - - -
+        """
+        pulumi.set(__self__, "trigger_id", trigger_id)
+        pulumi.set(__self__, "uri", uri)
+
+    @property
+    @pulumi.getter(name="triggerId")
+    def trigger_id(self) -> builtins.str:
+        """
+        The API trigger ID of the Application Integration workflow.
+        """
+        return pulumi.get(self, "trigger_id")
+
+    @property
+    @pulumi.getter
+    def uri(self) -> builtins.str:
+        """
+        The endpoint URI should be a valid REST URI for triggering an Application
+        Integration.
+        Format:
+        `https://integrations.googleapis.com/v1/{name=projects/*/locations/*/integrations/*}:execute`
+        or
+        `https://{location}-integrations.googleapis.com/v1/{name=projects/*/locations/*/integrations/*}:execute`
+
+        - - -
+        """
+        return pulumi.get(self, "uri")
+
+
+@pulumi.output_type
+class CurationPluginInstanceAction(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "actionId":
+            suggest = "action_id"
+        elif key == "pluginInstance":
+            suggest = "plugin_instance"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CurationPluginInstanceAction. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CurationPluginInstanceAction.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CurationPluginInstanceAction.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 action_id: Optional[builtins.str] = None,
+                 plugin_instance: Optional[builtins.str] = None):
+        """
+        :param builtins.str action_id: (Output)
+               The action ID that is using the curation.
+               This should map to one of the action IDs specified
+               in action configs in the plugin.
+        :param builtins.str plugin_instance: (Output)
+               Plugin instance that is using the curation.
+               Format is
+               `projects/{project}/locations/{locati on}/plugins/{plugin}/instances/{instance}`
+        """
+        if action_id is not None:
+            pulumi.set(__self__, "action_id", action_id)
+        if plugin_instance is not None:
+            pulumi.set(__self__, "plugin_instance", plugin_instance)
+
+    @property
+    @pulumi.getter(name="actionId")
+    def action_id(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        The action ID that is using the curation.
+        This should map to one of the action IDs specified
+        in action configs in the plugin.
+        """
+        return pulumi.get(self, "action_id")
+
+    @property
+    @pulumi.getter(name="pluginInstance")
+    def plugin_instance(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Plugin instance that is using the curation.
+        Format is
+        `projects/{project}/locations/{locati on}/plugins/{plugin}/instances/{instance}`
+        """
+        return pulumi.get(self, "plugin_instance")
+
+

pulumi_gcp/beyondcorp/get_security_gateway.py

@@ -28,10 +28,13 @@ class GetSecurityGatewayResult:
     """
     A collection of values returned by getSecurityGateway.
     """
-    def __init__(__self__, create_time=None, display_name=None, external_ips=None, hubs=None, id=None, location=None, name=None, project=None, security_gateway_id=None, state=None, update_time=None):
+    def __init__(__self__, create_time=None, delegating_service_account=None, display_name=None, external_ips=None, hubs=None, id=None, location=None, name=None, project=None, security_gateway_id=None, state=None, update_time=None):
         if create_time and not isinstance(create_time, str):
             raise TypeError("Expected argument 'create_time' to be a str")
         pulumi.set(__self__, "create_time", create_time)
+        if delegating_service_account and not isinstance(delegating_service_account, str):
+            raise TypeError("Expected argument 'delegating_service_account' to be a str")
+        pulumi.set(__self__, "delegating_service_account", delegating_service_account)
         if display_name and not isinstance(display_name, str):
             raise TypeError("Expected argument 'display_name' to be a str")
         pulumi.set(__self__, "display_name", display_name)
@@ -68,6 +71,11 @@ class GetSecurityGatewayResult:
     def create_time(self) -> builtins.str:
         return pulumi.get(self, "create_time")
 
+    @property
+    @pulumi.getter(name="delegatingServiceAccount")
+    def delegating_service_account(self) -> builtins.str:
+        return pulumi.get(self, "delegating_service_account")
+
     @property
     @pulumi.getter(name="displayName")
     def display_name(self) -> builtins.str:
@@ -129,6 +137,7 @@ class AwaitableGetSecurityGatewayResult(GetSecurityGatewayResult):
             yield self
         return GetSecurityGatewayResult(
             create_time=self.create_time,
+            delegating_service_account=self.delegating_service_account,
             display_name=self.display_name,
             external_ips=self.external_ips,
             hubs=self.hubs,
@@ -171,6 +180,7 @@ def get_security_gateway(project: Optional[builtins.str] = None,
 
     return AwaitableGetSecurityGatewayResult(
         create_time=pulumi.get(__ret__, 'create_time'),
+        delegating_service_account=pulumi.get(__ret__, 'delegating_service_account'),
         display_name=pulumi.get(__ret__, 'display_name'),
         external_ips=pulumi.get(__ret__, 'external_ips'),
         hubs=pulumi.get(__ret__, 'hubs'),
@@ -210,6 +220,7 @@ def get_security_gateway_output(project: Optional[pulumi.Input[Optional[builtins
     __ret__ = pulumi.runtime.invoke_output('gcp:beyondcorp/getSecurityGateway:getSecurityGateway', __args__, opts=opts, typ=GetSecurityGatewayResult)
     return __ret__.apply(lambda __response__: GetSecurityGatewayResult(
         create_time=pulumi.get(__response__, 'create_time'),
+        delegating_service_account=pulumi.get(__response__, 'delegating_service_account'),
         display_name=pulumi.get(__response__, 'display_name'),
         external_ips=pulumi.get(__response__, 'external_ips'),
         hubs=pulumi.get(__response__, 'hubs'),

pulumi_gcp/beyondcorp/security_gateway.py

@@ -140,6 +140,7 @@ class SecurityGatewayArgs:
 class _SecurityGatewayState:
     def __init__(__self__, *,
                  create_time: Optional[pulumi.Input[builtins.str]] = None,
+                 delegating_service_account: Optional[pulumi.Input[builtins.str]] = None,
                  display_name: Optional[pulumi.Input[builtins.str]] = None,
                  external_ips: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                  hubs: Optional[pulumi.Input[Sequence[pulumi.Input['SecurityGatewayHubArgs']]]] = None,
@@ -152,6 +153,7 @@ class _SecurityGatewayState:
         """
         Input properties used for looking up and filtering SecurityGateway resources.
         :param pulumi.Input[builtins.str] create_time: Output only. Timestamp when the resource was created.
+        :param pulumi.Input[builtins.str] delegating_service_account: Service account used for operations that involve resources in consumer projects.
         :param pulumi.Input[builtins.str] display_name: Optional. An arbitrary user-provided name for the SecurityGateway.
                Cannot exceed 64 characters.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] external_ips: Output only. IP addresses that will be used for establishing
@@ -186,6 +188,8 @@ class _SecurityGatewayState:
         """
         if create_time is not None:
             pulumi.set(__self__, "create_time", create_time)
+        if delegating_service_account is not None:
+            pulumi.set(__self__, "delegating_service_account", delegating_service_account)
         if display_name is not None:
             pulumi.set(__self__, "display_name", display_name)
         if external_ips is not None:
@@ -220,6 +224,18 @@ class _SecurityGatewayState:
     def create_time(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "create_time", value)
 
+    @property
+    @pulumi.getter(name="delegatingServiceAccount")
+    def delegating_service_account(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Service account used for operations that involve resources in consumer projects.
+        """
+        return pulumi.get(self, "delegating_service_account")
+
+    @delegating_service_account.setter
+    def delegating_service_account(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "delegating_service_account", value)
+
     @property
     @pulumi.getter(name="displayName")
     def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -514,6 +530,7 @@ class SecurityGateway(pulumi.CustomResource):
                 raise TypeError("Missing required property 'security_gateway_id'")
             __props__.__dict__["security_gateway_id"] = security_gateway_id
             __props__.__dict__["create_time"] = None
+            __props__.__dict__["delegating_service_account"] = None
             __props__.__dict__["external_ips"] = None
             __props__.__dict__["name"] = None
             __props__.__dict__["state"] = None
@@ -529,6 +546,7 @@ class SecurityGateway(pulumi.CustomResource):
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
             create_time: Optional[pulumi.Input[builtins.str]] = None,
+            delegating_service_account: Optional[pulumi.Input[builtins.str]] = None,
             display_name: Optional[pulumi.Input[builtins.str]] = None,
             external_ips: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
             hubs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['SecurityGatewayHubArgs', 'SecurityGatewayHubArgsDict']]]]] = None,
@@ -546,6 +564,7 @@ class SecurityGateway(pulumi.CustomResource):
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[builtins.str] create_time: Output only. Timestamp when the resource was created.
+        :param pulumi.Input[builtins.str] delegating_service_account: Service account used for operations that involve resources in consumer projects.
         :param pulumi.Input[builtins.str] display_name: Optional. An arbitrary user-provided name for the SecurityGateway.
                Cannot exceed 64 characters.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] external_ips: Output only. IP addresses that will be used for establishing
@@ -583,6 +602,7 @@ class SecurityGateway(pulumi.CustomResource):
         __props__ = _SecurityGatewayState.__new__(_SecurityGatewayState)
 
         __props__.__dict__["create_time"] = create_time
+        __props__.__dict__["delegating_service_account"] = delegating_service_account
         __props__.__dict__["display_name"] = display_name
         __props__.__dict__["external_ips"] = external_ips
         __props__.__dict__["hubs"] = hubs
@@ -602,6 +622,14 @@ class SecurityGateway(pulumi.CustomResource):
         """
         return pulumi.get(self, "create_time")
 
+    @property
+    @pulumi.getter(name="delegatingServiceAccount")
+    def delegating_service_account(self) -> pulumi.Output[builtins.str]:
+        """
+        Service account used for operations that involve resources in consumer projects.
+        """
+        return pulumi.get(self, "delegating_service_account")
+
     @property
     @pulumi.getter(name="displayName")
     def display_name(self) -> pulumi.Output[Optional[builtins.str]]:

pulumi_gcp/bigquery/__init__.py

@@ -22,6 +22,7 @@ from .dataset_iam_policy import *
 from .get_connection_iam_policy import *
 from .get_dataset import *
 from .get_dataset_iam_policy import *
+from .get_datasets import *
 from .get_default_service_account import *
 from .get_table import *
 from .get_table_iam_policy import *

pulumi_gcp/bigquery/get_datasets.py

@@ -0,0 +1,131 @@
+# 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
+import copy
+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__ = [
+    'GetDatasetsResult',
+    'AwaitableGetDatasetsResult',
+    'get_datasets',
+    'get_datasets_output',
+]
+
+@pulumi.output_type
+class GetDatasetsResult:
+    """
+    A collection of values returned by getDatasets.
+    """
+    def __init__(__self__, datasets=None, id=None, project=None):
+        if datasets and not isinstance(datasets, list):
+            raise TypeError("Expected argument 'datasets' to be a list")
+        pulumi.set(__self__, "datasets", datasets)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if project and not isinstance(project, str):
+            raise TypeError("Expected argument 'project' to be a str")
+        pulumi.set(__self__, "project", project)
+
+    @property
+    @pulumi.getter
+    def datasets(self) -> Sequence['outputs.GetDatasetsDatasetResult']:
+        """
+        A list of all retrieved BigQuery datasets. Structure is defined below.
+        """
+        return pulumi.get(self, "datasets")
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def project(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "project")
+
+
+class AwaitableGetDatasetsResult(GetDatasetsResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetDatasetsResult(
+            datasets=self.datasets,
+            id=self.id,
+            project=self.project)
+
+
+def get_datasets(project: Optional[builtins.str] = None,
+                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDatasetsResult:
+    """
+    Get a list of datasets in a GCP project. For more information see
+    the [official documentation](https://cloud.google.com/bigquery/docs)
+    and [API](https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets/list).
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    datasets = gcp.bigquery.get_datasets(project="my-project")
+    ```
+
+
+    :param builtins.str project: The ID of the project in which the resource belongs.
+           If it is not provided, the provider project is used.
+    """
+    __args__ = dict()
+    __args__['project'] = project
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('gcp:bigquery/getDatasets:getDatasets', __args__, opts=opts, typ=GetDatasetsResult).value
+
+    return AwaitableGetDatasetsResult(
+        datasets=pulumi.get(__ret__, 'datasets'),
+        id=pulumi.get(__ret__, 'id'),
+        project=pulumi.get(__ret__, 'project'))
+def get_datasets_output(project: Optional[pulumi.Input[Optional[builtins.str]]] = None,
+                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDatasetsResult]:
+    """
+    Get a list of datasets in a GCP project. For more information see
+    the [official documentation](https://cloud.google.com/bigquery/docs)
+    and [API](https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets/list).
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    datasets = gcp.bigquery.get_datasets(project="my-project")
+    ```
+
+
+    :param builtins.str project: The ID of the project in which the resource belongs.
+           If it is not provided, the provider project is used.
+    """
+    __args__ = dict()
+    __args__['project'] = project
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('gcp:bigquery/getDatasets:getDatasets', __args__, opts=opts, typ=GetDatasetsResult)
+    return __ret__.apply(lambda __response__: GetDatasetsResult(
+        datasets=pulumi.get(__response__, 'datasets'),
+        id=pulumi.get(__response__, 'id'),
+        project=pulumi.get(__response__, 'project')))

pulumi_gcp/bigquery/outputs.py

@@ -115,6 +115,7 @@ __all__ = [
     'GetDatasetDefaultEncryptionConfigurationResult',
     'GetDatasetExternalCatalogDatasetOptionResult',
     'GetDatasetExternalDatasetReferenceResult',
+    'GetDatasetsDatasetResult',
     'GetTableBiglakeConfigurationResult',
     'GetTableEncryptionConfigurationResult',
     'GetTableExternalCatalogTableOptionResult',
@@ -7084,6 +7085,57 @@ class GetDatasetExternalDatasetReferenceResult(dict):
         return pulumi.get(self, "external_source")
 
 
+@pulumi.output_type
+class GetDatasetsDatasetResult(dict):
+    def __init__(__self__, *,
+                 dataset_id: builtins.str,
+                 friendly_name: builtins.str,
+                 labels: Mapping[str, builtins.str],
+                 location: builtins.str):
+        """
+        :param builtins.str dataset_id: The id of the dataset.
+        :param builtins.str friendly_name: The friendly name of the dataset.
+        :param Mapping[str, builtins.str] labels: User-provided dataset labels, in key/value pairs.
+        :param builtins.str location: The geographic location of the dataset.
+        """
+        pulumi.set(__self__, "dataset_id", dataset_id)
+        pulumi.set(__self__, "friendly_name", friendly_name)
+        pulumi.set(__self__, "labels", labels)
+        pulumi.set(__self__, "location", location)
+
+    @property
+    @pulumi.getter(name="datasetId")
+    def dataset_id(self) -> builtins.str:
+        """
+        The id of the dataset.
+        """
+        return pulumi.get(self, "dataset_id")
+
+    @property
+    @pulumi.getter(name="friendlyName")
+    def friendly_name(self) -> builtins.str:
+        """
+        The friendly name of the dataset.
+        """
+        return pulumi.get(self, "friendly_name")
+
+    @property
+    @pulumi.getter
+    def labels(self) -> Mapping[str, builtins.str]:
+        """
+        User-provided dataset labels, in key/value pairs.
+        """
+        return pulumi.get(self, "labels")
+
+    @property
+    @pulumi.getter
+    def location(self) -> builtins.str:
+        """
+        The geographic location of the dataset.
+        """
+        return pulumi.get(self, "location")
+
+
 @pulumi.output_type
 class GetTableBiglakeConfigurationResult(dict):
     def __init__(__self__, *,