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

__all__ = [
    'BranchCommit',
    'BranchProtectionAllowedToMerge',
    'BranchProtectionAllowedToPush',
    'BranchProtectionAllowedToUnprotect',
    'GroupEpicBoardList',
    'GroupIssueBoardList',
    'ProjectContainerExpirationPolicy',
    'ProjectIssueBoardList',
    'ProjectIssueTaskCompletionStatus',
    'ProjectProtectedEnvironmentApprovalRule',
    'ProjectProtectedEnvironmentDeployAccessLevel',
    'ProjectPushRules',
    'ProjectTagCommit',
    'ProjectTagRelease',
    'TagProtectionAllowedToCreate',
    'GetBranchCommitResult',
    'GetClusterAgentsClusterAgentResult',
    'GetGroupHooksHookResult',
    'GetGroupMembershipMemberResult',
    'GetGroupSubgroupsSubgroupResult',
    'GetGroupVariablesVariableResult',
    'GetGroupsGroupResult',
    'GetInstanceDeployKeysDeployKeyResult',
    'GetInstanceDeployKeysDeployKeyProjectsWithWriteAccessResult',
    'GetInstanceVariablesVariableResult',
    'GetMetadataKasResult',
    'GetProjectBranchesBranchResult',
    'GetProjectBranchesBranchCommitResult',
    'GetProjectContainerExpirationPolicyResult',
    'GetProjectHooksHookResult',
    'GetProjectIssueTaskCompletionStatusResult',
    'GetProjectIssuesIssueResult',
    'GetProjectIssuesIssueTaskCompletionStatusResult',
    'GetProjectMembershipMemberResult',
    'GetProjectMilestonesMilestoneResult',
    'GetProjectProtectedBranchMergeAccessLevelResult',
    'GetProjectProtectedBranchPushAccessLevelResult',
    'GetProjectProtectedBranchesProtectedBranchResult',
    'GetProjectProtectedBranchesProtectedBranchMergeAccessLevelResult',
    'GetProjectProtectedBranchesProtectedBranchPushAccessLevelResult',
    'GetProjectPushRuleResult',
    'GetProjectTagCommitResult',
    'GetProjectTagReleaseResult',
    'GetProjectTagsTagResult',
    'GetProjectTagsTagCommitResult',
    'GetProjectTagsTagReleaseResult',
    'GetProjectVariablesVariableResult',
    'GetProjectsProjectResult',
    'GetProjectsProjectContainerExpirationPolicyResult',
    'GetProjectsProjectForkedFromProjectResult',
    'GetProjectsProjectNamespaceResult',
    'GetProjectsProjectOwnerResult',
    'GetProjectsProjectPermissionResult',
    'GetProjectsProjectSharedWithGroupResult',
    'GetReleaseLinksReleaseLinkResult',
    'GetRepositoryTreeTreeResult',
    'GetUserSshkeysKeyResult',
    'GetUsersUserResult',
]

