import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type RegistryIdOrAlias = string;
export type RepositoryName = string;
export type BatchedOperationLayerDigest = string;
export type LayerDigest = string;
export type LayerSizeInBytes = number;
export type MediaType = string;
export type LayerFailureReason = string;
export type ExceptionMessage = string;
export type ImageDigest = string;
export type ImageTag = string;
export type ImageFailureReason = string;
export type UploadId = string;
export type RegistryId = string;
export type RepositoryDescription = string;
export type Architecture = string;
export type OperatingSystem = string;
export type LogoImageBlob = Uint8Array;
export type AboutText = string;
export type UsageText = string;
export type TagKey = string;
export type TagValue = string;
export type Arn = string;
export type Url = string;
export type CreationTimestamp = Date;
export type ResourceUrl = string;
export type MarketplaceCertified = boolean;
export type ForceFlag = boolean;
export type RepositoryPolicyText = string;
export type NextToken = string;
export type MaxResults = number;
export type ImageSizeInBytes = number;
export type PushTimestamp = Date;
export type RegistryVerified = boolean;
export type RegistryAliasName = string;
export type PrimaryRegistryAliasFlag = boolean;
export type DefaultRegistryAliasFlag = boolean;
export type Base64 = string;
export type ExpirationTimestamp = Date;
export type RegistryDisplayName = string;
export type PartSize = number;
export type ImageManifest = string;
export type LayerPartBlob = Uint8Array;
export type BatchedOperationLayerDigestList = string[];
export declare const BatchedOperationLayerDigestList: S.$Array<S.String>;
export interface BatchCheckLayerAvailabilityRequest {
    registryId?: string;
    repositoryName: string;
    layerDigests: string[];
}
export declare const BatchCheckLayerAvailabilityRequest: S.Schema<BatchCheckLayerAvailabilityRequest>;
export type LayerAvailability = "AVAILABLE" | "UNAVAILABLE" | (string & {});
export declare const LayerAvailability: S.String;
export interface Layer {
    layerDigest?: string;
    layerAvailability?: LayerAvailability;
    layerSize?: number;
    mediaType?: string;
}
export declare const Layer: S.Schema<Layer>;
export type LayerList = Layer[];
export declare const LayerList: S.$Array<S.Schema<Layer>>;
export type LayerFailureCode = "InvalidLayerDigest" | "MissingLayerDigest" | (string & {});
export declare const LayerFailureCode: S.String;
export interface LayerFailure {
    layerDigest?: string;
    failureCode?: LayerFailureCode;
    failureReason?: string;
}
export declare const LayerFailure: S.Schema<LayerFailure>;
export type LayerFailureList = LayerFailure[];
export declare const LayerFailureList: S.$Array<S.Schema<LayerFailure>>;
export interface BatchCheckLayerAvailabilityResponse {
    layers?: Layer[];
    failures?: LayerFailure[];
}
export declare const BatchCheckLayerAvailabilityResponse: S.Schema<BatchCheckLayerAvailabilityResponse>;
export interface ImageIdentifier {
    imageDigest?: string;
    imageTag?: string;
}
export declare const ImageIdentifier: S.Schema<ImageIdentifier>;
export type ImageIdentifierList = ImageIdentifier[];
export declare const ImageIdentifierList: S.$Array<S.Schema<ImageIdentifier>>;
export interface BatchDeleteImageRequest {
    registryId?: string;
    repositoryName: string;
    imageIds: ImageIdentifier[];
}
export declare const BatchDeleteImageRequest: S.Schema<BatchDeleteImageRequest>;
export type ImageFailureCode = "InvalidImageDigest" | "InvalidImageTag" | "ImageTagDoesNotMatchDigest" | "ImageNotFound" | "MissingDigestAndTag" | "ImageReferencedByManifestList" | "KmsError" | (string & {});
export declare const ImageFailureCode: S.String;
export interface ImageFailure {
    imageId?: ImageIdentifier;
    failureCode?: ImageFailureCode;
    failureReason?: string;
}
export declare const ImageFailure: S.Schema<ImageFailure>;
export type ImageFailureList = ImageFailure[];
export declare const ImageFailureList: S.$Array<S.Schema<ImageFailure>>;
export interface BatchDeleteImageResponse {
    imageIds?: ImageIdentifier[];
    failures?: ImageFailure[];
}
export declare const BatchDeleteImageResponse: S.Schema<BatchDeleteImageResponse>;
export type LayerDigestList = string[];
export declare const LayerDigestList: S.$Array<S.String>;
export interface CompleteLayerUploadRequest {
    registryId?: string;
    repositoryName: string;
    uploadId: string;
    layerDigests: string[];
}
export declare const CompleteLayerUploadRequest: S.Schema<CompleteLayerUploadRequest>;
export interface CompleteLayerUploadResponse {
    registryId?: string;
    repositoryName?: string;
    uploadId?: string;
    layerDigest?: string;
}
export declare const CompleteLayerUploadResponse: S.Schema<CompleteLayerUploadResponse>;
export type ArchitectureList = string[];
export declare const ArchitectureList: S.$Array<S.String>;
export type OperatingSystemList = string[];
export declare const OperatingSystemList: S.$Array<S.String>;
export interface RepositoryCatalogDataInput {
    description?: string;
    architectures?: string[];
    operatingSystems?: string[];
    logoImageBlob?: Uint8Array;
    aboutText?: string;
    usageText?: string;
}
export declare const RepositoryCatalogDataInput: S.Schema<RepositoryCatalogDataInput>;
export interface Tag {
    Key?: string;
    Value?: string;
}
export declare const Tag: S.Schema<Tag>;
export type TagList = Tag[];
export declare const TagList: S.$Array<S.Schema<Tag>>;
export interface CreateRepositoryRequest {
    repositoryName: string;
    catalogData?: RepositoryCatalogDataInput;
    tags?: Tag[];
}
export declare const CreateRepositoryRequest: S.Schema<CreateRepositoryRequest>;
export interface Repository {
    repositoryArn?: string;
    registryId?: string;
    repositoryName?: string;
    repositoryUri?: string;
    createdAt?: Date;
}
export declare const Repository: S.Schema<Repository>;
export interface RepositoryCatalogData {
    description?: string;
    architectures?: string[];
    operatingSystems?: string[];
    logoUrl?: string;
    aboutText?: string;
    usageText?: string;
    marketplaceCertified?: boolean;
}
export declare const RepositoryCatalogData: S.Schema<RepositoryCatalogData>;
export interface CreateRepositoryResponse {
    repository?: Repository;
    catalogData?: RepositoryCatalogData;
}
export declare const CreateRepositoryResponse: S.Schema<CreateRepositoryResponse>;
export interface DeleteRepositoryRequest {
    registryId?: string;
    repositoryName: string;
    force?: boolean;
}
export declare const DeleteRepositoryRequest: S.Schema<DeleteRepositoryRequest>;
export interface DeleteRepositoryResponse {
    repository?: Repository;
}
export declare const DeleteRepositoryResponse: S.Schema<DeleteRepositoryResponse>;
export interface DeleteRepositoryPolicyRequest {
    registryId?: string;
    repositoryName: string;
}
export declare const DeleteRepositoryPolicyRequest: S.Schema<DeleteRepositoryPolicyRequest>;
export interface DeleteRepositoryPolicyResponse {
    registryId?: string;
    repositoryName?: string;
    policyText?: string;
}
export declare const DeleteRepositoryPolicyResponse: S.Schema<DeleteRepositoryPolicyResponse>;
export interface DescribeImagesRequest {
    registryId?: string;
    repositoryName: string;
    imageIds?: ImageIdentifier[];
    nextToken?: string;
    maxResults?: number;
}
export declare const DescribeImagesRequest: S.Schema<DescribeImagesRequest>;
export type ImageTagList = string[];
export declare const ImageTagList: S.$Array<S.String>;
export interface ImageDetail {
    registryId?: string;
    repositoryName?: string;
    imageDigest?: string;
    imageTags?: string[];
    imageSizeInBytes?: number;
    imagePushedAt?: Date;
    imageManifestMediaType?: string;
    artifactMediaType?: string;
}
export declare const ImageDetail: S.Schema<ImageDetail>;
export type ImageDetailList = ImageDetail[];
export declare const ImageDetailList: S.$Array<S.Schema<ImageDetail>>;
export interface DescribeImagesResponse {
    imageDetails?: ImageDetail[];
    nextToken?: string;
}
export declare const DescribeImagesResponse: S.Schema<DescribeImagesResponse>;
export interface DescribeImageTagsRequest {
    registryId?: string;
    repositoryName: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const DescribeImageTagsRequest: S.Schema<DescribeImageTagsRequest>;
export interface ReferencedImageDetail {
    imageDigest?: string;
    imageSizeInBytes?: number;
    imagePushedAt?: Date;
    imageManifestMediaType?: string;
    artifactMediaType?: string;
}
export declare const ReferencedImageDetail: S.Schema<ReferencedImageDetail>;
export interface ImageTagDetail {
    imageTag?: string;
    createdAt?: Date;
    imageDetail?: ReferencedImageDetail;
}
export declare const ImageTagDetail: S.Schema<ImageTagDetail>;
export type ImageTagDetailList = ImageTagDetail[];
export declare const ImageTagDetailList: S.$Array<S.Schema<ImageTagDetail>>;
export interface DescribeImageTagsResponse {
    imageTagDetails?: ImageTagDetail[];
    nextToken?: string;
}
export declare const DescribeImageTagsResponse: S.Schema<DescribeImageTagsResponse>;
export interface DescribeRegistriesRequest {
    nextToken?: string;
    maxResults?: number;
}
export declare const DescribeRegistriesRequest: S.Schema<DescribeRegistriesRequest>;
export type RegistryAliasStatus = "ACTIVE" | "PENDING" | "REJECTED" | (string & {});
export declare const RegistryAliasStatus: S.String;
export interface RegistryAlias {
    name: string;
    status: RegistryAliasStatus;
    primaryRegistryAlias: boolean;
    defaultRegistryAlias: boolean;
}
export declare const RegistryAlias: S.Schema<RegistryAlias>;
export type RegistryAliasList = RegistryAlias[];
export declare const RegistryAliasList: S.$Array<S.Schema<RegistryAlias>>;
export interface Registry {
    registryId: string;
    registryArn: string;
    registryUri: string;
    verified: boolean;
    aliases: RegistryAlias[];
}
export declare const Registry: S.Schema<Registry>;
export type RegistryList = Registry[];
export declare const RegistryList: S.$Array<S.Schema<Registry>>;
export interface DescribeRegistriesResponse {
    registries: Registry[];
    nextToken?: string;
}
export declare const DescribeRegistriesResponse: S.Schema<DescribeRegistriesResponse>;
export type RepositoryNameList = string[];
export declare const RepositoryNameList: S.$Array<S.String>;
export interface DescribeRepositoriesRequest {
    registryId?: string;
    repositoryNames?: string[];
    nextToken?: string;
    maxResults?: number;
}
export declare const DescribeRepositoriesRequest: S.Schema<DescribeRepositoriesRequest>;
export type RepositoryList = Repository[];
export declare const RepositoryList: S.$Array<S.Schema<Repository>>;
export interface DescribeRepositoriesResponse {
    repositories?: Repository[];
    nextToken?: string;
}
export declare const DescribeRepositoriesResponse: S.Schema<DescribeRepositoriesResponse>;
export interface GetAuthorizationTokenRequest {
}
export declare const GetAuthorizationTokenRequest: S.Schema<GetAuthorizationTokenRequest>;
export interface AuthorizationData {
    authorizationToken?: string;
    expiresAt?: Date;
}
export declare const AuthorizationData: S.Schema<AuthorizationData>;
export interface GetAuthorizationTokenResponse {
    authorizationData?: AuthorizationData;
}
export declare const GetAuthorizationTokenResponse: S.Schema<GetAuthorizationTokenResponse>;
export interface GetRegistryCatalogDataRequest {
}
export declare const GetRegistryCatalogDataRequest: S.Schema<GetRegistryCatalogDataRequest>;
export interface RegistryCatalogData {
    displayName?: string;
}
export declare const RegistryCatalogData: S.Schema<RegistryCatalogData>;
export interface GetRegistryCatalogDataResponse {
    registryCatalogData: RegistryCatalogData;
}
export declare const GetRegistryCatalogDataResponse: S.Schema<GetRegistryCatalogDataResponse>;
export interface GetRepositoryCatalogDataRequest {
    registryId?: string;
    repositoryName: string;
}
export declare const GetRepositoryCatalogDataRequest: S.Schema<GetRepositoryCatalogDataRequest>;
export interface GetRepositoryCatalogDataResponse {
    catalogData?: RepositoryCatalogData;
}
export declare const GetRepositoryCatalogDataResponse: S.Schema<GetRepositoryCatalogDataResponse>;
export interface GetRepositoryPolicyRequest {
    registryId?: string;
    repositoryName: string;
}
export declare const GetRepositoryPolicyRequest: S.Schema<GetRepositoryPolicyRequest>;
export interface GetRepositoryPolicyResponse {
    registryId?: string;
    repositoryName?: string;
    policyText?: string;
}
export declare const GetRepositoryPolicyResponse: S.Schema<GetRepositoryPolicyResponse>;
export interface InitiateLayerUploadRequest {
    registryId?: string;
    repositoryName: string;
}
export declare const InitiateLayerUploadRequest: S.Schema<InitiateLayerUploadRequest>;
export interface InitiateLayerUploadResponse {
    uploadId?: string;
    partSize?: number;
}
export declare const InitiateLayerUploadResponse: S.Schema<InitiateLayerUploadResponse>;
export interface ListTagsForResourceRequest {
    resourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface ListTagsForResourceResponse {
    tags?: Tag[];
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface PutImageRequest {
    registryId?: string;
    repositoryName: string;
    imageManifest: string;
    imageManifestMediaType?: string;
    imageTag?: string;
    imageDigest?: string;
}
export declare const PutImageRequest: S.Schema<PutImageRequest>;
export interface Image {
    registryId?: string;
    repositoryName?: string;
    imageId?: ImageIdentifier;
    imageManifest?: string;
    imageManifestMediaType?: string;
}
export declare const Image: S.Schema<Image>;
export interface PutImageResponse {
    image?: Image;
}
export declare const PutImageResponse: S.Schema<PutImageResponse>;
export interface PutRegistryCatalogDataRequest {
    displayName?: string;
}
export declare const PutRegistryCatalogDataRequest: S.Schema<PutRegistryCatalogDataRequest>;
export interface PutRegistryCatalogDataResponse {
    registryCatalogData: RegistryCatalogData;
}
export declare const PutRegistryCatalogDataResponse: S.Schema<PutRegistryCatalogDataResponse>;
export interface PutRepositoryCatalogDataRequest {
    registryId?: string;
    repositoryName: string;
    catalogData: RepositoryCatalogDataInput;
}
export declare const PutRepositoryCatalogDataRequest: S.Schema<PutRepositoryCatalogDataRequest>;
export interface PutRepositoryCatalogDataResponse {
    catalogData?: RepositoryCatalogData;
}
export declare const PutRepositoryCatalogDataResponse: S.Schema<PutRepositoryCatalogDataResponse>;
export interface SetRepositoryPolicyRequest {
    registryId?: string;
    repositoryName: string;
    policyText: string;
    force?: boolean;
}
export declare const SetRepositoryPolicyRequest: S.Schema<SetRepositoryPolicyRequest>;
export interface SetRepositoryPolicyResponse {
    registryId?: string;
    repositoryName?: string;
    policyText?: string;
}
export declare const SetRepositoryPolicyResponse: S.Schema<SetRepositoryPolicyResponse>;
export interface TagResourceRequest {
    resourceArn: string;
    tags: Tag[];
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagResourceRequest {
    resourceArn: string;
    tagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export interface UploadLayerPartRequest {
    registryId?: string;
    repositoryName: string;
    uploadId: string;
    partFirstByte: number;
    partLastByte: number;
    layerPartBlob: Uint8Array;
}
export declare const UploadLayerPartRequest: S.Schema<UploadLayerPartRequest>;
export interface UploadLayerPartResponse {
    registryId?: string;
    repositoryName?: string;
    uploadId?: string;
    lastByteReceived?: number;
}
export declare const UploadLayerPartResponse: S.Schema<UploadLayerPartResponse>;
declare const InvalidParameterException_base: S.Class<InvalidParameterException, S.TaggedStruct<"InvalidParameterException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidParameterException extends InvalidParameterException_base {
}
declare const RegistryNotFoundException_base: S.Class<RegistryNotFoundException, S.TaggedStruct<"RegistryNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class RegistryNotFoundException extends RegistryNotFoundException_base {
}
declare const RepositoryNotFoundException_base: S.Class<RepositoryNotFoundException, S.TaggedStruct<"RepositoryNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class RepositoryNotFoundException extends RepositoryNotFoundException_base {
}
declare const ServerException_base: S.Class<ServerException, S.TaggedStruct<"ServerException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class ServerException extends ServerException_base {
}
declare const UnsupportedCommandException_base: S.Class<UnsupportedCommandException, S.TaggedStruct<"UnsupportedCommandException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class UnsupportedCommandException extends UnsupportedCommandException_base {
}
declare const EmptyUploadException_base: S.Class<EmptyUploadException, S.TaggedStruct<"EmptyUploadException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class EmptyUploadException extends EmptyUploadException_base {
}
declare const InvalidLayerException_base: S.Class<InvalidLayerException, S.TaggedStruct<"InvalidLayerException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidLayerException extends InvalidLayerException_base {
}
declare const LayerAlreadyExistsException_base: S.Class<LayerAlreadyExistsException, S.TaggedStruct<"LayerAlreadyExistsException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AlreadyExistsError: true;
    };
});
export declare class LayerAlreadyExistsException extends LayerAlreadyExistsException_base {
}
declare const LayerPartTooSmallException_base: S.Class<LayerPartTooSmallException, S.TaggedStruct<"LayerPartTooSmallException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class LayerPartTooSmallException extends LayerPartTooSmallException_base {
}
declare const UploadNotFoundException_base: S.Class<UploadNotFoundException, S.TaggedStruct<"UploadNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class UploadNotFoundException extends UploadNotFoundException_base {
}
declare const InvalidTagParameterException_base: S.Class<InvalidTagParameterException, S.TaggedStruct<"InvalidTagParameterException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidTagParameterException extends InvalidTagParameterException_base {
}
declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class LimitExceededException extends LimitExceededException_base {
}
declare const RepositoryAlreadyExistsException_base: S.Class<RepositoryAlreadyExistsException, S.TaggedStruct<"RepositoryAlreadyExistsException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AlreadyExistsError: true;
    };
});
export declare class RepositoryAlreadyExistsException extends RepositoryAlreadyExistsException_base {
}
declare const TooManyTagsException_base: S.Class<TooManyTagsException, S.TaggedStruct<"TooManyTagsException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class TooManyTagsException extends TooManyTagsException_base {
}
declare const RepositoryNotEmptyException_base: S.Class<RepositoryNotEmptyException, S.TaggedStruct<"RepositoryNotEmptyException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class RepositoryNotEmptyException extends RepositoryNotEmptyException_base {
}
declare const RepositoryPolicyNotFoundException_base: S.Class<RepositoryPolicyNotFoundException, S.TaggedStruct<"RepositoryPolicyNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class RepositoryPolicyNotFoundException extends RepositoryPolicyNotFoundException_base {
}
declare const ImageNotFoundException_base: S.Class<ImageNotFoundException, S.TaggedStruct<"ImageNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class ImageNotFoundException extends ImageNotFoundException_base {
}
declare const RepositoryCatalogDataNotFoundException_base: S.Class<RepositoryCatalogDataNotFoundException, S.TaggedStruct<"RepositoryCatalogDataNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class RepositoryCatalogDataNotFoundException extends RepositoryCatalogDataNotFoundException_base {
}
declare const ImageAlreadyExistsException_base: S.Class<ImageAlreadyExistsException, S.TaggedStruct<"ImageAlreadyExistsException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AlreadyExistsError: true;
    };
});
export declare class ImageAlreadyExistsException extends ImageAlreadyExistsException_base {
}
declare const ImageDigestDoesNotMatchException_base: S.Class<ImageDigestDoesNotMatchException, S.TaggedStruct<"ImageDigestDoesNotMatchException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class ImageDigestDoesNotMatchException extends ImageDigestDoesNotMatchException_base {
}
declare const ImageTagAlreadyExistsException_base: S.Class<ImageTagAlreadyExistsException, S.TaggedStruct<"ImageTagAlreadyExistsException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AlreadyExistsError: true;
    };
});
export declare class ImageTagAlreadyExistsException extends ImageTagAlreadyExistsException_base {
}
declare const LayersNotFoundException_base: S.Class<LayersNotFoundException, S.TaggedStruct<"LayersNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class LayersNotFoundException extends LayersNotFoundException_base {
}
declare const ReferencedImagesNotFoundException_base: S.Class<ReferencedImagesNotFoundException, S.TaggedStruct<"ReferencedImagesNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class ReferencedImagesNotFoundException extends ReferencedImagesNotFoundException_base {
}
declare const InvalidLayerPartException_base: S.Class<InvalidLayerPartException, S.TaggedStruct<"InvalidLayerPartException", {
    readonly registryId: S.optional<S.String>;
    readonly repositoryName: S.optional<S.String>;
    readonly uploadId: S.optional<S.String>;
    readonly lastValidByteReceived: S.optional<S.Number>;
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidLayerPartException extends InvalidLayerPartException_base {
}
export type BatchCheckLayerAvailabilityError = InvalidParameterException | RegistryNotFoundException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Checks the availability of one or more image layers that are within a repository in a
 * public registry. When an image is pushed to a repository, each image layer is checked to
 * verify if it has been uploaded before. If it has been uploaded, then the image layer is
 * skipped.
 *
 * This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the `docker` CLI to pull, tag, and push images.
 */
export declare const batchCheckLayerAvailability: API.OperationMethod<BatchCheckLayerAvailabilityRequest, BatchCheckLayerAvailabilityResponse, BatchCheckLayerAvailabilityError, Credentials | Region | HttpClient.HttpClient>;
export type BatchDeleteImageError = InvalidParameterException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Deletes a list of specified images that are within a repository in a public registry.
 * Images are specified with either an `imageTag` or
 * `imageDigest`.
 *
 * You can remove a tag from an image by specifying the image's tag in your request. When
 * you remove the last tag from an image, the image is deleted from your repository.
 *
 * You can completely delete an image (and all of its tags) by specifying the digest of the
 * image in your request.
 */
export declare const batchDeleteImage: API.OperationMethod<BatchDeleteImageRequest, BatchDeleteImageResponse, BatchDeleteImageError, Credentials | Region | HttpClient.HttpClient>;
export type CompleteLayerUploadError = EmptyUploadException | InvalidLayerException | InvalidParameterException | LayerAlreadyExistsException | LayerPartTooSmallException | RegistryNotFoundException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | UploadNotFoundException | CommonErrors;
/**
 * Informs Amazon ECR that the image layer upload is complete for a specified public registry,
 * repository name, and upload ID. You can optionally provide a `sha256` digest of
 * the image layer for data validation purposes.
 *
 * When an image is pushed, the CompleteLayerUpload API is called once for each new image
 * layer to verify that the upload is complete.
 *
 * This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the `docker` CLI to pull, tag, and push images.
 */
export declare const completeLayerUpload: API.OperationMethod<CompleteLayerUploadRequest, CompleteLayerUploadResponse, CompleteLayerUploadError, Credentials | Region | HttpClient.HttpClient>;
export type CreateRepositoryError = InvalidParameterException | InvalidTagParameterException | LimitExceededException | RepositoryAlreadyExistsException | ServerException | TooManyTagsException | UnsupportedCommandException | CommonErrors;
/**
 * Creates a repository in a public registry. For more information, see Amazon ECR
 * repositories in the *Amazon Elastic Container Registry User Guide*.
 */
export declare const createRepository: API.OperationMethod<CreateRepositoryRequest, CreateRepositoryResponse, CreateRepositoryError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteRepositoryError = InvalidParameterException | RepositoryNotEmptyException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Deletes a repository in a public registry. If the repository contains images, you must
 * either manually delete all images in the repository or use the `force` option.
 * This option deletes all images on your behalf before deleting the repository.
 */
export declare const deleteRepository: API.OperationMethod<DeleteRepositoryRequest, DeleteRepositoryResponse, DeleteRepositoryError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteRepositoryPolicyError = InvalidParameterException | RepositoryNotFoundException | RepositoryPolicyNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Deletes the repository policy that's associated with the specified repository.
 */
export declare const deleteRepositoryPolicy: API.OperationMethod<DeleteRepositoryPolicyRequest, DeleteRepositoryPolicyResponse, DeleteRepositoryPolicyError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeImagesError = ImageNotFoundException | InvalidParameterException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Returns metadata that's related to the images in a repository in a public
 * registry.
 *
 * Beginning with Docker version 1.9, the Docker client compresses image layers before
 * pushing them to a V2 Docker registry. The output of the `docker images`
 * command shows the uncompressed image size. Therefore, it might return a larger image
 * size than the image sizes that are returned by DescribeImages.
 */
export declare const describeImages: API.OperationMethod<DescribeImagesRequest, DescribeImagesResponse, DescribeImagesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeImagesRequest) => stream.Stream<DescribeImagesResponse, DescribeImagesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeImagesRequest) => stream.Stream<ImageDetail, DescribeImagesError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeImageTagsError = InvalidParameterException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Returns the image tag details for a repository in a public registry.
 */
