# 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__ = [
    'DeploymentProjectSettings',
    'DnsRecordSrv',
    'ProjectEnvironment',
    'ProjectGitComments',
    'ProjectGitRepository',
    'ProjectGitRepositoryDeployHook',
    'ProjectOptionsAllowlist',
    'ProjectOptionsAllowlistPath',
    'ProjectPasswordProtection',
    'ProjectTrustedIps',
    'ProjectTrustedIpsAddress',
    'ProjectVercelAuthentication',
    'GetProjectEnvironmentResult',
    'GetProjectGitCommentsResult',
    'GetProjectGitRepositoryResult',
    'GetProjectGitRepositoryDeployHookResult',
    'GetProjectOptionsAllowlistResult',
    'GetProjectOptionsAllowlistPathResult',
    'GetProjectPasswordProtectionResult',
    'GetProjectTrustedIpsResult',
    'GetProjectTrustedIpsAddressResult',
    'GetProjectVercelAuthenticationResult',
]

@pulumi.output_type
class DeploymentProjectSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "buildCommand":
            suggest = "build_command"
        elif key == "installCommand":
            suggest = "install_command"
        elif key == "outputDirectory":
            suggest = "output_directory"
        elif key == "rootDirectory":
            suggest = "root_directory"

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

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

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

    def __init__(__self__, *,
                 build_command: Optional[str] = None,
                 framework: Optional[str] = None,
                 install_command: Optional[str] = None,
                 output_directory: Optional[str] = None,
                 root_directory: Optional[str] = None):
        """
        :param str build_command: The build command for this deployment. If omitted, this value will be taken from the project or automatically detected.
        :param str framework: The framework that is being used for this deployment. If omitted, no framework is selected.
        :param str install_command: The install command for this deployment. If omitted, this value will be taken from the project or automatically detected.
        :param str output_directory: The output directory of the deployment. If omitted, this value will be taken from the project or automatically detected.
        :param str root_directory: The name of a directory or relative path to the source code of your project. When null is used it will default to the project root.
        """
        if build_command is not None:
            pulumi.set(__self__, "build_command", build_command)
        if framework is not None:
            pulumi.set(__self__, "framework", framework)
        if install_command is not None:
            pulumi.set(__self__, "install_command", install_command)
        if output_directory is not None:
            pulumi.set(__self__, "output_directory", output_directory)
        if root_directory is not None:
            pulumi.set(__self__, "root_directory", root_directory)

    @property
    @pulumi.getter(name="buildCommand")
    def build_command(self) -> Optional[str]:
        """
        The build command for this deployment. If omitted, this value will be taken from the project or automatically detected.
        """
        return pulumi.get(self, "build_command")

    @property
    @pulumi.getter
    def framework(self) -> Optional[str]:
        """
        The framework that is being used for this deployment. If omitted, no framework is selected.
        """
        return pulumi.get(self, "framework")

    @property
    @pulumi.getter(name="installCommand")
    def install_command(self) -> Optional[str]:
        """
        The install command for this deployment. If omitted, this value will be taken from the project or automatically detected.
        """
        return pulumi.get(self, "install_command")

    @property
    @pulumi.getter(name="outputDirectory")
    def output_directory(self) -> Optional[str]:
        """
        The output directory of the deployment. If omitted, this value will be taken from the project or automatically detected.
        """
        return pulumi.get(self, "output_directory")

    @property
    @pulumi.getter(name="rootDirectory")
    def root_directory(self) -> Optional[str]:
        """
        The name of a directory or relative path to the source code of your project. When null is used it will default to the project root.
        """
        return pulumi.get(self, "root_directory")