@pulumi.output_type
class BranchCommit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authorEmail":
            suggest = "author_email"
        elif key == "authorName":
            suggest = "author_name"
        elif key == "authoredDate":
            suggest = "authored_date"
        elif key == "committedDate":
            suggest = "committed_date"
        elif key == "committerEmail":
            suggest = "committer_email"
        elif key == "committerName":
            suggest = "committer_name"
        elif key == "parentIds":
            suggest = "parent_ids"
        elif key == "shortId":
            suggest = "short_id"

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

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

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

    def __init__(__self__, *,
                 author_email: Optional[str] = None,
                 author_name: Optional[str] = None,
                 authored_date: Optional[str] = None,
                 committed_date: Optional[str] = None,
                 committer_email: Optional[str] = None,
                 committer_name: Optional[str] = None,
                 id: Optional[str] = None,
                 message: Optional[str] = None,
                 parent_ids: Optional[Sequence[str]] = None,
                 short_id: Optional[str] = None,
                 title: Optional[str] = None):
        BranchCommit._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            author_email=author_email,
            author_name=author_name,
            authored_date=authored_date,
            committed_date=committed_date,
            committer_email=committer_email,
            committer_name=committer_name,
            id=id,
            message=message,
            parent_ids=parent_ids,
            short_id=short_id,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             author_email: Optional[str] = None,
             author_name: Optional[str] = None,
             authored_date: Optional[str] = None,
             committed_date: Optional[str] = None,
             committer_email: Optional[str] = None,
             committer_name: Optional[str] = None,
             id: Optional[str] = None,
             message: Optional[str] = None,
             parent_ids: Optional[Sequence[str]] = None,
             short_id: Optional[str] = None,
             title: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if author_email is not None:
            _setter("author_email", author_email)
        if author_name is not None:
            _setter("author_name", author_name)
        if authored_date is not None:
            _setter("authored_date", authored_date)
        if committed_date is not None:
            _setter("committed_date", committed_date)
        if committer_email is not None:
            _setter("committer_email", committer_email)
        if committer_name is not None:
            _setter("committer_name", committer_name)
        if id is not None:
            _setter("id", id)
        if message is not None:
            _setter("message", message)
        if parent_ids is not None:
            _setter("parent_ids", parent_ids)
        if short_id is not None:
            _setter("short_id", short_id)
        if title is not None:
            _setter("title", title)

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class BranchProtectionAllowedToMerge(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessLevel":
            suggest = "access_level"
        elif key == "accessLevelDescription":
            suggest = "access_level_description"
        elif key == "groupId":
            suggest = "group_id"
        elif key == "userId":
            suggest = "user_id"

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

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

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

    def __init__(__self__, *,
                 access_level: Optional[str] = None,
                 access_level_description: Optional[str] = None,
                 group_id: Optional[int] = None,
                 user_id: Optional[int] = None):
        """
        :param str access_level: Level of access.
        :param str access_level_description: Readable description of level of access.
        :param int group_id: The ID of a GitLab group allowed to perform the relevant action. Mutually exclusive with `user_id`.
        :param int user_id: The ID of a GitLab user allowed to perform the relevant action. Mutually exclusive with `group_id`.
        """
        BranchProtectionAllowedToMerge._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            access_level=access_level,
            access_level_description=access_level_description,
            group_id=group_id,
            user_id=user_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             access_level: Optional[str] = None,
             access_level_description: Optional[str] = None,
             group_id: Optional[int] = None,
             user_id: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if access_level is not None:
            _setter("access_level", access_level)
        if access_level_description is not None:
            _setter("access_level_description", access_level_description)
        if group_id is not None:
            _setter("group_id", group_id)
        if user_id is not None:
            _setter("user_id", user_id)

    @property
    @pulumi.getter(name="accessLevel")
    def access_level(self) -> Optional[str]:
        """
        Level of access.
        """
        return pulumi.get(self, "access_level")

    @property
    @pulumi.getter(name="accessLevelDescription")
    def access_level_description(self) -> Optional[str]:
        """
        Readable description of level of access.
        """
        return pulumi.get(self, "access_level_description")

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> Optional[int]:
        """
        The ID of a GitLab group allowed to perform the relevant action. Mutually exclusive with `user_id`.
        """
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> Optional[int]:
        """
        The ID of a GitLab user allowed to perform the relevant action. Mutually exclusive with `group_id`.
        """
        return pulumi.get(self, "user_id")


@pulumi.output_type
class BranchProtectionAllowedToPush(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessLevel":
            suggest = "access_level"
        elif key == "accessLevelDescription":
            suggest = "access_level_description"
        elif key == "groupId":
            suggest = "group_id"
        elif key == "userId":
            suggest = "user_id"

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

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

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

    def __init__(__self__, *,
                 access_level: Optional[str] = None,
                 access_level_description: Optional[str] = None,
                 group_id: Optional[int] = None,
                 user_id: Optional[int] = None):
        """
        :param str access_level: Level of access.
        :param str access_level_description: Readable description of level of access.
        :param int group_id: The ID of a GitLab group allowed to perform the relevant action. Mutually exclusive with `user_id`.
        :param int user_id: The ID of a GitLab user allowed to perform the relevant action. Mutually exclusive with `group_id`.
        """
        BranchProtectionAllowedToPush._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            access_level=access_level,
            access_level_description=access_level_description,
            group_id=group_id,
            user_id=user_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             access_level: Optional[str] = None,
             access_level_description: Optional[str] = None,
             group_id: Optional[int] = None,
             user_id: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if access_level is not None:
            _setter("access_level", access_level)
        if access_level_description is not None:
            _setter("access_level_description", access_level_description)
        if group_id is not None:
            _setter("group_id", group_id)
        if user_id is not None:
            _setter("user_id", user_id)

    @property
    @pulumi.getter(name="accessLevel")
    def access_level(self) -> Optional[str]:
        """
        Level of access.
        """
        return pulumi.get(self, "access_level")

    @property
    @pulumi.getter(name="accessLevelDescription")
    def access_level_description(self) -> Optional[str]:
        """
        Readable description of level of access.
        """
        return pulumi.get(self, "access_level_description")

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> Optional[int]:
        """
        The ID of a GitLab group allowed to perform the relevant action. Mutually exclusive with `user_id`.
        """
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> Optional[int]:
        """
        The ID of a GitLab user allowed to perform the relevant action. Mutually exclusive with `group_id`.
        """
        return pulumi.get(self, "user_id")


@pulumi.output_type
class BranchProtectionAllowedToUnprotect(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessLevel":
            suggest = "access_level"
        elif key == "accessLevelDescription":
            suggest = "access_level_description"
        elif key == "groupId":
            suggest = "group_id"
        elif key == "userId":
            suggest = "user_id"

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

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

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

    def __init__(__self__, *,
                 access_level: Optional[str] = None,
                 access_level_description: Optional[str] = None,
                 group_id: Optional[int] = None,
                 user_id: Optional[int] = None):
        """
        :param str access_level: Level of access.
        :param str access_level_description: Readable description of level of access.
        :param int group_id: The ID of a GitLab group allowed to perform the relevant action. Mutually exclusive with `user_id`.
        :param int user_id: The ID of a GitLab user allowed to perform the relevant action. Mutually exclusive with `group_id`.
        """
        BranchProtectionAllowedToUnprotect._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            access_level=access_level,
            access_level_description=access_level_description,
            group_id=group_id,
            user_id=user_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             access_level: Optional[str] = None,
             access_level_description: Optional[str] = None,
             group_id: Optional[int] = None,
             user_id: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if access_level is not None:
            _setter("access_level", access_level)
        if access_level_description is not None:
            _setter("access_level_description", access_level_description)
        if group_id is not None:
            _setter("group_id", group_id)
        if user_id is not None:
            _setter("user_id", user_id)

    @property
    @pulumi.getter(name="accessLevel")
    def access_level(self) -> Optional[str]:
        """
        Level of access.
        """
        return pulumi.get(self, "access_level")

    @property
    @pulumi.getter(name="accessLevelDescription")
    def access_level_description(self) -> Optional[str]:
        """
        Readable description of level of access.
        """
        return pulumi.get(self, "access_level_description")

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> Optional[int]:
        """
        The ID of a GitLab group allowed to perform the relevant action. Mutually exclusive with `user_id`.
        """
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> Optional[int]:
        """
        The ID of a GitLab user allowed to perform the relevant action. Mutually exclusive with `group_id`.
        """
        return pulumi.get(self, "user_id")


@pulumi.output_type
class GroupEpicBoardList(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "labelId":
            suggest = "label_id"

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

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

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

    def __init__(__self__, *,
                 id: Optional[int] = None,
                 label_id: Optional[int] = None,
                 position: Optional[int] = None):
        """
        :param int id: The ID of the list.
        :param int label_id: The ID of the label the list should be scoped to.
        :param int position: The position of the list within the board. The position for the list is sed on the its position in the `lists` array.
        """
        GroupEpicBoardList._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            id=id,
            label_id=label_id,
            position=position,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             id: Optional[int] = None,
             label_id: Optional[int] = None,
             position: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if id is not None:
            _setter("id", id)
        if label_id is not None:
            _setter("label_id", label_id)
        if position is not None:
            _setter("position", position)

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

    @property
    @pulumi.getter(name="labelId")
    def label_id(self) -> Optional[int]:
        """
        The ID of the label the list should be scoped to.
        """
        return pulumi.get(self, "label_id")

    @property
    @pulumi.getter
    def position(self) -> Optional[int]:
        """
        The position of the list within the board. The position for the list is sed on the its position in the `lists` array.
        """
        return pulumi.get(self, "position")


@pulumi.output_type
class GroupIssueBoardList(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "labelId":
            suggest = "label_id"

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

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

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

    def __init__(__self__, *,
                 id: Optional[int] = None,
                 label_id: Optional[int] = None,
                 position: Optional[int] = None):
        """
        :param int id: The ID of the list.
        :param int label_id: The ID of the label the list should be scoped to.
        :param int position: The position of the list within the board. The position for the list is based on the its position in the `lists` array.
        """
        GroupIssueBoardList._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            id=id,
            label_id=label_id,
            position=position,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             id: Optional[int] = None,
             label_id: Optional[int] = None,
             position: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if id is not None:
            _setter("id", id)
        if label_id is not None:
            _setter("label_id", label_id)
        if position is not None:
            _setter("position", position)

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

    @property
    @pulumi.getter(name="labelId")
    def label_id(self) -> Optional[int]:
        """
        The ID of the label the list should be scoped to.
        """
        return pulumi.get(self, "label_id")

    @property
    @pulumi.getter
    def position(self) -> Optional[int]:
        """
        The position of the list within the board. The position for the list is based on the its position in the `lists` array.
        """
        return pulumi.get(self, "position")


@pulumi.output_type
class ProjectContainerExpirationPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keepN":
            suggest = "keep_n"
        elif key == "nameRegex":
            suggest = "name_regex"
        elif key == "nameRegexDelete":
            suggest = "name_regex_delete"
        elif key == "nameRegexKeep":
            suggest = "name_regex_keep"
        elif key == "nextRunAt":
            suggest = "next_run_at"
        elif key == "olderThan":
            suggest = "older_than"

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

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

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

    def __init__(__self__, *,
                 cadence: Optional[str] = None,
                 enabled: Optional[bool] = None,
                 keep_n: Optional[int] = None,
                 name_regex: Optional[str] = None,
                 name_regex_delete: Optional[str] = None,
                 name_regex_keep: Optional[str] = None,
                 next_run_at: Optional[str] = None,
                 older_than: Optional[str] = None):
        """
        :param str cadence: The cadence of the policy. Valid values are: `1d`, `7d`, `14d`, `1month`, `3month`.
        :param bool enabled: If true, the policy is enabled.
        :param int keep_n: The number of images to keep.
        :param str name_regex: The regular expression to match image names to delete.
        :param str name_regex_delete: The regular expression to match image names to delete.
        :param str name_regex_keep: The regular expression to match image names to keep.
        :param str next_run_at: The next time the policy will run.
        :param str older_than: The number of days to keep images.
        """
        ProjectContainerExpirationPolicy._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            cadence=cadence,
            enabled=enabled,
            keep_n=keep_n,
            name_regex=name_regex,
            name_regex_delete=name_regex_delete,
            name_regex_keep=name_regex_keep,
            next_run_at=next_run_at,
            older_than=older_than,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             cadence: Optional[str] = None,
             enabled: Optional[bool] = None,
             keep_n: Optional[int] = None,
             name_regex: Optional[str] = None,
             name_regex_delete: Optional[str] = None,
             name_regex_keep: Optional[str] = None,
             next_run_at: Optional[str] = None,
             older_than: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if cadence is not None:
            _setter("cadence", cadence)
        if enabled is not None:
            _setter("enabled", enabled)
        if keep_n is not None:
            _setter("keep_n", keep_n)
        if name_regex is not None:
            _setter("name_regex", name_regex)
        if name_regex_delete is not None:
            _setter("name_regex_delete", name_regex_delete)
        if name_regex_keep is not None:
            _setter("name_regex_keep", name_regex_keep)
        if next_run_at is not None:
            _setter("next_run_at", next_run_at)
        if older_than is not None:
            _setter("older_than", older_than)

    @property
    @pulumi.getter
    def cadence(self) -> Optional[str]:
        """
        The cadence of the policy. Valid values are: `1d`, `7d`, `14d`, `1month`, `3month`.
        """
        return pulumi.get(self, "cadence")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        If true, the policy is enabled.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="keepN")
    def keep_n(self) -> Optional[int]:
        """
        The number of images to keep.
        """
        return pulumi.get(self, "keep_n")

    @property
    @pulumi.getter(name="nameRegex")
    def name_regex(self) -> Optional[str]:
        """
        The regular expression to match image names to delete.
        """
        warnings.warn("""`name_regex` has been deprecated. Use `name_regex_delete` instead.""", DeprecationWarning)
        pulumi.log.warn("""name_regex is deprecated: `name_regex` has been deprecated. Use `name_regex_delete` instead.""")

        return pulumi.get(self, "name_regex")

    @property
    @pulumi.getter(name="nameRegexDelete")
    def name_regex_delete(self) -> Optional[str]:
        """
        The regular expression to match image names to delete.
        """
        return pulumi.get(self, "name_regex_delete")

    @property
    @pulumi.getter(name="nameRegexKeep")
    def name_regex_keep(self) -> Optional[str]:
        """
        The regular expression to match image names to keep.
        """
        return pulumi.get(self, "name_regex_keep")

    @property
    @pulumi.getter(name="nextRunAt")
    def next_run_at(self) -> Optional[str]:
        """
        The next time the policy will run.
        """
        return pulumi.get(self, "next_run_at")

    @property
    @pulumi.getter(name="olderThan")
    def older_than(self) -> Optional[str]:
        """
        The number of days to keep images.
        """
        return pulumi.get(self, "older_than")


@pulumi.output_type
class ProjectIssueBoardList(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "assigneeId":
            suggest = "assignee_id"
        elif key == "iterationId":
            suggest = "iteration_id"
        elif key == "labelId":
            suggest = "label_id"
        elif key == "milestoneId":
            suggest = "milestone_id"

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

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

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

    def __init__(__self__, *,
                 assignee_id: Optional[int] = None,
                 id: Optional[int] = None,
                 iteration_id: Optional[int] = None,
                 label_id: Optional[int] = None,
                 milestone_id: Optional[int] = None,
                 position: Optional[int] = None):
        """
        :param int assignee_id: The ID of the assignee the list should be scoped to. Requires a GitLab EE license.
        :param int id: The ID of the list
        :param int iteration_id: The ID of the iteration the list should be scoped to. Requires a GitLab EE license.
        :param int label_id: The ID of the label the list should be scoped to. Requires a GitLab EE license.
        :param int milestone_id: The ID of the milestone the list should be scoped to. Requires a GitLab EE license.
        :param int position: The position of the list within the board. The position for the list is based on the its position in the `lists` array.
        """
        ProjectIssueBoardList._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            assignee_id=assignee_id,
            id=id,
            iteration_id=iteration_id,
            label_id=label_id,
            milestone_id=milestone_id,
            position=position,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             assignee_id: Optional[int] = None,
             id: Optional[int] = None,
             iteration_id: Optional[int] = None,
             label_id: Optional[int] = None,
             milestone_id: Optional[int] = None,
             position: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if assignee_id is not None:
            _setter("assignee_id", assignee_id)
        if id is not None:
            _setter("id", id)
        if iteration_id is not None:
            _setter("iteration_id", iteration_id)
        if label_id is not None:
            _setter("label_id", label_id)
        if milestone_id is not None:
            _setter("milestone_id", milestone_id)
        if position is not None:
            _setter("position", position)

    @property
    @pulumi.getter(name="assigneeId")
    def assignee_id(self) -> Optional[int]:
        """
        The ID of the assignee the list should be scoped to. Requires a GitLab EE license.
        """
        return pulumi.get(self, "assignee_id")

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

    @property
    @pulumi.getter(name="iterationId")
    def iteration_id(self) -> Optional[int]:
        """
        The ID of the iteration the list should be scoped to. Requires a GitLab EE license.
        """
        return pulumi.get(self, "iteration_id")

    @property
    @pulumi.getter(name="labelId")
    def label_id(self) -> Optional[int]:
        """
        The ID of the label the list should be scoped to. Requires a GitLab EE license.
        """
        return pulumi.get(self, "label_id")

    @property
    @pulumi.getter(name="milestoneId")
    def milestone_id(self) -> Optional[int]:
        """
        The ID of the milestone the list should be scoped to. Requires a GitLab EE license.
        """
        return pulumi.get(self, "milestone_id")

    @property
    @pulumi.getter
    def position(self) -> Optional[int]:
        """
        The position of the list within the board. The position for the list is based on the its position in the `lists` array.
        """
        return pulumi.get(self, "position")


@pulumi.output_type
class ProjectIssueTaskCompletionStatus(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "completedCount":
            suggest = "completed_count"

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

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

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

    def __init__(__self__, *,
                 completed_count: Optional[int] = None,
                 count: Optional[int] = None):
        ProjectIssueTaskCompletionStatus._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            completed_count=completed_count,
            count=count,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             completed_count: Optional[int] = None,
             count: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if completed_count is not None:
            _setter("completed_count", completed_count)
        if count is not None:
            _setter("count", count)

    @property
    @pulumi.getter(name="completedCount")
    def completed_count(self) -> Optional[int]:
        return pulumi.get(self, "completed_count")

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


@pulumi.output_type
class ProjectProtectedEnvironmentApprovalRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessLevel":
            suggest = "access_level"
        elif key == "accessLevelDescription":
            suggest = "access_level_description"
        elif key == "groupId":
            suggest = "group_id"
        elif key == "requiredApprovals":
            suggest = "required_approvals"
        elif key == "userId":
            suggest = "user_id"

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

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

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

    def __init__(__self__, *,
                 access_level: Optional[str] = None,
                 access_level_description: Optional[str] = None,
                 group_id: Optional[int] = None,
                 id: Optional[int] = None,
                 required_approvals: Optional[int] = None,
                 user_id: Optional[int] = None):
        """
        :param str access_level: Levels of access allowed to approve a deployment to this protected environment. Valid values are `developer`, `maintainer`.
        :param str access_level_description: Readable description of level of access.
        :param int group_id: The ID of the group allowed to approve a deployment to this protected environment. The project must be shared with the group. This is mutually exclusive with user_id.
        :param int id: The unique ID of the Approval Rules object.
        :param int required_approvals: The number of approval required to allow deployment to this protected environment. This is mutually exclusive with user_id.
        :param int user_id: The ID of the user allowed to approve a deployment to this protected environment. The user must be a member of the project. This is mutually exclusive with group*id and required*approvals.
        """
        ProjectProtectedEnvironmentApprovalRule._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            access_level=access_level,
            access_level_description=access_level_description,
            group_id=group_id,
            id=id,
            required_approvals=required_approvals,
            user_id=user_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             access_level: Optional[str] = None,
             access_level_description: Optional[str] = None,
             group_id: Optional[int] = None,
             id: Optional[int] = None,
             required_approvals: Optional[int] = None,
             user_id: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if access_level is not None:
            _setter("access_level", access_level)
        if access_level_description is not None:
            _setter("access_level_description", access_level_description)
        if group_id is not None:
            _setter("group_id", group_id)
        if id is not None:
            _setter("id", id)
        if required_approvals is not None:
            _setter("required_approvals", required_approvals)
        if user_id is not None:
            _setter("user_id", user_id)

    @property
    @pulumi.getter(name="accessLevel")
    def access_level(self) -> Optional[str]:
        """
        Levels of access allowed to approve a deployment to this protected environment. Valid values are `developer`, `maintainer`.
        """
        return pulumi.get(self, "access_level")

    @property
    @pulumi.getter(name="accessLevelDescription")
    def access_level_description(self) -> Optional[str]:
        """
        Readable description of level of access.
        """
        return pulumi.get(self, "access_level_description")

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> Optional[int]:
        """
        The ID of the group allowed to approve a deployment to this protected environment. The project must be shared with the group. This is mutually exclusive with user_id.
        """
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter
    def id(self) -> Optional[int]:
        """
        The unique ID of the Approval Rules object.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="requiredApprovals")
    def required_approvals(self) -> Optional[int]:
        """
        The number of approval required to allow deployment to this protected environment. This is mutually exclusive with user_id.
        """
        return pulumi.get(self, "required_approvals")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> Optional[int]:
        """
        The ID of the user allowed to approve a deployment to this protected environment. The user must be a member of the project. This is mutually exclusive with group*id and required*approvals.
        """
        return pulumi.get(self, "user_id")


@pulumi.output_type
class ProjectProtectedEnvironmentDeployAccessLevel(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessLevel":
            suggest = "access_level"
        elif key == "accessLevelDescription":
            suggest = "access_level_description"
        elif key == "groupId":
            suggest = "group_id"
        elif key == "userId":
            suggest = "user_id"

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

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

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

    def __init__(__self__, *,
                 access_level: Optional[str] = None,
                 access_level_description: Optional[str] = None,
                 group_id: Optional[int] = None,
                 id: Optional[int] = None,
                 user_id: Optional[int] = None):
        """
        :param str access_level: Levels of access required to deploy to this protected environment. Valid values are `developer`, `maintainer`.
        :param str access_level_description: Readable description of level of access.
        :param int group_id: The ID of the group allowed to deploy to this protected environment. The project must be shared with the group.
        :param int id: The unique ID of the Deploy Access Level object.
        :param int user_id: The ID of the user allowed to deploy to this protected environment. The user must be a member of the project.
        """
        ProjectProtectedEnvironmentDeployAccessLevel._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            access_level=access_level,
            access_level_description=access_level_description,
            group_id=group_id,
            id=id,
            user_id=user_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             access_level: Optional[str] = None,
             access_level_description: Optional[str] = None,
             group_id: Optional[int] = None,
             id: Optional[int] = None,
             user_id: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if access_level is not None:
            _setter("access_level", access_level)
        if access_level_description is not None:
            _setter("access_level_description", access_level_description)
        if group_id is not None:
            _setter("group_id", group_id)
        if id is not None:
            _setter("id", id)
        if user_id is not None:
            _setter("user_id", user_id)

    @property
    @pulumi.getter(name="accessLevel")
    def access_level(self) -> Optional[str]:
        """
        Levels of access required to deploy to this protected environment. Valid values are `developer`, `maintainer`.
        """
        return pulumi.get(self, "access_level")

    @property
    @pulumi.getter(name="accessLevelDescription")
    def access_level_description(self) -> Optional[str]:
        """
        Readable description of level of access.
        """
        return pulumi.get(self, "access_level_description")

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> Optional[int]:
        """
        The ID of the group allowed to deploy to this protected environment. The project must be shared with the group.
        """
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter
    def id(self) -> Optional[int]:
        """
        The unique ID of the Deploy Access Level object.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> Optional[int]:
        """
        The ID of the user allowed to deploy to this protected environment. The user must be a member of the project.
        """
        return pulumi.get(self, "user_id")


@pulumi.output_type
class ProjectPushRules(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authorEmailRegex":
            suggest = "author_email_regex"
        elif key == "branchNameRegex":
            suggest = "branch_name_regex"
        elif key == "commitCommitterCheck":
            suggest = "commit_committer_check"
        elif key == "commitMessageNegativeRegex":
            suggest = "commit_message_negative_regex"
        elif key == "commitMessageRegex":
            suggest = "commit_message_regex"
        elif key == "denyDeleteTag":
            suggest = "deny_delete_tag"
        elif key == "fileNameRegex":
            suggest = "file_name_regex"
        elif key == "maxFileSize":
            suggest = "max_file_size"
        elif key == "memberCheck":
            suggest = "member_check"
        elif key == "preventSecrets":
            suggest = "prevent_secrets"
        elif key == "rejectUnsignedCommits":
            suggest = "reject_unsigned_commits"

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

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

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

    def __init__(__self__, *,
                 author_email_regex: Optional[str] = None,
                 branch_name_regex: Optional[str] = None,
                 commit_committer_check: Optional[bool] = None,
                 commit_message_negative_regex: Optional[str] = None,
                 commit_message_regex: Optional[str] = None,
                 deny_delete_tag: Optional[bool] = None,
                 file_name_regex: Optional[str] = None,
                 max_file_size: Optional[int] = None,
                 member_check: Optional[bool] = None,
                 prevent_secrets: Optional[bool] = None,
                 reject_unsigned_commits: Optional[bool] = None):
        """
        :param str author_email_regex: All commit author emails must match this regex, e.g. `@my-company.com$`.
        :param str branch_name_regex: All branch names must match this regex, e.g. `(feature|hotfix)\\/*`.
        :param bool commit_committer_check: Users can only push commits to this repository that were committed with one of their own verified emails.
        :param str commit_message_negative_regex: No commit message is allowed to match this regex, for example `ssh\\:\\/\\/`.
        :param str commit_message_regex: All commit messages must match this regex, e.g. `Fixed \\d+\\..*`.
        :param bool deny_delete_tag: Deny deleting a tag.
        :param str file_name_regex: All committed filenames must not match this regex, e.g. `(jar|exe)$`.
        :param int max_file_size: Maximum file size (MB).
        :param bool member_check: Restrict commits by author (email) to existing GitLab users.
        :param bool prevent_secrets: GitLab will reject any files that are likely to contain secrets.
        :param bool reject_unsigned_commits: Reject commit when it’s not signed through GPG.
        """
        ProjectPushRules._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            author_email_regex=author_email_regex,
            branch_name_regex=branch_name_regex,
            commit_committer_check=commit_committer_check,
            commit_message_negative_regex=commit_message_negative_regex,
            commit_message_regex=commit_message_regex,
            deny_delete_tag=deny_delete_tag,
            file_name_regex=file_name_regex,
            max_file_size=max_file_size,
            member_check=member_check,
            prevent_secrets=prevent_secrets,
            reject_unsigned_commits=reject_unsigned_commits,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             author_email_regex: Optional[str] = None,
             branch_name_regex: Optional[str] = None,
             commit_committer_check: Optional[bool] = None,
             commit_message_negative_regex: Optional[str] = None,
             commit_message_regex: Optional[str] = None,
             deny_delete_tag: Optional[bool] = None,
             file_name_regex: Optional[str] = None,
             max_file_size: Optional[int] = None,
             member_check: Optional[bool] = None,
             prevent_secrets: Optional[bool] = None,
             reject_unsigned_commits: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if author_email_regex is not None:
            _setter("author_email_regex", author_email_regex)
        if branch_name_regex is not None:
            _setter("branch_name_regex", branch_name_regex)
        if commit_committer_check is not None:
            _setter("commit_committer_check", commit_committer_check)
        if commit_message_negative_regex is not None:
            _setter("commit_message_negative_regex", commit_message_negative_regex)
        if commit_message_regex is not None:
            _setter("commit_message_regex", commit_message_regex)
        if deny_delete_tag is not None:
            _setter("deny_delete_tag", deny_delete_tag)
        if file_name_regex is not None:
            _setter("file_name_regex", file_name_regex)
        if max_file_size is not None:
            _setter("max_file_size", max_file_size)
        if member_check is not None:
            _setter("member_check", member_check)
        if prevent_secrets is not None:
            _setter("prevent_secrets", prevent_secrets)
        if reject_unsigned_commits is not None:
            _setter("reject_unsigned_commits", reject_unsigned_commits)

    @property
    @pulumi.getter(name="authorEmailRegex")
    def author_email_regex(self) -> Optional[str]:
        """
        All commit author emails must match this regex, e.g. `@my-company.com$`.
        """
        return pulumi.get(self, "author_email_regex")

    @property
    @pulumi.getter(name="branchNameRegex")
    def branch_name_regex(self) -> Optional[str]:
        """
        All branch names must match this regex, e.g. `(feature|hotfix)\\/*`.
        """
        return pulumi.get(self, "branch_name_regex")

    @property
    @pulumi.getter(name="commitCommitterCheck")
    def commit_committer_check(self) -> Optional[bool]:
        """
        Users can only push commits to this repository that were committed with one of their own verified emails.
        """
        return pulumi.get(self, "commit_committer_check")

    @property
    @pulumi.getter(name="commitMessageNegativeRegex")
    def commit_message_negative_regex(self) -> Optional[str]:
        """
        No commit message is allowed to match this regex, for example `ssh\\:\\/\\/`.
        """
        return pulumi.get(self, "commit_message_negative_regex")

    @property
    @pulumi.getter(name="commitMessageRegex")
    def commit_message_regex(self) -> Optional[str]:
        """
        All commit messages must match this regex, e.g. `Fixed \\d+\\..*`.
        """
        return pulumi.get(self, "commit_message_regex")

    @property
    @pulumi.getter(name="denyDeleteTag")
    def deny_delete_tag(self) -> Optional[bool]:
        """
        Deny deleting a tag.
        """
        return pulumi.get(self, "deny_delete_tag")

    @property
    @pulumi.getter(name="fileNameRegex")
    def file_name_regex(self) -> Optional[str]:
        """
        All committed filenames must not match this regex, e.g. `(jar|exe)$`.
        """
        return pulumi.get(self, "file_name_regex")

    @property
    @pulumi.getter(name="maxFileSize")
    def max_file_size(self) -> Optional[int]:
        """
        Maximum file size (MB).
        """
        return pulumi.get(self, "max_file_size")

    @property
    @pulumi.getter(name="memberCheck")
    def member_check(self) -> Optional[bool]:
        """
        Restrict commits by author (email) to existing GitLab users.
        """
        return pulumi.get(self, "member_check")

    @property
    @pulumi.getter(name="preventSecrets")
    def prevent_secrets(self) -> Optional[bool]:
        """
        GitLab will reject any files that are likely to contain secrets.
        """
        return pulumi.get(self, "prevent_secrets")

    @property
    @pulumi.getter(name="rejectUnsignedCommits")
    def reject_unsigned_commits(self) -> Optional[bool]:
        """
        Reject commit when it’s not signed through GPG.
        """
        return pulumi.get(self, "reject_unsigned_commits")


@pulumi.output_type
class ProjectTagCommit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authorEmail":
            suggest = "author_email"
        elif key == "authorName":
            suggest = "author_name"
        elif key == "authoredDate":
            suggest = "authored_date"
        elif key == "committedDate":
            suggest = "committed_date"
        elif key == "committerEmail":
            suggest = "committer_email"
        elif key == "committerName":
            suggest = "committer_name"
        elif key == "parentIds":
            suggest = "parent_ids"
        elif key == "shortId":
            suggest = "short_id"

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

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

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

    def __init__(__self__, *,
                 author_email: Optional[str] = None,
                 author_name: Optional[str] = None,
                 authored_date: Optional[str] = None,
                 committed_date: Optional[str] = None,
                 committer_email: Optional[str] = None,
                 committer_name: Optional[str] = None,
                 id: Optional[str] = None,
                 message: Optional[str] = None,
                 parent_ids: Optional[Sequence[str]] = None,
                 short_id: Optional[str] = None,
                 title: Optional[str] = None):
        ProjectTagCommit._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            author_email=author_email,
            author_name=author_name,
            authored_date=authored_date,
            committed_date=committed_date,
            committer_email=committer_email,
            committer_name=committer_name,
            id=id,
            message=message,
            parent_ids=parent_ids,
            short_id=short_id,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             author_email: Optional[str] = None,
             author_name: Optional[str] = None,
             authored_date: Optional[str] = None,
             committed_date: Optional[str] = None,
             committer_email: Optional[str] = None,
             committer_name: Optional[str] = None,
             id: Optional[str] = None,
             message: Optional[str] = None,
             parent_ids: Optional[Sequence[str]] = None,
             short_id: Optional[str] = None,
             title: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if author_email is not None:
            _setter("author_email", author_email)
        if author_name is not None:
            _setter("author_name", author_name)
        if authored_date is not None:
            _setter("authored_date", authored_date)
        if committed_date is not None:
            _setter("committed_date", committed_date)
        if committer_email is not None:
            _setter("committer_email", committer_email)
        if committer_name is not None:
            _setter("committer_name", committer_name)
        if id is not None:
            _setter("id", id)
        if message is not None:
            _setter("message", message)
        if parent_ids is not None:
            _setter("parent_ids", parent_ids)
        if short_id is not None:
            _setter("short_id", short_id)
        if title is not None:
            _setter("title", title)

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class ProjectTagRelease(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tagName":
            suggest = "tag_name"

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

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

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

    def __init__(__self__, *,
                 description: Optional[str] = None,
                 tag_name: Optional[str] = None):
        ProjectTagRelease._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            description=description,
            tag_name=tag_name,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             description: Optional[str] = None,
             tag_name: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if description is not None:
            _setter("description", description)
        if tag_name is not None:
            _setter("tag_name", tag_name)

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

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


@pulumi.output_type
class TagProtectionAllowedToCreate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessLevel":
            suggest = "access_level"
        elif key == "accessLevelDescription":
            suggest = "access_level_description"
        elif key == "groupId":
            suggest = "group_id"
        elif key == "userId":
            suggest = "user_id"

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

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

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

    def __init__(__self__, *,
                 access_level: Optional[str] = None,
                 access_level_description: Optional[str] = None,
                 group_id: Optional[int] = None,
                 user_id: Optional[int] = None):
        """
        :param str access_level: Level of access.
        :param str access_level_description: Readable description of level of access.
        :param int group_id: The ID of a GitLab group allowed to perform the relevant action. Mutually exclusive with `user_id`.
        :param int user_id: The ID of a GitLab user allowed to perform the relevant action. Mutually exclusive with `group_id`.
        """
        TagProtectionAllowedToCreate._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            access_level=access_level,
            access_level_description=access_level_description,
            group_id=group_id,
            user_id=user_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             access_level: Optional[str] = None,
             access_level_description: Optional[str] = None,
             group_id: Optional[int] = None,
             user_id: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions]=None):
        if access_level is not None:
            _setter("access_level", access_level)
        if access_level_description is not None:
            _setter("access_level_description", access_level_description)
        if group_id is not None:
            _setter("group_id", group_id)
        if user_id is not None:
            _setter("user_id", user_id)

    @property
    @pulumi.getter(name="accessLevel")
    def access_level(self) -> Optional[str]:
        """
        Level of access.
        """
        return pulumi.get(self, "access_level")

    @property
    @pulumi.getter(name="accessLevelDescription")
    def access_level_description(self) -> Optional[str]:
        """
        Readable description of level of access.
        """
        return pulumi.get(self, "access_level_description")

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> Optional[int]:
        """
        The ID of a GitLab group allowed to perform the relevant action. Mutually exclusive with `user_id`.
        """
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> Optional[int]:
        """
        The ID of a GitLab user allowed to perform the relevant action. Mutually exclusive with `group_id`.
        """
        return pulumi.get(self, "user_id")


@pulumi.output_type
class GetBranchCommitResult(dict):
    def __init__(__self__, *,
                 author_email: str,
                 author_name: str,
                 authored_date: str,
                 committed_date: str,
                 committer_email: str,
                 committer_name: str,
                 id: str,
                 message: str,
                 parent_ids: Sequence[str],
                 short_id: str,
                 title: str):
        GetBranchCommitResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            author_email=author_email,
            author_name=author_name,
            authored_date=authored_date,
            committed_date=committed_date,
            committer_email=committer_email,
            committer_name=committer_name,
            id=id,
            message=message,
            parent_ids=parent_ids,
            short_id=short_id,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             author_email: str,
             author_name: str,
             authored_date: str,
             committed_date: str,
             committer_email: str,
             committer_name: str,
             id: str,
             message: str,
             parent_ids: Sequence[str],
             short_id: str,
             title: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("author_email", author_email)
        _setter("author_name", author_name)
        _setter("authored_date", authored_date)
        _setter("committed_date", committed_date)
        _setter("committer_email", committer_email)
        _setter("committer_name", committer_name)
        _setter("id", id)
        _setter("message", message)
        _setter("parent_ids", parent_ids)
        _setter("short_id", short_id)
        _setter("title", title)

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="parentIds")
    def parent_ids(self) -> Sequence[str]:
        return pulumi.get(self, "parent_ids")

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

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


@pulumi.output_type
class GetClusterAgentsClusterAgentResult(dict):
    def __init__(__self__, *,
                 agent_id: int,
                 created_at: str,
                 created_by_user_id: int,
                 name: str,
                 project: str):
        GetClusterAgentsClusterAgentResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            agent_id=agent_id,
            created_at=created_at,
            created_by_user_id=created_by_user_id,
            name=name,
            project=project,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             agent_id: int,
             created_at: str,
             created_by_user_id: int,
             name: str,
             project: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("agent_id", agent_id)
        _setter("created_at", created_at)
        _setter("created_by_user_id", created_by_user_id)
        _setter("name", name)
        _setter("project", project)

    @property
    @pulumi.getter(name="agentId")
    def agent_id(self) -> int:
        return pulumi.get(self, "agent_id")

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

    @property
    @pulumi.getter(name="createdByUserId")
    def created_by_user_id(self) -> int:
        return pulumi.get(self, "created_by_user_id")

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

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


@pulumi.output_type
class GetGroupHooksHookResult(dict):
    def __init__(__self__, *,
                 confidential_issues_events: bool,
                 confidential_note_events: bool,
                 deployment_events: bool,
                 enable_ssl_verification: bool,
                 group: str,
                 group_id: int,
                 hook_id: int,
                 issues_events: bool,
                 job_events: bool,
                 merge_requests_events: bool,
                 note_events: bool,
                 pipeline_events: bool,
                 push_events: bool,
                 push_events_branch_filter: str,
                 releases_events: bool,
                 subgroup_events: bool,
                 tag_push_events: bool,
                 token: str,
                 url: str,
                 wiki_page_events: bool):
        GetGroupHooksHookResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            confidential_issues_events=confidential_issues_events,
            confidential_note_events=confidential_note_events,
            deployment_events=deployment_events,
            enable_ssl_verification=enable_ssl_verification,
            group=group,
            group_id=group_id,
            hook_id=hook_id,
            issues_events=issues_events,
            job_events=job_events,
            merge_requests_events=merge_requests_events,
            note_events=note_events,
            pipeline_events=pipeline_events,
            push_events=push_events,
            push_events_branch_filter=push_events_branch_filter,
            releases_events=releases_events,
            subgroup_events=subgroup_events,
            tag_push_events=tag_push_events,
            token=token,
            url=url,
            wiki_page_events=wiki_page_events,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             confidential_issues_events: bool,
             confidential_note_events: bool,
             deployment_events: bool,
             enable_ssl_verification: bool,
             group: str,
             group_id: int,
             hook_id: int,
             issues_events: bool,
             job_events: bool,
             merge_requests_events: bool,
             note_events: bool,
             pipeline_events: bool,
             push_events: bool,
             push_events_branch_filter: str,
             releases_events: bool,
             subgroup_events: bool,
             tag_push_events: bool,
             token: str,
             url: str,
             wiki_page_events: bool,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("confidential_issues_events", confidential_issues_events)
        _setter("confidential_note_events", confidential_note_events)
        _setter("deployment_events", deployment_events)
        _setter("enable_ssl_verification", enable_ssl_verification)
        _setter("group", group)
        _setter("group_id", group_id)
        _setter("hook_id", hook_id)
        _setter("issues_events", issues_events)
        _setter("job_events", job_events)
        _setter("merge_requests_events", merge_requests_events)
        _setter("note_events", note_events)
        _setter("pipeline_events", pipeline_events)
        _setter("push_events", push_events)
        _setter("push_events_branch_filter", push_events_branch_filter)
        _setter("releases_events", releases_events)
        _setter("subgroup_events", subgroup_events)
        _setter("tag_push_events", tag_push_events)
        _setter("token", token)
        _setter("url", url)
        _setter("wiki_page_events", wiki_page_events)

    @property
    @pulumi.getter(name="confidentialIssuesEvents")
    def confidential_issues_events(self) -> bool:
        return pulumi.get(self, "confidential_issues_events")

    @property
    @pulumi.getter(name="confidentialNoteEvents")
    def confidential_note_events(self) -> bool:
        return pulumi.get(self, "confidential_note_events")

    @property
    @pulumi.getter(name="deploymentEvents")
    def deployment_events(self) -> bool:
        return pulumi.get(self, "deployment_events")

    @property
    @pulumi.getter(name="enableSslVerification")
    def enable_ssl_verification(self) -> bool:
        return pulumi.get(self, "enable_ssl_verification")

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

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> int:
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="hookId")
    def hook_id(self) -> int:
        return pulumi.get(self, "hook_id")

    @property
    @pulumi.getter(name="issuesEvents")
    def issues_events(self) -> bool:
        return pulumi.get(self, "issues_events")

    @property
    @pulumi.getter(name="jobEvents")
    def job_events(self) -> bool:
        return pulumi.get(self, "job_events")

    @property
    @pulumi.getter(name="mergeRequestsEvents")
    def merge_requests_events(self) -> bool:
        return pulumi.get(self, "merge_requests_events")

    @property
    @pulumi.getter(name="noteEvents")
    def note_events(self) -> bool:
        return pulumi.get(self, "note_events")

    @property
    @pulumi.getter(name="pipelineEvents")
    def pipeline_events(self) -> bool:
        return pulumi.get(self, "pipeline_events")

    @property
    @pulumi.getter(name="pushEvents")
    def push_events(self) -> bool:
        return pulumi.get(self, "push_events")

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

    @property
    @pulumi.getter(name="releasesEvents")
    def releases_events(self) -> bool:
        return pulumi.get(self, "releases_events")

    @property
    @pulumi.getter(name="subgroupEvents")
    def subgroup_events(self) -> bool:
        return pulumi.get(self, "subgroup_events")

    @property
    @pulumi.getter(name="tagPushEvents")
    def tag_push_events(self) -> bool:
        return pulumi.get(self, "tag_push_events")

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

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

    @property
    @pulumi.getter(name="wikiPageEvents")
    def wiki_page_events(self) -> bool:
        return pulumi.get(self, "wiki_page_events")


@pulumi.output_type
class GetGroupMembershipMemberResult(dict):
    def __init__(__self__, *,
                 access_level: str,
                 avatar_url: str,
                 expires_at: str,
                 id: int,
                 name: str,
                 state: str,
                 username: str,
                 web_url: str):
        GetGroupMembershipMemberResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            access_level=access_level,
            avatar_url=avatar_url,
            expires_at=expires_at,
            id=id,
            name=name,
            state=state,
            username=username,
            web_url=web_url,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             access_level: str,
             avatar_url: str,
             expires_at: str,
             id: int,
             name: str,
             state: str,
             username: str,
             web_url: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("access_level", access_level)
        _setter("avatar_url", avatar_url)
        _setter("expires_at", expires_at)
        _setter("id", id)
        _setter("name", name)
        _setter("state", state)
        _setter("username", username)
        _setter("web_url", web_url)

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetGroupSubgroupsSubgroupResult(dict):
    def __init__(__self__, *,
                 auto_devops_enabled: bool,
                 avatar_url: str,
                 created_at: str,
                 default_branch_protection: int,
                 description: str,
                 emails_disabled: bool,
                 file_template_project_id: int,
                 full_name: str,
                 full_path: str,
                 group_id: int,
                 ip_restriction_ranges: str,
                 lfs_enabled: bool,
                 mentions_disabled: bool,
                 name: str,
                 parent_id: int,
                 path: str,
                 project_creation_level: str,
                 request_access_enabled: bool,
                 require_two_factor_authentication: bool,
                 share_with_group_lock: bool,
                 statistics: Mapping[str, str],
                 subgroup_creation_level: str,
                 two_factor_grace_period: int,
                 visibility: str,
                 web_url: str,
                 wiki_access_level: str):
        GetGroupSubgroupsSubgroupResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            auto_devops_enabled=auto_devops_enabled,
            avatar_url=avatar_url,
            created_at=created_at,
            default_branch_protection=default_branch_protection,
            description=description,
            emails_disabled=emails_disabled,
            file_template_project_id=file_template_project_id,
            full_name=full_name,
            full_path=full_path,
            group_id=group_id,
            ip_restriction_ranges=ip_restriction_ranges,
            lfs_enabled=lfs_enabled,
            mentions_disabled=mentions_disabled,
            name=name,
            parent_id=parent_id,
            path=path,
            project_creation_level=project_creation_level,
            request_access_enabled=request_access_enabled,
            require_two_factor_authentication=require_two_factor_authentication,
            share_with_group_lock=share_with_group_lock,
            statistics=statistics,
            subgroup_creation_level=subgroup_creation_level,
            two_factor_grace_period=two_factor_grace_period,
            visibility=visibility,
            web_url=web_url,
            wiki_access_level=wiki_access_level,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             auto_devops_enabled: bool,
             avatar_url: str,
             created_at: str,
             default_branch_protection: int,
             description: str,
             emails_disabled: bool,
             file_template_project_id: int,
             full_name: str,
             full_path: str,
             group_id: int,
             ip_restriction_ranges: str,
             lfs_enabled: bool,
             mentions_disabled: bool,
             name: str,
             parent_id: int,
             path: str,
             project_creation_level: str,
             request_access_enabled: bool,
             require_two_factor_authentication: bool,
             share_with_group_lock: bool,
             statistics: Mapping[str, str],
             subgroup_creation_level: str,
             two_factor_grace_period: int,
             visibility: str,
             web_url: str,
             wiki_access_level: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("auto_devops_enabled", auto_devops_enabled)
        _setter("avatar_url", avatar_url)
        _setter("created_at", created_at)
        _setter("default_branch_protection", default_branch_protection)
        _setter("description", description)
        _setter("emails_disabled", emails_disabled)
        _setter("file_template_project_id", file_template_project_id)
        _setter("full_name", full_name)
        _setter("full_path", full_path)
        _setter("group_id", group_id)
        _setter("ip_restriction_ranges", ip_restriction_ranges)
        _setter("lfs_enabled", lfs_enabled)
        _setter("mentions_disabled", mentions_disabled)
        _setter("name", name)
        _setter("parent_id", parent_id)
        _setter("path", path)
        _setter("project_creation_level", project_creation_level)
        _setter("request_access_enabled", request_access_enabled)
        _setter("require_two_factor_authentication", require_two_factor_authentication)
        _setter("share_with_group_lock", share_with_group_lock)
        _setter("statistics", statistics)
        _setter("subgroup_creation_level", subgroup_creation_level)
        _setter("two_factor_grace_period", two_factor_grace_period)
        _setter("visibility", visibility)
        _setter("web_url", web_url)
        _setter("wiki_access_level", wiki_access_level)

    @property
    @pulumi.getter(name="autoDevopsEnabled")
    def auto_devops_enabled(self) -> bool:
        return pulumi.get(self, "auto_devops_enabled")

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

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

    @property
    @pulumi.getter(name="defaultBranchProtection")
    def default_branch_protection(self) -> int:
        return pulumi.get(self, "default_branch_protection")

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

    @property
    @pulumi.getter(name="emailsDisabled")
    def emails_disabled(self) -> bool:
        return pulumi.get(self, "emails_disabled")

    @property
    @pulumi.getter(name="fileTemplateProjectId")
    def file_template_project_id(self) -> int:
        return pulumi.get(self, "file_template_project_id")

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

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

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> int:
        return pulumi.get(self, "group_id")

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

    @property
    @pulumi.getter(name="lfsEnabled")
    def lfs_enabled(self) -> bool:
        return pulumi.get(self, "lfs_enabled")

    @property
    @pulumi.getter(name="mentionsDisabled")
    def mentions_disabled(self) -> bool:
        return pulumi.get(self, "mentions_disabled")

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

    @property
    @pulumi.getter(name="parentId")
    def parent_id(self) -> int:
        return pulumi.get(self, "parent_id")

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

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

    @property
    @pulumi.getter(name="requestAccessEnabled")
    def request_access_enabled(self) -> bool:
        return pulumi.get(self, "request_access_enabled")

    @property
    @pulumi.getter(name="requireTwoFactorAuthentication")
    def require_two_factor_authentication(self) -> bool:
        return pulumi.get(self, "require_two_factor_authentication")

    @property
    @pulumi.getter(name="shareWithGroupLock")
    def share_with_group_lock(self) -> bool:
        return pulumi.get(self, "share_with_group_lock")

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

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

    @property
    @pulumi.getter(name="twoFactorGracePeriod")
    def two_factor_grace_period(self) -> int:
        return pulumi.get(self, "two_factor_grace_period")

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

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

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


@pulumi.output_type
class GetGroupVariablesVariableResult(dict):
    def __init__(__self__, *,
                 environment_scope: str,
                 group: str,
                 key: str,
                 masked: bool,
                 protected: bool,
                 raw: bool,
                 value: str,
                 variable_type: str):
        GetGroupVariablesVariableResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            environment_scope=environment_scope,
            group=group,
            key=key,
            masked=masked,
            protected=protected,
            raw=raw,
            value=value,
            variable_type=variable_type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             environment_scope: str,
             group: str,
             key: str,
             masked: bool,
             protected: bool,
             raw: bool,
             value: str,
             variable_type: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("environment_scope", environment_scope)
        _setter("group", group)
        _setter("key", key)
        _setter("masked", masked)
        _setter("protected", protected)
        _setter("raw", raw)
        _setter("value", value)
        _setter("variable_type", variable_type)

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetGroupsGroupResult(dict):
    def __init__(__self__, *,
                 default_branch_protection: int,
                 description: str,
                 full_name: str,
                 full_path: str,
                 group_id: int,
                 lfs_enabled: bool,
                 name: str,
                 parent_id: int,
                 path: str,
                 prevent_forking_outside_group: bool,
                 request_access_enabled: bool,
                 runners_token: str,
                 visibility_level: str,
                 web_url: str,
                 wiki_access_level: str):
        GetGroupsGroupResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            default_branch_protection=default_branch_protection,
            description=description,
            full_name=full_name,
            full_path=full_path,
            group_id=group_id,
            lfs_enabled=lfs_enabled,
            name=name,
            parent_id=parent_id,
            path=path,
            prevent_forking_outside_group=prevent_forking_outside_group,
            request_access_enabled=request_access_enabled,
            runners_token=runners_token,
            visibility_level=visibility_level,
            web_url=web_url,
            wiki_access_level=wiki_access_level,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             default_branch_protection: int,
             description: str,
             full_name: str,
             full_path: str,
             group_id: int,
             lfs_enabled: bool,
             name: str,
             parent_id: int,
             path: str,
             prevent_forking_outside_group: bool,
             request_access_enabled: bool,
             runners_token: str,
             visibility_level: str,
             web_url: str,
             wiki_access_level: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("default_branch_protection", default_branch_protection)
        _setter("description", description)
        _setter("full_name", full_name)
        _setter("full_path", full_path)
        _setter("group_id", group_id)
        _setter("lfs_enabled", lfs_enabled)
        _setter("name", name)
        _setter("parent_id", parent_id)
        _setter("path", path)
        _setter("prevent_forking_outside_group", prevent_forking_outside_group)
        _setter("request_access_enabled", request_access_enabled)
        _setter("runners_token", runners_token)
        _setter("visibility_level", visibility_level)
        _setter("web_url", web_url)
        _setter("wiki_access_level", wiki_access_level)

    @property
    @pulumi.getter(name="defaultBranchProtection")
    def default_branch_protection(self) -> int:
        return pulumi.get(self, "default_branch_protection")

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

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

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

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> int:
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="lfsEnabled")
    def lfs_enabled(self) -> bool:
        return pulumi.get(self, "lfs_enabled")

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

    @property
    @pulumi.getter(name="parentId")
    def parent_id(self) -> int:
        return pulumi.get(self, "parent_id")

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

    @property
    @pulumi.getter(name="preventForkingOutsideGroup")
    def prevent_forking_outside_group(self) -> bool:
        return pulumi.get(self, "prevent_forking_outside_group")

    @property
    @pulumi.getter(name="requestAccessEnabled")
    def request_access_enabled(self) -> bool:
        return pulumi.get(self, "request_access_enabled")

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

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

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

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


@pulumi.output_type
class GetInstanceDeployKeysDeployKeyResult(dict):
    def __init__(__self__, *,
                 created_at: str,
                 fingerprint: str,
                 id: int,
                 key: str,
                 projects_with_write_accesses: Sequence['outputs.GetInstanceDeployKeysDeployKeyProjectsWithWriteAccessResult'],
                 title: str):
        GetInstanceDeployKeysDeployKeyResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            created_at=created_at,
            fingerprint=fingerprint,
            id=id,
            key=key,
            projects_with_write_accesses=projects_with_write_accesses,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             created_at: str,
             fingerprint: str,
             id: int,
             key: str,
             projects_with_write_accesses: Sequence['outputs.GetInstanceDeployKeysDeployKeyProjectsWithWriteAccessResult'],
             title: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("created_at", created_at)
        _setter("fingerprint", fingerprint)
        _setter("id", id)
        _setter("key", key)
        _setter("projects_with_write_accesses", projects_with_write_accesses)
        _setter("title", title)

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

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

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

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

    @property
    @pulumi.getter(name="projectsWithWriteAccesses")
    def projects_with_write_accesses(self) -> Sequence['outputs.GetInstanceDeployKeysDeployKeyProjectsWithWriteAccessResult']:
        return pulumi.get(self, "projects_with_write_accesses")

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


@pulumi.output_type
class GetInstanceDeployKeysDeployKeyProjectsWithWriteAccessResult(dict):
    def __init__(__self__, *,
                 created_at: str,
                 description: str,
                 id: int,
                 name: str,
                 name_with_namespace: str,
                 path: str,
                 path_with_namespace: str):
        GetInstanceDeployKeysDeployKeyProjectsWithWriteAccessResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            created_at=created_at,
            description=description,
            id=id,
            name=name,
            name_with_namespace=name_with_namespace,
            path=path,
            path_with_namespace=path_with_namespace,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             created_at: str,
             description: str,
             id: int,
             name: str,
             name_with_namespace: str,
             path: str,
             path_with_namespace: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("created_at", created_at)
        _setter("description", description)
        _setter("id", id)
        _setter("name", name)
        _setter("name_with_namespace", name_with_namespace)
        _setter("path", path)
        _setter("path_with_namespace", path_with_namespace)

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

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

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

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

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

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

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


@pulumi.output_type
class GetInstanceVariablesVariableResult(dict):
    def __init__(__self__, *,
                 key: str,
                 masked: bool,
                 protected: bool,
                 raw: bool,
                 value: str,
                 variable_type: str):
        GetInstanceVariablesVariableResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            key=key,
            masked=masked,
            protected=protected,
            raw=raw,
            value=value,
            variable_type=variable_type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             key: str,
             masked: bool,
             protected: bool,
             raw: bool,
             value: str,
             variable_type: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("key", key)
        _setter("masked", masked)
        _setter("protected", protected)
        _setter("raw", raw)
        _setter("value", value)
        _setter("variable_type", variable_type)

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

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

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

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

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

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


@pulumi.output_type
class GetMetadataKasResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 external_url: str,
                 version: str):
        """
        :param bool enabled: Indicates whether KAS is enabled.
        :param str external_url: URL used by the agents to communicate with KAS. It’s null if kas.enabled is false.
        :param str version: Version of KAS. It’s null if kas.enabled is false.
        """
        GetMetadataKasResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            enabled=enabled,
            external_url=external_url,
            version=version,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             enabled: bool,
             external_url: str,
             version: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("enabled", enabled)
        _setter("external_url", external_url)
        _setter("version", version)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether KAS is enabled.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="externalUrl")
    def external_url(self) -> str:
        """
        URL used by the agents to communicate with KAS. It’s null if kas.enabled is false.
        """
        return pulumi.get(self, "external_url")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        Version of KAS. It’s null if kas.enabled is false.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetProjectBranchesBranchResult(dict):
    def __init__(__self__, *,
                 can_push: bool,
                 commits: Sequence['outputs.GetProjectBranchesBranchCommitResult'],
                 default: bool,
                 developers_can_merge: bool,
                 developers_can_push: bool,
                 merged: bool,
                 name: str,
                 protected: bool,
                 web_url: str):
        GetProjectBranchesBranchResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            can_push=can_push,
            commits=commits,
            default=default,
            developers_can_merge=developers_can_merge,
            developers_can_push=developers_can_push,
            merged=merged,
            name=name,
            protected=protected,
            web_url=web_url,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             can_push: bool,
             commits: Sequence['outputs.GetProjectBranchesBranchCommitResult'],
             default: bool,
             developers_can_merge: bool,
             developers_can_push: bool,
             merged: bool,
             name: str,
             protected: bool,
             web_url: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("can_push", can_push)
        _setter("commits", commits)
        _setter("default", default)
        _setter("developers_can_merge", developers_can_merge)
        _setter("developers_can_push", developers_can_push)
        _setter("merged", merged)
        _setter("name", name)
        _setter("protected", protected)
        _setter("web_url", web_url)

    @property
    @pulumi.getter(name="canPush")
    def can_push(self) -> bool:
        return pulumi.get(self, "can_push")

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

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

    @property
    @pulumi.getter(name="developersCanMerge")
    def developers_can_merge(self) -> bool:
        return pulumi.get(self, "developers_can_merge")

    @property
    @pulumi.getter(name="developersCanPush")
    def developers_can_push(self) -> bool:
        return pulumi.get(self, "developers_can_push")

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

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

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

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


@pulumi.output_type
class GetProjectBranchesBranchCommitResult(dict):
    def __init__(__self__, *,
                 author_email: str,
                 author_name: str,
                 authored_date: str,
                 committed_date: str,
                 committer_email: str,
                 committer_name: str,
                 id: str,
                 message: str,
                 parent_ids: Sequence[str],
                 short_id: str,
                 title: str):
        GetProjectBranchesBranchCommitResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            author_email=author_email,
            author_name=author_name,
            authored_date=authored_date,
            committed_date=committed_date,
            committer_email=committer_email,
            committer_name=committer_name,
            id=id,
            message=message,
            parent_ids=parent_ids,
            short_id=short_id,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             author_email: str,
             author_name: str,
             authored_date: str,
             committed_date: str,
             committer_email: str,
             committer_name: str,
             id: str,
             message: str,
             parent_ids: Sequence[str],
             short_id: str,
             title: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("author_email", author_email)
        _setter("author_name", author_name)
        _setter("authored_date", authored_date)
        _setter("committed_date", committed_date)
        _setter("committer_email", committer_email)
        _setter("committer_name", committer_name)
        _setter("id", id)
        _setter("message", message)
        _setter("parent_ids", parent_ids)
        _setter("short_id", short_id)
        _setter("title", title)

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="parentIds")
    def parent_ids(self) -> Sequence[str]:
        return pulumi.get(self, "parent_ids")

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

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