export declare const describeImageTags: API.OperationMethod<DescribeImageTagsRequest, DescribeImageTagsResponse, DescribeImageTagsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeImageTagsRequest) => stream.Stream<DescribeImageTagsResponse, DescribeImageTagsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeImageTagsRequest) => stream.Stream<ImageTagDetail, DescribeImageTagsError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeRegistriesError = InvalidParameterException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Returns details for a public registry.
 */
export declare const describeRegistries: API.OperationMethod<DescribeRegistriesRequest, DescribeRegistriesResponse, DescribeRegistriesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeRegistriesRequest) => stream.Stream<DescribeRegistriesResponse, DescribeRegistriesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeRegistriesRequest) => stream.Stream<Registry, DescribeRegistriesError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeRepositoriesError = InvalidParameterException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Describes repositories that are in a public registry.
 */
export declare const describeRepositories: API.OperationMethod<DescribeRepositoriesRequest, DescribeRepositoriesResponse, DescribeRepositoriesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeRepositoriesRequest) => stream.Stream<DescribeRepositoriesResponse, DescribeRepositoriesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeRepositoriesRequest) => stream.Stream<Repository, DescribeRepositoriesError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetAuthorizationTokenError = InvalidParameterException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Retrieves an authorization token. An authorization token represents your IAM
 * authentication credentials. You can use it to access any Amazon ECR registry that your IAM
 * principal has access to. The authorization token is valid for 12 hours. This API requires
 * the `ecr-public:GetAuthorizationToken` and
 * `sts:GetServiceBearerToken` permissions.
 */
