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

__all__ = [
    'RepoDomainList',
    'GetEndpointAclPoliciesPolicyResult',
    'GetNamespacesNamespaceResult',
    'GetReposRepoResult',
    'GetReposRepoDomainListResult',
    'GetReposRepoTagResult',
]

@pulumi.output_type
class RepoDomainList(dict):
    def __init__(__self__, *,
                 internal: Optional[str] = None,
                 public: Optional[str] = None,
                 vpc: Optional[str] = None):
        """
        :param str internal: Domain of internal endpoint, only in some regions.
        :param str public: Domain of public endpoint.
        :param str vpc: Domain of vpc endpoint.
        """
        if internal is not None:
            pulumi.set(__self__, "internal", internal)
        if public is not None:
            pulumi.set(__self__, "public", public)
        if vpc is not None:
            pulumi.set(__self__, "vpc", vpc)

    @property
    @pulumi.getter
    def internal(self) -> Optional[str]:
        """
        Domain of internal endpoint, only in some regions.
        """
        return pulumi.get(self, "internal")

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

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


@pulumi.output_type
class GetEndpointAclPoliciesPolicyResult(dict):
    def __init__(__self__, *,
                 description: str,
                 endpoint_type: str,
                 entry: str,
                 id: str,
                 instance_id: str):
        """
        :param str description: The description of the entry.
        :param str endpoint_type: The type of endpoint.
        :param str entry: The IP segment that allowed to access.
        :param str id: The ID of the Endpoint Acl Policy.
        :param str instance_id: The ID of the CR Instance.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "endpoint_type", endpoint_type)
        pulumi.set(__self__, "entry", entry)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "instance_id", instance_id)

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

    @property
    @pulumi.getter(name="endpointType")
    def endpoint_type(self) -> str:
        """
        The type of endpoint.
        """
        return pulumi.get(self, "endpoint_type")

    @property
    @pulumi.getter
    def entry(self) -> str:
        """
        The IP segment that allowed to access.
        """
        return pulumi.get(self, "entry")

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

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> str:
        """
        The ID of the CR Instance.
        """
        return pulumi.get(self, "instance_id")


@pulumi.output_type
class GetNamespacesNamespaceResult(dict):
    def __init__(__self__, *,
                 auto_create: bool,
                 default_visibility: str,
                 name: str):
        """
        :param bool auto_create: Boolean, when it set to true, repositories are automatically created when pushing new images. If it set to false, you create repository for images before pushing.
        :param str default_visibility: `PUBLIC` or `PRIVATE`, default repository visibility in this namespace.
        :param str name: Name of Container Registry namespace.
        """
        pulumi.set(__self__, "auto_create", auto_create)
        pulumi.set(__self__, "default_visibility", default_visibility)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="autoCreate")
    def auto_create(self) -> bool:
        """
        Boolean, when it set to true, repositories are automatically created when pushing new images. If it set to false, you create repository for images before pushing.
        """
        return pulumi.get(self, "auto_create")

    @property
    @pulumi.getter(name="defaultVisibility")
    def default_visibility(self) -> str:
        """
        `PUBLIC` or `PRIVATE`, default repository visibility in this namespace.
        """
        return pulumi.get(self, "default_visibility")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of Container Registry namespace.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetReposRepoResult(dict):
    def __init__(__self__, *,
                 domain_list: 'outputs.GetReposRepoDomainListResult',
                 name: str,
                 namespace: str,
                 repo_type: str,
                 summary: str,
                 tags: Sequence['outputs.GetReposRepoTagResult']):
        """
        :param 'GetReposRepoDomainListArgs' domain_list: The repository domain list.
        :param str name: Name of container registry namespace.
        :param str namespace: Name of container registry namespace where the repositories are located in.
        :param str repo_type: `PUBLIC` or `PRIVATE`, repository's visibility.
        :param str summary: The repository general information.
        :param Sequence['GetReposRepoTagArgs'] tags: A list of image tags belong to this repository. Each contains several attributes, see `Block Tag`.
        """
        pulumi.set(__self__, "domain_list", domain_list)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "repo_type", repo_type)
        pulumi.set(__self__, "summary", summary)
        pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="domainList")
    def domain_list(self) -> 'outputs.GetReposRepoDomainListResult':
        """
        The repository domain list.
        """
        return pulumi.get(self, "domain_list")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of container registry namespace.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def namespace(self) -> str:
        """
        Name of container registry namespace where the repositories are located in.
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter(name="repoType")
    def repo_type(self) -> str:
        """
        `PUBLIC` or `PRIVATE`, repository's visibility.
        """
        return pulumi.get(self, "repo_type")

    @property
    @pulumi.getter
    def summary(self) -> str:
        """
        The repository general information.
        """
        return pulumi.get(self, "summary")

    @property
    @pulumi.getter
    def tags(self) -> Sequence['outputs.GetReposRepoTagResult']:
        """
        A list of image tags belong to this repository. Each contains several attributes, see `Block Tag`.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetReposRepoDomainListResult(dict):
    def __init__(__self__, *,
                 internal: str,
                 public: str,
                 vpc: str):
        """
        :param str internal: Domain of internal endpoint, only in some regions.
        :param str public: Domain of public endpoint.
        :param str vpc: Domain of vpc endpoint.
        """
        pulumi.set(__self__, "internal", internal)
        pulumi.set(__self__, "public", public)
        pulumi.set(__self__, "vpc", vpc)

    @property
    @pulumi.getter
    def internal(self) -> str:
        """
        Domain of internal endpoint, only in some regions.
        """
        return pulumi.get(self, "internal")

    @property
    @pulumi.getter
    def public(self) -> str:
        """
        Domain of public endpoint.
        """
        return pulumi.get(self, "public")

    @property
    @pulumi.getter
    def vpc(self) -> str:
        """
        Domain of vpc endpoint.
        """
        return pulumi.get(self, "vpc")


@pulumi.output_type
class GetReposRepoTagResult(dict):
    def __init__(__self__, *,
                 digest: str,
                 image_create: int,
                 image_id: str,
                 image_size: int,
                 image_update: int,
                 status: str,
                 tag: str):
        """
        :param str digest: Digest of this image.
        :param int image_create: Create time of this image, unix time in nanoseconds.
        :param str image_id: Id of this image.
        :param int image_size: Status of this image, in bytes.
        :param int image_update: Last update time of this image, unix time in nanoseconds.
        :param str status: Status of this image.
        :param str tag: Tag of this image.
        """
        pulumi.set(__self__, "digest", digest)
        pulumi.set(__self__, "image_create", image_create)
        pulumi.set(__self__, "image_id", image_id)
        pulumi.set(__self__, "image_size", image_size)
        pulumi.set(__self__, "image_update", image_update)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tag", tag)

    @property
    @pulumi.getter
    def digest(self) -> str:
        """
        Digest of this image.
        """
        return pulumi.get(self, "digest")

    @property
    @pulumi.getter(name="imageCreate")
    def image_create(self) -> int:
        """
        Create time of this image, unix time in nanoseconds.
        """
        return pulumi.get(self, "image_create")

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> str:
        """
        Id of this image.
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="imageSize")
    def image_size(self) -> int:
        """
        Status of this image, in bytes.
        """
        return pulumi.get(self, "image_size")

    @property
    @pulumi.getter(name="imageUpdate")
    def image_update(self) -> int:
        """
        Last update time of this image, unix time in nanoseconds.
        """
        return pulumi.get(self, "image_update")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        Status of this image.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def tag(self) -> str:
        """
        Tag of this image.
        """
        return pulumi.get(self, "tag")