@pulumi.output_type
class GetProjectContainerExpirationPolicyResult(dict):
    def __init__(__self__, *,
                 cadence: str,
                 enabled: bool,
                 keep_n: int,
                 name_regex: str,
                 name_regex_delete: str,
                 name_regex_keep: str,
                 next_run_at: str,
                 older_than: str):
        GetProjectContainerExpirationPolicyResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            cadence=cadence,
            enabled=enabled,
            keep_n=keep_n,
            name_regex=name_regex,
            name_regex_delete=name_regex_delete,
            name_regex_keep=name_regex_keep,
            next_run_at=next_run_at,
            older_than=older_than,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             cadence: str,
             enabled: bool,
             keep_n: int,
             name_regex: str,
             name_regex_delete: str,
             name_regex_keep: str,
             next_run_at: str,
             older_than: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("cadence", cadence)
        _setter("enabled", enabled)
        _setter("keep_n", keep_n)
        _setter("name_regex", name_regex)
        _setter("name_regex_delete", name_regex_delete)
        _setter("name_regex_keep", name_regex_keep)
        _setter("next_run_at", next_run_at)
        _setter("older_than", older_than)

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

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

    @property
    @pulumi.getter(name="keepN")
    def keep_n(self) -> int:
        return pulumi.get(self, "keep_n")

    @property
    @pulumi.getter(name="nameRegex")
    def name_regex(self) -> str:
        warnings.warn("""`name_regex` has been deprecated. Use `name_regex_delete` instead.""", DeprecationWarning)
        pulumi.log.warn("""name_regex is deprecated: `name_regex` has been deprecated. Use `name_regex_delete` instead.""")

        return pulumi.get(self, "name_regex")

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

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

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

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


