@aws-sdk/client-ecr 3.43.0 → 3.47.0

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

@@ -64,10 +64,6 @@ export interface InvalidParameterException extends __SmithyException, $MetadataB
     
     message?: string;
 }
-export declare namespace InvalidParameterException {
-    
-    const filterSensitiveLog: (obj: InvalidParameterException) => any;
-}
 
 export interface RepositoryNotFoundException extends __SmithyException, $MetadataBearer {
     name: "RepositoryNotFoundException";
@@ -75,10 +71,6 @@ export interface RepositoryNotFoundException extends __SmithyException, $Metadat
     
     message?: string;
 }
-export declare namespace RepositoryNotFoundException {
-    
-    const filterSensitiveLog: (obj: RepositoryNotFoundException) => any;
-}
 
 export interface ServerException extends __SmithyException, $MetadataBearer {
     name: "ServerException";
@@ -86,10 +78,6 @@ export interface ServerException extends __SmithyException, $MetadataBearer {
     
     message?: string;
 }
-export declare namespace ServerException {
-    
-    const filterSensitiveLog: (obj: ServerException) => any;
-}
 
 export interface ImageIdentifier {
     
@@ -187,6 +175,82 @@ export declare namespace BatchGetImageResponse {
     
     const filterSensitiveLog: (obj: BatchGetImageResponse) => any;
 }
+export interface BatchGetRepositoryScanningConfigurationRequest {
+    
+    repositoryNames: string[] | undefined;
+}
+export declare namespace BatchGetRepositoryScanningConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: BatchGetRepositoryScanningConfigurationRequest) => any;
+}
+export declare enum ScanningConfigurationFailureCode {
+    REPOSITORY_NOT_FOUND = "REPOSITORY_NOT_FOUND"
+}
+
+export interface RepositoryScanningConfigurationFailure {
+    
+    repositoryName?: string;
+    
+    failureCode?: ScanningConfigurationFailureCode | string;
+    
+    failureReason?: string;
+}
+export declare namespace RepositoryScanningConfigurationFailure {
+    
+    const filterSensitiveLog: (obj: RepositoryScanningConfigurationFailure) => any;
+}
+export declare enum ScanningRepositoryFilterType {
+    WILDCARD = "WILDCARD"
+}
+
+export interface ScanningRepositoryFilter {
+    
+    filter: string | undefined;
+    
+    filterType: ScanningRepositoryFilterType | string | undefined;
+}
+export declare namespace ScanningRepositoryFilter {
+    
+    const filterSensitiveLog: (obj: ScanningRepositoryFilter) => any;
+}
+export declare enum ScanFrequency {
+    CONTINUOUS_SCAN = "CONTINUOUS_SCAN",
+    MANUAL = "MANUAL",
+    SCAN_ON_PUSH = "SCAN_ON_PUSH"
+}
+
+export interface RepositoryScanningConfiguration {
+    
+    repositoryArn?: string;
+    
+    repositoryName?: string;
+    
+    scanOnPush?: boolean;
+    
+    scanFrequency?: ScanFrequency | string;
+    
+    appliedScanFilters?: ScanningRepositoryFilter[];
+}
+export declare namespace RepositoryScanningConfiguration {
+    
+    const filterSensitiveLog: (obj: RepositoryScanningConfiguration) => any;
+}
+export interface BatchGetRepositoryScanningConfigurationResponse {
+    
+    scanningConfigurations?: RepositoryScanningConfiguration[];
+    
+    failures?: RepositoryScanningConfigurationFailure[];
+}
+export declare namespace BatchGetRepositoryScanningConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: BatchGetRepositoryScanningConfigurationResponse) => any;
+}
+
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    message?: string;
+}
 export interface CompleteLayerUploadRequest {
     
     registryId?: string;
@@ -222,10 +286,6 @@ export interface EmptyUploadException extends __SmithyException, $MetadataBearer
     
     message?: string;
 }
-export declare namespace EmptyUploadException {
-    
-    const filterSensitiveLog: (obj: EmptyUploadException) => any;
-}
 
 export interface InvalidLayerException extends __SmithyException, $MetadataBearer {
     name: "InvalidLayerException";
@@ -233,10 +293,6 @@ export interface InvalidLayerException extends __SmithyException, $MetadataBeare
     
     message?: string;
 }