export declare const getAuthorizationToken: API.OperationMethod<GetAuthorizationTokenRequest, GetAuthorizationTokenResponse, GetAuthorizationTokenError, Credentials | Region | HttpClient.HttpClient>;
export type GetRegistryCatalogDataError = ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Retrieves catalog metadata for a public registry.
 */
export declare const getRegistryCatalogData: API.OperationMethod<GetRegistryCatalogDataRequest, GetRegistryCatalogDataResponse, GetRegistryCatalogDataError, Credentials | Region | HttpClient.HttpClient>;
export type GetRepositoryCatalogDataError = InvalidParameterException | RepositoryCatalogDataNotFoundException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Retrieve catalog metadata for a repository in a public registry. This metadata is
 * displayed publicly in the Amazon ECR Public Gallery.
 */
export declare const getRepositoryCatalogData: API.OperationMethod<GetRepositoryCatalogDataRequest, GetRepositoryCatalogDataResponse, GetRepositoryCatalogDataError, Credentials | Region | HttpClient.HttpClient>;
export type GetRepositoryPolicyError = InvalidParameterException | RepositoryNotFoundException | RepositoryPolicyNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Retrieves the repository policy for the specified repository.
 */
export declare const getRepositoryPolicy: API.OperationMethod<GetRepositoryPolicyRequest, GetRepositoryPolicyResponse, GetRepositoryPolicyError, Credentials | Region | HttpClient.HttpClient>;
export type InitiateLayerUploadError = InvalidParameterException | RegistryNotFoundException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Notifies Amazon ECR that you intend to upload an image layer.
 *
 * When an image is pushed, the InitiateLayerUpload API is called once for each image layer
 * that hasn't already been uploaded. Whether an image layer uploads is determined by the
 * BatchCheckLayerAvailability API action.
 *
 * This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the `docker` CLI to pull, tag, and push images.
 */