@pulumi.output_type
class GetProjectHooksHookResult(dict):
    def __init__(__self__, *,
                 confidential_issues_events: bool,
                 confidential_note_events: bool,
                 deployment_events: bool,
                 enable_ssl_verification: bool,
                 hook_id: int,
                 issues_events: bool,
                 job_events: bool,
                 merge_requests_events: bool,
                 note_events: bool,
                 pipeline_events: bool,
                 project: str,
                 project_id: int,
                 push_events: bool,
                 push_events_branch_filter: str,
                 releases_events: bool,
                 tag_push_events: bool,
                 token: str,
                 url: str,
                 wiki_page_events: bool):
        GetProjectHooksHookResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            confidential_issues_events=confidential_issues_events,
            confidential_note_events=confidential_note_events,
            deployment_events=deployment_events,
            enable_ssl_verification=enable_ssl_verification,
            hook_id=hook_id,
            issues_events=issues_events,
            job_events=job_events,
            merge_requests_events=merge_requests_events,
            note_events=note_events,
            pipeline_events=pipeline_events,
            project=project,
            project_id=project_id,
            push_events=push_events,
            push_events_branch_filter=push_events_branch_filter,
            releases_events=releases_events,
            tag_push_events=tag_push_events,
            token=token,
            url=url,
            wiki_page_events=wiki_page_events,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             confidential_issues_events: bool,
             confidential_note_events: bool,
             deployment_events: bool,
             enable_ssl_verification: bool,
             hook_id: int,
             issues_events: bool,
             job_events: bool,
             merge_requests_events: bool,
             note_events: bool,
             pipeline_events: bool,
             project: str,
             project_id: int,
             push_events: bool,
             push_events_branch_filter: str,
             releases_events: bool,
             tag_push_events: bool,
             token: str,
             url: str,
             wiki_page_events: bool,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("confidential_issues_events", confidential_issues_events)
        _setter("confidential_note_events", confidential_note_events)
        _setter("deployment_events", deployment_events)
        _setter("enable_ssl_verification", enable_ssl_verification)
        _setter("hook_id", hook_id)
        _setter("issues_events", issues_events)
        _setter("job_events", job_events)
        _setter("merge_requests_events", merge_requests_events)
        _setter("note_events", note_events)
        _setter("pipeline_events", pipeline_events)
        _setter("project", project)
        _setter("project_id", project_id)
        _setter("push_events", push_events)
        _setter("push_events_branch_filter", push_events_branch_filter)
        _setter("releases_events", releases_events)
        _setter("tag_push_events", tag_push_events)
        _setter("token", token)
        _setter("url", url)
        _setter("wiki_page_events", wiki_page_events)

    @property
    @pulumi.getter(name="confidentialIssuesEvents")
    def confidential_issues_events(self) -> bool:
        return pulumi.get(self, "confidential_issues_events")

    @property
    @pulumi.getter(name="confidentialNoteEvents")
    def confidential_note_events(self) -> bool:
        return pulumi.get(self, "confidential_note_events")

    @property
    @pulumi.getter(name="deploymentEvents")
    def deployment_events(self) -> bool:
        return pulumi.get(self, "deployment_events")

    @property
    @pulumi.getter(name="enableSslVerification")
    def enable_ssl_verification(self) -> bool:
        return pulumi.get(self, "enable_ssl_verification")

    @property
    @pulumi.getter(name="hookId")
    def hook_id(self) -> int:
        return pulumi.get(self, "hook_id")

    @property
    @pulumi.getter(name="issuesEvents")
    def issues_events(self) -> bool:
        return pulumi.get(self, "issues_events")

    @property
    @pulumi.getter(name="jobEvents")
    def job_events(self) -> bool:
        return pulumi.get(self, "job_events")

    @property
    @pulumi.getter(name="mergeRequestsEvents")
    def merge_requests_events(self) -> bool:
        return pulumi.get(self, "merge_requests_events")

    @property
    @pulumi.getter(name="noteEvents")
    def note_events(self) -> bool:
        return pulumi.get(self, "note_events")

    @property
    @pulumi.getter(name="pipelineEvents")
    def pipeline_events(self) -> bool:
        return pulumi.get(self, "pipeline_events")

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

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> int:
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="pushEvents")
    def push_events(self) -> bool:
        return pulumi.get(self, "push_events")

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

    @property
    @pulumi.getter(name="releasesEvents")
    def releases_events(self) -> bool:
        return pulumi.get(self, "releases_events")

    @property
    @pulumi.getter(name="tagPushEvents")
    def tag_push_events(self) -> bool:
        return pulumi.get(self, "tag_push_events")

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

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

    @property
    @pulumi.getter(name="wikiPageEvents")
    def wiki_page_events(self) -> bool:
        return pulumi.get(self, "wiki_page_events")


