pulumi-gcp 8.0.0rc0__py3-none-any.whl → 8.1.0__py3-none-any.whl

pulumi_gcp/certificateauthority/authority.py

@@ -49,7 +49,8 @@ class AuthorityArgs:
         :param pulumi.Input[str] location: Location of the CertificateAuthority. A full list of valid locations can be found by
                running `gcloud privateca locations list`.
         :param pulumi.Input[str] pool: The name of the CaPool this Certificate Authority belongs to.
-        :param pulumi.Input[str] desired_state: Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA.
+        :param pulumi.Input[str] desired_state: Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA. Possible values:
+               ENABLED, DISABLED, STAGED.
         :param pulumi.Input[str] gcs_bucket: The name of a Cloud Storage bucket where this CertificateAuthority will publish content, such as the CA certificate and
                CRLs. This must be a bucket name, without any prefixes (such as 'gs://') or suffixes (such as '.googleapis.com'). For
                example, to use a bucket named my-bucket, you would simply specify 'my-bucket'. If not specified, a managed bucket will
@@ -177,7 +178,8 @@ class AuthorityArgs:
     @pulumi.getter(name="desiredState")
     def desired_state(self) -> Optional[pulumi.Input[str]]:
         """
-        Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA.
+        Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA. Possible values:
+        ENABLED, DISABLED, STAGED.
         """
         return pulumi.get(self, "desired_state")
 
@@ -340,7 +342,8 @@ class _AuthorityState:
         :param pulumi.Input[str] create_time: The time at which this CertificateAuthority was created.
                A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine
                fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
-        :param pulumi.Input[str] desired_state: Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA.
+        :param pulumi.Input[str] desired_state: Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA. Possible values:
+               ENABLED, DISABLED, STAGED.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] effective_labels: All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
         :param pulumi.Input[str] gcs_bucket: The name of a Cloud Storage bucket where this CertificateAuthority will publish content, such as the CA certificate and
                CRLs. This must be a bucket name, without any prefixes (such as 'gs://') or suffixes (such as '.googleapis.com'). For
@@ -496,7 +499,8 @@ class _AuthorityState:
     @pulumi.getter(name="desiredState")
     def desired_state(self) -> Optional[pulumi.Input[str]]:
         """
-        Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA.
+        Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA. Possible values:
+        ENABLED, DISABLED, STAGED.
         """
         return pulumi.get(self, "desired_state")
 
@@ -1069,7 +1073,8 @@ class Authority(pulumi.CustomResource):
         :param pulumi.Input[str] certificate_authority_id: The user provided Resource ID for this Certificate Authority.
         :param pulumi.Input[Union['AuthorityConfigArgs', 'AuthorityConfigArgsDict']] config: The config used to create a self-signed X.509 certificate or CSR.
                Structure is documented below.
-        :param pulumi.Input[str] desired_state: Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA.
+        :param pulumi.Input[str] desired_state: Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA. Possible values:
+               ENABLED, DISABLED, STAGED.
         :param pulumi.Input[str] gcs_bucket: The name of a Cloud Storage bucket where this CertificateAuthority will publish content, such as the CA certificate and
                CRLs. This must be a bucket name, without any prefixes (such as 'gs://') or suffixes (such as '.googleapis.com'). For
                example, to use a bucket named my-bucket, you would simply specify 'my-bucket'. If not specified, a managed bucket will
@@ -1530,7 +1535,8 @@ class Authority(pulumi.CustomResource):
         :param pulumi.Input[str] create_time: The time at which this CertificateAuthority was created.
                A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine
                fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
-        :param pulumi.Input[str] desired_state: Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA.
+        :param pulumi.Input[str] desired_state: Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA. Possible values:
+               ENABLED, DISABLED, STAGED.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] effective_labels: All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
         :param pulumi.Input[str] gcs_bucket: The name of a Cloud Storage bucket where this CertificateAuthority will publish content, such as the CA certificate and
                CRLs. This must be a bucket name, without any prefixes (such as 'gs://') or suffixes (such as '.googleapis.com'). For
@@ -1647,7 +1653,8 @@ class Authority(pulumi.CustomResource):
     @pulumi.getter(name="desiredState")
     def desired_state(self) -> pulumi.Output[Optional[str]]:
         """
-        Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA.
+        Desired state of the CertificateAuthority. Set this field to 'STAGED' to create a 'STAGED' root CA. Possible values:
+        ENABLED, DISABLED, STAGED.
         """
         return pulumi.get(self, "desired_state")
 

