# 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 pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'FeatureMembershipConfigmanagement',
    'FeatureMembershipConfigmanagementBinauthz',
    'FeatureMembershipConfigmanagementConfigSync',
    'FeatureMembershipConfigmanagementConfigSyncGit',
    'FeatureMembershipConfigmanagementConfigSyncOci',
    'FeatureMembershipConfigmanagementHierarchyController',
    'FeatureMembershipConfigmanagementPolicyController',
    'FeatureMembershipConfigmanagementPolicyControllerMonitoring',
    'FeatureMembershipMesh',
    'FeatureResourceState',
    'FeatureSpec',
    'FeatureSpecMulticlusteringress',
    'FeatureState',
    'FeatureStateState',
    'MembershipAuthority',
    'MembershipEndpoint',
    'MembershipEndpointGkeCluster',
    'MembershipIamBindingCondition',
    'MembershipIamMemberCondition',
]

@pulumi.output_type
class FeatureMembershipConfigmanagement(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configSync":
            suggest = "config_sync"
        elif key == "hierarchyController":
            suggest = "hierarchy_controller"
        elif key == "policyController":
            suggest = "policy_controller"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureMembershipConfigmanagement. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureMembershipConfigmanagement.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureMembershipConfigmanagement.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 binauthz: Optional['outputs.FeatureMembershipConfigmanagementBinauthz'] = None,
                 config_sync: Optional['outputs.FeatureMembershipConfigmanagementConfigSync'] = None,
                 hierarchy_controller: Optional['outputs.FeatureMembershipConfigmanagementHierarchyController'] = None,
                 policy_controller: Optional['outputs.FeatureMembershipConfigmanagementPolicyController'] = None,
                 version: Optional[str] = None):
        """
        :param 'FeatureMembershipConfigmanagementBinauthzArgs' binauthz: Binauthz configuration for the cluster. Structure is documented below.
        :param 'FeatureMembershipConfigmanagementConfigSyncArgs' config_sync: Config Sync configuration for the cluster. Structure is documented below.
        :param 'FeatureMembershipConfigmanagementHierarchyControllerArgs' hierarchy_controller: Hierarchy Controller configuration for the cluster. Structure is documented below.
        :param 'FeatureMembershipConfigmanagementPolicyControllerArgs' policy_controller: Policy Controller configuration for the cluster. Structure is documented below.
        :param str version: Version of ACM installed.
        """
        if binauthz is not None:
            pulumi.set(__self__, "binauthz", binauthz)
        if config_sync is not None:
            pulumi.set(__self__, "config_sync", config_sync)
        if hierarchy_controller is not None:
            pulumi.set(__self__, "hierarchy_controller", hierarchy_controller)
        if policy_controller is not None:
            pulumi.set(__self__, "policy_controller", policy_controller)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def binauthz(self) -> Optional['outputs.FeatureMembershipConfigmanagementBinauthz']:
        """
        Binauthz configuration for the cluster. Structure is documented below.
        """
        return pulumi.get(self, "binauthz")

    @property
    @pulumi.getter(name="configSync")
    def config_sync(self) -> Optional['outputs.FeatureMembershipConfigmanagementConfigSync']:
        """
        Config Sync configuration for the cluster. Structure is documented below.
        """
        return pulumi.get(self, "config_sync")

    @property
    @pulumi.getter(name="hierarchyController")
    def hierarchy_controller(self) -> Optional['outputs.FeatureMembershipConfigmanagementHierarchyController']:
        """
        Hierarchy Controller configuration for the cluster. Structure is documented below.
        """
        return pulumi.get(self, "hierarchy_controller")

    @property
    @pulumi.getter(name="policyController")
    def policy_controller(self) -> Optional['outputs.FeatureMembershipConfigmanagementPolicyController']:
        """
        Policy Controller configuration for the cluster. Structure is documented below.
        """
        return pulumi.get(self, "policy_controller")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Version of ACM installed.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class FeatureMembershipConfigmanagementBinauthz(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        """
        :param bool enabled: Whether binauthz is enabled in this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Whether binauthz is enabled in this cluster.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class FeatureMembershipConfigmanagementConfigSync(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "preventDrift":
            suggest = "prevent_drift"
        elif key == "sourceFormat":
            suggest = "source_format"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureMembershipConfigmanagementConfigSync. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureMembershipConfigmanagementConfigSync.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureMembershipConfigmanagementConfigSync.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 git: Optional['outputs.FeatureMembershipConfigmanagementConfigSyncGit'] = None,
                 oci: Optional['outputs.FeatureMembershipConfigmanagementConfigSyncOci'] = None,
                 prevent_drift: Optional[bool] = None,
                 source_format: Optional[str] = None):
        """
        :param 'FeatureMembershipConfigmanagementConfigSyncGitArgs' git: (Optional) Structure is documented below.
        :param 'FeatureMembershipConfigmanagementConfigSyncOciArgs' oci: (Optional) Supported from ACM versions 1.12.0 onwards. Structure is documented below.
        :param bool prevent_drift: Supported from ACM versions 1.10.0 onwards. Set to true to enable the Config Sync admission webhook to prevent drifts. If set to "false", disables the Config Sync admission webhook and does not prevent drifts.
        :param str source_format: Specifies whether the Config Sync Repo is in "hierarchical" or "unstructured" mode.
        """
        if git is not None:
            pulumi.set(__self__, "git", git)
        if oci is not None:
            pulumi.set(__self__, "oci", oci)
        if prevent_drift is not None:
            pulumi.set(__self__, "prevent_drift", prevent_drift)
        if source_format is not None:
            pulumi.set(__self__, "source_format", source_format)

    @property
    @pulumi.getter
    def git(self) -> Optional['outputs.FeatureMembershipConfigmanagementConfigSyncGit']:
        """
        (Optional) Structure is documented below.
        """
        return pulumi.get(self, "git")

    @property
    @pulumi.getter
    def oci(self) -> Optional['outputs.FeatureMembershipConfigmanagementConfigSyncOci']:
        """
        (Optional) Supported from ACM versions 1.12.0 onwards. Structure is documented below.
        """
        return pulumi.get(self, "oci")

    @property
    @pulumi.getter(name="preventDrift")
    def prevent_drift(self) -> Optional[bool]:
        """
        Supported from ACM versions 1.10.0 onwards. Set to true to enable the Config Sync admission webhook to prevent drifts. If set to "false", disables the Config Sync admission webhook and does not prevent drifts.
        """
        return pulumi.get(self, "prevent_drift")

    @property
    @pulumi.getter(name="sourceFormat")
    def source_format(self) -> Optional[str]:
        """
        Specifies whether the Config Sync Repo is in "hierarchical" or "unstructured" mode.
        """
        return pulumi.get(self, "source_format")


@pulumi.output_type
class FeatureMembershipConfigmanagementConfigSyncGit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gcpServiceAccountEmail":
            suggest = "gcp_service_account_email"
        elif key == "httpsProxy":
            suggest = "https_proxy"
        elif key == "policyDir":
            suggest = "policy_dir"
        elif key == "secretType":
            suggest = "secret_type"
        elif key == "syncBranch":
            suggest = "sync_branch"
        elif key == "syncRepo":
            suggest = "sync_repo"
        elif key == "syncRev":
            suggest = "sync_rev"
        elif key == "syncWaitSecs":
            suggest = "sync_wait_secs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureMembershipConfigmanagementConfigSyncGit. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureMembershipConfigmanagementConfigSyncGit.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureMembershipConfigmanagementConfigSyncGit.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 gcp_service_account_email: Optional[str] = None,
                 https_proxy: Optional[str] = None,
                 policy_dir: Optional[str] = None,
                 secret_type: Optional[str] = None,
                 sync_branch: Optional[str] = None,
                 sync_repo: Optional[str] = None,
                 sync_rev: Optional[str] = None,
                 sync_wait_secs: Optional[str] = None):
        """
        :param str gcp_service_account_email: The GCP Service Account Email used for auth when secretType is gcpServiceAccount.
        :param str https_proxy: URL for the HTTPS proxy to be used when communicating with the Git repo.
        :param str policy_dir: The path within the Git repository that represents the top level of the repo to sync. Default: the root directory of the repository.
        :param str secret_type: Type of secret configured for access to the Git repo.
        :param str sync_branch: The branch of the repository to sync from. Default: master.
        :param str sync_repo: The URL of the Git repository to use as the source of truth.
        :param str sync_rev: Git revision (tag or hash) to check out. Default HEAD.
        :param str sync_wait_secs: Period in seconds between consecutive syncs. Default: 15.
        """
        if gcp_service_account_email is not None:
            pulumi.set(__self__, "gcp_service_account_email", gcp_service_account_email)
        if https_proxy is not None:
            pulumi.set(__self__, "https_proxy", https_proxy)
        if policy_dir is not None:
            pulumi.set(__self__, "policy_dir", policy_dir)
        if secret_type is not None:
            pulumi.set(__self__, "secret_type", secret_type)
        if sync_branch is not None:
            pulumi.set(__self__, "sync_branch", sync_branch)
        if sync_repo is not None:
            pulumi.set(__self__, "sync_repo", sync_repo)
        if sync_rev is not None:
            pulumi.set(__self__, "sync_rev", sync_rev)
        if sync_wait_secs is not None:
            pulumi.set(__self__, "sync_wait_secs", sync_wait_secs)

    @property
    @pulumi.getter(name="gcpServiceAccountEmail")
    def gcp_service_account_email(self) -> Optional[str]:
        """
        The GCP Service Account Email used for auth when secretType is gcpServiceAccount.
        """
        return pulumi.get(self, "gcp_service_account_email")

    @property
    @pulumi.getter(name="httpsProxy")
    def https_proxy(self) -> Optional[str]:
        """
        URL for the HTTPS proxy to be used when communicating with the Git repo.
        """
        return pulumi.get(self, "https_proxy")

    @property
    @pulumi.getter(name="policyDir")
    def policy_dir(self) -> Optional[str]:
        """
        The path within the Git repository that represents the top level of the repo to sync. Default: the root directory of the repository.
        """
        return pulumi.get(self, "policy_dir")

    @property
    @pulumi.getter(name="secretType")
    def secret_type(self) -> Optional[str]:
        """
        Type of secret configured for access to the Git repo.
        """
        return pulumi.get(self, "secret_type")

    @property
    @pulumi.getter(name="syncBranch")
    def sync_branch(self) -> Optional[str]:
        """
        The branch of the repository to sync from. Default: master.
        """
        return pulumi.get(self, "sync_branch")

    @property
    @pulumi.getter(name="syncRepo")
    def sync_repo(self) -> Optional[str]:
        """
        The URL of the Git repository to use as the source of truth.
        """
        return pulumi.get(self, "sync_repo")

    @property
    @pulumi.getter(name="syncRev")
    def sync_rev(self) -> Optional[str]:
        """
        Git revision (tag or hash) to check out. Default HEAD.
        """
        return pulumi.get(self, "sync_rev")

    @property
    @pulumi.getter(name="syncWaitSecs")
    def sync_wait_secs(self) -> Optional[str]:
        """
        Period in seconds between consecutive syncs. Default: 15.
        """
        return pulumi.get(self, "sync_wait_secs")


@pulumi.output_type
class FeatureMembershipConfigmanagementConfigSyncOci(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gcpServiceAccountEmail":
            suggest = "gcp_service_account_email"
        elif key == "policyDir":
            suggest = "policy_dir"
        elif key == "secretType":
            suggest = "secret_type"
        elif key == "syncRepo":
            suggest = "sync_repo"
        elif key == "syncWaitSecs":
            suggest = "sync_wait_secs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureMembershipConfigmanagementConfigSyncOci. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureMembershipConfigmanagementConfigSyncOci.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureMembershipConfigmanagementConfigSyncOci.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 gcp_service_account_email: Optional[str] = None,
                 policy_dir: Optional[str] = None,
                 secret_type: Optional[str] = None,
                 sync_repo: Optional[str] = None,
                 sync_wait_secs: Optional[str] = None):
        """
        :param str gcp_service_account_email: The GCP Service Account Email used for auth when secret_type is gcpserviceaccount.
        :param str policy_dir: The absolute path of the directory that contains the local resources. Default: the root directory of the image.
        :param str secret_type: Type of secret configured for access to the OCI Image. Must be one of gcenode, gcpserviceaccount or none.
        :param str sync_repo: The OCI image repository URL for the package to sync from. e.g. LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY_NAME/PACKAGE_NAME.
        :param str sync_wait_secs: Period in seconds(int64 format) between consecutive syncs. Default: 15.
        """
        if gcp_service_account_email is not None:
            pulumi.set(__self__, "gcp_service_account_email", gcp_service_account_email)
        if policy_dir is not None:
            pulumi.set(__self__, "policy_dir", policy_dir)
        if secret_type is not None:
            pulumi.set(__self__, "secret_type", secret_type)
        if sync_repo is not None:
            pulumi.set(__self__, "sync_repo", sync_repo)
        if sync_wait_secs is not None:
            pulumi.set(__self__, "sync_wait_secs", sync_wait_secs)

    @property
    @pulumi.getter(name="gcpServiceAccountEmail")
    def gcp_service_account_email(self) -> Optional[str]:
        """
        The GCP Service Account Email used for auth when secret_type is gcpserviceaccount.
        """
        return pulumi.get(self, "gcp_service_account_email")

    @property
    @pulumi.getter(name="policyDir")
    def policy_dir(self) -> Optional[str]:
        """
        The absolute path of the directory that contains the local resources. Default: the root directory of the image.
        """
        return pulumi.get(self, "policy_dir")

    @property
    @pulumi.getter(name="secretType")
    def secret_type(self) -> Optional[str]:
        """
        Type of secret configured for access to the OCI Image. Must be one of gcenode, gcpserviceaccount or none.
        """
        return pulumi.get(self, "secret_type")

    @property
    @pulumi.getter(name="syncRepo")
    def sync_repo(self) -> Optional[str]:
        """
        The OCI image repository URL for the package to sync from. e.g. LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY_NAME/PACKAGE_NAME.
        """
        return pulumi.get(self, "sync_repo")

    @property
    @pulumi.getter(name="syncWaitSecs")
    def sync_wait_secs(self) -> Optional[str]:
        """
        Period in seconds(int64 format) between consecutive syncs. Default: 15.
        """
        return pulumi.get(self, "sync_wait_secs")


@pulumi.output_type
class FeatureMembershipConfigmanagementHierarchyController(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableHierarchicalResourceQuota":
            suggest = "enable_hierarchical_resource_quota"
        elif key == "enablePodTreeLabels":
            suggest = "enable_pod_tree_labels"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureMembershipConfigmanagementHierarchyController. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureMembershipConfigmanagementHierarchyController.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureMembershipConfigmanagementHierarchyController.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_hierarchical_resource_quota: Optional[bool] = None,
                 enable_pod_tree_labels: Optional[bool] = None,
                 enabled: Optional[bool] = None):
        """
        :param bool enable_hierarchical_resource_quota: Whether hierarchical resource quota is enabled in this cluster.
        :param bool enable_pod_tree_labels: Whether pod tree labels are enabled in this cluster.
        :param bool enabled: Whether Hierarchy Controller is enabled in this cluster.
        """
        if enable_hierarchical_resource_quota is not None:
            pulumi.set(__self__, "enable_hierarchical_resource_quota", enable_hierarchical_resource_quota)
        if enable_pod_tree_labels is not None:
            pulumi.set(__self__, "enable_pod_tree_labels", enable_pod_tree_labels)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="enableHierarchicalResourceQuota")
    def enable_hierarchical_resource_quota(self) -> Optional[bool]:
        """
        Whether hierarchical resource quota is enabled in this cluster.
        """
        return pulumi.get(self, "enable_hierarchical_resource_quota")

    @property
    @pulumi.getter(name="enablePodTreeLabels")
    def enable_pod_tree_labels(self) -> Optional[bool]:
        """
        Whether pod tree labels are enabled in this cluster.
        """
        return pulumi.get(self, "enable_pod_tree_labels")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Whether Hierarchy Controller is enabled in this cluster.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class FeatureMembershipConfigmanagementPolicyController(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "auditIntervalSeconds":
            suggest = "audit_interval_seconds"
        elif key == "exemptableNamespaces":
            suggest = "exemptable_namespaces"
        elif key == "logDeniesEnabled":
            suggest = "log_denies_enabled"
        elif key == "mutationEnabled":
            suggest = "mutation_enabled"
        elif key == "referentialRulesEnabled":
            suggest = "referential_rules_enabled"
        elif key == "templateLibraryInstalled":
            suggest = "template_library_installed"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureMembershipConfigmanagementPolicyController. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureMembershipConfigmanagementPolicyController.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureMembershipConfigmanagementPolicyController.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 audit_interval_seconds: Optional[str] = None,
                 enabled: Optional[bool] = None,
                 exemptable_namespaces: Optional[Sequence[str]] = None,
                 log_denies_enabled: Optional[bool] = None,
                 monitoring: Optional['outputs.FeatureMembershipConfigmanagementPolicyControllerMonitoring'] = None,
                 mutation_enabled: Optional[bool] = None,
                 referential_rules_enabled: Optional[bool] = None,
                 template_library_installed: Optional[bool] = None):
        """
        :param str audit_interval_seconds: Sets the interval for Policy Controller Audit Scans (in seconds). When set to 0, this disables audit functionality altogether.
        :param bool enabled: Enables the installation of Policy Controller. If false, the rest of PolicyController fields take no effect.
        :param Sequence[str] exemptable_namespaces: The set of namespaces that are excluded from Policy Controller checks. Namespaces do not need to currently exist on the cluster.
        :param bool log_denies_enabled: Logs all denies and dry run failures.
        :param 'FeatureMembershipConfigmanagementPolicyControllerMonitoringArgs' monitoring: Specifies the backends Policy Controller should export metrics to. For example, to specify metrics should be exported to Cloud Monitoring and Prometheus, specify backends: [\\"cloudmonitoring\\", \\"prometheus\\"]. Default: [\\"cloudmonitoring\\", \\"prometheus\\"]
        :param bool mutation_enabled: Enables mutation in policy controller. If true, mutation CRDs, webhook, and controller deployment will be deployed to the cluster.
        :param bool referential_rules_enabled: Enables the ability to use Constraint Templates that reference to objects other than the object currently being evaluated.
        :param bool template_library_installed: Installs the default template library along with Policy Controller.
        """
        if audit_interval_seconds is not None:
            pulumi.set(__self__, "audit_interval_seconds", audit_interval_seconds)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if exemptable_namespaces is not None:
            pulumi.set(__self__, "exemptable_namespaces", exemptable_namespaces)
        if log_denies_enabled is not None:
            pulumi.set(__self__, "log_denies_enabled", log_denies_enabled)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if mutation_enabled is not None:
            pulumi.set(__self__, "mutation_enabled", mutation_enabled)
        if referential_rules_enabled is not None:
            pulumi.set(__self__, "referential_rules_enabled", referential_rules_enabled)
        if template_library_installed is not None:
            pulumi.set(__self__, "template_library_installed", template_library_installed)

    @property
    @pulumi.getter(name="auditIntervalSeconds")
    def audit_interval_seconds(self) -> Optional[str]:
        """
        Sets the interval for Policy Controller Audit Scans (in seconds). When set to 0, this disables audit functionality altogether.
        """
        return pulumi.get(self, "audit_interval_seconds")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Enables the installation of Policy Controller. If false, the rest of PolicyController fields take no effect.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="exemptableNamespaces")
    def exemptable_namespaces(self) -> Optional[Sequence[str]]:
        """
        The set of namespaces that are excluded from Policy Controller checks. Namespaces do not need to currently exist on the cluster.
        """
        return pulumi.get(self, "exemptable_namespaces")

    @property
    @pulumi.getter(name="logDeniesEnabled")
    def log_denies_enabled(self) -> Optional[bool]:
        """
        Logs all denies and dry run failures.
        """
        return pulumi.get(self, "log_denies_enabled")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional['outputs.FeatureMembershipConfigmanagementPolicyControllerMonitoring']:
        """
        Specifies the backends Policy Controller should export metrics to. For example, to specify metrics should be exported to Cloud Monitoring and Prometheus, specify backends: [\\"cloudmonitoring\\", \\"prometheus\\"]. Default: [\\"cloudmonitoring\\", \\"prometheus\\"]
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="mutationEnabled")
    def mutation_enabled(self) -> Optional[bool]:
        """
        Enables mutation in policy controller. If true, mutation CRDs, webhook, and controller deployment will be deployed to the cluster.
        """
        return pulumi.get(self, "mutation_enabled")

    @property
    @pulumi.getter(name="referentialRulesEnabled")
    def referential_rules_enabled(self) -> Optional[bool]:
        """
        Enables the ability to use Constraint Templates that reference to objects other than the object currently being evaluated.
        """
        return pulumi.get(self, "referential_rules_enabled")

    @property
    @pulumi.getter(name="templateLibraryInstalled")
    def template_library_installed(self) -> Optional[bool]:
        """
        Installs the default template library along with Policy Controller.
        """
        return pulumi.get(self, "template_library_installed")