@pulumi.output_type
class GetProjectIssueTaskCompletionStatusResult(dict):
    def __init__(__self__, *,
                 completed_count: int,
                 count: int):
        GetProjectIssueTaskCompletionStatusResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            completed_count=completed_count,
            count=count,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             completed_count: int,
             count: int,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("completed_count", completed_count)
        _setter("count", count)

    @property
    @pulumi.getter(name="completedCount")
    def completed_count(self) -> int:
        return pulumi.get(self, "completed_count")

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


@pulumi.output_type
class GetProjectIssuesIssueResult(dict):
    def __init__(__self__, *,
                 assignee_ids: Sequence[int],
                 author_id: int,
                 closed_at: str,
                 closed_by_user_id: int,
                 confidential: bool,
                 created_at: str,
                 description: str,
                 discussion_locked: bool,
                 discussion_to_resolve: str,
                 downvotes: int,
                 due_date: str,
                 epic_id: int,
                 epic_issue_id: int,
                 external_id: str,
                 human_time_estimate: str,
                 human_total_time_spent: str,
                 iid: int,
                 issue_id: int,
                 issue_link_id: int,
                 issue_type: str,
                 labels: Sequence[str],
                 links: Mapping[str, str],
                 merge_request_to_resolve_discussions_of: int,
                 merge_requests_count: int,
                 milestone_id: int,
                 moved_to_id: int,
                 project: str,
                 references: Mapping[str, str],
                 state: str,
                 subscribed: bool,
                 task_completion_statuses: Sequence['outputs.GetProjectIssuesIssueTaskCompletionStatusResult'],
                 time_estimate: int,
                 title: str,
                 total_time_spent: int,
                 updated_at: str,
                 upvotes: int,
                 user_notes_count: int,
                 web_url: str,
                 weight: int):
        GetProjectIssuesIssueResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            assignee_ids=assignee_ids,
            author_id=author_id,
            closed_at=closed_at,
            closed_by_user_id=closed_by_user_id,
            confidential=confidential,
            created_at=created_at,
            description=description,
            discussion_locked=discussion_locked,
            discussion_to_resolve=discussion_to_resolve,
            downvotes=downvotes,
            due_date=due_date,
            epic_id=epic_id,
            epic_issue_id=epic_issue_id,
            external_id=external_id,
            human_time_estimate=human_time_estimate,
            human_total_time_spent=human_total_time_spent,
            iid=iid,
            issue_id=issue_id,
            issue_link_id=issue_link_id,
            issue_type=issue_type,
            labels=labels,
            links=links,
            merge_request_to_resolve_discussions_of=merge_request_to_resolve_discussions_of,
            merge_requests_count=merge_requests_count,
            milestone_id=milestone_id,
            moved_to_id=moved_to_id,
            project=project,
            references=references,
            state=state,
            subscribed=subscribed,
            task_completion_statuses=task_completion_statuses,
            time_estimate=time_estimate,
            title=title,
            total_time_spent=total_time_spent,
            updated_at=updated_at,
            upvotes=upvotes,
            user_notes_count=user_notes_count,
            web_url=web_url,
            weight=weight,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             assignee_ids: Sequence[int],
             author_id: int,
             closed_at: str,
             closed_by_user_id: int,
             confidential: bool,
             created_at: str,
             description: str,
             discussion_locked: bool,
             discussion_to_resolve: str,
             downvotes: int,
             due_date: str,
             epic_id: int,
             epic_issue_id: int,
             external_id: str,
             human_time_estimate: str,
             human_total_time_spent: str,
             iid: int,
             issue_id: int,
             issue_link_id: int,
             issue_type: str,
             labels: Sequence[str],
             links: Mapping[str, str],
             merge_request_to_resolve_discussions_of: int,
             merge_requests_count: int,
             milestone_id: int,
             moved_to_id: int,
             project: str,
             references: Mapping[str, str],
             state: str,
             subscribed: bool,
             task_completion_statuses: Sequence['outputs.GetProjectIssuesIssueTaskCompletionStatusResult'],
             time_estimate: int,
             title: str,
             total_time_spent: int,
             updated_at: str,
             upvotes: int,
             user_notes_count: int,
             web_url: str,
             weight: int,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("assignee_ids", assignee_ids)
        _setter("author_id", author_id)
        _setter("closed_at", closed_at)
        _setter("closed_by_user_id", closed_by_user_id)
        _setter("confidential", confidential)
        _setter("created_at", created_at)
        _setter("description", description)
        _setter("discussion_locked", discussion_locked)
        _setter("discussion_to_resolve", discussion_to_resolve)
        _setter("downvotes", downvotes)
        _setter("due_date", due_date)
        _setter("epic_id", epic_id)
        _setter("epic_issue_id", epic_issue_id)
        _setter("external_id", external_id)
        _setter("human_time_estimate", human_time_estimate)
        _setter("human_total_time_spent", human_total_time_spent)
        _setter("iid", iid)
        _setter("issue_id", issue_id)
        _setter("issue_link_id", issue_link_id)
        _setter("issue_type", issue_type)
        _setter("labels", labels)
        _setter("links", links)
        _setter("merge_request_to_resolve_discussions_of", merge_request_to_resolve_discussions_of)
        _setter("merge_requests_count", merge_requests_count)
        _setter("milestone_id", milestone_id)
        _setter("moved_to_id", moved_to_id)
        _setter("project", project)
        _setter("references", references)
        _setter("state", state)
        _setter("subscribed", subscribed)
        _setter("task_completion_statuses", task_completion_statuses)
        _setter("time_estimate", time_estimate)
        _setter("title", title)
        _setter("total_time_spent", total_time_spent)
        _setter("updated_at", updated_at)
        _setter("upvotes", upvotes)
        _setter("user_notes_count", user_notes_count)
        _setter("web_url", web_url)
        _setter("weight", weight)

    @property
    @pulumi.getter(name="assigneeIds")
    def assignee_ids(self) -> Sequence[int]:
        return pulumi.get(self, "assignee_ids")

    @property
    @pulumi.getter(name="authorId")
    def author_id(self) -> int:
        return pulumi.get(self, "author_id")

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

    @property
    @pulumi.getter(name="closedByUserId")
    def closed_by_user_id(self) -> int:
        return pulumi.get(self, "closed_by_user_id")

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

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

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

    @property
    @pulumi.getter(name="discussionLocked")
    def discussion_locked(self) -> bool:
        return pulumi.get(self, "discussion_locked")

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

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

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

    @property
    @pulumi.getter(name="epicId")
    def epic_id(self) -> int:
        return pulumi.get(self, "epic_id")

    @property
    @pulumi.getter(name="epicIssueId")
    def epic_issue_id(self) -> int:
        return pulumi.get(self, "epic_issue_id")

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

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

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

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

    @property
    @pulumi.getter(name="issueId")
    def issue_id(self) -> int:
        return pulumi.get(self, "issue_id")

    @property
    @pulumi.getter(name="issueLinkId")
    def issue_link_id(self) -> int:
        return pulumi.get(self, "issue_link_id")

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

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

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

    @property
    @pulumi.getter(name="mergeRequestToResolveDiscussionsOf")
    def merge_request_to_resolve_discussions_of(self) -> int:
        return pulumi.get(self, "merge_request_to_resolve_discussions_of")

    @property
    @pulumi.getter(name="mergeRequestsCount")
    def merge_requests_count(self) -> int:
        return pulumi.get(self, "merge_requests_count")

    @property
    @pulumi.getter(name="milestoneId")
    def milestone_id(self) -> int:
        return pulumi.get(self, "milestone_id")

    @property
    @pulumi.getter(name="movedToId")
    def moved_to_id(self) -> int:
        return pulumi.get(self, "moved_to_id")

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

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

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

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

    @property
    @pulumi.getter(name="taskCompletionStatuses")
    def task_completion_statuses(self) -> Sequence['outputs.GetProjectIssuesIssueTaskCompletionStatusResult']:
        return pulumi.get(self, "task_completion_statuses")

    @property
    @pulumi.getter(name="timeEstimate")
    def time_estimate(self) -> int:
        return pulumi.get(self, "time_estimate")

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

    @property
    @pulumi.getter(name="totalTimeSpent")
    def total_time_spent(self) -> int:
        return pulumi.get(self, "total_time_spent")

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

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

    @property
    @pulumi.getter(name="userNotesCount")
    def user_notes_count(self) -> int:
        return pulumi.get(self, "user_notes_count")

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

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


@pulumi.output_type
class GetProjectIssuesIssueTaskCompletionStatusResult(dict):
    def __init__(__self__, *,
                 completed_count: int,
                 count: int):
        GetProjectIssuesIssueTaskCompletionStatusResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            completed_count=completed_count,
            count=count,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             completed_count: int,
             count: int,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("completed_count", completed_count)
        _setter("count", count)

    @property
    @pulumi.getter(name="completedCount")
    def completed_count(self) -> int:
        return pulumi.get(self, "completed_count")

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


@pulumi.output_type
class GetProjectMembershipMemberResult(dict):
    def __init__(__self__, *,
                 access_level: str,
                 avatar_url: str,
                 expires_at: str,
                 id: int,
                 name: str,
                 state: str,
                 username: str,
                 web_url: str):
        GetProjectMembershipMemberResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            access_level=access_level,
            avatar_url=avatar_url,
            expires_at=expires_at,
            id=id,
            name=name,
            state=state,
            username=username,
            web_url=web_url,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             access_level: str,
             avatar_url: str,
             expires_at: str,
             id: int,
             name: str,
             state: str,
             username: str,
             web_url: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("access_level", access_level)
        _setter("avatar_url", avatar_url)
        _setter("expires_at", expires_at)
        _setter("id", id)
        _setter("name", name)
        _setter("state", state)
        _setter("username", username)
        _setter("web_url", web_url)

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetProjectMilestonesMilestoneResult(dict):
    def __init__(__self__, *,
                 created_at: str,
                 description: str,
                 due_date: str,
                 expired: bool,
                 iid: int,
                 milestone_id: int,
                 project: str,
                 project_id: int,
                 start_date: str,
                 state: str,
                 title: str,
                 updated_at: str,
                 web_url: str):
        GetProjectMilestonesMilestoneResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            created_at=created_at,
            description=description,
            due_date=due_date,
            expired=expired,
            iid=iid,
            milestone_id=milestone_id,
            project=project,
            project_id=project_id,
            start_date=start_date,
            state=state,
            title=title,
            updated_at=updated_at,
            web_url=web_url,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             created_at: str,
             description: str,
             due_date: str,
             expired: bool,
             iid: int,
             milestone_id: int,
             project: str,
             project_id: int,
             start_date: str,
             state: str,
             title: str,
             updated_at: str,
             web_url: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("created_at", created_at)
        _setter("description", description)
        _setter("due_date", due_date)
        _setter("expired", expired)
        _setter("iid", iid)
        _setter("milestone_id", milestone_id)
        _setter("project", project)
        _setter("project_id", project_id)
        _setter("start_date", start_date)
        _setter("state", state)
        _setter("title", title)
        _setter("updated_at", updated_at)
        _setter("web_url", web_url)

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

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

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

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

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

    @property
    @pulumi.getter(name="milestoneId")
    def milestone_id(self) -> int:
        return pulumi.get(self, "milestone_id")

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

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> int:
        return pulumi.get(self, "project_id")

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

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

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

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

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