export declare const initiateLayerUpload: API.OperationMethod<InitiateLayerUploadRequest, InitiateLayerUploadResponse, InitiateLayerUploadError, Credentials | Region | HttpClient.HttpClient>;
export type ListTagsForResourceError = InvalidParameterException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * List the tags for an Amazon ECR Public resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type PutImageError = ImageAlreadyExistsException | ImageDigestDoesNotMatchException | ImageTagAlreadyExistsException | InvalidParameterException | LayersNotFoundException | LimitExceededException | ReferencedImagesNotFoundException | RegistryNotFoundException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Creates or updates the image manifest and tags that are associated with an image.
 *
 * When an image is pushed and all new image layers have been uploaded, the PutImage API is
 * called once to create or update the image manifest and the tags that are associated with
 * the image.
 *
 * This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the `docker` CLI to pull, tag, and push images.
 */
export declare const putImage: API.OperationMethod<PutImageRequest, PutImageResponse, PutImageError, Credentials | Region | HttpClient.HttpClient>;
export type PutRegistryCatalogDataError = InvalidParameterException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Create or update the catalog data for a public registry.
 */
export declare const putRegistryCatalogData: API.OperationMethod<PutRegistryCatalogDataRequest, PutRegistryCatalogDataResponse, PutRegistryCatalogDataError, Credentials | Region | HttpClient.HttpClient>;
export type PutRepositoryCatalogDataError = InvalidParameterException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Creates or updates the catalog data for a repository in a public registry.
 */
