@aws-sdk/client-ecr 3.34.0 → 3.37.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1545 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export interface BatchCheckLayerAvailabilityRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    layerDigests: string[] | undefined;
+}
+export declare namespace BatchCheckLayerAvailabilityRequest {
+    
+    const filterSensitiveLog: (obj: BatchCheckLayerAvailabilityRequest) => any;
+}
+export declare enum LayerFailureCode {
+    InvalidLayerDigest = "InvalidLayerDigest",
+    MissingLayerDigest = "MissingLayerDigest"
+}
+
+export interface LayerFailure {
+    
+    layerDigest?: string;
+    
+    failureCode?: LayerFailureCode | string;
+    
+    failureReason?: string;
+}
+export declare namespace LayerFailure {
+    
+    const filterSensitiveLog: (obj: LayerFailure) => any;
+}
+export declare enum LayerAvailability {
+    AVAILABLE = "AVAILABLE",
+    UNAVAILABLE = "UNAVAILABLE"
+}
+
+export interface Layer {
+    
+    layerDigest?: string;
+    
+    layerAvailability?: LayerAvailability | string;
+    
+    layerSize?: number;
+    
+    mediaType?: string;
+}
+export declare namespace Layer {
+    
+    const filterSensitiveLog: (obj: Layer) => any;
+}
+export interface BatchCheckLayerAvailabilityResponse {
+    
+    layers?: Layer[];
+    
+    failures?: LayerFailure[];
+}
+export declare namespace BatchCheckLayerAvailabilityResponse {
+    
+    const filterSensitiveLog: (obj: BatchCheckLayerAvailabilityResponse) => any;
+}
+
+export interface InvalidParameterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameterException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidParameterException {
+    
+    const filterSensitiveLog: (obj: InvalidParameterException) => any;
+}
+
+export interface RepositoryNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "RepositoryNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace RepositoryNotFoundException {
+    
+    const filterSensitiveLog: (obj: RepositoryNotFoundException) => any;
+}
+
+export interface ServerException extends __SmithyException, $MetadataBearer {
+    name: "ServerException";
+    $fault: "server";
+    
+    message?: string;
+}
+export declare namespace ServerException {
+    
+    const filterSensitiveLog: (obj: ServerException) => any;
+}
+
+export interface ImageIdentifier {
+    
+    imageDigest?: string;
+    
+    imageTag?: string;
+}
+export declare namespace ImageIdentifier {
+    
+    const filterSensitiveLog: (obj: ImageIdentifier) => any;
+}
+
+export interface BatchDeleteImageRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    imageIds: ImageIdentifier[] | undefined;
+}
+export declare namespace BatchDeleteImageRequest {
+    
+    const filterSensitiveLog: (obj: BatchDeleteImageRequest) => any;
+}
+export declare enum ImageFailureCode {
+    ImageNotFound = "ImageNotFound",
+    ImageReferencedByManifestList = "ImageReferencedByManifestList",
+    ImageTagDoesNotMatchDigest = "ImageTagDoesNotMatchDigest",
+    InvalidImageDigest = "InvalidImageDigest",
+    InvalidImageTag = "InvalidImageTag",
+    KmsError = "KmsError",
+    MissingDigestAndTag = "MissingDigestAndTag"
+}
+
+export interface ImageFailure {
+    
+    imageId?: ImageIdentifier;
+    
+    failureCode?: ImageFailureCode | string;
+    
+    failureReason?: string;
+}
+export declare namespace ImageFailure {
+    
+    const filterSensitiveLog: (obj: ImageFailure) => any;
+}
+export interface BatchDeleteImageResponse {
+    
+    imageIds?: ImageIdentifier[];
+    
+    failures?: ImageFailure[];
+}
+export declare namespace BatchDeleteImageResponse {
+    
+    const filterSensitiveLog: (obj: BatchDeleteImageResponse) => any;
+}
+export interface BatchGetImageRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    imageIds: ImageIdentifier[] | undefined;
+    
+    acceptedMediaTypes?: string[];
+}
+export declare namespace BatchGetImageRequest {
+    
+    const filterSensitiveLog: (obj: BatchGetImageRequest) => any;
+}
+
+export interface Image {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    imageId?: ImageIdentifier;
+    
+    imageManifest?: string;
+    
+    imageManifestMediaType?: string;
+}
+export declare namespace Image {
+    
+    const filterSensitiveLog: (obj: Image) => any;
+}
+export interface BatchGetImageResponse {
+    
+    images?: Image[];
+    
+    failures?: ImageFailure[];
+}
+export declare namespace BatchGetImageResponse {
+    
+    const filterSensitiveLog: (obj: BatchGetImageResponse) => any;
+}
+export interface CompleteLayerUploadRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    uploadId: string | undefined;
+    
+    layerDigests: string[] | undefined;
+}
+export declare namespace CompleteLayerUploadRequest {
+    
+    const filterSensitiveLog: (obj: CompleteLayerUploadRequest) => any;
+}
+export interface CompleteLayerUploadResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    uploadId?: string;
+    
+    layerDigest?: string;
+}
+export declare namespace CompleteLayerUploadResponse {
+    
+    const filterSensitiveLog: (obj: CompleteLayerUploadResponse) => any;
+}
+
+export interface EmptyUploadException extends __SmithyException, $MetadataBearer {
+    name: "EmptyUploadException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace EmptyUploadException {
+    
+    const filterSensitiveLog: (obj: EmptyUploadException) => any;
+}
+
+export interface InvalidLayerException extends __SmithyException, $MetadataBearer {
+    name: "InvalidLayerException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidLayerException {
+    
+    const filterSensitiveLog: (obj: InvalidLayerException) => any;
+}
+
+export interface KmsException extends __SmithyException, $MetadataBearer {
+    name: "KmsException";
+    $fault: "client";
+    message?: string;
+    
+    kmsError?: string;
+}
+export declare namespace KmsException {
+    
+    const filterSensitiveLog: (obj: KmsException) => any;
+}
+
+export interface LayerAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "LayerAlreadyExistsException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace LayerAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: LayerAlreadyExistsException) => any;
+}
+
+export interface LayerPartTooSmallException extends __SmithyException, $MetadataBearer {
+    name: "LayerPartTooSmallException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace LayerPartTooSmallException {
+    
+    const filterSensitiveLog: (obj: LayerPartTooSmallException) => any;
+}
+
+export interface UploadNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "UploadNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace UploadNotFoundException {
+    
+    const filterSensitiveLog: (obj: UploadNotFoundException) => any;
+}
+export declare enum EncryptionType {
+    AES256 = "AES256",
+    KMS = "KMS"
+}
+
+export interface EncryptionConfiguration {
+    
+    encryptionType: EncryptionType | string | undefined;
+    
+    kmsKey?: string;
+}
+export declare namespace EncryptionConfiguration {
+    
+    const filterSensitiveLog: (obj: EncryptionConfiguration) => any;
+}
+
+export interface ImageScanningConfiguration {
+    
+    scanOnPush?: boolean;
+}
+export declare namespace ImageScanningConfiguration {
+    
+    const filterSensitiveLog: (obj: ImageScanningConfiguration) => any;
+}
+export declare enum ImageTagMutability {
+    IMMUTABLE = "IMMUTABLE",
+    MUTABLE = "MUTABLE"
+}
+
+export interface Tag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateRepositoryRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    tags?: Tag[];
+    
+    imageTagMutability?: ImageTagMutability | string;
+    
+    imageScanningConfiguration?: ImageScanningConfiguration;
+    
+    encryptionConfiguration?: EncryptionConfiguration;
+}
+export declare namespace CreateRepositoryRequest {
+    
+    const filterSensitiveLog: (obj: CreateRepositoryRequest) => any;
+}
+
+export interface Repository {
+    
+    repositoryArn?: string;
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    repositoryUri?: string;
+    
+    createdAt?: Date;
+    
+    imageTagMutability?: ImageTagMutability | string;
+    
+    imageScanningConfiguration?: ImageScanningConfiguration;
+    
+    encryptionConfiguration?: EncryptionConfiguration;
+}
+export declare namespace Repository {
+    
+    const filterSensitiveLog: (obj: Repository) => any;
+}
+export interface CreateRepositoryResponse {
+    
+    repository?: Repository;
+}
+export declare namespace CreateRepositoryResponse {
+    
+    const filterSensitiveLog: (obj: CreateRepositoryResponse) => any;
+}
+
+export interface InvalidTagParameterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTagParameterException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidTagParameterException {
+    
+    const filterSensitiveLog: (obj: InvalidTagParameterException) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace LimitExceededException {
+    
+    const filterSensitiveLog: (obj: LimitExceededException) => any;
+}
+
+export interface RepositoryAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "RepositoryAlreadyExistsException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace RepositoryAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: RepositoryAlreadyExistsException) => any;
+}
+
+export interface TooManyTagsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyTagsException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace TooManyTagsException {
+    
+    const filterSensitiveLog: (obj: TooManyTagsException) => any;
+}
+export interface DeleteLifecyclePolicyRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+}
+export declare namespace DeleteLifecyclePolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteLifecyclePolicyRequest) => any;
+}
+export interface DeleteLifecyclePolicyResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    lifecyclePolicyText?: string;
+    
+    lastEvaluatedAt?: Date;
+}
+export declare namespace DeleteLifecyclePolicyResponse {
+    
+    const filterSensitiveLog: (obj: DeleteLifecyclePolicyResponse) => any;
+}
+
+export interface LifecyclePolicyNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "LifecyclePolicyNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace LifecyclePolicyNotFoundException {
+    
+    const filterSensitiveLog: (obj: LifecyclePolicyNotFoundException) => any;
+}
+export interface DeleteRegistryPolicyRequest {
+}
+export declare namespace DeleteRegistryPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRegistryPolicyRequest) => any;
+}
+export interface DeleteRegistryPolicyResponse {
+    
+    registryId?: string;
+    
+    policyText?: string;
+}
+export declare namespace DeleteRegistryPolicyResponse {
+    
+    const filterSensitiveLog: (obj: DeleteRegistryPolicyResponse) => any;
+}
+
+export interface RegistryPolicyNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "RegistryPolicyNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace RegistryPolicyNotFoundException {
+    
+    const filterSensitiveLog: (obj: RegistryPolicyNotFoundException) => any;
+}
+
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ValidationException {
+    
+    const filterSensitiveLog: (obj: ValidationException) => any;
+}
+export interface DeleteRepositoryRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    force?: boolean;
+}
+export declare namespace DeleteRepositoryRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRepositoryRequest) => any;
+}
+export interface DeleteRepositoryResponse {
+    
+    repository?: Repository;
+}
+export declare namespace DeleteRepositoryResponse {
+    
+    const filterSensitiveLog: (obj: DeleteRepositoryResponse) => any;
+}
+
+export interface RepositoryNotEmptyException extends __SmithyException, $MetadataBearer {
+    name: "RepositoryNotEmptyException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace RepositoryNotEmptyException {
+    
+    const filterSensitiveLog: (obj: RepositoryNotEmptyException) => any;
+}
+export interface DeleteRepositoryPolicyRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+}
+export declare namespace DeleteRepositoryPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRepositoryPolicyRequest) => any;
+}
+export interface DeleteRepositoryPolicyResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    policyText?: string;
+}
+export declare namespace DeleteRepositoryPolicyResponse {
+    
+    const filterSensitiveLog: (obj: DeleteRepositoryPolicyResponse) => any;
+}
+
+export interface RepositoryPolicyNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "RepositoryPolicyNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace RepositoryPolicyNotFoundException {
+    
+    const filterSensitiveLog: (obj: RepositoryPolicyNotFoundException) => any;
+}
+export interface DescribeImageReplicationStatusRequest {
+    
+    repositoryName: string | undefined;
+    
+    imageId: ImageIdentifier | undefined;
+    
+    registryId?: string;
+}
+export declare namespace DescribeImageReplicationStatusRequest {
+    
+    const filterSensitiveLog: (obj: DescribeImageReplicationStatusRequest) => any;
+}
+export declare enum ReplicationStatus {
+    COMPLETE = "COMPLETE",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS"
+}
+
+export interface ImageReplicationStatus {
+    
+    region?: string;
+    
+    registryId?: string;
+    
+    status?: ReplicationStatus | string;
+    
+    failureCode?: string;
+}
+export declare namespace ImageReplicationStatus {
+    
+    const filterSensitiveLog: (obj: ImageReplicationStatus) => any;
+}
+export interface DescribeImageReplicationStatusResponse {
+    
+    repositoryName?: string;
+    
+    imageId?: ImageIdentifier;
+    
+    replicationStatuses?: ImageReplicationStatus[];
+}
+export declare namespace DescribeImageReplicationStatusResponse {
+    
+    const filterSensitiveLog: (obj: DescribeImageReplicationStatusResponse) => any;
+}
+
+export interface ImageNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ImageNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ImageNotFoundException {
+    
+    const filterSensitiveLog: (obj: ImageNotFoundException) => any;
+}
+export declare enum TagStatus {
+    ANY = "ANY",
+    TAGGED = "TAGGED",
+    UNTAGGED = "UNTAGGED"
+}
+
+export interface DescribeImagesFilter {
+    
+    tagStatus?: TagStatus | string;
+}
+export declare namespace DescribeImagesFilter {
+    
+    const filterSensitiveLog: (obj: DescribeImagesFilter) => any;
+}
+export interface DescribeImagesRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    imageIds?: ImageIdentifier[];
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    filter?: DescribeImagesFilter;
+}
+export declare namespace DescribeImagesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeImagesRequest) => any;
+}
+export declare enum FindingSeverity {
+    CRITICAL = "CRITICAL",
+    HIGH = "HIGH",
+    INFORMATIONAL = "INFORMATIONAL",
+    LOW = "LOW",
+    MEDIUM = "MEDIUM",
+    UNDEFINED = "UNDEFINED"
+}
+
+export interface ImageScanFindingsSummary {
+    
+    imageScanCompletedAt?: Date;
+    
+    vulnerabilitySourceUpdatedAt?: Date;
+    
+    findingSeverityCounts?: {
+        [key: string]: number;
+    };
+}
+export declare namespace ImageScanFindingsSummary {
+    
+    const filterSensitiveLog: (obj: ImageScanFindingsSummary) => any;
+}
+export declare enum ScanStatus {
+    COMPLETE = "COMPLETE",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS"
+}
+
+export interface ImageScanStatus {
+    
+    status?: ScanStatus | string;
+    
+    description?: string;
+}
+export declare namespace ImageScanStatus {
+    
+    const filterSensitiveLog: (obj: ImageScanStatus) => any;
+}
+
+export interface ImageDetail {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    imageDigest?: string;
+    
+    imageTags?: string[];
+    
+    imageSizeInBytes?: number;
+    
+    imagePushedAt?: Date;
+    
+    imageScanStatus?: ImageScanStatus;
+    
+    imageScanFindingsSummary?: ImageScanFindingsSummary;
+    
+    imageManifestMediaType?: string;
+    
+    artifactMediaType?: string;
+}
+export declare namespace ImageDetail {
+    
+    const filterSensitiveLog: (obj: ImageDetail) => any;
+}
+export interface DescribeImagesResponse {
+    
+    imageDetails?: ImageDetail[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeImagesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeImagesResponse) => any;
+}
+export interface DescribeImageScanFindingsRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    imageId: ImageIdentifier | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace DescribeImageScanFindingsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeImageScanFindingsRequest) => any;
+}
+
+export interface Attribute {
+    
+    key: string | undefined;
+    
+    value?: string;
+}
+export declare namespace Attribute {
+    
+    const filterSensitiveLog: (obj: Attribute) => any;
+}
+
+export interface ImageScanFinding {
+    
+    name?: string;
+    
+    description?: string;
+    
+    uri?: string;
+    
+    severity?: FindingSeverity | string;
+    
+    attributes?: Attribute[];
+}
+export declare namespace ImageScanFinding {
+    
+    const filterSensitiveLog: (obj: ImageScanFinding) => any;
+}
+
+export interface ImageScanFindings {
+    
+    imageScanCompletedAt?: Date;
+    
+    vulnerabilitySourceUpdatedAt?: Date;
+    
+    findings?: ImageScanFinding[];
+    
+    findingSeverityCounts?: {
+        [key: string]: number;
+    };
+}
+export declare namespace ImageScanFindings {
+    
+    const filterSensitiveLog: (obj: ImageScanFindings) => any;
+}
+export interface DescribeImageScanFindingsResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    imageId?: ImageIdentifier;
+    
+    imageScanStatus?: ImageScanStatus;
+    
+    imageScanFindings?: ImageScanFindings;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeImageScanFindingsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeImageScanFindingsResponse) => any;
+}
+
+export interface ScanNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ScanNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ScanNotFoundException {
+    
+    const filterSensitiveLog: (obj: ScanNotFoundException) => any;
+}
+export interface DescribeRegistryRequest {
+}
+export declare namespace DescribeRegistryRequest {
+    
+    const filterSensitiveLog: (obj: DescribeRegistryRequest) => any;
+}
+
+export interface ReplicationDestination {
+    
+    region: string | undefined;
+    
+    registryId: string | undefined;
+}
+export declare namespace ReplicationDestination {
+    
+    const filterSensitiveLog: (obj: ReplicationDestination) => any;
+}
+export declare enum RepositoryFilterType {
+    PREFIX_MATCH = "PREFIX_MATCH"
+}
+
+export interface RepositoryFilter {
+    
+    filter: string | undefined;
+    
+    filterType: RepositoryFilterType | string | undefined;
+}
+export declare namespace RepositoryFilter {
+    
+    const filterSensitiveLog: (obj: RepositoryFilter) => any;
+}
+
+export interface ReplicationRule {
+    
+    destinations: ReplicationDestination[] | undefined;
+    
+    repositoryFilters?: RepositoryFilter[];
+}
+export declare namespace ReplicationRule {
+    
+    const filterSensitiveLog: (obj: ReplicationRule) => any;
+}
+
+export interface ReplicationConfiguration {
+    
+    rules: ReplicationRule[] | undefined;
+}
+export declare namespace ReplicationConfiguration {
+    
+    const filterSensitiveLog: (obj: ReplicationConfiguration) => any;
+}
+export interface DescribeRegistryResponse {
+    
+    registryId?: string;
+    
+    replicationConfiguration?: ReplicationConfiguration;
+}
+export declare namespace DescribeRegistryResponse {
+    
+    const filterSensitiveLog: (obj: DescribeRegistryResponse) => any;
+}
+export interface DescribeRepositoriesRequest {
+    
+    registryId?: string;
+    
+    repositoryNames?: string[];
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace DescribeRepositoriesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeRepositoriesRequest) => any;
+}
+export interface DescribeRepositoriesResponse {
+    
+    repositories?: Repository[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeRepositoriesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeRepositoriesResponse) => any;
+}
+export interface GetAuthorizationTokenRequest {
+    
+    registryIds?: string[];
+}
+export declare namespace GetAuthorizationTokenRequest {
+    
+    const filterSensitiveLog: (obj: GetAuthorizationTokenRequest) => any;
+}
+
+export interface AuthorizationData {
+    
+    authorizationToken?: string;
+    
+    expiresAt?: Date;
+    
+    proxyEndpoint?: string;
+}
+export declare namespace AuthorizationData {
+    
+    const filterSensitiveLog: (obj: AuthorizationData) => any;
+}
+export interface GetAuthorizationTokenResponse {
+    
+    authorizationData?: AuthorizationData[];
+}
+export declare namespace GetAuthorizationTokenResponse {
+    
+    const filterSensitiveLog: (obj: GetAuthorizationTokenResponse) => any;
+}
+export interface GetDownloadUrlForLayerRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    layerDigest: string | undefined;
+}
+export declare namespace GetDownloadUrlForLayerRequest {
+    
+    const filterSensitiveLog: (obj: GetDownloadUrlForLayerRequest) => any;
+}
+export interface GetDownloadUrlForLayerResponse {
+    
+    downloadUrl?: string;
+    
+    layerDigest?: string;
+}
+export declare namespace GetDownloadUrlForLayerResponse {
+    
+    const filterSensitiveLog: (obj: GetDownloadUrlForLayerResponse) => any;
+}
+
+export interface LayerInaccessibleException extends __SmithyException, $MetadataBearer {
+    name: "LayerInaccessibleException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace LayerInaccessibleException {
+    
+    const filterSensitiveLog: (obj: LayerInaccessibleException) => any;
+}
+
+export interface LayersNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "LayersNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace LayersNotFoundException {
+    
+    const filterSensitiveLog: (obj: LayersNotFoundException) => any;
+}
+export interface GetLifecyclePolicyRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+}
+export declare namespace GetLifecyclePolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetLifecyclePolicyRequest) => any;
+}
+export interface GetLifecyclePolicyResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    lifecyclePolicyText?: string;
+    
+    lastEvaluatedAt?: Date;
+}
+export declare namespace GetLifecyclePolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetLifecyclePolicyResponse) => any;
+}
+
+export interface LifecyclePolicyPreviewFilter {
+    
+    tagStatus?: TagStatus | string;
+}
+export declare namespace LifecyclePolicyPreviewFilter {
+    
+    const filterSensitiveLog: (obj: LifecyclePolicyPreviewFilter) => any;
+}
+export interface GetLifecyclePolicyPreviewRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    imageIds?: ImageIdentifier[];
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    filter?: LifecyclePolicyPreviewFilter;
+}
+export declare namespace GetLifecyclePolicyPreviewRequest {
+    
+    const filterSensitiveLog: (obj: GetLifecyclePolicyPreviewRequest) => any;
+}
+export declare enum ImageActionType {
+    EXPIRE = "EXPIRE"
+}
+
+export interface LifecyclePolicyRuleAction {
+    
+    type?: ImageActionType | string;
+}
+export declare namespace LifecyclePolicyRuleAction {
+    
+    const filterSensitiveLog: (obj: LifecyclePolicyRuleAction) => any;
+}
+
+export interface LifecyclePolicyPreviewResult {
+    
+    imageTags?: string[];
+    
+    imageDigest?: string;
+    
+    imagePushedAt?: Date;
+    
+    action?: LifecyclePolicyRuleAction;
+    
+    appliedRulePriority?: number;
+}
+export declare namespace LifecyclePolicyPreviewResult {
+    
+    const filterSensitiveLog: (obj: LifecyclePolicyPreviewResult) => any;
+}
+export declare enum LifecyclePolicyPreviewStatus {
+    COMPLETE = "COMPLETE",
+    EXPIRED = "EXPIRED",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS"
+}
+
+export interface LifecyclePolicyPreviewSummary {
+    
+    expiringImageTotalCount?: number;
+}
+export declare namespace LifecyclePolicyPreviewSummary {
+    
+    const filterSensitiveLog: (obj: LifecyclePolicyPreviewSummary) => any;
+}
+export interface GetLifecyclePolicyPreviewResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    lifecyclePolicyText?: string;
+    
+    status?: LifecyclePolicyPreviewStatus | string;
+    
+    nextToken?: string;
+    
+    previewResults?: LifecyclePolicyPreviewResult[];
+    
+    summary?: LifecyclePolicyPreviewSummary;
+}
+export declare namespace GetLifecyclePolicyPreviewResponse {
+    
+    const filterSensitiveLog: (obj: GetLifecyclePolicyPreviewResponse) => any;
+}
+
+export interface LifecyclePolicyPreviewNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "LifecyclePolicyPreviewNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace LifecyclePolicyPreviewNotFoundException {
+    
+    const filterSensitiveLog: (obj: LifecyclePolicyPreviewNotFoundException) => any;
+}
+export interface GetRegistryPolicyRequest {
+}
+export declare namespace GetRegistryPolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetRegistryPolicyRequest) => any;
+}
+export interface GetRegistryPolicyResponse {
+    
+    registryId?: string;
+    
+    policyText?: string;
+}
+export declare namespace GetRegistryPolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetRegistryPolicyResponse) => any;
+}
+export interface GetRepositoryPolicyRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+}
+export declare namespace GetRepositoryPolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetRepositoryPolicyRequest) => any;
+}
+export interface GetRepositoryPolicyResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    policyText?: string;
+}
+export declare namespace GetRepositoryPolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetRepositoryPolicyResponse) => any;
+}
+export interface InitiateLayerUploadRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+}
+export declare namespace InitiateLayerUploadRequest {
+    
+    const filterSensitiveLog: (obj: InitiateLayerUploadRequest) => any;
+}
+export interface InitiateLayerUploadResponse {
+    
+    uploadId?: string;
+    
+    partSize?: number;
+}
+export declare namespace InitiateLayerUploadResponse {
+    
+    const filterSensitiveLog: (obj: InitiateLayerUploadResponse) => any;
+}
+
+export interface ListImagesFilter {
+    
+    tagStatus?: TagStatus | string;
+}
+export declare namespace ListImagesFilter {
+    
+    const filterSensitiveLog: (obj: ListImagesFilter) => any;
+}
+export interface ListImagesRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    filter?: ListImagesFilter;
+}
+export declare namespace ListImagesRequest {
+    
+    const filterSensitiveLog: (obj: ListImagesRequest) => any;
+}
+export interface ListImagesResponse {
+    
+    imageIds?: ImageIdentifier[];
+    
+    nextToken?: string;
+}
+export declare namespace ListImagesResponse {
+    
+    const filterSensitiveLog: (obj: ListImagesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export interface ImageAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "ImageAlreadyExistsException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ImageAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: ImageAlreadyExistsException) => any;
+}
+
+export interface ImageDigestDoesNotMatchException extends __SmithyException, $MetadataBearer {
+    name: "ImageDigestDoesNotMatchException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ImageDigestDoesNotMatchException {
+    
+    const filterSensitiveLog: (obj: ImageDigestDoesNotMatchException) => any;
+}
+
+export interface ImageTagAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "ImageTagAlreadyExistsException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ImageTagAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: ImageTagAlreadyExistsException) => any;
+}
+export interface PutImageRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    imageManifest: string | undefined;
+    
+    imageManifestMediaType?: string;
+    
+    imageTag?: string;
+    
+    imageDigest?: string;
+}
+export declare namespace PutImageRequest {
+    
+    const filterSensitiveLog: (obj: PutImageRequest) => any;
+}
+export interface PutImageResponse {
+    
+    image?: Image;
+}
+export declare namespace PutImageResponse {
+    
+    const filterSensitiveLog: (obj: PutImageResponse) => any;
+}
+
+export interface ReferencedImagesNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ReferencedImagesNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ReferencedImagesNotFoundException {
+    
+    const filterSensitiveLog: (obj: ReferencedImagesNotFoundException) => any;
+}
+export interface PutImageScanningConfigurationRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    imageScanningConfiguration: ImageScanningConfiguration | undefined;
+}
+export declare namespace PutImageScanningConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: PutImageScanningConfigurationRequest) => any;
+}
+export interface PutImageScanningConfigurationResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    imageScanningConfiguration?: ImageScanningConfiguration;
+}
+export declare namespace PutImageScanningConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: PutImageScanningConfigurationResponse) => any;
+}
+export interface PutImageTagMutabilityRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    imageTagMutability: ImageTagMutability | string | undefined;
+}
+export declare namespace PutImageTagMutabilityRequest {
+    
+    const filterSensitiveLog: (obj: PutImageTagMutabilityRequest) => any;
+}
+export interface PutImageTagMutabilityResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    imageTagMutability?: ImageTagMutability | string;
+}
+export declare namespace PutImageTagMutabilityResponse {
+    
+    const filterSensitiveLog: (obj: PutImageTagMutabilityResponse) => any;
+}
+export interface PutLifecyclePolicyRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    lifecyclePolicyText: string | undefined;
+}
+export declare namespace PutLifecyclePolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutLifecyclePolicyRequest) => any;
+}
+export interface PutLifecyclePolicyResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    lifecyclePolicyText?: string;
+}
+export declare namespace PutLifecyclePolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutLifecyclePolicyResponse) => any;
+}
+export interface PutRegistryPolicyRequest {
+    
+    policyText: string | undefined;
+}
+export declare namespace PutRegistryPolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutRegistryPolicyRequest) => any;
+}
+export interface PutRegistryPolicyResponse {
+    
+    registryId?: string;
+    
+    policyText?: string;
+}
+export declare namespace PutRegistryPolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutRegistryPolicyResponse) => any;
+}
+export interface PutReplicationConfigurationRequest {
+    
+    replicationConfiguration: ReplicationConfiguration | undefined;
+}
+export declare namespace PutReplicationConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: PutReplicationConfigurationRequest) => any;
+}
+export interface PutReplicationConfigurationResponse {
+    
+    replicationConfiguration?: ReplicationConfiguration;
+}
+export declare namespace PutReplicationConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: PutReplicationConfigurationResponse) => any;
+}
+export interface SetRepositoryPolicyRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    policyText: string | undefined;
+    
+    force?: boolean;
+}
+export declare namespace SetRepositoryPolicyRequest {
+    
+    const filterSensitiveLog: (obj: SetRepositoryPolicyRequest) => any;
+}
+export interface SetRepositoryPolicyResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    policyText?: string;
+}
+export declare namespace SetRepositoryPolicyResponse {
+    
+    const filterSensitiveLog: (obj: SetRepositoryPolicyResponse) => any;
+}
+export interface StartImageScanRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    imageId: ImageIdentifier | undefined;
+}
+export declare namespace StartImageScanRequest {
+    
+    const filterSensitiveLog: (obj: StartImageScanRequest) => any;
+}
+export interface StartImageScanResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    imageId?: ImageIdentifier;
+    
+    imageScanStatus?: ImageScanStatus;
+}
+export declare namespace StartImageScanResponse {
+    
+    const filterSensitiveLog: (obj: StartImageScanResponse) => any;
+}
+
+export interface UnsupportedImageTypeException extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedImageTypeException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace UnsupportedImageTypeException {
+    
+    const filterSensitiveLog: (obj: UnsupportedImageTypeException) => any;
+}
+
+export interface LifecyclePolicyPreviewInProgressException extends __SmithyException, $MetadataBearer {
+    name: "LifecyclePolicyPreviewInProgressException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace LifecyclePolicyPreviewInProgressException {
+    
+    const filterSensitiveLog: (obj: LifecyclePolicyPreviewInProgressException) => any;
+}
+export interface StartLifecyclePolicyPreviewRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    lifecyclePolicyText?: string;
+}
+export declare namespace StartLifecyclePolicyPreviewRequest {
+    
+    const filterSensitiveLog: (obj: StartLifecyclePolicyPreviewRequest) => any;
+}
+export interface StartLifecyclePolicyPreviewResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    lifecyclePolicyText?: string;
+    
+    status?: LifecyclePolicyPreviewStatus | string;
+}
+export declare namespace StartLifecyclePolicyPreviewResponse {
+    
+    const filterSensitiveLog: (obj: StartLifecyclePolicyPreviewResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+
+export interface InvalidLayerPartException extends __SmithyException, $MetadataBearer {
+    name: "InvalidLayerPartException";
+    $fault: "client";
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    uploadId?: string;
+    
+    lastValidByteReceived?: number;
+    
+    message?: string;
+}
+export declare namespace InvalidLayerPartException {
+    
+    const filterSensitiveLog: (obj: InvalidLayerPartException) => any;
+}
+export interface UploadLayerPartRequest {
+    
+    registryId?: string;
+    
+    repositoryName: string | undefined;
+    
+    uploadId: string | undefined;
+    
+    partFirstByte: number | undefined;
+    
+    partLastByte: number | undefined;
+    
+    layerPartBlob: Uint8Array | undefined;
+}
+export declare namespace UploadLayerPartRequest {
+    
+    const filterSensitiveLog: (obj: UploadLayerPartRequest) => any;
+}
+export interface UploadLayerPartResponse {
+    
+    registryId?: string;
+    
+    repositoryName?: string;
+    
+    uploadId?: string;
+    
+    lastByteReceived?: number;
+}
+export declare namespace UploadLayerPartResponse {
+    
+    const filterSensitiveLog: (obj: UploadLayerPartResponse) => any;
+}