@pulumi.output_type
class DnsRecordSrv(dict):
    def __init__(__self__, *,
                 port: int,
                 priority: int,
                 target: str,
                 weight: int):
        """
        :param int port: The TCP or UDP port on which the service is to be found.
        :param int priority: The priority of the target host, lower value means more preferred.
        :param str target: The canonical hostname of the machine providing the service, ending in a dot.
        :param int weight: A relative weight for records with the same priority, higher value means higher chance of getting picked.
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "target", target)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The TCP or UDP port on which the service is to be found.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def priority(self) -> int:
        """
        The priority of the target host, lower value means more preferred.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def target(self) -> str:
        """
        The canonical hostname of the machine providing the service, ending in a dot.
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter
    def weight(self) -> int:
        """
        A relative weight for records with the same priority, higher value means higher chance of getting picked.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class ProjectEnvironment(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gitBranch":
            suggest = "git_branch"

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

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

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

    def __init__(__self__, *,
                 key: str,
                 targets: Sequence[str],
                 value: str,
                 git_branch: Optional[str] = None,
                 id: Optional[str] = None,
                 sensitive: Optional[bool] = None):
        """
        :param str key: The name of the Environment Variable.
        :param Sequence[str] targets: The environments that the Environment Variable should be present on. Valid targets are either `production`, `preview`, or `development`.
        :param str value: The value of the Environment Variable.
        :param str git_branch: The git branch of the Environment Variable.
        :param str id: The ID of the Environment Variable.
        :param bool sensitive: Whether the Environment Variable is sensitive or not. (May be affected by a [team-wide environment variable policy](https://vercel.com/docs/projects/environment-variables/sensitive-environment-variables#environment-variables-policy))
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "targets", targets)
        pulumi.set(__self__, "value", value)
        if git_branch is not None:
            pulumi.set(__self__, "git_branch", git_branch)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if sensitive is not None:
            pulumi.set(__self__, "sensitive", sensitive)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The name of the Environment Variable.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def targets(self) -> Sequence[str]:
        """
        The environments that the Environment Variable should be present on. Valid targets are either `production`, `preview`, or `development`.
        """
        return pulumi.get(self, "targets")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The value of the Environment Variable.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter(name="gitBranch")
    def git_branch(self) -> Optional[str]:
        """
        The git branch of the Environment Variable.
        """
        return pulumi.get(self, "git_branch")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        The ID of the Environment Variable.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def sensitive(self) -> Optional[bool]:
        """
        Whether the Environment Variable is sensitive or not. (May be affected by a [team-wide environment variable policy](https://vercel.com/docs/projects/environment-variables/sensitive-environment-variables#environment-variables-policy))
        """
        return pulumi.get(self, "sensitive")


@pulumi.output_type
class ProjectGitComments(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "onCommit":
            suggest = "on_commit"
        elif key == "onPullRequest":
            suggest = "on_pull_request"

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

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

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

    def __init__(__self__, *,
                 on_commit: bool,
                 on_pull_request: bool):
        """
        :param bool on_commit: Whether Commit comments are enabled
        :param bool on_pull_request: Whether Pull Request comments are enabled
        """
        pulumi.set(__self__, "on_commit", on_commit)
        pulumi.set(__self__, "on_pull_request", on_pull_request)

    @property
    @pulumi.getter(name="onCommit")
    def on_commit(self) -> bool:
        """
        Whether Commit comments are enabled
        """
        return pulumi.get(self, "on_commit")

    @property
    @pulumi.getter(name="onPullRequest")
    def on_pull_request(self) -> bool:
        """
        Whether Pull Request comments are enabled
        """
        return pulumi.get(self, "on_pull_request")


@pulumi.output_type
class ProjectGitRepository(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deployHooks":
            suggest = "deploy_hooks"
        elif key == "productionBranch":
            suggest = "production_branch"

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

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

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

    def __init__(__self__, *,
                 repo: str,
                 type: str,
                 deploy_hooks: Optional[Sequence['outputs.ProjectGitRepositoryDeployHook']] = None,
                 production_branch: Optional[str] = None):
        """
        :param str repo: The name of the git repository. For example: `vercel/next.js`.
        :param str type: The git provider of the repository. Must be either `github`, `gitlab`, or `bitbucket`.
        :param Sequence['ProjectGitRepositoryDeployHookArgs'] deploy_hooks: Deploy hooks are unique URLs that allow you to trigger a deployment of a given branch. See https://vercel.com/docs/deployments/deploy-hooks for full information.
        :param str production_branch: By default, every commit pushed to the main branch will trigger a Production Deployment instead of the usual Preview Deployment. You can switch to a different branch here.
        """
        pulumi.set(__self__, "repo", repo)
        pulumi.set(__self__, "type", type)
        if deploy_hooks is not None:
            pulumi.set(__self__, "deploy_hooks", deploy_hooks)
        if production_branch is not None:
            pulumi.set(__self__, "production_branch", production_branch)

    @property
    @pulumi.getter
    def repo(self) -> str:
        """
        The name of the git repository. For example: `vercel/next.js`.
        """
        return pulumi.get(self, "repo")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The git provider of the repository. Must be either `github`, `gitlab`, or `bitbucket`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="deployHooks")
    def deploy_hooks(self) -> Optional[Sequence['outputs.ProjectGitRepositoryDeployHook']]:
        """
        Deploy hooks are unique URLs that allow you to trigger a deployment of a given branch. See https://vercel.com/docs/deployments/deploy-hooks for full information.
        """
        return pulumi.get(self, "deploy_hooks")

    @property
    @pulumi.getter(name="productionBranch")
    def production_branch(self) -> Optional[str]:
        """
        By default, every commit pushed to the main branch will trigger a Production Deployment instead of the usual Preview Deployment. You can switch to a different branch here.
        """
        return pulumi.get(self, "production_branch")


@pulumi.output_type
class ProjectGitRepositoryDeployHook(dict):
    def __init__(__self__, *,
                 name: str,
                 ref: str,
                 id: Optional[str] = None,
                 url: Optional[str] = None):
        """
        :param str name: The name of the deploy hook.
        :param str ref: The branch or commit hash that should be deployed.
        :param str id: The ID of the deploy hook.
        :param str url: A URL that, when a POST request is made to, will trigger a new deployment.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "ref", ref)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the deploy hook.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def ref(self) -> str:
        """
        The branch or commit hash that should be deployed.
        """
        return pulumi.get(self, "ref")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        The ID of the deploy hook.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        """
        A URL that, when a POST request is made to, will trigger a new deployment.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class ProjectOptionsAllowlist(dict):
    def __init__(__self__, *,
                 paths: Sequence['outputs.ProjectOptionsAllowlistPath']):
        """
        :param Sequence['ProjectOptionsAllowlistPathArgs'] paths: The allowed paths for the OPTIONS Allowlist. Incoming requests will bypass Deployment Protection if they have the method `OPTIONS` and **start with** one of the path values.
        """
        pulumi.set(__self__, "paths", paths)

    @property
    @pulumi.getter
    def paths(self) -> Sequence['outputs.ProjectOptionsAllowlistPath']:
        """
        The allowed paths for the OPTIONS Allowlist. Incoming requests will bypass Deployment Protection if they have the method `OPTIONS` and **start with** one of the path values.
        """
        return pulumi.get(self, "paths")


@pulumi.output_type
class ProjectOptionsAllowlistPath(dict):
    def __init__(__self__, *,
                 value: str):
        """
        :param str value: The path prefix to compare with the incoming request path.
        """
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The path prefix to compare with the incoming request path.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class ProjectPasswordProtection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deploymentType":
            suggest = "deployment_type"

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

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

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

    def __init__(__self__, *,
                 deployment_type: str,
                 password: str):
        """
        :param str deployment_type: The deployment environment to protect. Must be one of `standard_protection`, `all_deployments`, or `only_preview_deployments`.
        :param str password: The password that visitors must enter to gain access to your Preview Deployments. Drift detection is not possible for this field.
        """
        pulumi.set(__self__, "deployment_type", deployment_type)
        pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter(name="deploymentType")
    def deployment_type(self) -> str:
        """
        The deployment environment to protect. Must be one of `standard_protection`, `all_deployments`, or `only_preview_deployments`.
        """
        return pulumi.get(self, "deployment_type")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password that visitors must enter to gain access to your Preview Deployments. Drift detection is not possible for this field.
        """
        return pulumi.get(self, "password")


@pulumi.output_type
class ProjectTrustedIps(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deploymentType":
            suggest = "deployment_type"
        elif key == "protectionMode":
            suggest = "protection_mode"

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

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

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

    def __init__(__self__, *,
                 addresses: Sequence['outputs.ProjectTrustedIpsAddress'],
                 deployment_type: str,
                 protection_mode: Optional[str] = None):
        """
        :param Sequence['ProjectTrustedIpsAddressArgs'] addresses: The allowed IP addressses and CIDR ranges with optional descriptions.
        :param str deployment_type: The deployment environment to protect. Must be one of `standard_protection`, `all_deployments`, `only_production_deployments`, or `only_preview_deployments`.
        :param str protection_mode: Whether or not Trusted IPs is optional to access a deployment. Must be either `trusted_ip_required` or `trusted_ip_optional`. `trusted_ip_optional` is only available with Standalone Trusted IPs.
        """
        pulumi.set(__self__, "addresses", addresses)
        pulumi.set(__self__, "deployment_type", deployment_type)
        if protection_mode is not None:
            pulumi.set(__self__, "protection_mode", protection_mode)

    @property
    @pulumi.getter
    def addresses(self) -> Sequence['outputs.ProjectTrustedIpsAddress']:
        """
        The allowed IP addressses and CIDR ranges with optional descriptions.
        """
        return pulumi.get(self, "addresses")

    @property
    @pulumi.getter(name="deploymentType")
    def deployment_type(self) -> str:
        """
        The deployment environment to protect. Must be one of `standard_protection`, `all_deployments`, `only_production_deployments`, or `only_preview_deployments`.
        """
        return pulumi.get(self, "deployment_type")

    @property
    @pulumi.getter(name="protectionMode")
    def protection_mode(self) -> Optional[str]:
        """
        Whether or not Trusted IPs is optional to access a deployment. Must be either `trusted_ip_required` or `trusted_ip_optional`. `trusted_ip_optional` is only available with Standalone Trusted IPs.
        """
        return pulumi.get(self, "protection_mode")


@pulumi.output_type
class ProjectTrustedIpsAddress(dict):
    def __init__(__self__, *,
                 value: str,
                 note: Optional[str] = None):
        """
        :param str value: The address or CIDR range that can access deployments.
        :param str note: A description for the value
        """
        pulumi.set(__self__, "value", value)
        if note is not None:
            pulumi.set(__self__, "note", note)

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The address or CIDR range that can access deployments.
        """
        return pulumi.get(self, "value")

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


@pulumi.output_type
class ProjectVercelAuthentication(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deploymentType":
            suggest = "deployment_type"

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

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

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

    def __init__(__self__, *,
                 deployment_type: str):
        """
        :param str deployment_type: The deployment environment to protect. Must be one of `standard_protection`, `all_deployments`, `only_preview_deployments`, or `none`.
        """
        pulumi.set(__self__, "deployment_type", deployment_type)

    @property
    @pulumi.getter(name="deploymentType")
    def deployment_type(self) -> str:
        """
        The deployment environment to protect. Must be one of `standard_protection`, `all_deployments`, `only_preview_deployments`, or `none`.
        """
        return pulumi.get(self, "deployment_type")


@pulumi.output_type
class GetProjectEnvironmentResult(dict):
    def __init__(__self__, *,
                 git_branch: str,
                 id: str,
                 key: str,
                 sensitive: bool,
                 targets: Sequence[str],
                 value: str):
        """
        :param str git_branch: The git branch of the environment variable.
        :param str id: The ID of the environment variable
        :param str key: The name of the environment variable.
        :param bool sensitive: Whether the Environment Variable is sensitive or not. Note that the value will be `null` for sensitive environment variables.
        :param Sequence[str] targets: The environments that the environment variable should be present on. Valid targets are either `production`, `preview`, or `development`.
        :param str value: The value of the environment variable.
        """
        pulumi.set(__self__, "git_branch", git_branch)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "sensitive", sensitive)
        pulumi.set(__self__, "targets", targets)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="gitBranch")
    def git_branch(self) -> str:
        """
        The git branch of the environment variable.
        """
        return pulumi.get(self, "git_branch")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the environment variable
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The name of the environment variable.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def sensitive(self) -> bool:
        """
        Whether the Environment Variable is sensitive or not. Note that the value will be `null` for sensitive environment variables.
        """
        return pulumi.get(self, "sensitive")

    @property
    @pulumi.getter
    def targets(self) -> Sequence[str]:
        """
        The environments that the environment variable should be present on. Valid targets are either `production`, `preview`, or `development`.
        """
        return pulumi.get(self, "targets")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The value of the environment variable.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetProjectGitCommentsResult(dict):
    def __init__(__self__, *,
                 on_commit: bool,
                 on_pull_request: bool):
        """
        :param bool on_commit: Whether Commit comments are enabled
        :param bool on_pull_request: Whether Pull Request comments are enabled
        """
        pulumi.set(__self__, "on_commit", on_commit)
        pulumi.set(__self__, "on_pull_request", on_pull_request)

    @property
    @pulumi.getter(name="onCommit")
    def on_commit(self) -> bool:
        """
        Whether Commit comments are enabled
        """
        return pulumi.get(self, "on_commit")

    @property
    @pulumi.getter(name="onPullRequest")
    def on_pull_request(self) -> bool:
        """
        Whether Pull Request comments are enabled
        """
        return pulumi.get(self, "on_pull_request")


@pulumi.output_type
class GetProjectGitRepositoryResult(dict):
    def __init__(__self__, *,
                 deploy_hooks: Sequence['outputs.GetProjectGitRepositoryDeployHookResult'],
                 production_branch: str,
                 repo: str,
                 type: str):
        """
        :param Sequence['GetProjectGitRepositoryDeployHookArgs'] deploy_hooks: Deploy hooks are unique URLs that allow you to trigger a deployment of a given branch. See https://vercel.com/docs/deployments/deploy-hooks for full information.
        :param str production_branch: By default, every commit pushed to the main branch will trigger a Production Deployment instead of the usual Preview Deployment. You can switch to a different branch here.
        :param str repo: The name of the git repository. For example: `vercel/next.js`.
        :param str type: The git provider of the repository. Must be either `github`, `gitlab`, or `bitbucket`.
        """
        pulumi.set(__self__, "deploy_hooks", deploy_hooks)
        pulumi.set(__self__, "production_branch", production_branch)
        pulumi.set(__self__, "repo", repo)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="deployHooks")
    def deploy_hooks(self) -> Sequence['outputs.GetProjectGitRepositoryDeployHookResult']:
        """
        Deploy hooks are unique URLs that allow you to trigger a deployment of a given branch. See https://vercel.com/docs/deployments/deploy-hooks for full information.
        """
        return pulumi.get(self, "deploy_hooks")

    @property
    @pulumi.getter(name="productionBranch")
    def production_branch(self) -> str:
        """
        By default, every commit pushed to the main branch will trigger a Production Deployment instead of the usual Preview Deployment. You can switch to a different branch here.
        """
        return pulumi.get(self, "production_branch")

    @property
    @pulumi.getter
    def repo(self) -> str:
        """
        The name of the git repository. For example: `vercel/next.js`.
        """
        return pulumi.get(self, "repo")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The git provider of the repository. Must be either `github`, `gitlab`, or `bitbucket`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetProjectGitRepositoryDeployHookResult(dict):
    def __init__(__self__, *,
                 id: str,
                 name: str,
                 ref: str,
                 url: str):
        """
        :param str id: The ID of the deploy hook.
        :param str name: The name of the deploy hook.
        :param str ref: The branch or commit hash that should be deployed.
        :param str url: A URL that, when a POST request is made to, will trigger a new deployment.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "ref", ref)
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the deploy hook.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the deploy hook.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def ref(self) -> str:
        """
        The branch or commit hash that should be deployed.
        """
        return pulumi.get(self, "ref")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        A URL that, when a POST request is made to, will trigger a new deployment.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetProjectOptionsAllowlistResult(dict):
    def __init__(__self__, *,
                 paths: Sequence['outputs.GetProjectOptionsAllowlistPathResult']):
        """
        :param Sequence['GetProjectOptionsAllowlistPathArgs'] paths: The allowed paths for the OPTIONS Allowlist. Incoming requests will bypass Deployment Protection if they have the method `OPTIONS` and **start with** one of the path values.
        """
        pulumi.set(__self__, "paths", paths)

    @property
    @pulumi.getter
    def paths(self) -> Sequence['outputs.GetProjectOptionsAllowlistPathResult']:
        """
        The allowed paths for the OPTIONS Allowlist. Incoming requests will bypass Deployment Protection if they have the method `OPTIONS` and **start with** one of the path values.
        """
        return pulumi.get(self, "paths")


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

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


@pulumi.output_type
class GetProjectPasswordProtectionResult(dict):
    def __init__(__self__, *,
                 deployment_type: str):
        """
        :param str deployment_type: The deployment environment that will be protected.
        """
        pulumi.set(__self__, "deployment_type", deployment_type)

    @property
    @pulumi.getter(name="deploymentType")
    def deployment_type(self) -> str:
        """
        The deployment environment that will be protected.
        """
        return pulumi.get(self, "deployment_type")


@pulumi.output_type
class GetProjectTrustedIpsResult(dict):
    def __init__(__self__, *,
                 addresses: Sequence['outputs.GetProjectTrustedIpsAddressResult'],
                 deployment_type: str,
                 protection_mode: str):
        """
        :param Sequence['GetProjectTrustedIpsAddressArgs'] addresses: The allowed IP addressses and CIDR ranges with optional descriptions.
        :param str deployment_type: The deployment environment that will be protected.
        :param str protection_mode: Whether or not Trusted IPs is required or optional to access a deployment.
        """
        pulumi.set(__self__, "addresses", addresses)
        pulumi.set(__self__, "deployment_type", deployment_type)
        pulumi.set(__self__, "protection_mode", protection_mode)

    @property
    @pulumi.getter
    def addresses(self) -> Sequence['outputs.GetProjectTrustedIpsAddressResult']:
        """
        The allowed IP addressses and CIDR ranges with optional descriptions.
        """
        return pulumi.get(self, "addresses")

    @property
    @pulumi.getter(name="deploymentType")
    def deployment_type(self) -> str:
        """
        The deployment environment that will be protected.
        """
        return pulumi.get(self, "deployment_type")

    @property
    @pulumi.getter(name="protectionMode")
    def protection_mode(self) -> str:
        """
        Whether or not Trusted IPs is required or optional to access a deployment.
        """
        return pulumi.get(self, "protection_mode")


@pulumi.output_type
class GetProjectTrustedIpsAddressResult(dict):
    def __init__(__self__, *,
                 note: str,
                 value: str):
        pulumi.set(__self__, "note", note)
        pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class GetProjectVercelAuthenticationResult(dict):
    def __init__(__self__, *,
                 deployment_type: str):
        """
        :param str deployment_type: The deployment environment that will be protected.
        """
        pulumi.set(__self__, "deployment_type", deployment_type)

    @property
    @pulumi.getter(name="deploymentType")
    def deployment_type(self) -> str:
        """
        The deployment environment that will be protected.
        """
        return pulumi.get(self, "deployment_type")