@pulumi.output_type
class GetProjectProtectedBranchMergeAccessLevelResult(dict):
    def __init__(__self__, *,
                 access_level: str,
                 access_level_description: str,
                 group_id: int,
                 user_id: int):
        GetProjectProtectedBranchMergeAccessLevelResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            access_level=access_level,
            access_level_description=access_level_description,
            group_id=group_id,
            user_id=user_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             access_level: str,
             access_level_description: str,
             group_id: int,
             user_id: int,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("access_level", access_level)
        _setter("access_level_description", access_level_description)
        _setter("group_id", group_id)
        _setter("user_id", user_id)

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

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

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> int:
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> int:
        return pulumi.get(self, "user_id")


@pulumi.output_type
class GetProjectProtectedBranchPushAccessLevelResult(dict):
    def __init__(__self__, *,
                 access_level: str,
                 access_level_description: str,
                 group_id: int,
                 user_id: int):
        GetProjectProtectedBranchPushAccessLevelResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            access_level=access_level,
            access_level_description=access_level_description,
            group_id=group_id,
            user_id=user_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             access_level: str,
             access_level_description: str,
             group_id: int,
             user_id: int,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("access_level", access_level)
        _setter("access_level_description", access_level_description)
        _setter("group_id", group_id)
        _setter("user_id", user_id)

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

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

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> int:
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> int:
        return pulumi.get(self, "user_id")


@pulumi.output_type
class GetProjectProtectedBranchesProtectedBranchResult(dict):
    def __init__(__self__, *,
                 allow_force_push: bool,
                 code_owner_approval_required: bool,
                 id: int,
                 merge_access_levels: Sequence['outputs.GetProjectProtectedBranchesProtectedBranchMergeAccessLevelResult'],
                 name: str,
                 push_access_levels: Sequence['outputs.GetProjectProtectedBranchesProtectedBranchPushAccessLevelResult']):
        GetProjectProtectedBranchesProtectedBranchResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            allow_force_push=allow_force_push,
            code_owner_approval_required=code_owner_approval_required,
            id=id,
            merge_access_levels=merge_access_levels,
            name=name,
            push_access_levels=push_access_levels,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             allow_force_push: bool,
             code_owner_approval_required: bool,
             id: int,
             merge_access_levels: Sequence['outputs.GetProjectProtectedBranchesProtectedBranchMergeAccessLevelResult'],
             name: str,
             push_access_levels: Sequence['outputs.GetProjectProtectedBranchesProtectedBranchPushAccessLevelResult'],
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("allow_force_push", allow_force_push)
        _setter("code_owner_approval_required", code_owner_approval_required)
        _setter("id", id)
        _setter("merge_access_levels", merge_access_levels)
        _setter("name", name)
        _setter("push_access_levels", push_access_levels)

    @property
    @pulumi.getter(name="allowForcePush")
    def allow_force_push(self) -> bool:
        return pulumi.get(self, "allow_force_push")

    @property
    @pulumi.getter(name="codeOwnerApprovalRequired")
    def code_owner_approval_required(self) -> bool:
        return pulumi.get(self, "code_owner_approval_required")

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

    @property
    @pulumi.getter(name="mergeAccessLevels")
    def merge_access_levels(self) -> Sequence['outputs.GetProjectProtectedBranchesProtectedBranchMergeAccessLevelResult']:
        return pulumi.get(self, "merge_access_levels")

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

    @property
    @pulumi.getter(name="pushAccessLevels")
    def push_access_levels(self) -> Sequence['outputs.GetProjectProtectedBranchesProtectedBranchPushAccessLevelResult']:
        return pulumi.get(self, "push_access_levels")


@pulumi.output_type
class GetProjectProtectedBranchesProtectedBranchMergeAccessLevelResult(dict):
    def __init__(__self__, *,
                 access_level: str,
                 access_level_description: str,
                 group_id: int,
                 user_id: int):
        GetProjectProtectedBranchesProtectedBranchMergeAccessLevelResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            access_level=access_level,
            access_level_description=access_level_description,
            group_id=group_id,
            user_id=user_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             access_level: str,
             access_level_description: str,
             group_id: int,
             user_id: int,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("access_level", access_level)
        _setter("access_level_description", access_level_description)
        _setter("group_id", group_id)
        _setter("user_id", user_id)

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

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

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> int:
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> int:
        return pulumi.get(self, "user_id")


@pulumi.output_type
class GetProjectProtectedBranchesProtectedBranchPushAccessLevelResult(dict):
    def __init__(__self__, *,
                 access_level: str,
                 access_level_description: str,
                 group_id: int,
                 user_id: int):
        GetProjectProtectedBranchesProtectedBranchPushAccessLevelResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            access_level=access_level,
            access_level_description=access_level_description,
            group_id=group_id,
            user_id=user_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             access_level: str,
             access_level_description: str,
             group_id: int,
             user_id: int,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("access_level", access_level)
        _setter("access_level_description", access_level_description)
        _setter("group_id", group_id)
        _setter("user_id", user_id)

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

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

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> int:
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> int:
        return pulumi.get(self, "user_id")


@pulumi.output_type
class GetProjectPushRuleResult(dict):
    def __init__(__self__, *,
                 author_email_regex: str,
                 branch_name_regex: str,
                 commit_committer_check: bool,
                 commit_message_negative_regex: str,
                 commit_message_regex: str,
                 deny_delete_tag: bool,
                 file_name_regex: str,
                 max_file_size: int,
                 member_check: bool,
                 prevent_secrets: bool,
                 reject_unsigned_commits: bool):
        GetProjectPushRuleResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            author_email_regex=author_email_regex,
            branch_name_regex=branch_name_regex,
            commit_committer_check=commit_committer_check,
            commit_message_negative_regex=commit_message_negative_regex,
            commit_message_regex=commit_message_regex,
            deny_delete_tag=deny_delete_tag,
            file_name_regex=file_name_regex,
            max_file_size=max_file_size,
            member_check=member_check,
            prevent_secrets=prevent_secrets,
            reject_unsigned_commits=reject_unsigned_commits,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             author_email_regex: str,
             branch_name_regex: str,
             commit_committer_check: bool,
             commit_message_negative_regex: str,
             commit_message_regex: str,
             deny_delete_tag: bool,
             file_name_regex: str,
             max_file_size: int,
             member_check: bool,
             prevent_secrets: bool,
             reject_unsigned_commits: bool,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("author_email_regex", author_email_regex)
        _setter("branch_name_regex", branch_name_regex)
        _setter("commit_committer_check", commit_committer_check)
        _setter("commit_message_negative_regex", commit_message_negative_regex)
        _setter("commit_message_regex", commit_message_regex)
        _setter("deny_delete_tag", deny_delete_tag)
        _setter("file_name_regex", file_name_regex)
        _setter("max_file_size", max_file_size)
        _setter("member_check", member_check)
        _setter("prevent_secrets", prevent_secrets)
        _setter("reject_unsigned_commits", reject_unsigned_commits)

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

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

    @property
    @pulumi.getter(name="commitCommitterCheck")
    def commit_committer_check(self) -> bool:
        return pulumi.get(self, "commit_committer_check")

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

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

    @property
    @pulumi.getter(name="denyDeleteTag")
    def deny_delete_tag(self) -> bool:
        return pulumi.get(self, "deny_delete_tag")

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

    @property
    @pulumi.getter(name="maxFileSize")
    def max_file_size(self) -> int:
        return pulumi.get(self, "max_file_size")

    @property
    @pulumi.getter(name="memberCheck")
    def member_check(self) -> bool:
        return pulumi.get(self, "member_check")

    @property
    @pulumi.getter(name="preventSecrets")
    def prevent_secrets(self) -> bool:
        return pulumi.get(self, "prevent_secrets")

    @property
    @pulumi.getter(name="rejectUnsignedCommits")
    def reject_unsigned_commits(self) -> bool:
        return pulumi.get(self, "reject_unsigned_commits")


@pulumi.output_type
class GetProjectTagCommitResult(dict):
    def __init__(__self__, *,
                 author_email: str,
                 author_name: str,
                 authored_date: str,
                 committed_date: str,
                 committer_email: str,
                 committer_name: str,
                 id: str,
                 message: str,
                 parent_ids: Sequence[str],
                 short_id: str,
                 title: str):
        GetProjectTagCommitResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            author_email=author_email,
            author_name=author_name,
            authored_date=authored_date,
            committed_date=committed_date,
            committer_email=committer_email,
            committer_name=committer_name,
            id=id,
            message=message,
            parent_ids=parent_ids,
            short_id=short_id,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             author_email: str,
             author_name: str,
             authored_date: str,
             committed_date: str,
             committer_email: str,
             committer_name: str,
             id: str,
             message: str,
             parent_ids: Sequence[str],
             short_id: str,
             title: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("author_email", author_email)
        _setter("author_name", author_name)
        _setter("authored_date", authored_date)
        _setter("committed_date", committed_date)
        _setter("committer_email", committer_email)
        _setter("committer_name", committer_name)
        _setter("id", id)
        _setter("message", message)
        _setter("parent_ids", parent_ids)
        _setter("short_id", short_id)
        _setter("title", title)

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="parentIds")
    def parent_ids(self) -> Sequence[str]:
        return pulumi.get(self, "parent_ids")

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

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


@pulumi.output_type
class GetProjectTagReleaseResult(dict):
    def __init__(__self__, *,
                 description: str,
                 tag_name: str):
        GetProjectTagReleaseResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            description=description,
            tag_name=tag_name,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             description: str,
             tag_name: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("description", description)
        _setter("tag_name", tag_name)

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

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


@pulumi.output_type
class GetProjectTagsTagResult(dict):
    def __init__(__self__, *,
                 commits: Sequence['outputs.GetProjectTagsTagCommitResult'],
                 message: str,
                 name: str,
                 protected: bool,
                 releases: Sequence['outputs.GetProjectTagsTagReleaseResult'],
                 target: str):
        GetProjectTagsTagResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            commits=commits,
            message=message,
            name=name,
            protected=protected,
            releases=releases,
            target=target,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             commits: Sequence['outputs.GetProjectTagsTagCommitResult'],
             message: str,
             name: str,
             protected: bool,
             releases: Sequence['outputs.GetProjectTagsTagReleaseResult'],
             target: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("commits", commits)
        _setter("message", message)
        _setter("name", name)
        _setter("protected", protected)
        _setter("releases", releases)
        _setter("target", target)

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

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

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

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

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

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


@pulumi.output_type
class GetProjectTagsTagCommitResult(dict):
    def __init__(__self__, *,
                 author_email: str,
                 author_name: str,
                 authored_date: str,
                 committed_date: str,
                 committer_email: str,
                 committer_name: str,
                 id: str,
                 message: str,
                 parent_ids: Sequence[str],
                 short_id: str,
                 title: str):
        GetProjectTagsTagCommitResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            author_email=author_email,
            author_name=author_name,
            authored_date=authored_date,
            committed_date=committed_date,
            committer_email=committer_email,
            committer_name=committer_name,
            id=id,
            message=message,
            parent_ids=parent_ids,
            short_id=short_id,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             author_email: str,
             author_name: str,
             authored_date: str,
             committed_date: str,
             committer_email: str,
             committer_name: str,
             id: str,
             message: str,
             parent_ids: Sequence[str],
             short_id: str,
             title: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("author_email", author_email)
        _setter("author_name", author_name)
        _setter("authored_date", authored_date)
        _setter("committed_date", committed_date)
        _setter("committer_email", committer_email)
        _setter("committer_name", committer_name)
        _setter("id", id)
        _setter("message", message)
        _setter("parent_ids", parent_ids)
        _setter("short_id", short_id)
        _setter("title", title)

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="parentIds")
    def parent_ids(self) -> Sequence[str]:
        return pulumi.get(self, "parent_ids")

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

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


@pulumi.output_type
class GetProjectTagsTagReleaseResult(dict):
    def __init__(__self__, *,
                 description: str,
                 tag_name: str):
        GetProjectTagsTagReleaseResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            description=description,
            tag_name=tag_name,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             description: str,
             tag_name: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("description", description)
        _setter("tag_name", tag_name)

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

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


