pulumi-vault 7.6.0a1764657486__py3-none-any.whl

pulumi_vault/pkisecret/get_backend_key.py

@@ -0,0 +1,211 @@
+# 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
+
+__all__ = [
+    'GetBackendKeyResult',
+    'AwaitableGetBackendKeyResult',
+    'get_backend_key',
+    'get_backend_key_output',
+]
+
+@pulumi.output_type
+class GetBackendKeyResult:
+    """
+    A collection of values returned by getBackendKey.
+    """
+    def __init__(__self__, backend=None, id=None, key_id=None, key_name=None, key_ref=None, key_type=None, namespace=None):
+        if backend and not isinstance(backend, str):
+            raise TypeError("Expected argument 'backend' to be a str")
+        pulumi.set(__self__, "backend", backend)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if key_id and not isinstance(key_id, str):
+            raise TypeError("Expected argument 'key_id' to be a str")
+        pulumi.set(__self__, "key_id", key_id)
+        if key_name and not isinstance(key_name, str):
+            raise TypeError("Expected argument 'key_name' to be a str")
+        pulumi.set(__self__, "key_name", key_name)
+        if key_ref and not isinstance(key_ref, str):
+            raise TypeError("Expected argument 'key_ref' to be a str")
+        pulumi.set(__self__, "key_ref", key_ref)
+        if key_type and not isinstance(key_type, str):
+            raise TypeError("Expected argument 'key_type' to be a str")
+        pulumi.set(__self__, "key_type", key_type)
+        if namespace and not isinstance(namespace, str):
+            raise TypeError("Expected argument 'namespace' to be a str")
+        pulumi.set(__self__, "namespace", namespace)
+
+    @_builtins.property
+    @pulumi.getter
+    def backend(self) -> _builtins.str:
+        return pulumi.get(self, "backend")
+
+    @_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(name="keyId")
+    def key_id(self) -> _builtins.str:
+        """
+        ID of the key.
+        """
+        return pulumi.get(self, "key_id")
+
+    @_builtins.property
+    @pulumi.getter(name="keyName")
+    def key_name(self) -> _builtins.str:
+        """
+        Name of the key.
+        """
+        return pulumi.get(self, "key_name")
+
+    @_builtins.property
+    @pulumi.getter(name="keyRef")
+    def key_ref(self) -> _builtins.str:
+        return pulumi.get(self, "key_ref")
+
+    @_builtins.property
+    @pulumi.getter(name="keyType")
+    def key_type(self) -> _builtins.str:
+        """
+        Type of the key.
+        """
+        return pulumi.get(self, "key_type")
+
+    @_builtins.property
+    @pulumi.getter
+    def namespace(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "namespace")
+
+
+class AwaitableGetBackendKeyResult(GetBackendKeyResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetBackendKeyResult(
+            backend=self.backend,
+            id=self.id,
+            key_id=self.key_id,
+            key_name=self.key_name,
+            key_ref=self.key_ref,
+            key_type=self.key_type,
+            namespace=self.namespace)
+
+
+def get_backend_key(backend: Optional[_builtins.str] = None,
+                    key_ref: Optional[_builtins.str] = None,
+                    namespace: Optional[_builtins.str] = None,
+                    opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetBackendKeyResult:
+    """
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_vault as vault
+
+    pki = vault.Mount("pki",
+        path="pki",
+        type="pki",
+        description="PKI secret engine mount")
+    key = vault.pkisecret.SecretBackendKey("key",
+        backend=pki.path,
+        type="internal",
+        key_name="example",
+        key_type="rsa",
+        key_bits=4096)
+    example = key.key_id.apply(lambda key_id: vault.pkiSecret.get_backend_key_output(backend=key_vault_mount["path"],
+        key_ref=key_id))
+    ```
+
+
+    :param _builtins.str backend: The path to the PKI secret backend to
+           read the key from, with no leading or trailing `/`s.
+    :param _builtins.str key_ref: Reference to an existing key.
+    :param _builtins.str namespace: The namespace of the target resource.
+           The value should not contain leading or trailing forward slashes.
+           The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
+           *Available only for Vault Enterprise*.
+    """
+    __args__ = dict()
+    __args__['backend'] = backend
+    __args__['keyRef'] = key_ref
+    __args__['namespace'] = namespace
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('vault:pkiSecret/getBackendKey:getBackendKey', __args__, opts=opts, typ=GetBackendKeyResult).value
+
+    return AwaitableGetBackendKeyResult(
+        backend=pulumi.get(__ret__, 'backend'),
+        id=pulumi.get(__ret__, 'id'),
+        key_id=pulumi.get(__ret__, 'key_id'),
+        key_name=pulumi.get(__ret__, 'key_name'),
+        key_ref=pulumi.get(__ret__, 'key_ref'),
+        key_type=pulumi.get(__ret__, 'key_type'),
+        namespace=pulumi.get(__ret__, 'namespace'))
+def get_backend_key_output(backend: Optional[pulumi.Input[_builtins.str]] = None,
+                           key_ref: Optional[pulumi.Input[_builtins.str]] = None,
+                           namespace: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                           opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetBackendKeyResult]:
+    """
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_vault as vault
+
+    pki = vault.Mount("pki",
+        path="pki",
+        type="pki",
+        description="PKI secret engine mount")
+    key = vault.pkisecret.SecretBackendKey("key",
+        backend=pki.path,
+        type="internal",
+        key_name="example",
+        key_type="rsa",
+        key_bits=4096)
+    example = key.key_id.apply(lambda key_id: vault.pkiSecret.get_backend_key_output(backend=key_vault_mount["path"],
+        key_ref=key_id))
+    ```
+
+
+    :param _builtins.str backend: The path to the PKI secret backend to
+           read the key from, with no leading or trailing `/`s.
+    :param _builtins.str key_ref: Reference to an existing key.
+    :param _builtins.str namespace: The namespace of the target resource.
+           The value should not contain leading or trailing forward slashes.
+           The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
+           *Available only for Vault Enterprise*.
+    """
+    __args__ = dict()
+    __args__['backend'] = backend
+    __args__['keyRef'] = key_ref
+    __args__['namespace'] = namespace
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('vault:pkiSecret/getBackendKey:getBackendKey', __args__, opts=opts, typ=GetBackendKeyResult)
+    return __ret__.apply(lambda __response__: GetBackendKeyResult(
+        backend=pulumi.get(__response__, 'backend'),
+        id=pulumi.get(__response__, 'id'),
+        key_id=pulumi.get(__response__, 'key_id'),
+        key_name=pulumi.get(__response__, 'key_name'),
+        key_ref=pulumi.get(__response__, 'key_ref'),
+        key_type=pulumi.get(__response__, 'key_type'),
+        namespace=pulumi.get(__response__, 'namespace')))

pulumi_vault/pkisecret/get_backend_keys.py

@@ -0,0 +1,192 @@
+# 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
+
+__all__ = [
+    'GetBackendKeysResult',
+    'AwaitableGetBackendKeysResult',
+    'get_backend_keys',
+    'get_backend_keys_output',
+]
+
+@pulumi.output_type
+class GetBackendKeysResult:
+    """
+    A collection of values returned by getBackendKeys.
+    """
+    def __init__(__self__, backend=None, id=None, key_info=None, key_info_json=None, keys=None, namespace=None):
+        if backend and not isinstance(backend, str):
+            raise TypeError("Expected argument 'backend' to be a str")
+        pulumi.set(__self__, "backend", backend)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if key_info and not isinstance(key_info, dict):
+            raise TypeError("Expected argument 'key_info' to be a dict")
+        pulumi.set(__self__, "key_info", key_info)
+        if key_info_json and not isinstance(key_info_json, str):
+            raise TypeError("Expected argument 'key_info_json' to be a str")
+        pulumi.set(__self__, "key_info_json", key_info_json)
+        if keys and not isinstance(keys, list):
+            raise TypeError("Expected argument 'keys' to be a list")
+        pulumi.set(__self__, "keys", keys)
+        if namespace and not isinstance(namespace, str):
+            raise TypeError("Expected argument 'namespace' to be a str")
+        pulumi.set(__self__, "namespace", namespace)
+
+    @_builtins.property
+    @pulumi.getter
+    def backend(self) -> _builtins.str:
+        return pulumi.get(self, "backend")
+
+    @_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(name="keyInfo")
+    def key_info(self) -> Mapping[str, _builtins.str]:
+        """
+        Map of key strings read from Vault.
+        """
+        return pulumi.get(self, "key_info")
+
+    @_builtins.property
+    @pulumi.getter(name="keyInfoJson")
+    def key_info_json(self) -> _builtins.str:
+        """
+        JSON-encoded key data read from Vault.
+        """
+        return pulumi.get(self, "key_info_json")
+
+    @_builtins.property
+    @pulumi.getter
+    def keys(self) -> Sequence[_builtins.str]:
+        """
+        Keys used under the backend path.
+        """
+        return pulumi.get(self, "keys")
+
+    @_builtins.property
+    @pulumi.getter
+    def namespace(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "namespace")
+
+
+class AwaitableGetBackendKeysResult(GetBackendKeysResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetBackendKeysResult(
+            backend=self.backend,
+            id=self.id,
+            key_info=self.key_info,
+            key_info_json=self.key_info_json,
+            keys=self.keys,
+            namespace=self.namespace)
+
+
+def get_backend_keys(backend: Optional[_builtins.str] = None,
+                     namespace: Optional[_builtins.str] = None,
+                     opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetBackendKeysResult:
+    """
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_vault as vault
+
+    pki = vault.Mount("pki",
+        path="pki",
+        type="pki",
+        description="PKI secret engine mount")
+    root = vault.pkisecret.SecretBackendRootCert("root",
+        backend=pki.path,
+        type="internal",
+        common_name="example",
+        ttl="86400",
+        key_name="example")
+    example = vault.pkiSecret.get_backend_keys_output(backend=root.backend)
+    ```
+
+
+    :param _builtins.str backend: The path to the PKI secret backend to
+           read the keys from, with no leading or trailing `/`s.
+    :param _builtins.str namespace: The namespace of the target resource.
+           The value should not contain leading or trailing forward slashes.
+           The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
+           *Available only for Vault Enterprise*.
+    """
+    __args__ = dict()
+    __args__['backend'] = backend
+    __args__['namespace'] = namespace
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('vault:pkiSecret/getBackendKeys:getBackendKeys', __args__, opts=opts, typ=GetBackendKeysResult).value
+
+    return AwaitableGetBackendKeysResult(
+        backend=pulumi.get(__ret__, 'backend'),
+        id=pulumi.get(__ret__, 'id'),
+        key_info=pulumi.get(__ret__, 'key_info'),
+        key_info_json=pulumi.get(__ret__, 'key_info_json'),
+        keys=pulumi.get(__ret__, 'keys'),
+        namespace=pulumi.get(__ret__, 'namespace'))
+def get_backend_keys_output(backend: Optional[pulumi.Input[_builtins.str]] = None,
+                            namespace: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                            opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetBackendKeysResult]:
+    """
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_vault as vault
+
+    pki = vault.Mount("pki",
+        path="pki",
+        type="pki",
+        description="PKI secret engine mount")
+    root = vault.pkisecret.SecretBackendRootCert("root",
+        backend=pki.path,
+        type="internal",
+        common_name="example",
+        ttl="86400",
+        key_name="example")
+    example = vault.pkiSecret.get_backend_keys_output(backend=root.backend)
+    ```
+
+
+    :param _builtins.str backend: The path to the PKI secret backend to
+           read the keys from, with no leading or trailing `/`s.
+    :param _builtins.str namespace: The namespace of the target resource.
+           The value should not contain leading or trailing forward slashes.
+           The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
+           *Available only for Vault Enterprise*.
+    """
+    __args__ = dict()
+    __args__['backend'] = backend
+    __args__['namespace'] = namespace
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('vault:pkiSecret/getBackendKeys:getBackendKeys', __args__, opts=opts, typ=GetBackendKeysResult)
+    return __ret__.apply(lambda __response__: GetBackendKeysResult(
+        backend=pulumi.get(__response__, 'backend'),
+        id=pulumi.get(__response__, 'id'),
+        key_info=pulumi.get(__response__, 'key_info'),
+        key_info_json=pulumi.get(__response__, 'key_info_json'),
+        keys=pulumi.get(__response__, 'keys'),
+        namespace=pulumi.get(__response__, 'namespace')))

pulumi_vault/pkisecret/outputs.py

@@ -0,0 +1,270 @@
+# 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
+
+__all__ = [
+    'BackendConfigCmpv2Authenticators',
+    'BackendConfigEstAuthenticators',
+    'BackendConfigScepAuthenticators',
+    'BackendConfigScepExternalValidation',
+    'SecretBackendRolePolicyIdentifier',
+    'GetBackendConfigCmpv2AuthenticatorResult',
+    'GetBackendConfigEstAuthenticatorResult',
+    'GetBackendConfigScepAuthenticatorResult',
+    'GetBackendConfigScepExternalValidationResult',
+]
+
+@pulumi.output_type
+class BackendConfigCmpv2Authenticators(dict):
+    def __init__(__self__, *,
+                 cert: Optional[Mapping[str, _builtins.str]] = None):
+        """
+        :param Mapping[str, _builtins.str] cert: "The accessor (required) and cert_role (optional) properties for cert auth backends".
+        """
+        if cert is not None:
+            pulumi.set(__self__, "cert", cert)
+
+    @_builtins.property
+    @pulumi.getter
+    def cert(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        "The accessor (required) and cert_role (optional) properties for cert auth backends".
+        """
+        return pulumi.get(self, "cert")
+
+
+@pulumi.output_type
+class BackendConfigEstAuthenticators(dict):
+    def __init__(__self__, *,
+                 cert: Optional[Mapping[str, _builtins.str]] = None,
+                 userpass: Optional[Mapping[str, _builtins.str]] = None):
+        """
+        :param Mapping[str, _builtins.str] cert: The accessor (required) and cert_role (optional) properties for cert auth backends.
+        :param Mapping[str, _builtins.str] userpass: The accessor (required) property for user pass auth backends.
+        """
+        if cert is not None:
+            pulumi.set(__self__, "cert", cert)
+        if userpass is not None:
+            pulumi.set(__self__, "userpass", userpass)
+
+    @_builtins.property
+    @pulumi.getter
+    def cert(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        The accessor (required) and cert_role (optional) properties for cert auth backends.
+        """
+        return pulumi.get(self, "cert")
+
+    @_builtins.property
+    @pulumi.getter
+    def userpass(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        The accessor (required) property for user pass auth backends.
+        """
+        return pulumi.get(self, "userpass")
+
+
+@pulumi.output_type
+class BackendConfigScepAuthenticators(dict):
+    def __init__(__self__, *,
+                 cert: Optional[Mapping[str, _builtins.str]] = None,
+                 scep: Optional[Mapping[str, _builtins.str]] = None):
+        """
+        :param Mapping[str, _builtins.str] cert: The accessor and cert_role properties for cert auth backends
+        :param Mapping[str, _builtins.str] scep: The accessor property for SCEP auth backends
+        """
+        if cert is not None:
+            pulumi.set(__self__, "cert", cert)
+        if scep is not None:
+            pulumi.set(__self__, "scep", scep)
+
+    @_builtins.property
+    @pulumi.getter
+    def cert(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        The accessor and cert_role properties for cert auth backends
+        """
+        return pulumi.get(self, "cert")
+
+    @_builtins.property
+    @pulumi.getter
+    def scep(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        The accessor property for SCEP auth backends
+        """
+        return pulumi.get(self, "scep")
+
+
+@pulumi.output_type
+class BackendConfigScepExternalValidation(dict):
+    def __init__(__self__, *,
+                 intune: Optional[Mapping[str, _builtins.str]] = None):
+        """
+        :param Mapping[str, _builtins.str] intune: The credentials to enable Microsoft Intune validation of SCEP requests
+        """
+        if intune is not None:
+            pulumi.set(__self__, "intune", intune)
+
+    @_builtins.property
+    @pulumi.getter
+    def intune(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        The credentials to enable Microsoft Intune validation of SCEP requests
+        """
+        return pulumi.get(self, "intune")
+
+
+@pulumi.output_type
+class SecretBackendRolePolicyIdentifier(dict):
+    def __init__(__self__, *,
+                 oid: _builtins.str,
+                 cps: Optional[_builtins.str] = None,
+                 notice: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str oid: The OID for the policy identifier
+        :param _builtins.str cps: The URL of the CPS for the policy identifier
+        :param _builtins.str notice: A notice for the policy identifier
+        """
+        pulumi.set(__self__, "oid", oid)
+        if cps is not None:
+            pulumi.set(__self__, "cps", cps)
+        if notice is not None:
+            pulumi.set(__self__, "notice", notice)
+
+    @_builtins.property
+    @pulumi.getter
+    def oid(self) -> _builtins.str:
+        """
+        The OID for the policy identifier
+        """
+        return pulumi.get(self, "oid")
+
+    @_builtins.property
+    @pulumi.getter
+    def cps(self) -> Optional[_builtins.str]:
+        """
+        The URL of the CPS for the policy identifier
+        """
+        return pulumi.get(self, "cps")
+
+    @_builtins.property
+    @pulumi.getter
+    def notice(self) -> Optional[_builtins.str]:
+        """
+        A notice for the policy identifier
+        """
+        return pulumi.get(self, "notice")
+
+
+@pulumi.output_type
+class GetBackendConfigCmpv2AuthenticatorResult(dict):
+    def __init__(__self__, *,
+                 cert: Optional[Mapping[str, _builtins.str]] = None):
+        """
+        :param Mapping[str, _builtins.str] cert: The accessor and cert_role properties for cert auth backends
+        """
+        if cert is not None:
+            pulumi.set(__self__, "cert", cert)
+
+    @_builtins.property
+    @pulumi.getter
+    def cert(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        The accessor and cert_role properties for cert auth backends
+        """
+        return pulumi.get(self, "cert")
+
+
+@pulumi.output_type
+class GetBackendConfigEstAuthenticatorResult(dict):
+    def __init__(__self__, *,
+                 cert: Optional[Mapping[str, _builtins.str]] = None,
+                 userpass: Optional[Mapping[str, _builtins.str]] = None):
+        """
+        :param Mapping[str, _builtins.str] cert: The accessor and cert_role properties for cert auth backends.
+        :param Mapping[str, _builtins.str] userpass: The accessor property for user pass auth backends.
+        """
+        if cert is not None:
+            pulumi.set(__self__, "cert", cert)
+        if userpass is not None:
+            pulumi.set(__self__, "userpass", userpass)
+
+    @_builtins.property
+    @pulumi.getter
+    def cert(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        The accessor and cert_role properties for cert auth backends.
+        """
+        return pulumi.get(self, "cert")
+
+    @_builtins.property
+    @pulumi.getter
+    def userpass(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        The accessor property for user pass auth backends.
+        """
+        return pulumi.get(self, "userpass")
+
+
+@pulumi.output_type
+class GetBackendConfigScepAuthenticatorResult(dict):
+    def __init__(__self__, *,
+                 cert: Optional[Mapping[str, _builtins.str]] = None,
+                 scep: Optional[Mapping[str, _builtins.str]] = None):
+        """
+        :param Mapping[str, _builtins.str] cert: The accessor and cert_role properties for cert auth backends.
+        :param Mapping[str, _builtins.str] scep: The accessor property for scep auth backends.
+        """
+        if cert is not None:
+            pulumi.set(__self__, "cert", cert)
+        if scep is not None:
+            pulumi.set(__self__, "scep", scep)
+
+    @_builtins.property
+    @pulumi.getter
+    def cert(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        The accessor and cert_role properties for cert auth backends.
+        """
+        return pulumi.get(self, "cert")
+
+    @_builtins.property
+    @pulumi.getter
+    def scep(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        The accessor property for scep auth backends.
+        """
+        return pulumi.get(self, "scep")
+
+
+@pulumi.output_type
+class GetBackendConfigScepExternalValidationResult(dict):
+    def __init__(__self__, *,
+                 intune: Optional[Mapping[str, _builtins.str]] = None):
+        """
+        :param Mapping[str, _builtins.str] intune: The tenant_id, client_id, client_secret and environment properties for Microsoft Intune validation of SCEP requests.
+        """
+        if intune is not None:
+            pulumi.set(__self__, "intune", intune)
+
+    @_builtins.property
+    @pulumi.getter
+    def intune(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        The tenant_id, client_id, client_secret and environment properties for Microsoft Intune validation of SCEP requests.
+        """
+        return pulumi.get(self, "intune")
+
+