pulumi_gcp/certificatemanager/__init__.py

@@ -11,6 +11,7 @@ from .certificate_map import *
 from .certificate_map_entry import *
 from .dns_authorization import *
 from .get_certificate_map import *
+from .get_certificates import *
 from .trust_config import *
 from ._inputs import *
 from . import outputs

pulumi_gcp/certificatemanager/certificate.py

@@ -205,6 +205,7 @@ class _CertificateState:
                  name: Optional[pulumi.Input[str]] = None,
                  project: Optional[pulumi.Input[str]] = None,
                  pulumi_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 san_dnsnames: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  scope: Optional[pulumi.Input[str]] = None,
                  self_managed: Optional[pulumi.Input['CertificateSelfManagedArgs']] = None):
         """
@@ -229,6 +230,7 @@ class _CertificateState:
                If it is not provided, the provider project is used.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] pulumi_labels: The combination of labels configured directly on the resource
                and default labels configured on the provider.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] san_dnsnames: The list of Subject Alternative Names of dnsName type defined in the certificate (see RFC 5280 4.2.1.6)
         :param pulumi.Input[str] scope: The scope of the certificate.
                DEFAULT: Certificates with default scope are served from core Google data centers.
                If unsure, choose this option.
@@ -257,6 +259,8 @@ class _CertificateState:
             pulumi.set(__self__, "project", project)
         if pulumi_labels is not None:
             pulumi.set(__self__, "pulumi_labels", pulumi_labels)
+        if san_dnsnames is not None:
+            pulumi.set(__self__, "san_dnsnames", san_dnsnames)
         if scope is not None:
             pulumi.set(__self__, "scope", scope)
         if self_managed is not None:
@@ -370,6 +374,18 @@ class _CertificateState:
     def pulumi_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "pulumi_labels", value)
 
+    @property
+    @pulumi.getter(name="sanDnsnames")
+    def san_dnsnames(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The list of Subject Alternative Names of dnsName type defined in the certificate (see RFC 5280 4.2.1.6)
+        """
+        return pulumi.get(self, "san_dnsnames")
+
+    @san_dnsnames.setter
+    def san_dnsnames(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "san_dnsnames", value)
+
     @property
     @pulumi.getter
     def scope(self) -> Optional[pulumi.Input[str]]:
@@ -1077,6 +1093,7 @@ class Certificate(pulumi.CustomResource):
             __props__.__dict__["self_managed"] = self_managed
             __props__.__dict__["effective_labels"] = None
             __props__.__dict__["pulumi_labels"] = None
+            __props__.__dict__["san_dnsnames"] = None
         secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["effectiveLabels", "pulumiLabels"])
         opts = pulumi.ResourceOptions.merge(opts, secret_opts)
         super(Certificate, __self__).__init__(
@@ -1097,6 +1114,7 @@ class Certificate(pulumi.CustomResource):
             name: Optional[pulumi.Input[str]] = None,
             project: Optional[pulumi.Input[str]] = None,
             pulumi_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+            san_dnsnames: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             scope: Optional[pulumi.Input[str]] = None,
             self_managed: Optional[pulumi.Input[Union['CertificateSelfManagedArgs', 'CertificateSelfManagedArgsDict']]] = None) -> 'Certificate':
         """
@@ -1126,6 +1144,7 @@ class Certificate(pulumi.CustomResource):
                If it is not provided, the provider project is used.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] pulumi_labels: The combination of labels configured directly on the resource
                and default labels configured on the provider.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] san_dnsnames: The list of Subject Alternative Names of dnsName type defined in the certificate (see RFC 5280 4.2.1.6)
         :param pulumi.Input[str] scope: The scope of the certificate.
                DEFAULT: Certificates with default scope are served from core Google data centers.
                If unsure, choose this option.
@@ -1150,6 +1169,7 @@ class Certificate(pulumi.CustomResource):
         __props__.__dict__["name"] = name
         __props__.__dict__["project"] = project
         __props__.__dict__["pulumi_labels"] = pulumi_labels
+        __props__.__dict__["san_dnsnames"] = san_dnsnames
         __props__.__dict__["scope"] = scope
         __props__.__dict__["self_managed"] = self_managed
         return Certificate(resource_name, opts=opts, __props__=__props__)
@@ -1230,6 +1250,14 @@ class Certificate(pulumi.CustomResource):
         """
         return pulumi.get(self, "pulumi_labels")
 
