pulumi-gcp 8.42.0a1758178363__py3-none-any.whl → 9.0.0a1758219982__py3-none-any.whl

pulumi_gcp/artifactregistry/outputs.py

@@ -775,7 +775,6 @@ class RepositoryRemoteRepositoryConfigDockerRepository(dict):
         :param 'RepositoryRemoteRepositoryConfigDockerRepositoryCustomRepositoryArgs' custom_repository: [Deprecated, please use commonRepository instead] Settings for a remote repository with a custom uri.
                Structure is documented below.
         :param _builtins.str public_repository: Address of the remote repository.
-               Default value is `DOCKER_HUB`.
                Possible values are: `DOCKER_HUB`.
         """
         if custom_repository is not None:
@@ -797,7 +796,6 @@ class RepositoryRemoteRepositoryConfigDockerRepository(dict):
     def public_repository(self) -> Optional[_builtins.str]:
         """
         Address of the remote repository.
-        Default value is `DOCKER_HUB`.
         Possible values are: `DOCKER_HUB`.
         """
         return pulumi.get(self, "public_repository")
@@ -850,7 +848,6 @@ class RepositoryRemoteRepositoryConfigMavenRepository(dict):
         :param 'RepositoryRemoteRepositoryConfigMavenRepositoryCustomRepositoryArgs' custom_repository: [Deprecated, please use commonRepository instead] Settings for a remote repository with a custom uri.
                Structure is documented below.
         :param _builtins.str public_repository: Address of the remote repository.
-               Default value is `MAVEN_CENTRAL`.
                Possible values are: `MAVEN_CENTRAL`.
         """
         if custom_repository is not None:
@@ -872,7 +869,6 @@ class RepositoryRemoteRepositoryConfigMavenRepository(dict):
     def public_repository(self) -> Optional[_builtins.str]:
         """
         Address of the remote repository.
-        Default value is `MAVEN_CENTRAL`.
         Possible values are: `MAVEN_CENTRAL`.
         """
         return pulumi.get(self, "public_repository")
@@ -925,7 +921,6 @@ class RepositoryRemoteRepositoryConfigNpmRepository(dict):
         :param 'RepositoryRemoteRepositoryConfigNpmRepositoryCustomRepositoryArgs' custom_repository: [Deprecated, please use commonRepository instead] Settings for a remote repository with a custom uri.
                Structure is documented below.
         :param _builtins.str public_repository: Address of the remote repository.
-               Default value is `NPMJS`.
                Possible values are: `NPMJS`.
         """
         if custom_repository is not None:
@@ -947,7 +942,6 @@ class RepositoryRemoteRepositoryConfigNpmRepository(dict):
     def public_repository(self) -> Optional[_builtins.str]:
         """
         Address of the remote repository.
-        Default value is `NPMJS`.
         Possible values are: `NPMJS`.
         """
         return pulumi.get(self, "public_repository")
@@ -1000,7 +994,6 @@ class RepositoryRemoteRepositoryConfigPythonRepository(dict):
         :param 'RepositoryRemoteRepositoryConfigPythonRepositoryCustomRepositoryArgs' custom_repository: [Deprecated, please use commonRepository instead] Settings for a remote repository with a custom uri.
                Structure is documented below.
         :param _builtins.str public_repository: Address of the remote repository.
-               Default value is `PYPI`.
                Possible values are: `PYPI`.
         """
         if custom_repository is not None:
@@ -1022,7 +1015,6 @@ class RepositoryRemoteRepositoryConfigPythonRepository(dict):
     def public_repository(self) -> Optional[_builtins.str]:
         """
         Address of the remote repository.
-        Default value is `PYPI`.
         Possible values are: `PYPI`.
         """
         return pulumi.get(self, "public_repository")