-export declare namespace InvalidLayerException {
-    
-    const filterSensitiveLog: (obj: InvalidLayerException) => any;
-}
 
 export interface KmsException extends __SmithyException, $MetadataBearer {
     name: "KmsException";
@@ -245,10 +301,6 @@ export interface KmsException extends __SmithyException, $MetadataBearer {
     
     kmsError?: string;
 }
-export declare namespace KmsException {
-    
-    const filterSensitiveLog: (obj: KmsException) => any;
-}
 
 export interface LayerAlreadyExistsException extends __SmithyException, $MetadataBearer {
     name: "LayerAlreadyExistsException";
@@ -256,10 +308,6 @@ export interface LayerAlreadyExistsException extends __SmithyException, $Metadat
     
     message?: string;
 }
-export declare namespace LayerAlreadyExistsException {
-    
-    const filterSensitiveLog: (obj: LayerAlreadyExistsException) => any;
-}
 
 export interface LayerPartTooSmallException extends __SmithyException, $MetadataBearer {
     name: "LayerPartTooSmallException";
@@ -267,10 +315,6 @@ export interface LayerPartTooSmallException extends __SmithyException, $Metadata
     
     message?: string;
 }
-export declare namespace LayerPartTooSmallException {
-    
-    const filterSensitiveLog: (obj: LayerPartTooSmallException) => any;
-}
 
 export interface UploadNotFoundException extends __SmithyException, $MetadataBearer {
     name: "UploadNotFoundException";
@@ -278,9 +322,50 @@ export interface UploadNotFoundException extends __SmithyException, $MetadataBea
     
     message?: string;
 }
-export declare namespace UploadNotFoundException {
+export interface CreatePullThroughCacheRuleRequest {
+    
+    ecrRepositoryPrefix: string | undefined;
+    
+    upstreamRegistryUrl: string | undefined;
+    
+    registryId?: string;
+}
+export declare namespace CreatePullThroughCacheRuleRequest {
+    
+    const filterSensitiveLog: (obj: CreatePullThroughCacheRuleRequest) => any;
+}
+export interface CreatePullThroughCacheRuleResponse {
     
-    const filterSensitiveLog: (obj: UploadNotFoundException) => any;
+    ecrRepositoryPrefix?: string;
+    
+    upstreamRegistryUrl?: string;
+    
+    createdAt?: Date;
+    
+    registryId?: string;
+}
+export declare namespace CreatePullThroughCacheRuleResponse {
+    
+    const filterSensitiveLog: (obj: CreatePullThroughCacheRuleResponse) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+
+export interface PullThroughCacheRuleAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "PullThroughCacheRuleAlreadyExistsException";
+    $fault: "client";
+    message?: string;
+}
+
+export interface UnsupportedUpstreamRegistryException extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedUpstreamRegistryException";
+    $fault: "client";
+    message?: string;
 }
 export declare enum EncryptionType {
     AES256 = "AES256",
@@ -376,21 +461,6 @@ export interface InvalidTagParameterException extends __SmithyException, $Metada
     $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";
@@ -398,20 +468,12 @@ export interface RepositoryAlreadyExistsException extends __SmithyException, $Me
     
     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;
@@ -442,9 +504,35 @@ export interface LifecyclePolicyNotFoundException extends __SmithyException, $Me
     $fault: "client";
     message?: string;
 }
-export declare namespace LifecyclePolicyNotFoundException {
+export interface DeletePullThroughCacheRuleRequest {
+    
+    ecrRepositoryPrefix: string | undefined;
+    
+    registryId?: string;
+}
+export declare namespace DeletePullThroughCacheRuleRequest {
     
-    const filterSensitiveLog: (obj: LifecyclePolicyNotFoundException) => any;
+    const filterSensitiveLog: (obj: DeletePullThroughCacheRuleRequest) => any;
+}
+export interface DeletePullThroughCacheRuleResponse {
+    
+    ecrRepositoryPrefix?: string;
+    
+    upstreamRegistryUrl?: string;
+    
+    createdAt?: Date;
+    
+    registryId?: string;
+}
+export declare namespace DeletePullThroughCacheRuleResponse {
+    
+    const filterSensitiveLog: (obj: DeletePullThroughCacheRuleResponse) => any;
+}
+
+export interface PullThroughCacheRuleNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "PullThroughCacheRuleNotFoundException";
+    $fault: "client";
+    message?: string;
 }
 export interface DeleteRegistryPolicyRequest {
 }
@@ -468,20 +556,6 @@ export interface RegistryPolicyNotFoundException extends __SmithyException, $Met
     $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;
@@ -509,10 +583,6 @@ export interface RepositoryNotEmptyException extends __SmithyException, $Metadat
     
     message?: string;
 }