@pulumi.output_type
class FeatureMembershipConfigmanagementPolicyControllerMonitoring(dict):
    def __init__(__self__, *,
                 backends: Optional[Sequence[str]] = None):
        if backends is not None:
            pulumi.set(__self__, "backends", backends)

    @property
    @pulumi.getter
    def backends(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "backends")


@pulumi.output_type
class FeatureMembershipMesh(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "controlPlane":
            suggest = "control_plane"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureMembershipMesh. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureMembershipMesh.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureMembershipMesh.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 control_plane: Optional[str] = None,
                 management: Optional[str] = None):
        """
        :param str management: Whether to automatically manage Service Mesh. Can either be `MANAGEMENT_AUTOMATIC` or `MANAGEMENT_MANUAL`.
        """
        if control_plane is not None:
            pulumi.set(__self__, "control_plane", control_plane)
        if management is not None:
            pulumi.set(__self__, "management", management)

    @property
    @pulumi.getter(name="controlPlane")
    def control_plane(self) -> Optional[str]:
        return pulumi.get(self, "control_plane")

    @property
    @pulumi.getter
    def management(self) -> Optional[str]:
        """
        Whether to automatically manage Service Mesh. Can either be `MANAGEMENT_AUTOMATIC` or `MANAGEMENT_MANUAL`.
        """
        return pulumi.get(self, "management")