@@ -1956,7 +1948,7 @@ class GetRepositoryRemoteRepositoryConfigDockerRepositoryResult(dict):
                  public_repository: _builtins.str):
         """
         :param Sequence['GetRepositoryRemoteRepositoryConfigDockerRepositoryCustomRepositoryArgs'] custom_repositories: [Deprecated, please use commonRepository instead] Settings for a remote repository with a custom uri.
-        :param _builtins.str public_repository: Address of the remote repository. Default value: "DOCKER_HUB" Possible values: ["DOCKER_HUB"]
+        :param _builtins.str public_repository: Address of the remote repository. Possible values: ["DOCKER_HUB"]
         """
         pulumi.set(__self__, "custom_repositories", custom_repositories)
         pulumi.set(__self__, "public_repository", public_repository)
@@ -1973,7 +1965,7 @@ class GetRepositoryRemoteRepositoryConfigDockerRepositoryResult(dict):
     @pulumi.getter(name="publicRepository")
     def public_repository(self) -> _builtins.str:
         """
-        Address of the remote repository. Default value: "DOCKER_HUB" Possible values: ["DOCKER_HUB"]
+        Address of the remote repository. Possible values: ["DOCKER_HUB"]
         """
         return pulumi.get(self, "public_repository")
 
@@ -2003,7 +1995,7 @@ class GetRepositoryRemoteRepositoryConfigMavenRepositoryResult(dict):
                  public_repository: _builtins.str):
         """
         :param Sequence['GetRepositoryRemoteRepositoryConfigMavenRepositoryCustomRepositoryArgs'] custom_repositories: [Deprecated, please use commonRepository instead] Settings for a remote repository with a custom uri.
-        :param _builtins.str public_repository: Address of the remote repository. Default value: "MAVEN_CENTRAL" Possible values: ["MAVEN_CENTRAL"]
+        :param _builtins.str public_repository: Address of the remote repository. Possible values: ["MAVEN_CENTRAL"]
         """
         pulumi.set(__self__, "custom_repositories", custom_repositories)
         pulumi.set(__self__, "public_repository", public_repository)
@@ -2020,7 +2012,7 @@ class GetRepositoryRemoteRepositoryConfigMavenRepositoryResult(dict):
     @pulumi.getter(name="publicRepository")
     def public_repository(self) -> _builtins.str:
         """
-        Address of the remote repository. Default value: "MAVEN_CENTRAL" Possible values: ["MAVEN_CENTRAL"]
+        Address of the remote repository. Possible values: ["MAVEN_CENTRAL"]
         """
         return pulumi.get(self, "public_repository")
 
@@ -2050,7 +2042,7 @@ class GetRepositoryRemoteRepositoryConfigNpmRepositoryResult(dict):
                  public_repository: _builtins.str):
         """
         :param Sequence['GetRepositoryRemoteRepositoryConfigNpmRepositoryCustomRepositoryArgs'] custom_repositories: [Deprecated, please use commonRepository instead] Settings for a remote repository with a custom uri.
-        :param _builtins.str public_repository: Address of the remote repository. Default value: "NPMJS" Possible values: ["NPMJS"]
+        :param _builtins.str public_repository: Address of the remote repository. Possible values: ["NPMJS"]
         """
         pulumi.set(__self__, "custom_repositories", custom_repositories)
         pulumi.set(__self__, "public_repository", public_repository)
@@ -2067,7 +2059,7 @@ class GetRepositoryRemoteRepositoryConfigNpmRepositoryResult(dict):
     @pulumi.getter(name="publicRepository")
     def public_repository(self) -> _builtins.str:
         """
-        Address of the remote repository. Default value: "NPMJS" Possible values: ["NPMJS"]
+        Address of the remote repository. Possible values: ["NPMJS"]
         """
         return pulumi.get(self, "public_repository")
 
@@ -2097,7 +2089,7 @@ class GetRepositoryRemoteRepositoryConfigPythonRepositoryResult(dict):
                  public_repository: _builtins.str):
         """
         :param Sequence['GetRepositoryRemoteRepositoryConfigPythonRepositoryCustomRepositoryArgs'] custom_repositories: [Deprecated, please use commonRepository instead] Settings for a remote repository with a custom uri.
-        :param _builtins.str public_repository: Address of the remote repository. Default value: "PYPI" Possible values: ["PYPI"]
+        :param _builtins.str public_repository: Address of the remote repository. Possible values: ["PYPI"]
         """
         pulumi.set(__self__, "custom_repositories", custom_repositories)
         pulumi.set(__self__, "public_repository", public_repository)