-export declare namespace RepositoryNotEmptyException {
-    
-    const filterSensitiveLog: (obj: RepositoryNotEmptyException) => any;
-}
 export interface DeleteRepositoryPolicyRequest {
     
     registryId?: string;
@@ -542,10 +612,6 @@ export interface RepositoryPolicyNotFoundException extends __SmithyException, $M
     
     message?: string;
 }
-export declare namespace RepositoryPolicyNotFoundException {
-    
-    const filterSensitiveLog: (obj: RepositoryPolicyNotFoundException) => any;
-}
 export interface DescribeImageReplicationStatusRequest {
     
     repositoryName: string | undefined;
@@ -596,10 +662,6 @@ export interface ImageNotFoundException extends __SmithyException, $MetadataBear
     $fault: "client";
     message?: string;
 }
-export declare namespace ImageNotFoundException {
-    
-    const filterSensitiveLog: (obj: ImageNotFoundException) => any;
-}
 export declare enum TagStatus {
     ANY = "ANY",
     TAGGED = "TAGGED",
@@ -656,9 +718,14 @@ export declare namespace ImageScanFindingsSummary {
     const filterSensitiveLog: (obj: ImageScanFindingsSummary) => any;
 }
 export declare enum ScanStatus {
+    ACTIVE = "ACTIVE",
     COMPLETE = "COMPLETE",
     FAILED = "FAILED",
-    IN_PROGRESS = "IN_PROGRESS"
+    FINDINGS_UNAVAILABLE = "FINDINGS_UNAVAILABLE",
+    IN_PROGRESS = "IN_PROGRESS",
+    PENDING = "PENDING",
+    SCAN_ELIGIBILITY_EXPIRED = "SCAN_ELIGIBILITY_EXPIRED",
+    UNSUPPORTED_IMAGE = "UNSUPPORTED_IMAGE"
 }
 
 export interface ImageScanStatus {
@@ -725,6 +792,214 @@ export declare namespace DescribeImageScanFindingsRequest {
     const filterSensitiveLog: (obj: DescribeImageScanFindingsRequest) => any;
 }
 
+export interface CvssScore {
+    
+    baseScore?: number;
+    
+    scoringVector?: string;
+    
+    source?: string;
+    
+    version?: string;
+}
+export declare namespace CvssScore {
+    
+    const filterSensitiveLog: (obj: CvssScore) => any;
+}
+
+export interface VulnerablePackage {
+    
+    arch?: string;
+    
+    epoch?: number;
+    
+    filePath?: string;
+    
+    name?: string;
+    
+    packageManager?: string;
+    
+    release?: string;
+    
+    sourceLayerHash?: string;
+    
+    version?: string;
+}
+export declare namespace VulnerablePackage {
+    
+    const filterSensitiveLog: (obj: VulnerablePackage) => any;
+}
+
+export interface PackageVulnerabilityDetails {
+    
+    cvss?: CvssScore[];
+    
+    referenceUrls?: string[];
+    
+    relatedVulnerabilities?: string[];
+    
+    source?: string;
+    
+    sourceUrl?: string;
+    
+    vendorCreatedAt?: Date;
+    
+    vendorSeverity?: string;
+    
+    vendorUpdatedAt?: Date;
+    
+    vulnerabilityId?: string;
+    
+    vulnerablePackages?: VulnerablePackage[];
+}
+export declare namespace PackageVulnerabilityDetails {
+    
+    const filterSensitiveLog: (obj: PackageVulnerabilityDetails) => any;
+}
+
+export interface Recommendation {
+    
+    url?: string;
+    
+    text?: string;
+}
+export declare namespace Recommendation {
+    
+    const filterSensitiveLog: (obj: Recommendation) => any;
+}
+
+export interface Remediation {
+    
+    recommendation?: Recommendation;
+}
+export declare namespace Remediation {
+    
+    const filterSensitiveLog: (obj: Remediation) => any;
+}
+
+export interface AwsEcrContainerImageDetails {
+    
+    architecture?: string;
+    
+    author?: string;
+    
+    imageHash?: string;
+    
+    imageTags?: string[];
+    
+    platform?: string;
+    
+    pushedAt?: Date;
+    
+    registry?: string;
+    
+    repositoryName?: string;
+}
+export declare namespace AwsEcrContainerImageDetails {
+    
+    const filterSensitiveLog: (obj: AwsEcrContainerImageDetails) => any;
+}
+
+export interface ResourceDetails {
+    
+    awsEcrContainerImage?: AwsEcrContainerImageDetails;
+}
+export declare namespace ResourceDetails {
+    
+    const filterSensitiveLog: (obj: ResourceDetails) => any;
+}
+
+export interface Resource {
+    
+    details?: ResourceDetails;
+    
+    id?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    type?: string;
+}
+export declare namespace Resource {
+    
+    const filterSensitiveLog: (obj: Resource) => any;
+}
+
+export interface CvssScoreAdjustment {
+    
+    metric?: string;
+    
+    reason?: string;
+}
+export declare namespace CvssScoreAdjustment {
+    
+    const filterSensitiveLog: (obj: CvssScoreAdjustment) => any;
+}
+
+export interface CvssScoreDetails {
+    
+    adjustments?: CvssScoreAdjustment[];
+    
+    score?: number;
+    
+    scoreSource?: string;
+    
+    scoringVector?: string;
+    
+    version?: string;
+}
+export declare namespace CvssScoreDetails {
+    
+    const filterSensitiveLog: (obj: CvssScoreDetails) => any;
+}
+
+export interface ScoreDetails {
+    
+    cvss?: CvssScoreDetails;
+}
+export declare namespace ScoreDetails {
+    
+    const filterSensitiveLog: (obj: ScoreDetails) => any;
+}
+
+export interface EnhancedImageScanFinding {
+    
+    awsAccountId?: string;
+    
+    description?: string;
+    
+    findingArn?: string;
+    
+    firstObservedAt?: Date;
+    
+    lastObservedAt?: Date;
+    
+    packageVulnerabilityDetails?: PackageVulnerabilityDetails;
+    
+    remediation?: Remediation;
+    
+    resources?: Resource[];
+    
+    score?: number;
+    
+    scoreDetails?: ScoreDetails;
+    
+    severity?: string;
+    
+    status?: string;
+    
+    title?: string;
+    
+    type?: string;
+    
+    updatedAt?: Date;
+}
+export declare namespace EnhancedImageScanFinding {
+    
+    const filterSensitiveLog: (obj: EnhancedImageScanFinding) => any;
+}
+
 export interface Attribute {
     
     key: string | undefined;
@@ -759,11 +1034,13 @@ export interface ImageScanFindings {
     
     vulnerabilitySourceUpdatedAt?: Date;
     
-    findings?: ImageScanFinding[];
-    
     findingSeverityCounts?: {
         [key: string]: number;
     };
+    
+    findings?: ImageScanFinding[];
+    
+    enhancedFindings?: EnhancedImageScanFinding[];
 }
 export declare namespace ImageScanFindings {
     
@@ -793,9 +1070,44 @@ export interface ScanNotFoundException extends __SmithyException, $MetadataBeare
     $fault: "client";
     message?: string;
 }
-export declare namespace ScanNotFoundException {
+export interface DescribePullThroughCacheRulesRequest {
+    
+    registryId?: string;
+    
+    ecrRepositoryPrefixes?: string[];
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace DescribePullThroughCacheRulesRequest {
+    
+    const filterSensitiveLog: (obj: DescribePullThroughCacheRulesRequest) => any;
+}
+
+export interface PullThroughCacheRule {
+    
+    ecrRepositoryPrefix?: string;
+    
+    upstreamRegistryUrl?: string;
+    
+    createdAt?: Date;
+    
+    registryId?: string;
+}
+export declare namespace PullThroughCacheRule {
+    
+    const filterSensitiveLog: (obj: PullThroughCacheRule) => any;
+}
+export interface DescribePullThroughCacheRulesResponse {
+    
+    pullThroughCacheRules?: PullThroughCacheRule[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribePullThroughCacheRulesResponse {
     
-    const filterSensitiveLog: (obj: ScanNotFoundException) => any;
+    const filterSensitiveLog: (obj: DescribePullThroughCacheRulesResponse) => any;
 }
 export interface DescribeRegistryRequest {
 }
@@ -940,10 +1252,6 @@ export interface LayerInaccessibleException extends __SmithyException, $Metadata
     
     message?: string;
 }
-export declare namespace LayerInaccessibleException {
-    
-    const filterSensitiveLog: (obj: LayerInaccessibleException) => any;
-}
 
 export interface LayersNotFoundException extends __SmithyException, $MetadataBearer {
     name: "LayersNotFoundException";
@@ -951,10 +1259,6 @@ export interface LayersNotFoundException extends __SmithyException, $MetadataBea
     
     message?: string;
 }
-export declare namespace LayersNotFoundException {
-    
-    const filterSensitiveLog: (obj: LayersNotFoundException) => any;
-}
 export interface GetLifecyclePolicyRequest {
     
     registryId?: string;
@@ -1076,10 +1380,6 @@ export interface LifecyclePolicyPreviewNotFoundException extends __SmithyExcepti
     $fault: "client";
     message?: string;
 }
-export declare namespace LifecyclePolicyPreviewNotFoundException {
-    
-    const filterSensitiveLog: (obj: LifecyclePolicyPreviewNotFoundException) => any;
-}
 export interface GetRegistryPolicyRequest {
 }
 export declare namespace GetRegistryPolicyRequest {
@@ -1096,6 +1396,48 @@ export declare namespace GetRegistryPolicyResponse {
     
     const filterSensitiveLog: (obj: GetRegistryPolicyResponse) => any;
 }
+export interface GetRegistryScanningConfigurationRequest {
+}
+export declare namespace GetRegistryScanningConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetRegistryScanningConfigurationRequest) => any;
+}
+
+export interface RegistryScanningRule {
+    
+    scanFrequency: ScanFrequency | string | undefined;
+    
+    repositoryFilters: ScanningRepositoryFilter[] | undefined;
+}
+export declare namespace RegistryScanningRule {
+    
+    const filterSensitiveLog: (obj: RegistryScanningRule) => any;
+}
+export declare enum ScanType {
+    BASIC = "BASIC",
+    ENHANCED = "ENHANCED"
+}
+
+export interface RegistryScanningConfiguration {
+    
+    scanType?: ScanType | string;
+    
+    rules?: RegistryScanningRule[];
+}
+export declare namespace RegistryScanningConfiguration {
+    
+    const filterSensitiveLog: (obj: RegistryScanningConfiguration) => any;
+}
+export interface GetRegistryScanningConfigurationResponse {
+    
+    registryId?: string;
+    
+    scanningConfiguration?: RegistryScanningConfiguration;
+}
+export declare namespace GetRegistryScanningConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetRegistryScanningConfigurationResponse) => any;
+}
 export interface GetRepositoryPolicyRequest {
     
     registryId?: string;
@@ -1196,30 +1538,18 @@ export interface ImageAlreadyExistsException extends __SmithyException, $Metadat
     
     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;
@@ -1252,10 +1582,6 @@ export interface ReferencedImagesNotFoundException extends __SmithyException, $M
     $fault: "client";
     message?: string;
 }
-export declare namespace ReferencedImagesNotFoundException {
-    
-    const filterSensitiveLog: (obj: ReferencedImagesNotFoundException) => any;
-}
 export interface PutImageScanningConfigurationRequest {
     
     registryId?: string;
@@ -1346,6 +1672,24 @@ export declare namespace PutRegistryPolicyResponse {
     
     const filterSensitiveLog: (obj: PutRegistryPolicyResponse) => any;
 }
+export interface PutRegistryScanningConfigurationRequest {
+    
+    scanType?: ScanType | string;
+    
+    rules?: RegistryScanningRule[];
+}
+export declare namespace PutRegistryScanningConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: PutRegistryScanningConfigurationRequest) => any;
+}
+export interface PutRegistryScanningConfigurationResponse {
+    
+    registryScanningConfiguration?: RegistryScanningConfiguration;
+}
+export declare namespace PutRegistryScanningConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: PutRegistryScanningConfigurationResponse) => any;
+}
 export interface PutReplicationConfigurationRequest {
     
     replicationConfiguration: ReplicationConfiguration | undefined;
@@ -1420,20 +1764,12 @@ export interface UnsupportedImageTypeException extends __SmithyException, $Metad
     $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;
@@ -1507,10 +1843,6 @@ export interface InvalidLayerPartException extends __SmithyException, $MetadataB
     
     message?: string;
 }
-export declare namespace InvalidLayerPartException {
-    
-    const filterSensitiveLog: (obj: InvalidLayerPartException) => any;
-}
 export interface UploadLayerPartRequest {
     
     registryId?: string;