@pulumi.output_type
class FeatureResourceState(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hasResources":
            suggest = "has_resources"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureResourceState. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureResourceState.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureResourceState.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 has_resources: Optional[bool] = None,
                 state: Optional[str] = None):
        if has_resources is not None:
            pulumi.set(__self__, "has_resources", has_resources)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter(name="hasResources")
    def has_resources(self) -> Optional[bool]:
        return pulumi.get(self, "has_resources")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        return pulumi.get(self, "state")


@pulumi.output_type
class FeatureSpec(dict):
    def __init__(__self__, *,
                 multiclusteringress: Optional['outputs.FeatureSpecMulticlusteringress'] = None):
        """
        :param 'FeatureSpecMulticlusteringressArgs' multiclusteringress: Multicluster Ingress-specific spec.
               The `multiclusteringress` block supports:
        """
        if multiclusteringress is not None:
            pulumi.set(__self__, "multiclusteringress", multiclusteringress)

    @property
    @pulumi.getter
    def multiclusteringress(self) -> Optional['outputs.FeatureSpecMulticlusteringress']:
        """
        Multicluster Ingress-specific spec.
        The `multiclusteringress` block supports:
        """
        return pulumi.get(self, "multiclusteringress")


@pulumi.output_type
class FeatureSpecMulticlusteringress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configMembership":
            suggest = "config_membership"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureSpecMulticlusteringress. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureSpecMulticlusteringress.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureSpecMulticlusteringress.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config_membership: str):
        """
        :param str config_membership: Fully-qualified Membership name which hosts the MultiClusterIngress CRD. Example: `projects/foo-proj/locations/global/memberships/bar`
        """
        pulumi.set(__self__, "config_membership", config_membership)

    @property
    @pulumi.getter(name="configMembership")
    def config_membership(self) -> str:
        """
        Fully-qualified Membership name which hosts the MultiClusterIngress CRD. Example: `projects/foo-proj/locations/global/memberships/bar`
        """
        return pulumi.get(self, "config_membership")