@@ -2114,7 +2106,7 @@ class GetRepositoryRemoteRepositoryConfigPythonRepositoryResult(dict):
     @pulumi.getter(name="publicRepository")
     def public_repository(self) -> _builtins.str:
         """
-        Address of the remote repository. Default value: "PYPI" Possible values: ["PYPI"]
+        Address of the remote repository. Possible values: ["PYPI"]
         """
         return pulumi.get(self, "public_repository")
 

pulumi_gcp/artifactregistry/repository.py

@@ -350,6 +350,7 @@ class _RepositoryState:
                  name: Optional[pulumi.Input[_builtins.str]] = None,
                  project: Optional[pulumi.Input[_builtins.str]] = None,
                  pulumi_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
+                 registry_uri: Optional[pulumi.Input[_builtins.str]] = None,
                  remote_repository_config: Optional[pulumi.Input['RepositoryRemoteRepositoryConfigArgs']] = None,
                  repository_id: Optional[pulumi.Input[_builtins.str]] = None,
                  update_time: Optional[pulumi.Input[_builtins.str]] = None,
@@ -404,6 +405,7 @@ class _RepositoryState:
                If it is not provided, the provider project is used.
         :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] pulumi_labels: The combination of labels configured directly on the resource
                and default labels configured on the provider.
+        :param pulumi.Input[_builtins.str] registry_uri: The repository endpoint, for example: us-docker.pkg.dev/my-proj/my-repo.
         :param pulumi.Input['RepositoryRemoteRepositoryConfigArgs'] remote_repository_config: Configuration specific for a Remote Repository.
                Structure is documented below.
         :param pulumi.Input[_builtins.str] repository_id: The last part of the repository name, for example:
@@ -444,6 +446,8 @@ class _RepositoryState:
             pulumi.set(__self__, "project", project)
         if pulumi_labels is not None:
             pulumi.set(__self__, "pulumi_labels", pulumi_labels)
+        if registry_uri is not None:
+            pulumi.set(__self__, "registry_uri", registry_uri)
         if remote_repository_config is not None:
             pulumi.set(__self__, "remote_repository_config", remote_repository_config)
         if repository_id is not None:
@@ -667,6 +671,18 @@ class _RepositoryState:
     def pulumi_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
         pulumi.set(self, "pulumi_labels", value)
 