@pulumi.output_type
class GetProjectVariablesVariableResult(dict):
    def __init__(__self__, *,
                 environment_scope: str,
                 key: str,
                 masked: bool,
                 project: str,
                 protected: bool,
                 raw: bool,
                 value: str,
                 variable_type: str):
        GetProjectVariablesVariableResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            environment_scope=environment_scope,
            key=key,
            masked=masked,
            project=project,
            protected=protected,
            raw=raw,
            value=value,
            variable_type=variable_type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             environment_scope: str,
             key: str,
             masked: bool,
             project: str,
             protected: bool,
             raw: bool,
             value: str,
             variable_type: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("environment_scope", environment_scope)
        _setter("key", key)
        _setter("masked", masked)
        _setter("project", project)
        _setter("protected", protected)
        _setter("raw", raw)
        _setter("value", value)
        _setter("variable_type", variable_type)

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetProjectsProjectResult(dict):
    def __init__(__self__, *,
                 _links: Mapping[str, str],
                 allow_merge_on_skipped_pipeline: bool,
                 analytics_access_level: str,
                 approvals_before_merge: int,
                 archived: bool,
                 auto_cancel_pending_pipelines: str,
                 auto_devops_deploy_strategy: str,
                 auto_devops_enabled: bool,
                 autoclose_referenced_issues: bool,
                 avatar_url: str,
                 build_coverage_regex: str,
                 build_git_strategy: str,
                 build_timeout: int,
                 builds_access_level: str,
                 ci_config_path: str,
                 ci_default_git_depth: int,
                 ci_forward_deployment_enabled: bool,
                 container_expiration_policies: Sequence['outputs.GetProjectsProjectContainerExpirationPolicyResult'],
                 container_registry_access_level: str,
                 container_registry_enabled: bool,
                 created_at: str,
                 creator_id: int,
                 custom_attributes: Sequence[Mapping[str, str]],
                 default_branch: str,
                 description: str,
                 emails_disabled: bool,
                 environments_access_level: str,
                 external_authorization_classification_label: str,
                 feature_flags_access_level: str,
                 forked_from_projects: Sequence['outputs.GetProjectsProjectForkedFromProjectResult'],
                 forking_access_level: str,
                 forks_count: int,
                 http_url_to_repo: str,
                 id: int,
                 import_error: str,
                 import_status: str,
                 import_url: str,
                 infrastructure_access_level: str,
                 issues_access_level: str,
                 issues_enabled: bool,
                 jobs_enabled: bool,
                 keep_latest_artifact: bool,
                 last_activity_at: str,
                 lfs_enabled: bool,
                 merge_commit_template: str,
                 merge_method: str,
                 merge_pipelines_enabled: bool,
                 merge_requests_access_level: str,
                 merge_requests_enabled: bool,
                 merge_trains_enabled: bool,
                 mirror: bool,
                 mirror_overwrites_diverged_branches: bool,
                 mirror_trigger_builds: bool,
                 mirror_user_id: int,
                 monitor_access_level: str,
                 name: str,
                 name_with_namespace: str,
                 namespaces: Sequence['outputs.GetProjectsProjectNamespaceResult'],
                 only_allow_merge_if_all_discussions_are_resolved: bool,
                 only_allow_merge_if_pipeline_succeeds: bool,
                 only_mirror_protected_branches: bool,
                 open_issues_count: int,
                 owners: Sequence['outputs.GetProjectsProjectOwnerResult'],
                 packages_enabled: bool,
                 path: str,
                 path_with_namespace: str,
                 permissions: Sequence['outputs.GetProjectsProjectPermissionResult'],
                 public: bool,
                 public_builds: bool,
                 readme_url: str,
                 releases_access_level: str,
                 repository_access_level: str,
                 repository_storage: str,
                 request_access_enabled: bool,
                 requirements_access_level: str,
                 resolve_outdated_diff_discussions: bool,
                 restrict_user_defined_variables: bool,
                 runners_token: str,
                 security_and_compliance_access_level: str,
                 shared_runners_enabled: bool,
                 shared_with_groups: Sequence['outputs.GetProjectsProjectSharedWithGroupResult'],
                 snippets_access_level: str,
                 snippets_enabled: bool,
                 squash_commit_template: str,
                 ssh_url_to_repo: str,
                 star_count: int,
                 statistics: Mapping[str, int],
                 suggestion_commit_message: str,
                 tag_lists: Sequence[str],
                 topics: Sequence[str],
                 visibility: str,
                 web_url: str,
                 wiki_access_level: str,
                 wiki_enabled: bool):
        GetProjectsProjectResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            _links=_links,
            allow_merge_on_skipped_pipeline=allow_merge_on_skipped_pipeline,
            analytics_access_level=analytics_access_level,
            approvals_before_merge=approvals_before_merge,
            archived=archived,
            auto_cancel_pending_pipelines=auto_cancel_pending_pipelines,
            auto_devops_deploy_strategy=auto_devops_deploy_strategy,
            auto_devops_enabled=auto_devops_enabled,
            autoclose_referenced_issues=autoclose_referenced_issues,
            avatar_url=avatar_url,
            build_coverage_regex=build_coverage_regex,
            build_git_strategy=build_git_strategy,
            build_timeout=build_timeout,
            builds_access_level=builds_access_level,
            ci_config_path=ci_config_path,
            ci_default_git_depth=ci_default_git_depth,
            ci_forward_deployment_enabled=ci_forward_deployment_enabled,
            container_expiration_policies=container_expiration_policies,
            container_registry_access_level=container_registry_access_level,
            container_registry_enabled=container_registry_enabled,
            created_at=created_at,
            creator_id=creator_id,
            custom_attributes=custom_attributes,
            default_branch=default_branch,
            description=description,
            emails_disabled=emails_disabled,
            environments_access_level=environments_access_level,
            external_authorization_classification_label=external_authorization_classification_label,
            feature_flags_access_level=feature_flags_access_level,
            forked_from_projects=forked_from_projects,
            forking_access_level=forking_access_level,
            forks_count=forks_count,
            http_url_to_repo=http_url_to_repo,
            id=id,
            import_error=import_error,
            import_status=import_status,
            import_url=import_url,
            infrastructure_access_level=infrastructure_access_level,
            issues_access_level=issues_access_level,
            issues_enabled=issues_enabled,
            jobs_enabled=jobs_enabled,
            keep_latest_artifact=keep_latest_artifact,
            last_activity_at=last_activity_at,
            lfs_enabled=lfs_enabled,
            merge_commit_template=merge_commit_template,
            merge_method=merge_method,
            merge_pipelines_enabled=merge_pipelines_enabled,
            merge_requests_access_level=merge_requests_access_level,
            merge_requests_enabled=merge_requests_enabled,
            merge_trains_enabled=merge_trains_enabled,
            mirror=mirror,
            mirror_overwrites_diverged_branches=mirror_overwrites_diverged_branches,
            mirror_trigger_builds=mirror_trigger_builds,
            mirror_user_id=mirror_user_id,
            monitor_access_level=monitor_access_level,
            name=name,
            name_with_namespace=name_with_namespace,
            namespaces=namespaces,
            only_allow_merge_if_all_discussions_are_resolved=only_allow_merge_if_all_discussions_are_resolved,
            only_allow_merge_if_pipeline_succeeds=only_allow_merge_if_pipeline_succeeds,
            only_mirror_protected_branches=only_mirror_protected_branches,
            open_issues_count=open_issues_count,
            owners=owners,
            packages_enabled=packages_enabled,
            path=path,
            path_with_namespace=path_with_namespace,
            permissions=permissions,
            public=public,
            public_builds=public_builds,
            readme_url=readme_url,
            releases_access_level=releases_access_level,
            repository_access_level=repository_access_level,
            repository_storage=repository_storage,
            request_access_enabled=request_access_enabled,
            requirements_access_level=requirements_access_level,
            resolve_outdated_diff_discussions=resolve_outdated_diff_discussions,
            restrict_user_defined_variables=restrict_user_defined_variables,
            runners_token=runners_token,
            security_and_compliance_access_level=security_and_compliance_access_level,
            shared_runners_enabled=shared_runners_enabled,
            shared_with_groups=shared_with_groups,
            snippets_access_level=snippets_access_level,
            snippets_enabled=snippets_enabled,
            squash_commit_template=squash_commit_template,
            ssh_url_to_repo=ssh_url_to_repo,
            star_count=star_count,
            statistics=statistics,
            suggestion_commit_message=suggestion_commit_message,
            tag_lists=tag_lists,
            topics=topics,
            visibility=visibility,
            web_url=web_url,
            wiki_access_level=wiki_access_level,
            wiki_enabled=wiki_enabled,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             _links: Mapping[str, str],
             allow_merge_on_skipped_pipeline: bool,
             analytics_access_level: str,
             approvals_before_merge: int,
             archived: bool,
             auto_cancel_pending_pipelines: str,
             auto_devops_deploy_strategy: str,
             auto_devops_enabled: bool,
             autoclose_referenced_issues: bool,
             avatar_url: str,
             build_coverage_regex: str,
             build_git_strategy: str,
             build_timeout: int,
             builds_access_level: str,
             ci_config_path: str,
             ci_default_git_depth: int,
             ci_forward_deployment_enabled: bool,
             container_expiration_policies: Sequence['outputs.GetProjectsProjectContainerExpirationPolicyResult'],
             container_registry_access_level: str,
             container_registry_enabled: bool,
             created_at: str,
             creator_id: int,
             custom_attributes: Sequence[Mapping[str, str]],
             default_branch: str,
             description: str,
             emails_disabled: bool,
             environments_access_level: str,
             external_authorization_classification_label: str,
             feature_flags_access_level: str,
             forked_from_projects: Sequence['outputs.GetProjectsProjectForkedFromProjectResult'],
             forking_access_level: str,
             forks_count: int,
             http_url_to_repo: str,
             id: int,
             import_error: str,
             import_status: str,
             import_url: str,
             infrastructure_access_level: str,
             issues_access_level: str,
             issues_enabled: bool,
             jobs_enabled: bool,
             keep_latest_artifact: bool,
             last_activity_at: str,
             lfs_enabled: bool,
             merge_commit_template: str,
             merge_method: str,
             merge_pipelines_enabled: bool,
             merge_requests_access_level: str,
             merge_requests_enabled: bool,
             merge_trains_enabled: bool,
             mirror: bool,
             mirror_overwrites_diverged_branches: bool,
             mirror_trigger_builds: bool,
             mirror_user_id: int,
             monitor_access_level: str,
             name: str,
             name_with_namespace: str,
             namespaces: Sequence['outputs.GetProjectsProjectNamespaceResult'],
             only_allow_merge_if_all_discussions_are_resolved: bool,
             only_allow_merge_if_pipeline_succeeds: bool,
             only_mirror_protected_branches: bool,
             open_issues_count: int,
             owners: Sequence['outputs.GetProjectsProjectOwnerResult'],
             packages_enabled: bool,
             path: str,
             path_with_namespace: str,
             permissions: Sequence['outputs.GetProjectsProjectPermissionResult'],
             public: bool,
             public_builds: bool,
             readme_url: str,
             releases_access_level: str,
             repository_access_level: str,
             repository_storage: str,
             request_access_enabled: bool,
             requirements_access_level: str,
             resolve_outdated_diff_discussions: bool,
             restrict_user_defined_variables: bool,
             runners_token: str,
             security_and_compliance_access_level: str,
             shared_runners_enabled: bool,
             shared_with_groups: Sequence['outputs.GetProjectsProjectSharedWithGroupResult'],
             snippets_access_level: str,
             snippets_enabled: bool,
             squash_commit_template: str,
             ssh_url_to_repo: str,
             star_count: int,
             statistics: Mapping[str, int],
             suggestion_commit_message: str,
             tag_lists: Sequence[str],
             topics: Sequence[str],
             visibility: str,
             web_url: str,
             wiki_access_level: str,
             wiki_enabled: bool,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("_links", _links)
        _setter("allow_merge_on_skipped_pipeline", allow_merge_on_skipped_pipeline)
        _setter("analytics_access_level", analytics_access_level)
        _setter("approvals_before_merge", approvals_before_merge)
        _setter("archived", archived)
        _setter("auto_cancel_pending_pipelines", auto_cancel_pending_pipelines)
        _setter("auto_devops_deploy_strategy", auto_devops_deploy_strategy)
        _setter("auto_devops_enabled", auto_devops_enabled)
        _setter("autoclose_referenced_issues", autoclose_referenced_issues)
        _setter("avatar_url", avatar_url)
        _setter("build_coverage_regex", build_coverage_regex)
        _setter("build_git_strategy", build_git_strategy)
        _setter("build_timeout", build_timeout)
        _setter("builds_access_level", builds_access_level)
        _setter("ci_config_path", ci_config_path)
        _setter("ci_default_git_depth", ci_default_git_depth)
        _setter("ci_forward_deployment_enabled", ci_forward_deployment_enabled)
        _setter("container_expiration_policies", container_expiration_policies)
        _setter("container_registry_access_level", container_registry_access_level)
        _setter("container_registry_enabled", container_registry_enabled)
        _setter("created_at", created_at)
        _setter("creator_id", creator_id)
        _setter("custom_attributes", custom_attributes)
        _setter("default_branch", default_branch)
        _setter("description", description)
        _setter("emails_disabled", emails_disabled)
        _setter("environments_access_level", environments_access_level)
        _setter("external_authorization_classification_label", external_authorization_classification_label)
        _setter("feature_flags_access_level", feature_flags_access_level)
        _setter("forked_from_projects", forked_from_projects)
        _setter("forking_access_level", forking_access_level)
        _setter("forks_count", forks_count)
        _setter("http_url_to_repo", http_url_to_repo)
        _setter("id", id)
        _setter("import_error", import_error)
        _setter("import_status", import_status)
        _setter("import_url", import_url)
        _setter("infrastructure_access_level", infrastructure_access_level)
        _setter("issues_access_level", issues_access_level)
        _setter("issues_enabled", issues_enabled)
        _setter("jobs_enabled", jobs_enabled)
        _setter("keep_latest_artifact", keep_latest_artifact)
        _setter("last_activity_at", last_activity_at)
        _setter("lfs_enabled", lfs_enabled)
        _setter("merge_commit_template", merge_commit_template)
        _setter("merge_method", merge_method)
        _setter("merge_pipelines_enabled", merge_pipelines_enabled)
        _setter("merge_requests_access_level", merge_requests_access_level)
        _setter("merge_requests_enabled", merge_requests_enabled)
        _setter("merge_trains_enabled", merge_trains_enabled)
        _setter("mirror", mirror)
        _setter("mirror_overwrites_diverged_branches", mirror_overwrites_diverged_branches)
        _setter("mirror_trigger_builds", mirror_trigger_builds)
        _setter("mirror_user_id", mirror_user_id)
        _setter("monitor_access_level", monitor_access_level)
        _setter("name", name)
        _setter("name_with_namespace", name_with_namespace)
        _setter("namespaces", namespaces)
        _setter("only_allow_merge_if_all_discussions_are_resolved", only_allow_merge_if_all_discussions_are_resolved)
        _setter("only_allow_merge_if_pipeline_succeeds", only_allow_merge_if_pipeline_succeeds)
        _setter("only_mirror_protected_branches", only_mirror_protected_branches)
        _setter("open_issues_count", open_issues_count)
        _setter("owners", owners)
        _setter("packages_enabled", packages_enabled)
        _setter("path", path)
        _setter("path_with_namespace", path_with_namespace)
        _setter("permissions", permissions)
        _setter("public", public)
        _setter("public_builds", public_builds)
        _setter("readme_url", readme_url)
        _setter("releases_access_level", releases_access_level)
        _setter("repository_access_level", repository_access_level)
        _setter("repository_storage", repository_storage)
        _setter("request_access_enabled", request_access_enabled)
        _setter("requirements_access_level", requirements_access_level)
        _setter("resolve_outdated_diff_discussions", resolve_outdated_diff_discussions)
        _setter("restrict_user_defined_variables", restrict_user_defined_variables)
        _setter("runners_token", runners_token)
        _setter("security_and_compliance_access_level", security_and_compliance_access_level)
        _setter("shared_runners_enabled", shared_runners_enabled)
        _setter("shared_with_groups", shared_with_groups)
        _setter("snippets_access_level", snippets_access_level)
        _setter("snippets_enabled", snippets_enabled)
        _setter("squash_commit_template", squash_commit_template)
        _setter("ssh_url_to_repo", ssh_url_to_repo)
        _setter("star_count", star_count)
        _setter("statistics", statistics)
        _setter("suggestion_commit_message", suggestion_commit_message)
        _setter("tag_lists", tag_lists)
        _setter("topics", topics)
        _setter("visibility", visibility)
        _setter("web_url", web_url)
        _setter("wiki_access_level", wiki_access_level)
        _setter("wiki_enabled", wiki_enabled)

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

    @property
    @pulumi.getter(name="allowMergeOnSkippedPipeline")
    def allow_merge_on_skipped_pipeline(self) -> bool:
        return pulumi.get(self, "allow_merge_on_skipped_pipeline")

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

    @property
    @pulumi.getter(name="approvalsBeforeMerge")
    def approvals_before_merge(self) -> int:
        return pulumi.get(self, "approvals_before_merge")

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

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

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

    @property
    @pulumi.getter(name="autoDevopsEnabled")
    def auto_devops_enabled(self) -> bool:
        return pulumi.get(self, "auto_devops_enabled")

    @property
    @pulumi.getter(name="autocloseReferencedIssues")
    def autoclose_referenced_issues(self) -> bool:
        return pulumi.get(self, "autoclose_referenced_issues")

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

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

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

    @property
    @pulumi.getter(name="buildTimeout")
    def build_timeout(self) -> int:
        return pulumi.get(self, "build_timeout")

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

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

    @property
    @pulumi.getter(name="ciDefaultGitDepth")
    def ci_default_git_depth(self) -> int:
        return pulumi.get(self, "ci_default_git_depth")

    @property
    @pulumi.getter(name="ciForwardDeploymentEnabled")
    def ci_forward_deployment_enabled(self) -> bool:
        return pulumi.get(self, "ci_forward_deployment_enabled")

    @property
    @pulumi.getter(name="containerExpirationPolicies")
    def container_expiration_policies(self) -> Sequence['outputs.GetProjectsProjectContainerExpirationPolicyResult']:
        return pulumi.get(self, "container_expiration_policies")

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

    @property
    @pulumi.getter(name="containerRegistryEnabled")
    def container_registry_enabled(self) -> bool:
        return pulumi.get(self, "container_registry_enabled")

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

    @property
    @pulumi.getter(name="creatorId")
    def creator_id(self) -> int:
        return pulumi.get(self, "creator_id")

    @property
    @pulumi.getter(name="customAttributes")
    def custom_attributes(self) -> Sequence[Mapping[str, str]]:
        return pulumi.get(self, "custom_attributes")

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

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

    @property
    @pulumi.getter(name="emailsDisabled")
    def emails_disabled(self) -> bool:
        return pulumi.get(self, "emails_disabled")

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

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

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

    @property
    @pulumi.getter(name="forkedFromProjects")
    def forked_from_projects(self) -> Sequence['outputs.GetProjectsProjectForkedFromProjectResult']:
        return pulumi.get(self, "forked_from_projects")

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

    @property
    @pulumi.getter(name="forksCount")
    def forks_count(self) -> int:
        return pulumi.get(self, "forks_count")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="issuesEnabled")
    def issues_enabled(self) -> bool:
        return pulumi.get(self, "issues_enabled")

    @property
    @pulumi.getter(name="jobsEnabled")
    def jobs_enabled(self) -> bool:
        return pulumi.get(self, "jobs_enabled")

    @property
    @pulumi.getter(name="keepLatestArtifact")
    def keep_latest_artifact(self) -> bool:
        return pulumi.get(self, "keep_latest_artifact")

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

    @property
    @pulumi.getter(name="lfsEnabled")
    def lfs_enabled(self) -> bool:
        return pulumi.get(self, "lfs_enabled")

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

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

    @property
    @pulumi.getter(name="mergePipelinesEnabled")
    def merge_pipelines_enabled(self) -> bool:
        return pulumi.get(self, "merge_pipelines_enabled")

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

    @property
    @pulumi.getter(name="mergeRequestsEnabled")
    def merge_requests_enabled(self) -> bool:
        return pulumi.get(self, "merge_requests_enabled")

    @property
    @pulumi.getter(name="mergeTrainsEnabled")
    def merge_trains_enabled(self) -> bool:
        return pulumi.get(self, "merge_trains_enabled")

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

    @property
    @pulumi.getter(name="mirrorOverwritesDivergedBranches")
    def mirror_overwrites_diverged_branches(self) -> bool:
        return pulumi.get(self, "mirror_overwrites_diverged_branches")

    @property
    @pulumi.getter(name="mirrorTriggerBuilds")
    def mirror_trigger_builds(self) -> bool:
        return pulumi.get(self, "mirror_trigger_builds")

    @property
    @pulumi.getter(name="mirrorUserId")
    def mirror_user_id(self) -> int:
        return pulumi.get(self, "mirror_user_id")

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

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

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

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

    @property
    @pulumi.getter(name="onlyAllowMergeIfAllDiscussionsAreResolved")
    def only_allow_merge_if_all_discussions_are_resolved(self) -> bool:
        return pulumi.get(self, "only_allow_merge_if_all_discussions_are_resolved")

    @property
    @pulumi.getter(name="onlyAllowMergeIfPipelineSucceeds")
    def only_allow_merge_if_pipeline_succeeds(self) -> bool:
        return pulumi.get(self, "only_allow_merge_if_pipeline_succeeds")

    @property
    @pulumi.getter(name="onlyMirrorProtectedBranches")
    def only_mirror_protected_branches(self) -> bool:
        return pulumi.get(self, "only_mirror_protected_branches")

    @property
    @pulumi.getter(name="openIssuesCount")
    def open_issues_count(self) -> int:
        return pulumi.get(self, "open_issues_count")

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

    @property
    @pulumi.getter(name="packagesEnabled")
    def packages_enabled(self) -> bool:
        return pulumi.get(self, "packages_enabled")

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

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

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

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

    @property
    @pulumi.getter(name="publicBuilds")
    def public_builds(self) -> bool:
        return pulumi.get(self, "public_builds")

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

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

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

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

    @property
    @pulumi.getter(name="requestAccessEnabled")
    def request_access_enabled(self) -> bool:
        return pulumi.get(self, "request_access_enabled")

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

    @property
    @pulumi.getter(name="resolveOutdatedDiffDiscussions")
    def resolve_outdated_diff_discussions(self) -> bool:
        return pulumi.get(self, "resolve_outdated_diff_discussions")

    @property
    @pulumi.getter(name="restrictUserDefinedVariables")
    def restrict_user_defined_variables(self) -> bool:
        return pulumi.get(self, "restrict_user_defined_variables")

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

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

    @property
    @pulumi.getter(name="sharedRunnersEnabled")
    def shared_runners_enabled(self) -> bool:
        return pulumi.get(self, "shared_runners_enabled")

    @property
    @pulumi.getter(name="sharedWithGroups")
    def shared_with_groups(self) -> Sequence['outputs.GetProjectsProjectSharedWithGroupResult']:
        return pulumi.get(self, "shared_with_groups")

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

    @property
    @pulumi.getter(name="snippetsEnabled")
    def snippets_enabled(self) -> bool:
        return pulumi.get(self, "snippets_enabled")

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

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

    @property
    @pulumi.getter(name="starCount")
    def star_count(self) -> int:
        return pulumi.get(self, "star_count")

    @property
    @pulumi.getter
    def statistics(self) -> Mapping[str, int]:
        return pulumi.get(self, "statistics")

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

    @property
    @pulumi.getter(name="tagLists")
    def tag_lists(self) -> Sequence[str]:
        return pulumi.get(self, "tag_lists")

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

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

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

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

    @property
    @pulumi.getter(name="wikiEnabled")
    def wiki_enabled(self) -> bool:
        return pulumi.get(self, "wiki_enabled")