@pulumi.output_type
class FeatureState(dict):
    def __init__(__self__, *,
                 states: Optional[Sequence['outputs.FeatureStateState']] = None):
        if states is not None:
            pulumi.set(__self__, "states", states)

    @property
    @pulumi.getter
    def states(self) -> Optional[Sequence['outputs.FeatureStateState']]:
        return pulumi.get(self, "states")


@pulumi.output_type
class FeatureStateState(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "updateTime":
            suggest = "update_time"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FeatureStateState. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FeatureStateState.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FeatureStateState.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 code: Optional[str] = None,
                 description: Optional[str] = None,
                 update_time: Optional[str] = None):
        """
        :param str update_time: Output only. When the Feature resource was last updated.
        """
        if code is not None:
            pulumi.set(__self__, "code", code)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if update_time is not None:
            pulumi.set(__self__, "update_time", update_time)

    @property
    @pulumi.getter
    def code(self) -> Optional[str]:
        return pulumi.get(self, "code")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="updateTime")
    def update_time(self) -> Optional[str]:
        """
        Output only. When the Feature resource was last updated.
        """
        return pulumi.get(self, "update_time")


@pulumi.output_type
class MembershipAuthority(dict):
    def __init__(__self__, *,
                 issuer: str):
        pulumi.set(__self__, "issuer", issuer)

    @property
    @pulumi.getter
    def issuer(self) -> str:
        return pulumi.get(self, "issuer")