+    @_builtins.property
+    @pulumi.getter(name="registryUri")
+    def registry_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The repository endpoint, for example: us-docker.pkg.dev/my-proj/my-repo.
+        """
+        return pulumi.get(self, "registry_uri")
+
+    @registry_uri.setter
+    def registry_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "registry_uri", value)
+
     @_builtins.property
     @pulumi.getter(name="remoteRepositoryConfig")
     def remote_repository_config(self) -> Optional[pulumi.Input['RepositoryRemoteRepositoryConfigArgs']]:
@@ -2008,6 +2024,7 @@ class Repository(pulumi.CustomResource):
             __props__.__dict__["effective_labels"] = None
             __props__.__dict__["name"] = None
             __props__.__dict__["pulumi_labels"] = None
+            __props__.__dict__["registry_uri"] = None
             __props__.__dict__["update_time"] = None
         secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["effectiveLabels", "pulumiLabels"])
         opts = pulumi.ResourceOptions.merge(opts, secret_opts)
@@ -2036,6 +2053,7 @@ class Repository(pulumi.CustomResource):
             name: Optional[pulumi.Input[_builtins.str]] = None,
             project: Optional[pulumi.Input[_builtins.str]] = None,
             pulumi_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
+            registry_uri: Optional[pulumi.Input[_builtins.str]] = None,
             remote_repository_config: Optional[pulumi.Input[Union['RepositoryRemoteRepositoryConfigArgs', 'RepositoryRemoteRepositoryConfigArgsDict']]] = None,
             repository_id: Optional[pulumi.Input[_builtins.str]] = None,
             update_time: Optional[pulumi.Input[_builtins.str]] = None,
@@ -2095,6 +2113,7 @@ class Repository(pulumi.CustomResource):
                If it is not provided, the provider project is used.
         :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] pulumi_labels: The combination of labels configured directly on the resource
                and default labels configured on the provider.
+        :param pulumi.Input[_builtins.str] registry_uri: The repository endpoint, for example: us-docker.pkg.dev/my-proj/my-repo.
         :param pulumi.Input[Union['RepositoryRemoteRepositoryConfigArgs', 'RepositoryRemoteRepositoryConfigArgsDict']] remote_repository_config: Configuration specific for a Remote Repository.
                Structure is documented below.
         :param pulumi.Input[_builtins.str] repository_id: The last part of the repository name, for example:
@@ -2124,6 +2143,7 @@ class Repository(pulumi.CustomResource):
         __props__.__dict__["name"] = name
         __props__.__dict__["project"] = project
         __props__.__dict__["pulumi_labels"] = pulumi_labels
+        __props__.__dict__["registry_uri"] = registry_uri
         __props__.__dict__["remote_repository_config"] = remote_repository_config
         __props__.__dict__["repository_id"] = repository_id
         __props__.__dict__["update_time"] = update_time
@@ -2283,6 +2303,14 @@ class Repository(pulumi.CustomResource):
         """
         return pulumi.get(self, "pulumi_labels")
 
+    @_builtins.property
+    @pulumi.getter(name="registryUri")
+    def registry_uri(self) -> pulumi.Output[_builtins.str]:
+        """
+        The repository endpoint, for example: us-docker.pkg.dev/my-proj/my-repo.
+        """
+        return pulumi.get(self, "registry_uri")
+
     @_builtins.property
     @pulumi.getter(name="remoteRepositoryConfig")
     def remote_repository_config(self) -> pulumi.Output[Optional['outputs.RepositoryRemoteRepositoryConfig']]:

pulumi_gcp/backupdisasterrecovery/__init__.py

@@ -14,6 +14,7 @@ from .get_backup_plan import *
 from .get_backup_plan_association import *
 from .get_backup_vault import *
 from .get_data_source import *
+from .get_data_source_references import *
 from .get_management_server import *
 from .management_server import *
 from .service_config import *

pulumi_gcp/backupdisasterrecovery/backup_plan.py

@@ -187,7 +187,7 @@ class _BackupPlanState:
                If it is not provided, the provider project is used.
         :param pulumi.Input[_builtins.str] resource_type: The resource type to which the `BackupPlan` will be applied.
                Examples include, "compute.googleapis.com/Instance", "compute.googleapis.com/Disk", "sqladmin.googleapis.com/Instance" and "storage.googleapis.com/Bucket".
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] supported_resource_types: The list of all resource types to which the 'BackupPlan' can be applied.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] supported_resource_types: The list of all resource types to which the `BackupPlan` can be applied.
         :param pulumi.Input[_builtins.str] update_time: When the `BackupPlan` was last updated.
         """
         if backup_plan_id is not None:
@@ -356,7 +356,7 @@ class _BackupPlanState:
     @pulumi.getter(name="supportedResourceTypes")
     def supported_resource_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
         """
-        The list of all resource types to which the 'BackupPlan' can be applied.
+        The list of all resource types to which the `BackupPlan` can be applied.
         """
         return pulumi.get(self, "supported_resource_types")
 
@@ -759,7 +759,7 @@ class BackupPlan(pulumi.CustomResource):
                If it is not provided, the provider project is used.
         :param pulumi.Input[_builtins.str] resource_type: The resource type to which the `BackupPlan` will be applied.
                Examples include, "compute.googleapis.com/Instance", "compute.googleapis.com/Disk", "sqladmin.googleapis.com/Instance" and "storage.googleapis.com/Bucket".
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] supported_resource_types: The list of all resource types to which the 'BackupPlan' can be applied.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] supported_resource_types: The list of all resource types to which the `BackupPlan` can be applied.
         :param pulumi.Input[_builtins.str] update_time: When the `BackupPlan` was last updated.
         """
         opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