export declare const putRepositoryCatalogData: API.OperationMethod<PutRepositoryCatalogDataRequest, PutRepositoryCatalogDataResponse, PutRepositoryCatalogDataError, Credentials | Region | HttpClient.HttpClient>;
export type SetRepositoryPolicyError = InvalidParameterException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | CommonErrors;
/**
 * Applies a repository policy to the specified public repository to control access
 * permissions. For more information, see Amazon ECR Repository
 * Policies in the *Amazon Elastic Container Registry User Guide*.
 */
export declare const setRepositoryPolicy: API.OperationMethod<SetRepositoryPolicyRequest, SetRepositoryPolicyResponse, SetRepositoryPolicyError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = InvalidParameterException | InvalidTagParameterException | RepositoryNotFoundException | ServerException | TooManyTagsException | UnsupportedCommandException | CommonErrors;
/**
 * Associates the specified tags to a resource with the specified `resourceArn`.
 * If existing tags on a resource aren't specified in the request parameters, they aren't
 * changed. When a resource is deleted, the tags associated with that resource are also
 * deleted.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = InvalidParameterException | InvalidTagParameterException | RepositoryNotFoundException | ServerException | TooManyTagsException | UnsupportedCommandException | CommonErrors;
/**
 * Deletes specified tags from a resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UploadLayerPartError = InvalidLayerPartException | InvalidParameterException | LimitExceededException | RegistryNotFoundException | RepositoryNotFoundException | ServerException | UnsupportedCommandException | UploadNotFoundException | CommonErrors;
/**
 * Uploads an image layer part to Amazon ECR.
 *
 * When an image is pushed, each new image layer is uploaded in parts. The maximum size of
 * each image layer part can be 20971520 bytes (about 20MB). The UploadLayerPart API is called
 * once for each new image layer part.
 *
 * This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the `docker` CLI to pull, tag, and push images.
 */
export declare const uploadLayerPart: API.OperationMethod<UploadLayerPartRequest, UploadLayerPartResponse, UploadLayerPartError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=ecr-public.d.ts.map