+    @property
+    @pulumi.getter(name="sanDnsnames")
+    def san_dnsnames(self) -> pulumi.Output[Sequence[str]]:
+        """
+        The list of Subject Alternative Names of dnsName type defined in the certificate (see RFC 5280 4.2.1.6)
+        """
+        return pulumi.get(self, "san_dnsnames")
+
     @property
     @pulumi.getter
     def scope(self) -> pulumi.Output[Optional[str]]:

pulumi_gcp/certificatemanager/get_certificates.py

@@ -0,0 +1,150 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+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__ = [
+    'GetCertificatesResult',
+    'AwaitableGetCertificatesResult',
+    'get_certificates',
+    'get_certificates_output',
+]
+
+@pulumi.output_type
+class GetCertificatesResult:
+    """
+    A collection of values returned by getCertificates.
+    """
+    def __init__(__self__, certificates=None, filter=None, id=None, region=None):
+        if certificates and not isinstance(certificates, list):
+            raise TypeError("Expected argument 'certificates' to be a list")
+        pulumi.set(__self__, "certificates", certificates)
+        if filter and not isinstance(filter, str):
+            raise TypeError("Expected argument 'filter' to be a str")
+        pulumi.set(__self__, "filter", filter)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if region and not isinstance(region, str):
+            raise TypeError("Expected argument 'region' to be a str")
+        pulumi.set(__self__, "region", region)
+
+    @property
+    @pulumi.getter
+    def certificates(self) -> Sequence['outputs.GetCertificatesCertificateResult']:
+        return pulumi.get(self, "certificates")
+
+    @property
+    @pulumi.getter
+    def filter(self) -> Optional[str]:
+        return pulumi.get(self, "filter")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def region(self) -> Optional[str]:
+        return pulumi.get(self, "region")
+
+
+class AwaitableGetCertificatesResult(GetCertificatesResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetCertificatesResult(
+            certificates=self.certificates,
+            filter=self.filter,
+            id=self.id,
+            region=self.region)
+
+
+def get_certificates(filter: Optional[str] = None,
+                     region: Optional[str] = None,
+                     opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetCertificatesResult:
+    """
+    List all certificates within Google Certificate Manager for a given project, region or filter.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    default = gcp.certificatemanager.get_certificates()
+    ```
+
+    ### With A Filter
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    default = gcp.certificatemanager.get_certificates(filter="name:projects/PROJECT_ID/locations/REGION/certificates/certificate-name-*")
+    ```
+
+
+    :param str filter: Filter expression to restrict the certificates returned.
+    :param str region: The region in which the resource belongs. If it is not provided, `GLOBAL` is used.
+    """
+    __args__ = dict()
+    __args__['filter'] = filter
+    __args__['region'] = region
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('gcp:certificatemanager/getCertificates:getCertificates', __args__, opts=opts, typ=GetCertificatesResult).value
+
+    return AwaitableGetCertificatesResult(
+        certificates=pulumi.get(__ret__, 'certificates'),
+        filter=pulumi.get(__ret__, 'filter'),
+        id=pulumi.get(__ret__, 'id'),
+        region=pulumi.get(__ret__, 'region'))
+
+
+@_utilities.lift_output_func(get_certificates)
+def get_certificates_output(filter: Optional[pulumi.Input[Optional[str]]] = None,
+                            region: Optional[pulumi.Input[Optional[str]]] = None,
+                            opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetCertificatesResult]:
+    """
+    List all certificates within Google Certificate Manager for a given project, region or filter.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    default = gcp.certificatemanager.get_certificates()
+    ```
+
+    ### With A Filter
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    default = gcp.certificatemanager.get_certificates(filter="name:projects/PROJECT_ID/locations/REGION/certificates/certificate-name-*")
+    ```
+
+
+    :param str filter: Filter expression to restrict the certificates returned.
+    :param str region: The region in which the resource belongs. If it is not provided, `GLOBAL` is used.
+    """
+    ...

pulumi_gcp/certificatemanager/outputs.py

@@ -31,6 +31,10 @@ __all__ = [
     'TrustConfigTrustStoreTrustAnchor',
     'GetCertificateMapGclbTargetResult',
     'GetCertificateMapGclbTargetIpConfigResult',
+    'GetCertificatesCertificateResult',
+    'GetCertificatesCertificateManagedResult',
+    'GetCertificatesCertificateManagedAuthorizationAttemptInfoResult',
+    'GetCertificatesCertificateManagedProvisioningIssueResult',
 ]
 
 @pulumi.output_type
@@ -892,3 +896,321 @@ class GetCertificateMapGclbTargetIpConfigResult(dict):
         return pulumi.get(self, "ports")
 
 
+@pulumi.output_type
+class GetCertificatesCertificateResult(dict):
+    def __init__(__self__, *,
+                 description: str,
+                 effective_labels: Mapping[str, str],
+                 labels: Mapping[str, str],
+                 location: str,
+                 manageds: Sequence['outputs.GetCertificatesCertificateManagedResult'],
+                 name: str,
+                 project: str,
+                 pulumi_labels: Mapping[str, str],
+                 san_dnsnames: Sequence[str],
+                 scope: str):
+        """
+        :param str description: A human-readable description of the resource.
+        :param Mapping[str, str] labels: Set of label tags associated with the Certificate resource.
+               
+               **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
+               Please refer to the field 'effective_labels' for all of the labels present on the resource.
+        :param str location: The Certificate Manager location. If not specified, "global" is used.
+        :param Sequence['GetCertificatesCertificateManagedArgs'] manageds: Configuration and state of a Managed Certificate.
+               Certificate Manager provisions and renews Managed Certificates
+               automatically, for as long as it's authorized to do so.
+        :param str name: A user-defined name of the certificate. Certificate names must be unique
+               The name must be 1-64 characters long, and match the regular expression [a-zA-Z][a-zA-Z0-9_-]* which means the first character must be a letter,
+               and all following characters must be a dash, underscore, letter or digit.
+        :param str project: The ID of the project in which the resource belongs. If it
+               is not provided, the provider project is used.
+        :param Mapping[str, str] pulumi_labels: The combination of labels configured directly on the resource
+                and default labels configured on the provider.
+        :param Sequence[str] san_dnsnames: The list of Subject Alternative Names of dnsName type defined in the certificate (see RFC 5280 4.2.1.6)
+        :param str scope: The scope of the certificate.
+               
+               DEFAULT: Certificates with default scope are served from core Google data centers.
+               If unsure, choose this option.
+               
+               EDGE_CACHE: Certificates with scope EDGE_CACHE are special-purposed certificates, served from Edge Points of Presence.
+               See https://cloud.google.com/vpc/docs/edge-locations.
+               
+               ALL_REGIONS: Certificates with ALL_REGIONS scope are served from all GCP regions (You can only use ALL_REGIONS with global certs).
+               See https://cloud.google.com/compute/docs/regions-zones
+        """
+        pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "effective_labels", effective_labels)
+        pulumi.set(__self__, "labels", labels)
+        pulumi.set(__self__, "location", location)
+        pulumi.set(__self__, "manageds", manageds)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "project", project)
+        pulumi.set(__self__, "pulumi_labels", pulumi_labels)
+        pulumi.set(__self__, "san_dnsnames", san_dnsnames)
+        pulumi.set(__self__, "scope", scope)
+
+    @property
+    @pulumi.getter
+    def description(self) -> str:
+        """
+        A human-readable description of the resource.
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter(name="effectiveLabels")
+    def effective_labels(self) -> Mapping[str, str]:
+        return pulumi.get(self, "effective_labels")
+
+    @property
+    @pulumi.getter
+    def labels(self) -> Mapping[str, str]:
+        """
+        Set of label tags associated with the Certificate resource.
+
+        **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
+        Please refer to the field 'effective_labels' for all of the labels present on the resource.
+        """
+        return pulumi.get(self, "labels")
+
+    @property
+    @pulumi.getter
+    def location(self) -> str:
+        """
+        The Certificate Manager location. If not specified, "global" is used.
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter
+    def manageds(self) -> Sequence['outputs.GetCertificatesCertificateManagedResult']:
+        """
+        Configuration and state of a Managed Certificate.
+        Certificate Manager provisions and renews Managed Certificates
+        automatically, for as long as it's authorized to do so.
+        """
+        return pulumi.get(self, "manageds")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        A user-defined name of the certificate. Certificate names must be unique
+        The name must be 1-64 characters long, and match the regular expression [a-zA-Z][a-zA-Z0-9_-]* which means the first character must be a letter,
+        and all following characters must be a dash, underscore, letter or digit.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def project(self) -> str:
+        """
+        The ID of the project in which the resource belongs. If it
+        is not provided, the provider project is used.
+        """
+        return pulumi.get(self, "project")
+
+    @property
+    @pulumi.getter(name="pulumiLabels")
+    def pulumi_labels(self) -> Mapping[str, str]:
+        """
+        The combination of labels configured directly on the resource
+         and default labels configured on the provider.
+        """
+        return pulumi.get(self, "pulumi_labels")
+
+    @property
+    @pulumi.getter(name="sanDnsnames")
+    def san_dnsnames(self) -> Sequence[str]:
+        """
+        The list of Subject Alternative Names of dnsName type defined in the certificate (see RFC 5280 4.2.1.6)
+        """
+        return pulumi.get(self, "san_dnsnames")
+
+    @property
+    @pulumi.getter
+    def scope(self) -> str:
+        """
+        The scope of the certificate.
+
+        DEFAULT: Certificates with default scope are served from core Google data centers.
+        If unsure, choose this option.
+
+        EDGE_CACHE: Certificates with scope EDGE_CACHE are special-purposed certificates, served from Edge Points of Presence.
+        See https://cloud.google.com/vpc/docs/edge-locations.
+
+        ALL_REGIONS: Certificates with ALL_REGIONS scope are served from all GCP regions (You can only use ALL_REGIONS with global certs).
+        See https://cloud.google.com/compute/docs/regions-zones
+        """
+        return pulumi.get(self, "scope")
+
+
+@pulumi.output_type
+class GetCertificatesCertificateManagedResult(dict):
+    def __init__(__self__, *,
+                 authorization_attempt_infos: Sequence['outputs.GetCertificatesCertificateManagedAuthorizationAttemptInfoResult'],
+                 dns_authorizations: Sequence[str],
+                 domains: Sequence[str],
+                 issuance_config: str,
+                 provisioning_issues: Sequence['outputs.GetCertificatesCertificateManagedProvisioningIssueResult'],
+                 state: str):
+        """
+        :param Sequence['GetCertificatesCertificateManagedAuthorizationAttemptInfoArgs'] authorization_attempt_infos: Detailed state of the latest authorization attempt for each domain
+               specified for this Managed Certificate.
+        :param Sequence[str] dns_authorizations: Authorizations that will be used for performing domain authorization. Either issuanceConfig or dnsAuthorizations should be specificed, but not both.
+        :param Sequence[str] domains: The domains for which a managed SSL certificate will be generated.
+               Wildcard domains are only supported with DNS challenge resolution
+        :param str issuance_config: The resource name for a CertificateIssuanceConfig used to configure private PKI certificates in the format projects/*/locations/*/certificateIssuanceConfigs/*.
+               If this field is not set, the certificates will instead be publicly signed as documented at https://cloud.google.com/load-balancing/docs/ssl-certificates/google-managed-certs#caa.
+               Either issuanceConfig or dnsAuthorizations should be specificed, but not both.
+        :param Sequence['GetCertificatesCertificateManagedProvisioningIssueArgs'] provisioning_issues: Information about issues with provisioning this Managed Certificate.
+        :param str state: A state of this Managed Certificate.
+        """
+        pulumi.set(__self__, "authorization_attempt_infos", authorization_attempt_infos)
+        pulumi.set(__self__, "dns_authorizations", dns_authorizations)
+        pulumi.set(__self__, "domains", domains)
+        pulumi.set(__self__, "issuance_config", issuance_config)
+        pulumi.set(__self__, "provisioning_issues", provisioning_issues)
+        pulumi.set(__self__, "state", state)
+
+    @property
+    @pulumi.getter(name="authorizationAttemptInfos")
+    def authorization_attempt_infos(self) -> Sequence['outputs.GetCertificatesCertificateManagedAuthorizationAttemptInfoResult']:
+        """
+        Detailed state of the latest authorization attempt for each domain
+        specified for this Managed Certificate.
+        """
+        return pulumi.get(self, "authorization_attempt_infos")
+
+    @property
+    @pulumi.getter(name="dnsAuthorizations")
+    def dns_authorizations(self) -> Sequence[str]:
+        """
+        Authorizations that will be used for performing domain authorization. Either issuanceConfig or dnsAuthorizations should be specificed, but not both.
+        """
+        return pulumi.get(self, "dns_authorizations")
+
+    @property
+    @pulumi.getter
+    def domains(self) -> Sequence[str]:
+        """
+        The domains for which a managed SSL certificate will be generated.
+        Wildcard domains are only supported with DNS challenge resolution
+        """
+        return pulumi.get(self, "domains")
+
+    @property
+    @pulumi.getter(name="issuanceConfig")
+    def issuance_config(self) -> str:
+        """
+        The resource name for a CertificateIssuanceConfig used to configure private PKI certificates in the format projects/*/locations/*/certificateIssuanceConfigs/*.
+        If this field is not set, the certificates will instead be publicly signed as documented at https://cloud.google.com/load-balancing/docs/ssl-certificates/google-managed-certs#caa.
+        Either issuanceConfig or dnsAuthorizations should be specificed, but not both.
+        """
+        return pulumi.get(self, "issuance_config")
+
+    @property
+    @pulumi.getter(name="provisioningIssues")
+    def provisioning_issues(self) -> Sequence['outputs.GetCertificatesCertificateManagedProvisioningIssueResult']:
+        """
+        Information about issues with provisioning this Managed Certificate.
+        """
+        return pulumi.get(self, "provisioning_issues")
+
+    @property
+    @pulumi.getter
+    def state(self) -> str:
+        """
+        A state of this Managed Certificate.
+        """
+        return pulumi.get(self, "state")
+
+
+@pulumi.output_type
+class GetCertificatesCertificateManagedAuthorizationAttemptInfoResult(dict):
+    def __init__(__self__, *,
+                 details: str,
+                 domain: str,
+                 failure_reason: str,
+                 state: str):
+        """
+        :param str details: Human readable explanation for reaching the state. Provided to help
+               address the configuration issues.
+               Not guaranteed to be stable. For programmatic access use 'failure_reason' field.
+        :param str domain: Domain name of the authorization attempt.
+        :param str failure_reason: Reason for failure of the authorization attempt for the domain.
+        :param str state: State of the domain for managed certificate issuance.
+        """
+        pulumi.set(__self__, "details", details)
+        pulumi.set(__self__, "domain", domain)
+        pulumi.set(__self__, "failure_reason", failure_reason)
+        pulumi.set(__self__, "state", state)
+
+    @property
+    @pulumi.getter
+    def details(self) -> str:
+        """
+        Human readable explanation for reaching the state. Provided to help
+        address the configuration issues.
+        Not guaranteed to be stable. For programmatic access use 'failure_reason' field.
+        """
+        return pulumi.get(self, "details")
+
+    @property
+    @pulumi.getter
+    def domain(self) -> str:
+        """
+        Domain name of the authorization attempt.
+        """
+        return pulumi.get(self, "domain")
+
+    @property
+    @pulumi.getter(name="failureReason")
+    def failure_reason(self) -> str:
+        """
+        Reason for failure of the authorization attempt for the domain.
+        """
+        return pulumi.get(self, "failure_reason")
+
+    @property
+    @pulumi.getter
+    def state(self) -> str:
+        """
+        State of the domain for managed certificate issuance.
+        """
+        return pulumi.get(self, "state")
+
+
+@pulumi.output_type
+class GetCertificatesCertificateManagedProvisioningIssueResult(dict):
+    def __init__(__self__, *,
+                 details: str,
+                 reason: str):
+        """
+        :param str details: Human readable explanation about the issue. Provided to help address
+               the configuration issues.
+               Not guaranteed to be stable. For programmatic access use 'reason' field.
+        :param str reason: Reason for provisioning failures.
+        """
+        pulumi.set(__self__, "details", details)
+        pulumi.set(__self__, "reason", reason)
+
+    @property
+    @pulumi.getter
+    def details(self) -> str:
+        """
+        Human readable explanation about the issue. Provided to help address
+        the configuration issues.
+        Not guaranteed to be stable. For programmatic access use 'reason' field.
+        """
+        return pulumi.get(self, "details")
+
+    @property
+    @pulumi.getter
+    def reason(self) -> str:
+        """
+        Reason for provisioning failures.
+        """
+        return pulumi.get(self, "reason")
+
+