@@ -876,7 +876,7 @@ class BackupPlan(pulumi.CustomResource):
     @pulumi.getter(name="supportedResourceTypes")
     def supported_resource_types(self) -> pulumi.Output[Sequence[_builtins.str]]:
         """
-        The list of all resource types to which the 'BackupPlan' can be applied.
+        The list of all resource types to which the `BackupPlan` can be applied.
         """
         return pulumi.get(self, "supported_resource_types")
 

pulumi_gcp/backupdisasterrecovery/get_backup.py

@@ -27,13 +27,16 @@ class GetBackupResult:
     """
     A collection of values returned by getBackup.
     """
-    def __init__(__self__, backup_vault_id=None, backups=None, data_source_id=None, id=None, location=None, name=None, project=None):
+    def __init__(__self__, backup_vault_id=None, backups=None, create_time=None, data_source_id=None, id=None, location=None, name=None, project=None):
         if backup_vault_id and not isinstance(backup_vault_id, str):
             raise TypeError("Expected argument 'backup_vault_id' to be a str")
         pulumi.set(__self__, "backup_vault_id", backup_vault_id)
         if backups and not isinstance(backups, list):
             raise TypeError("Expected argument 'backups' to be a list")
         pulumi.set(__self__, "backups", backups)
+        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 data_source_id and not isinstance(data_source_id, str):
             raise TypeError("Expected argument 'data_source_id' to be a str")
         pulumi.set(__self__, "data_source_id", data_source_id)
@@ -60,6 +63,11 @@ class GetBackupResult:
     def backups(self) -> Sequence['outputs.GetBackupBackupResult']:
         return pulumi.get(self, "backups")
 
+    @_builtins.property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> _builtins.str:
+        return pulumi.get(self, "create_time")
+
     @_builtins.property
     @pulumi.getter(name="dataSourceId")
     def data_source_id(self) -> _builtins.str:
@@ -97,6 +105,7 @@ class AwaitableGetBackupResult(GetBackupResult):
         return GetBackupResult(
             backup_vault_id=self.backup_vault_id,
             backups=self.backups,
+            create_time=self.create_time,
             data_source_id=self.data_source_id,
             id=self.id,
             location=self.location,
@@ -141,6 +150,7 @@ def get_backup(backup_vault_id: Optional[_builtins.str] = None,
     return AwaitableGetBackupResult(
         backup_vault_id=pulumi.get(__ret__, 'backup_vault_id'),
         backups=pulumi.get(__ret__, 'backups'),
+        create_time=pulumi.get(__ret__, 'create_time'),
         data_source_id=pulumi.get(__ret__, 'data_source_id'),
         id=pulumi.get(__ret__, 'id'),
         location=pulumi.get(__ret__, 'location'),
@@ -182,6 +192,7 @@ def get_backup_output(backup_vault_id: Optional[pulumi.Input[_builtins.str]] = N
     return __ret__.apply(lambda __response__: GetBackupResult(
         backup_vault_id=pulumi.get(__response__, 'backup_vault_id'),
         backups=pulumi.get(__response__, 'backups'),
+        create_time=pulumi.get(__response__, 'create_time'),
         data_source_id=pulumi.get(__response__, 'data_source_id'),
         id=pulumi.get(__response__, 'id'),
         location=pulumi.get(__response__, 'location'),

pulumi_gcp/backupdisasterrecovery/get_backup_plan_association.py

@@ -163,6 +163,8 @@ def get_backup_plan_association(backup_plan_association_id: Optional[_builtins.s
                                 project: Optional[_builtins.str] = None,
                                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetBackupPlanAssociationResult:
     """
+    A Backup and DR BackupPlanAssociation.
+
     ## Example Usage
 
     ```python
@@ -205,6 +207,8 @@ def get_backup_plan_association_output(backup_plan_association_id: Optional[pulu
                                        project: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetBackupPlanAssociationResult]:
     """
+    A Backup and DR BackupPlanAssociation.
+
     ## Example Usage
 
     ```python

pulumi_gcp/backupdisasterrecovery/get_data_source_references.py

@@ -0,0 +1,135 @@
+# 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__ = [
+    'GetDataSourceReferencesResult',
+    'AwaitableGetDataSourceReferencesResult',
+    'get_data_source_references',
+    'get_data_source_references_output',
+]
+
+@pulumi.output_type
+class GetDataSourceReferencesResult:
+    """
+    A collection of values returned by getDataSourceReferences.
+    """
+    def __init__(__self__, data_source_references=None, id=None, location=None, project=None, resource_type=None):
+        if data_source_references and not isinstance(data_source_references, list):
+            raise TypeError("Expected argument 'data_source_references' to be a list")
+        pulumi.set(__self__, "data_source_references", data_source_references)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if location and not isinstance(location, str):
+            raise TypeError("Expected argument 'location' to be a str")
+        pulumi.set(__self__, "location", location)
+        if project and not isinstance(project, str):
+            raise TypeError("Expected argument 'project' to be a str")
+        pulumi.set(__self__, "project", project)
+        if resource_type and not isinstance(resource_type, str):
+            raise TypeError("Expected argument 'resource_type' to be a str")
+        pulumi.set(__self__, "resource_type", resource_type)
+
+    @_builtins.property
+    @pulumi.getter(name="dataSourceReferences")
+    def data_source_references(self) -> Sequence['outputs.GetDataSourceReferencesDataSourceReferenceResult']:
+        return pulumi.get(self, "data_source_references")
+
+    @_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 location(self) -> _builtins.str:
+        return pulumi.get(self, "location")
+
+    @_builtins.property
+    @pulumi.getter
+    def project(self) -> _builtins.str:
+        return pulumi.get(self, "project")
+
+    @_builtins.property
+    @pulumi.getter(name="resourceType")
+    def resource_type(self) -> _builtins.str:
+        return pulumi.get(self, "resource_type")
+
+
+class AwaitableGetDataSourceReferencesResult(GetDataSourceReferencesResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetDataSourceReferencesResult(
+            data_source_references=self.data_source_references,
+            id=self.id,
+            location=self.location,
+            project=self.project,
+            resource_type=self.resource_type)
+
+
+def get_data_source_references(location: Optional[_builtins.str] = None,
+                               project: Optional[_builtins.str] = None,
+                               resource_type: Optional[_builtins.str] = None,
+                               opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDataSourceReferencesResult:
+    """
+    A list of Backup and DR data source references.
+
+
+    :param _builtins.str project: - (Optional) The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
+    :param _builtins.str resource_type: - (Required) The resource type to get the data source references for. Examples include, "sqladmin.googleapis.com/Instance" , "compute.googleapis.com/Instance" (right now this service not available for compute Instances , it will be added soon )
+    """
+    __args__ = dict()
+    __args__['location'] = location
+    __args__['project'] = project
+    __args__['resourceType'] = resource_type
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('gcp:backupdisasterrecovery/getDataSourceReferences:getDataSourceReferences', __args__, opts=opts, typ=GetDataSourceReferencesResult).value
+
+    return AwaitableGetDataSourceReferencesResult(
+        data_source_references=pulumi.get(__ret__, 'data_source_references'),
+        id=pulumi.get(__ret__, 'id'),
+        location=pulumi.get(__ret__, 'location'),
+        project=pulumi.get(__ret__, 'project'),
+        resource_type=pulumi.get(__ret__, 'resource_type'))
+def get_data_source_references_output(location: Optional[pulumi.Input[_builtins.str]] = None,
+                                      project: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                                      resource_type: Optional[pulumi.Input[_builtins.str]] = None,
+                                      opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDataSourceReferencesResult]:
+    """
+    A list of Backup and DR data source references.
+
+
+    :param _builtins.str project: - (Optional) The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
+    :param _builtins.str resource_type: - (Required) The resource type to get the data source references for. Examples include, "sqladmin.googleapis.com/Instance" , "compute.googleapis.com/Instance" (right now this service not available for compute Instances , it will be added soon )
+    """
+    __args__ = dict()
+    __args__['location'] = location
+    __args__['project'] = project
+    __args__['resourceType'] = resource_type
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('gcp:backupdisasterrecovery/getDataSourceReferences:getDataSourceReferences', __args__, opts=opts, typ=GetDataSourceReferencesResult)
+    return __ret__.apply(lambda __response__: GetDataSourceReferencesResult(
+        data_source_references=pulumi.get(__response__, 'data_source_references'),
+        id=pulumi.get(__response__, 'id'),
+        location=pulumi.get(__response__, 'location'),
+        project=pulumi.get(__response__, 'project'),
+        resource_type=pulumi.get(__response__, 'resource_type')))

pulumi_gcp/backupdisasterrecovery/get_management_server.py

@@ -116,6 +116,8 @@ class AwaitableGetManagementServerResult(GetManagementServerResult):
 def get_management_server(location: Optional[_builtins.str] = None,
                           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetManagementServerResult:
     """
+    Get information about a Google Backup DR Management server.
+
     ## Example Usage
 
     ```python
@@ -142,6 +144,8 @@ def get_management_server(location: Optional[_builtins.str] = None,
 def get_management_server_output(location: Optional[pulumi.Input[_builtins.str]] = None,
                                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetManagementServerResult]:
     """
+    Get information about a Google Backup DR Management server.
+
     ## Example Usage
 
     ```python

pulumi_gcp/backupdisasterrecovery/outputs.py

@@ -37,6 +37,7 @@ __all__ = [
     'GetDataSourceDataSourceBackupApplianceApplicationResult',
     'GetDataSourceDataSourceGcpResourceResult',
     'GetDataSourceDataSourceGcpResourceComputeInstanceDataSourcePropertyResult',
+    'GetDataSourceReferencesDataSourceReferenceResult',
     'GetManagementServerManagementUriResult',
     'GetManagementServerNetworkResult',
 ]
@@ -566,18 +567,21 @@ class GetBackupBackupResult(dict):
     def __init__(__self__, *,
                  backup_id: _builtins.str,
                  backup_vault_id: _builtins.str,
+                 create_time: _builtins.str,
                  data_source_id: _builtins.str,
                  location: _builtins.str,
                  name: _builtins.str):
         """
         :param _builtins.str backup_id: Id of the requesting object, Backup.
         :param _builtins.str backup_vault_id: The ID of the Backup Vault of the Data Source in which the Backup belongs.
+        :param _builtins.str create_time: The time when the backup was created.
         :param _builtins.str data_source_id: The ID of the Data Source in which the Backup belongs.
         :param _builtins.str location: The location in which the Backup belongs.
         :param _builtins.str name: Name of the resource.
         """
         pulumi.set(__self__, "backup_id", backup_id)
         pulumi.set(__self__, "backup_vault_id", backup_vault_id)
+        pulumi.set(__self__, "create_time", create_time)
         pulumi.set(__self__, "data_source_id", data_source_id)
         pulumi.set(__self__, "location", location)
         pulumi.set(__self__, "name", name)
@@ -598,6 +602,14 @@ class GetBackupBackupResult(dict):
         """
         return pulumi.get(self, "backup_vault_id")
 
+    @_builtins.property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> _builtins.str:
+        """
+        The time when the backup was created.
+        """
+        return pulumi.get(self, "create_time")
+
     @_builtins.property
     @pulumi.getter(name="dataSourceId")
     def data_source_id(self) -> _builtins.str:
@@ -1287,6 +1299,97 @@ class GetDataSourceDataSourceGcpResourceComputeInstanceDataSourcePropertyResult(
         return pulumi.get(self, "total_disk_size_gb")
 
 
+@pulumi.output_type
+class GetDataSourceReferencesDataSourceReferenceResult(dict):
+    def __init__(__self__, *,
+                 backup_config_state: _builtins.str,
+                 backup_count: _builtins.int,
+                 data_source: _builtins.str,
+                 gcp_resource_name: _builtins.str,
+                 last_backup_state: _builtins.str,
+                 last_successful_backup_time: _builtins.str,
+                 name: _builtins.str,
+                 resource_type: _builtins.str):
+        """
+        :param _builtins.str backup_config_state: The state of the backup config for the data source.
+        :param _builtins.int backup_count: The number of backups for the data source.
+        :param _builtins.str data_source: The underlying data source resource.
+        :param _builtins.str gcp_resource_name: The GCP resource name for the data source.
+        :param _builtins.str last_backup_state: The state of the last backup.
+        :param _builtins.str last_successful_backup_time: The last time a successful backup was made.
+        :param _builtins.str resource_type: - (Required) The resource type to get the data source references for. Examples include, "sqladmin.googleapis.com/Instance" , "compute.googleapis.com/Instance" (right now this service not available for compute Instances , it will be added soon )
+        """
+        pulumi.set(__self__, "backup_config_state", backup_config_state)
+        pulumi.set(__self__, "backup_count", backup_count)
+        pulumi.set(__self__, "data_source", data_source)
+        pulumi.set(__self__, "gcp_resource_name", gcp_resource_name)
+        pulumi.set(__self__, "last_backup_state", last_backup_state)
+        pulumi.set(__self__, "last_successful_backup_time", last_successful_backup_time)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "resource_type", resource_type)
+
+    @_builtins.property
+    @pulumi.getter(name="backupConfigState")
+    def backup_config_state(self) -> _builtins.str:
+        """
+        The state of the backup config for the data source.
+        """
+        return pulumi.get(self, "backup_config_state")
+
+    @_builtins.property
+    @pulumi.getter(name="backupCount")
+    def backup_count(self) -> _builtins.int:
+        """
+        The number of backups for the data source.
+        """
+        return pulumi.get(self, "backup_count")
+
+    @_builtins.property
+    @pulumi.getter(name="dataSource")
+    def data_source(self) -> _builtins.str:
+        """
+        The underlying data source resource.
+        """
+        return pulumi.get(self, "data_source")
+
+    @_builtins.property
+    @pulumi.getter(name="gcpResourceName")
+    def gcp_resource_name(self) -> _builtins.str:
+        """
+        The GCP resource name for the data source.
+        """
+        return pulumi.get(self, "gcp_resource_name")
+
+    @_builtins.property
+    @pulumi.getter(name="lastBackupState")
+    def last_backup_state(self) -> _builtins.str:
+        """
+        The state of the last backup.
+        """
+        return pulumi.get(self, "last_backup_state")
+
+    @_builtins.property
+    @pulumi.getter(name="lastSuccessfulBackupTime")
+    def last_successful_backup_time(self) -> _builtins.str:
+        """
+        The last time a successful backup was made.
+        """
+        return pulumi.get(self, "last_successful_backup_time")
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> _builtins.str:
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter(name="resourceType")
+    def resource_type(self) -> _builtins.str:
+        """
+        - (Required) The resource type to get the data source references for. Examples include, "sqladmin.googleapis.com/Instance" , "compute.googleapis.com/Instance" (right now this service not available for compute Instances , it will be added soon )
+        """
+        return pulumi.get(self, "resource_type")
+
+
 @pulumi.output_type
 class GetManagementServerManagementUriResult(dict):
     def __init__(__self__, *,

pulumi_gcp/beyondcorp/__init__.py

@@ -9,14 +9,9 @@ import typing
 from .app_connection import *
 from .app_connector import *
 from .app_gateway import *
-from .application import *
-from .application_iam_binding import *
-from .application_iam_member import *
-from .application_iam_policy import *
 from .get_app_connection import *
 from .get_app_connector import *
 from .get_app_gateway import *
-from .get_application_iam_policy import *
 from .get_security_gateway import *
 from .get_security_gateway_application_iam_policy import *
 from .get_security_gateway_iam_policy import *