@pulumi.output_type
class GetProjectsProjectContainerExpirationPolicyResult(dict):
    def __init__(__self__, *,
                 cadence: str,
                 enabled: bool,
                 keep_n: int,
                 name_regex: str,
                 name_regex_delete: str,
                 name_regex_keep: str,
                 next_run_at: str,
                 older_than: str):
        GetProjectsProjectContainerExpirationPolicyResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            cadence=cadence,
            enabled=enabled,
            keep_n=keep_n,
            name_regex=name_regex,
            name_regex_delete=name_regex_delete,
            name_regex_keep=name_regex_keep,
            next_run_at=next_run_at,
            older_than=older_than,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             cadence: str,
             enabled: bool,
             keep_n: int,
             name_regex: str,
             name_regex_delete: str,
             name_regex_keep: str,
             next_run_at: str,
             older_than: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("cadence", cadence)
        _setter("enabled", enabled)
        _setter("keep_n", keep_n)
        _setter("name_regex", name_regex)
        _setter("name_regex_delete", name_regex_delete)
        _setter("name_regex_keep", name_regex_keep)
        _setter("next_run_at", next_run_at)
        _setter("older_than", older_than)

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

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

    @property
    @pulumi.getter(name="keepN")
    def keep_n(self) -> int:
        return pulumi.get(self, "keep_n")

    @property
    @pulumi.getter(name="nameRegex")
    def name_regex(self) -> str:
        warnings.warn("""`name_regex` has been deprecated. Use `name_regex_delete` instead.""", DeprecationWarning)
        pulumi.log.warn("""name_regex is deprecated: `name_regex` has been deprecated. Use `name_regex_delete` instead.""")

        return pulumi.get(self, "name_regex")

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

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

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

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


@pulumi.output_type
class GetProjectsProjectForkedFromProjectResult(dict):
    def __init__(__self__, *,
                 http_url_to_repo: str,
                 id: int,
                 name: str,
                 name_with_namespace: str,
                 path: str,
                 path_with_namespace: str,
                 web_url: str):
        GetProjectsProjectForkedFromProjectResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            http_url_to_repo=http_url_to_repo,
            id=id,
            name=name,
            name_with_namespace=name_with_namespace,
            path=path,
            path_with_namespace=path_with_namespace,
            web_url=web_url,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             http_url_to_repo: str,
             id: int,
             name: str,
             name_with_namespace: str,
             path: str,
             path_with_namespace: str,
             web_url: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("http_url_to_repo", http_url_to_repo)
        _setter("id", id)
        _setter("name", name)
        _setter("name_with_namespace", name_with_namespace)
        _setter("path", path)
        _setter("path_with_namespace", path_with_namespace)
        _setter("web_url", web_url)

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

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

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

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

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

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

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


@pulumi.output_type
class GetProjectsProjectNamespaceResult(dict):
    def __init__(__self__, *,
                 full_path: str,
                 id: int,
                 kind: str,
                 name: str,
                 path: str):
        GetProjectsProjectNamespaceResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            full_path=full_path,
            id=id,
            kind=kind,
            name=name,
            path=path,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             full_path: str,
             id: int,
             kind: str,
             name: str,
             path: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("full_path", full_path)
        _setter("id", id)
        _setter("kind", kind)
        _setter("name", name)
        _setter("path", path)

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

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

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

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

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


@pulumi.output_type
class GetProjectsProjectOwnerResult(dict):
    def __init__(__self__, *,
                 avatar_url: str,
                 id: int,
                 name: str,
                 state: str,
                 username: str,
                 website_url: str):
        GetProjectsProjectOwnerResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            avatar_url=avatar_url,
            id=id,
            name=name,
            state=state,
            username=username,
            website_url=website_url,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             avatar_url: str,
             id: int,
             name: str,
             state: str,
             username: str,
             website_url: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("avatar_url", avatar_url)
        _setter("id", id)
        _setter("name", name)
        _setter("state", state)
        _setter("username", username)
        _setter("website_url", website_url)

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

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

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

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

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

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


@pulumi.output_type
class GetProjectsProjectPermissionResult(dict):
    def __init__(__self__, *,
                 group_access: Mapping[str, int],
                 project_access: Mapping[str, int]):
        GetProjectsProjectPermissionResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            group_access=group_access,
            project_access=project_access,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             group_access: Mapping[str, int],
             project_access: Mapping[str, int],
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("group_access", group_access)
        _setter("project_access", project_access)

    @property
    @pulumi.getter(name="groupAccess")
    def group_access(self) -> Mapping[str, int]:
        return pulumi.get(self, "group_access")

    @property
    @pulumi.getter(name="projectAccess")
    def project_access(self) -> Mapping[str, int]:
        return pulumi.get(self, "project_access")


@pulumi.output_type
class GetProjectsProjectSharedWithGroupResult(dict):
    def __init__(__self__, *,
                 group_access_level: str,
                 group_id: int,
                 group_name: str):
        GetProjectsProjectSharedWithGroupResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            group_access_level=group_access_level,
            group_id=group_id,
            group_name=group_name,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             group_access_level: str,
             group_id: int,
             group_name: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("group_access_level", group_access_level)
        _setter("group_id", group_id)
        _setter("group_name", group_name)

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

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> int:
        return pulumi.get(self, "group_id")

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


@pulumi.output_type
class GetReleaseLinksReleaseLinkResult(dict):
    def __init__(__self__, *,
                 direct_asset_url: str,
                 external: bool,
                 filepath: str,
                 link_id: int,
                 link_type: str,
                 name: str,
                 project: str,
                 tag_name: str,
                 url: str):
        GetReleaseLinksReleaseLinkResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            direct_asset_url=direct_asset_url,
            external=external,
            filepath=filepath,
            link_id=link_id,
            link_type=link_type,
            name=name,
            project=project,
            tag_name=tag_name,
            url=url,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             direct_asset_url: str,
             external: bool,
             filepath: str,
             link_id: int,
             link_type: str,
             name: str,
             project: str,
             tag_name: str,
             url: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("direct_asset_url", direct_asset_url)
        _setter("external", external)
        _setter("filepath", filepath)
        _setter("link_id", link_id)
        _setter("link_type", link_type)
        _setter("name", name)
        _setter("project", project)
        _setter("tag_name", tag_name)
        _setter("url", url)

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

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

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

    @property
    @pulumi.getter(name="linkId")
    def link_id(self) -> int:
        return pulumi.get(self, "link_id")

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

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

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

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

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


@pulumi.output_type
class GetRepositoryTreeTreeResult(dict):
    def __init__(__self__, *,
                 id: str,
                 mode: str,
                 name: str,
                 path: str,
                 type: str):
        GetRepositoryTreeTreeResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            id=id,
            mode=mode,
            name=name,
            path=path,
            type=type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             id: str,
             mode: str,
             name: str,
             path: str,
             type: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("id", id)
        _setter("mode", mode)
        _setter("name", name)
        _setter("path", path)
        _setter("type", type)

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

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

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

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

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


@pulumi.output_type
class GetUserSshkeysKeyResult(dict):
    def __init__(__self__, *,
                 created_at: str,
                 expires_at: str,
                 key: str,
                 key_id: int,
                 title: str,
                 user_id: int):
        GetUserSshkeysKeyResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            created_at=created_at,
            expires_at=expires_at,
            key=key,
            key_id=key_id,
            title=title,
            user_id=user_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             created_at: str,
             expires_at: str,
             key: str,
             key_id: int,
             title: str,
             user_id: int,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("created_at", created_at)
        _setter("expires_at", expires_at)
        _setter("key", key)
        _setter("key_id", key_id)
        _setter("title", title)
        _setter("user_id", user_id)

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

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

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

    @property
    @pulumi.getter(name="keyId")
    def key_id(self) -> int:
        return pulumi.get(self, "key_id")

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

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> int:
        return pulumi.get(self, "user_id")


@pulumi.output_type
class GetUsersUserResult(dict):
    def __init__(__self__, *,
                 avatar_url: str,
                 bio: str,
                 can_create_group: bool,
                 can_create_project: bool,
                 color_scheme_id: int,
                 created_at: str,
                 current_sign_in_at: str,
                 email: str,
                 extern_uid: str,
                 external: bool,
                 id: int,
                 is_admin: bool,
                 last_sign_in_at: str,
                 linkedin: str,
                 location: str,
                 name: str,
                 namespace_id: int,
                 organization: str,
                 projects_limit: int,
                 provider: str,
                 skype: str,
                 state: str,
                 theme_id: int,
                 twitter: str,
                 two_factor_enabled: bool,
                 username: str,
                 website_url: str):
        GetUsersUserResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            avatar_url=avatar_url,
            bio=bio,
            can_create_group=can_create_group,
            can_create_project=can_create_project,
            color_scheme_id=color_scheme_id,
            created_at=created_at,
            current_sign_in_at=current_sign_in_at,
            email=email,
            extern_uid=extern_uid,
            external=external,
            id=id,
            is_admin=is_admin,
            last_sign_in_at=last_sign_in_at,
            linkedin=linkedin,
            location=location,
            name=name,
            namespace_id=namespace_id,
            organization=organization,
            projects_limit=projects_limit,
            provider=provider,
            skype=skype,
            state=state,
            theme_id=theme_id,
            twitter=twitter,
            two_factor_enabled=two_factor_enabled,
            username=username,
            website_url=website_url,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             avatar_url: str,
             bio: str,
             can_create_group: bool,
             can_create_project: bool,
             color_scheme_id: int,
             created_at: str,
             current_sign_in_at: str,
             email: str,
             extern_uid: str,
             external: bool,
             id: int,
             is_admin: bool,
             last_sign_in_at: str,
             linkedin: str,
             location: str,
             name: str,
             namespace_id: int,
             organization: str,
             projects_limit: int,
             provider: str,
             skype: str,
             state: str,
             theme_id: int,
             twitter: str,
             two_factor_enabled: bool,
             username: str,
             website_url: str,
             opts: Optional[pulumi.ResourceOptions]=None):
        _setter("avatar_url", avatar_url)
        _setter("bio", bio)
        _setter("can_create_group", can_create_group)
        _setter("can_create_project", can_create_project)
        _setter("color_scheme_id", color_scheme_id)
        _setter("created_at", created_at)
        _setter("current_sign_in_at", current_sign_in_at)
        _setter("email", email)
        _setter("extern_uid", extern_uid)
        _setter("external", external)
        _setter("id", id)
        _setter("is_admin", is_admin)
        _setter("last_sign_in_at", last_sign_in_at)
        _setter("linkedin", linkedin)
        _setter("location", location)
        _setter("name", name)
        _setter("namespace_id", namespace_id)
        _setter("organization", organization)
        _setter("projects_limit", projects_limit)
        _setter("provider", provider)
        _setter("skype", skype)
        _setter("state", state)
        _setter("theme_id", theme_id)
        _setter("twitter", twitter)
        _setter("two_factor_enabled", two_factor_enabled)
        _setter("username", username)
        _setter("website_url", website_url)

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

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

    @property
    @pulumi.getter(name="canCreateGroup")
    def can_create_group(self) -> bool:
        return pulumi.get(self, "can_create_group")

    @property
    @pulumi.getter(name="canCreateProject")
    def can_create_project(self) -> bool:
        return pulumi.get(self, "can_create_project")

    @property
    @pulumi.getter(name="colorSchemeId")
    def color_scheme_id(self) -> int:
        return pulumi.get(self, "color_scheme_id")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="isAdmin")
    def is_admin(self) -> bool:
        return pulumi.get(self, "is_admin")

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

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

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

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

    @property
    @pulumi.getter(name="namespaceId")
    def namespace_id(self) -> int:
        return pulumi.get(self, "namespace_id")

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

    @property
    @pulumi.getter(name="projectsLimit")
    def projects_limit(self) -> int:
        return pulumi.get(self, "projects_limit")

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

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

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

    @property
    @pulumi.getter(name="themeId")
    def theme_id(self) -> int:
        return pulumi.get(self, "theme_id")

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

    @property
    @pulumi.getter(name="twoFactorEnabled")
    def two_factor_enabled(self) -> bool:
        return pulumi.get(self, "two_factor_enabled")

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

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