@pulumi.output_type
class MembershipEndpoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gkeCluster":
            suggest = "gke_cluster"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MembershipEndpoint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MembershipEndpoint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MembershipEndpoint.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 gke_cluster: Optional['outputs.MembershipEndpointGkeCluster'] = None):
        """
        :param 'MembershipEndpointGkeClusterArgs' gke_cluster: If this Membership is a Kubernetes API server hosted on GKE, this is a self link to its GCP resource.
               Structure is documented below.
        """
        if gke_cluster is not None:
            pulumi.set(__self__, "gke_cluster", gke_cluster)

    @property
    @pulumi.getter(name="gkeCluster")
    def gke_cluster(self) -> Optional['outputs.MembershipEndpointGkeCluster']:
        """
        If this Membership is a Kubernetes API server hosted on GKE, this is a self link to its GCP resource.
        Structure is documented below.
        """
        return pulumi.get(self, "gke_cluster")


@pulumi.output_type
class MembershipEndpointGkeCluster(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceLink":
            suggest = "resource_link"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MembershipEndpointGkeCluster. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MembershipEndpointGkeCluster.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MembershipEndpointGkeCluster.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 resource_link: str):
        pulumi.set(__self__, "resource_link", resource_link)

    @property
    @pulumi.getter(name="resourceLink")
    def resource_link(self) -> str:
        return pulumi.get(self, "resource_link")


@pulumi.output_type
class MembershipIamBindingCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> str:
        return pulumi.get(self, "expression")

    @property
    @pulumi.getter
    def title(self) -> str:
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        return pulumi.get(self, "description")


@pulumi.output_type
class MembershipIamMemberCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> str:
        return pulumi.get(self, "expression")

    @property
    @pulumi.getter
    def title(self) -> str:
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        return pulumi.get(self, "description")


