@aws-sdk/client-ecr 3.1156.0 → 3.1157.0

package/dist-types/commands/DescribeReplicationBackfillResultsCommand.d.ts

@@ -0,0 +1,127 @@
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { DescribeReplicationBackfillResultsRequest, DescribeReplicationBackfillResultsResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+/**
+ * @public
+ *
+ * The input for {@link DescribeReplicationBackfillResultsCommand}.
+ */
+export interface DescribeReplicationBackfillResultsCommandInput extends DescribeReplicationBackfillResultsRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link DescribeReplicationBackfillResultsCommand}.
+ */
+export interface DescribeReplicationBackfillResultsCommandOutput extends DescribeReplicationBackfillResultsResponse, __MetadataBearer {
+}
+declare const DescribeReplicationBackfillResultsCommand_base: {
+    new (input: DescribeReplicationBackfillResultsCommandInput): import("@smithy/core/client").CommandImpl<DescribeReplicationBackfillResultsCommandInput, DescribeReplicationBackfillResultsCommandOutput, import("..").ECRClientResolvedConfig, import("..").ServiceInputTypes, import("..").ServiceOutputTypes>;
+    new (input: DescribeReplicationBackfillResultsCommandInput): import("@smithy/core/client").CommandImpl<DescribeReplicationBackfillResultsCommandInput, DescribeReplicationBackfillResultsCommandOutput, import("..").ECRClientResolvedConfig, import("..").ServiceInputTypes, import("..").ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * <p>Returns the status, progress, and per-image results for a replication backfill. The
+ *             backfill to describe is identified by the <code>replicationBackfillId</code> returned by
+ *             the <a>StartReplicationBackfill</a> operation.</p>
+ *          <note>
+ *             <p>The per-image results are available only after the replication backfill reaches a
+ *                 terminal status.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ECRClient, DescribeReplicationBackfillResultsCommand } from "@aws-sdk/client-ecr"; // ES Modules import
+ * // const { ECRClient, DescribeReplicationBackfillResultsCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
+ * // import type { ECRClientConfig } from "@aws-sdk/client-ecr";
+ * const config = {}; // type is ECRClientConfig
+ * const client = new ECRClient(config);
+ * const input = { // DescribeReplicationBackfillResultsRequest
+ *   registryId: "STRING_VALUE",
+ *   replicationBackfillId: "STRING_VALUE", // required
+ *   resultStatusFilter: "COMPLETE" || "FAILED",
+ *   maxResults: Number("int"),
+ *   nextToken: "STRING_VALUE",
+ * };
+ * const command = new DescribeReplicationBackfillResultsCommand(input);
+ * const response = await client.send(command);
+ * // { // DescribeReplicationBackfillResultsResponse
+ * //   registryId: "STRING_VALUE",
+ * //   replicationBackfillId: "STRING_VALUE",
+ * //   destination: { // ReplicationDestination
+ * //     region: "STRING_VALUE", // required
+ * //     registryId: "STRING_VALUE", // required
+ * //   },
+ * //   status: "PREPARING" || "IN_PROGRESS" || "COMPLETE" || "FAILED" || "STOPPING" || "STOPPED",
+ * //   failureCode: "STRING_VALUE",
+ * //   progress: { // ReplicationBackfillProgress
+ * //     totalReplicationCount: Number("int"), // required
+ * //     completedReplicationCount: Number("int"), // required
+ * //     failedReplicationCount: Number("int"), // required
+ * //     failureCodes: [ // ReplicationErrorList // required
+ * //       "STRING_VALUE",
+ * //     ],
+ * //   },
+ * //   results: [ // ReplicationBackfillResultList
+ * //     { // ReplicationBackfillResult
+ * //       repositoryName: "STRING_VALUE", // required
+ * //       imageId: { // ImageIdentifier
+ * //         imageDigest: "STRING_VALUE",
+ * //         imageTag: "STRING_VALUE",
+ * //       },
+ * //       status: "COMPLETE" || "FAILED", // required
+ * //       failureCode: "STRING_VALUE",
+ * //       subImageFailureCodes: [
+ * //         "STRING_VALUE",
+ * //       ],
+ * //     },
+ * //   ],
+ * //   startedAt: new Date("TIMESTAMP"),
+ * //   endedAt: new Date("TIMESTAMP"),
+ * //   nextToken: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param DescribeReplicationBackfillResultsCommandInput - {@link DescribeReplicationBackfillResultsCommandInput}
+ * @returns {@link DescribeReplicationBackfillResultsCommandOutput}
+ * @see {@link DescribeReplicationBackfillResultsCommandInput} for command's `input` shape.
+ * @see {@link DescribeReplicationBackfillResultsCommandOutput} for command's `response` shape.
+ * @see {@link ECRClientResolvedConfig | config} for ECRClient's `config` shape.
+ *
+ * @throws {@link InvalidParameterException} (client fault)
+ *  <p>The specified parameter is invalid. Review the available parameters for the API
+ *             request.</p>
+ *
+ * @throws {@link ReplicationBackfillNotFoundException} (client fault)
+ *  <p>The specified replication backfill could not be found. Check the specified replication
+ *             backfill ID and ensure that you are operating on the correct registry.</p>
+ *
+ * @throws {@link ServerException} (server fault)
+ *  <p>These errors are usually caused by a server-side issue.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>There was an exception validating this request.</p>
+ *
+ * @throws {@link ECRServiceException}
+ * <p>Base exception class for all service exceptions from ECR service.</p>
+ *
+ *
+ * @public
+ */
+export declare class DescribeReplicationBackfillResultsCommand extends DescribeReplicationBackfillResultsCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: DescribeReplicationBackfillResultsRequest;
+            output: DescribeReplicationBackfillResultsResponse;
+        };
+        sdk: {
+            input: DescribeReplicationBackfillResultsCommandInput;
+            output: DescribeReplicationBackfillResultsCommandOutput;
+        };
+    };
+}

package/dist-types/commands/ListReplicationBackfillsCommand.d.ts

@@ -0,0 +1,110 @@
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { ListReplicationBackfillsRequest, ListReplicationBackfillsResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+/**
+ * @public
+ *
+ * The input for {@link ListReplicationBackfillsCommand}.
+ */
+export interface ListReplicationBackfillsCommandInput extends ListReplicationBackfillsRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListReplicationBackfillsCommand}.
+ */
+export interface ListReplicationBackfillsCommandOutput extends ListReplicationBackfillsResponse, __MetadataBearer {
+}
+declare const ListReplicationBackfillsCommand_base: {
+    new (input: ListReplicationBackfillsCommandInput): import("@smithy/core/client").CommandImpl<ListReplicationBackfillsCommandInput, ListReplicationBackfillsCommandOutput, import("..").ECRClientResolvedConfig, import("..").ServiceInputTypes, import("..").ServiceOutputTypes>;
+    new (...[input]: [] | [ListReplicationBackfillsCommandInput]): import("@smithy/core/client").CommandImpl<ListReplicationBackfillsCommandInput, ListReplicationBackfillsCommandOutput, import("..").ECRClientResolvedConfig, import("..").ServiceInputTypes, import("..").ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * <p>Lists the replication backfills for a registry, including their status and
+ *             progress.</p>
+ *          <note>
+ *             <p>Replication backfills that have reached a terminal status are retained for 90 days
+ *                 after they end, after which they are no longer returned.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ECRClient, ListReplicationBackfillsCommand } from "@aws-sdk/client-ecr"; // ES Modules import
+ * // const { ECRClient, ListReplicationBackfillsCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
+ * // import type { ECRClientConfig } from "@aws-sdk/client-ecr";
+ * const config = {}; // type is ECRClientConfig
+ * const client = new ECRClient(config);
+ * const input = { // ListReplicationBackfillsRequest
+ *   registryId: "STRING_VALUE",
+ *   maxResults: Number("int"),
+ *   nextToken: "STRING_VALUE",
+ * };
+ * const command = new ListReplicationBackfillsCommand(input);
+ * const response = await client.send(command);
+ * // { // ListReplicationBackfillsResponse
+ * //   registryId: "STRING_VALUE",
+ * //   backfills: [ // ReplicationBackfillSummaryList
+ * //     { // ReplicationBackfillSummary
+ * //       replicationBackfillId: "STRING_VALUE", // required
+ * //       destination: { // ReplicationDestination
+ * //         region: "STRING_VALUE", // required
+ * //         registryId: "STRING_VALUE", // required
+ * //       },
+ * //       status: "PREPARING" || "IN_PROGRESS" || "COMPLETE" || "FAILED" || "STOPPING" || "STOPPED", // required
+ * //       failureCode: "STRING_VALUE",
+ * //       progress: { // ReplicationBackfillProgress
+ * //         totalReplicationCount: Number("int"), // required
+ * //         completedReplicationCount: Number("int"), // required
+ * //         failedReplicationCount: Number("int"), // required
+ * //         failureCodes: [ // ReplicationErrorList // required
+ * //           "STRING_VALUE",
+ * //         ],
+ * //       },
+ * //       startedAt: new Date("TIMESTAMP"), // required
+ * //       endedAt: new Date("TIMESTAMP"),
+ * //     },
+ * //   ],
+ * //   nextToken: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param ListReplicationBackfillsCommandInput - {@link ListReplicationBackfillsCommandInput}
+ * @returns {@link ListReplicationBackfillsCommandOutput}
+ * @see {@link ListReplicationBackfillsCommandInput} for command's `input` shape.
+ * @see {@link ListReplicationBackfillsCommandOutput} for command's `response` shape.
+ * @see {@link ECRClientResolvedConfig | config} for ECRClient's `config` shape.
+ *
+ * @throws {@link InvalidParameterException} (client fault)
+ *  <p>The specified parameter is invalid. Review the available parameters for the API
+ *             request.</p>
+ *
+ * @throws {@link ServerException} (server fault)
+ *  <p>These errors are usually caused by a server-side issue.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>There was an exception validating this request.</p>
+ *
+ * @throws {@link ECRServiceException}
+ * <p>Base exception class for all service exceptions from ECR service.</p>
+ *
+ *
+ * @public
+ */
+export declare class ListReplicationBackfillsCommand extends ListReplicationBackfillsCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: ListReplicationBackfillsRequest;
+            output: ListReplicationBackfillsResponse;
+        };
+        sdk: {
+            input: ListReplicationBackfillsCommandInput;
+            output: ListReplicationBackfillsCommandOutput;
+        };
+    };
+}

package/dist-types/commands/StartReplicationBackfillCommand.d.ts

@@ -0,0 +1,120 @@
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { StartReplicationBackfillRequest, StartReplicationBackfillResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+/**
+ * @public
+ *
+ * The input for {@link StartReplicationBackfillCommand}.
+ */
+export interface StartReplicationBackfillCommandInput extends StartReplicationBackfillRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link StartReplicationBackfillCommand}.
+ */
+export interface StartReplicationBackfillCommandOutput extends StartReplicationBackfillResponse, __MetadataBearer {
+}
+declare const StartReplicationBackfillCommand_base: {
+    new (input: StartReplicationBackfillCommandInput): import("@smithy/core/client").CommandImpl<StartReplicationBackfillCommandInput, StartReplicationBackfillCommandOutput, import("..").ECRClientResolvedConfig, import("..").ServiceInputTypes, import("..").ServiceOutputTypes>;
+    new (input: StartReplicationBackfillCommandInput): import("@smithy/core/client").CommandImpl<StartReplicationBackfillCommandInput, StartReplicationBackfillCommandOutput, import("..").ECRClientResolvedConfig, import("..").ServiceInputTypes, import("..").ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * <p>Starts a replication backfill for a registry. A replication backfill replicates a
+ *             registry's existing images that match its replication configuration to the specified
+ *             destination. Use the <a>DescribeReplicationBackfillResults</a> operation to
+ *             monitor the progress of a replication backfill, and to retrieve its per-image results
+ *             after it reaches a terminal status.</p>
+ *          <note>
+ *             <p>The destination must already be configured in the registry's replication
+ *                 configuration.</p>
+ *          </note>
+ *          <note>
+ *             <p>Only one replication backfill can be in progress for a given destination Region at
+ *                 a time. Starting a replication backfill for a destination Region that already has one
+ *                 in progress fails with a <code>ReplicationBackfillInProgressException</code>. In
+ *                 addition, a registry can have at most 10 replication backfills in progress at once.
+ *                 Starting a replication backfill that would exceed this limit fails with a
+ *                 <code>LimitExceededException</code>.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ECRClient, StartReplicationBackfillCommand } from "@aws-sdk/client-ecr"; // ES Modules import
+ * // const { ECRClient, StartReplicationBackfillCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
+ * // import type { ECRClientConfig } from "@aws-sdk/client-ecr";
+ * const config = {}; // type is ECRClientConfig
+ * const client = new ECRClient(config);
+ * const input = { // StartReplicationBackfillRequest
+ *   registryId: "STRING_VALUE",
+ *   destination: { // ReplicationDestination
+ *     region: "STRING_VALUE", // required
+ *     registryId: "STRING_VALUE", // required
+ *   },
+ * };
+ * const command = new StartReplicationBackfillCommand(input);
+ * const response = await client.send(command);
+ * // { // StartReplicationBackfillResponse
+ * //   replicationBackfillId: "STRING_VALUE",
+ * //   registryId: "STRING_VALUE",
+ * //   destination: { // ReplicationDestination
+ * //     region: "STRING_VALUE", // required
+ * //     registryId: "STRING_VALUE", // required
+ * //   },
+ * //   status: "PREPARING" || "IN_PROGRESS" || "COMPLETE" || "FAILED" || "STOPPING" || "STOPPED",
+ * //   startedAt: new Date("TIMESTAMP"),
+ * // };
+ *
+ * ```
+ *
+ * @param StartReplicationBackfillCommandInput - {@link StartReplicationBackfillCommandInput}
+ * @returns {@link StartReplicationBackfillCommandOutput}
+ * @see {@link StartReplicationBackfillCommandInput} for command's `input` shape.
+ * @see {@link StartReplicationBackfillCommandOutput} for command's `response` shape.
+ * @see {@link ECRClientResolvedConfig | config} for ECRClient's `config` shape.
+ *
+ * @throws {@link InvalidParameterException} (client fault)
+ *  <p>The specified parameter is invalid. Review the available parameters for the API
+ *             request.</p>
+ *
+ * @throws {@link LimitExceededException} (client fault)
+ *  <p>The operation did not succeed because it would have exceeded a service limit for your
+ *             account. For more information, see <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/service-quotas.html">Amazon ECR service quotas</a> in
+ *             the Amazon Elastic Container Registry User Guide.</p>
+ *
+ * @throws {@link ReplicationBackfillInProgressException} (client fault)
+ *  <p>A replication backfill is already in progress for the specified destination Region.
+ *             This occurs because only one replication backfill can be in progress for a given
+ *             destination Region at a time. Wait for the in progress backfill to reach a terminal
+ *             status, or stop it with the <a>StopReplicationBackfill</a> operation, before
+ *             starting another one.</p>
+ *
+ * @throws {@link ServerException} (server fault)
+ *  <p>These errors are usually caused by a server-side issue.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>There was an exception validating this request.</p>
+ *
+ * @throws {@link ECRServiceException}
+ * <p>Base exception class for all service exceptions from ECR service.</p>
+ *
+ *
+ * @public
+ */
+export declare class StartReplicationBackfillCommand extends StartReplicationBackfillCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: StartReplicationBackfillRequest;
+            output: StartReplicationBackfillResponse;
+        };
+        sdk: {
+            input: StartReplicationBackfillCommandInput;
+            output: StartReplicationBackfillCommandOutput;
+        };
+    };
+}

package/dist-types/commands/StopReplicationBackfillCommand.d.ts

@@ -0,0 +1,104 @@
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { StopReplicationBackfillRequest, StopReplicationBackfillResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+/**
+ * @public
+ *
+ * The input for {@link StopReplicationBackfillCommand}.
+ */
+export interface StopReplicationBackfillCommandInput extends StopReplicationBackfillRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link StopReplicationBackfillCommand}.
+ */
+export interface StopReplicationBackfillCommandOutput extends StopReplicationBackfillResponse, __MetadataBearer {
+}
+declare const StopReplicationBackfillCommand_base: {
+    new (input: StopReplicationBackfillCommandInput): import("@smithy/core/client").CommandImpl<StopReplicationBackfillCommandInput, StopReplicationBackfillCommandOutput, import("..").ECRClientResolvedConfig, import("..").ServiceInputTypes, import("..").ServiceOutputTypes>;
+    new (input: StopReplicationBackfillCommandInput): import("@smithy/core/client").CommandImpl<StopReplicationBackfillCommandInput, StopReplicationBackfillCommandOutput, import("..").ECRClientResolvedConfig, import("..").ServiceInputTypes, import("..").ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
+};
+/**
+ * <p>Stops an in progress replication backfill for a registry. The backfill to stop is
+ *             identified by the <code>replicationBackfillId</code> returned by the <a>StartReplicationBackfill</a> operation.</p>
+ *          <note>
+ *             <p>Images that have already been replicated are not affected, and replications that
+ *                 are already in progress continue to completion.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ECRClient, StopReplicationBackfillCommand } from "@aws-sdk/client-ecr"; // ES Modules import
+ * // const { ECRClient, StopReplicationBackfillCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
+ * // import type { ECRClientConfig } from "@aws-sdk/client-ecr";
+ * const config = {}; // type is ECRClientConfig
+ * const client = new ECRClient(config);
+ * const input = { // StopReplicationBackfillRequest
+ *   registryId: "STRING_VALUE",
+ *   replicationBackfillId: "STRING_VALUE", // required
+ * };
+ * const command = new StopReplicationBackfillCommand(input);
+ * const response = await client.send(command);
+ * // { // StopReplicationBackfillResponse
+ * //   registryId: "STRING_VALUE",
+ * //   replicationBackfillId: "STRING_VALUE",
+ * //   destination: { // ReplicationDestination
+ * //     region: "STRING_VALUE", // required
+ * //     registryId: "STRING_VALUE", // required
+ * //   },
+ * //   status: "PREPARING" || "IN_PROGRESS" || "COMPLETE" || "FAILED" || "STOPPING" || "STOPPED",
+ * //   startedAt: new Date("TIMESTAMP"),
+ * // };
+ *
+ * ```
+ *
+ * @param StopReplicationBackfillCommandInput - {@link StopReplicationBackfillCommandInput}
+ * @returns {@link StopReplicationBackfillCommandOutput}
+ * @see {@link StopReplicationBackfillCommandInput} for command's `input` shape.
+ * @see {@link StopReplicationBackfillCommandOutput} for command's `response` shape.
+ * @see {@link ECRClientResolvedConfig | config} for ECRClient's `config` shape.
+ *
+ * @throws {@link InvalidParameterException} (client fault)
+ *  <p>The specified parameter is invalid. Review the available parameters for the API
+ *             request.</p>
+ *
+ * @throws {@link ReplicationBackfillInvalidStatusException} (client fault)
+ *  <p>The requested operation can't be performed on the replication backfill because it is
+ *             not in a valid status for that operation. For example, you can't stop a replication
+ *             backfill that has already reached a terminal status. Use the <a>DescribeReplicationBackfillResults</a> operation to check the current status
+ *             before retrying.</p>
+ *
+ * @throws {@link ReplicationBackfillNotFoundException} (client fault)
+ *  <p>The specified replication backfill could not be found. Check the specified replication
+ *             backfill ID and ensure that you are operating on the correct registry.</p>
+ *
+ * @throws {@link ServerException} (server fault)
+ *  <p>These errors are usually caused by a server-side issue.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>There was an exception validating this request.</p>
+ *
+ * @throws {@link ECRServiceException}
+ * <p>Base exception class for all service exceptions from ECR service.</p>
+ *
+ *
+ * @public
+ */
+export declare class StopReplicationBackfillCommand extends StopReplicationBackfillCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: StopReplicationBackfillRequest;
+            output: StopReplicationBackfillResponse;
+        };
+        sdk: {
+            input: StopReplicationBackfillCommandInput;
+            output: StopReplicationBackfillCommandOutput;
+        };
+    };
+}

package/dist-types/commands/index.d.ts

@@ -20,6 +20,7 @@ export * from "./DescribeImageSigningStatusCommand";
 export * from "./DescribeImagesCommand";
 export * from "./DescribePullThroughCacheRulesCommand";
 export * from "./DescribeRegistryCommand";
+export * from "./DescribeReplicationBackfillResultsCommand";
 export * from "./DescribeRepositoriesCommand";
 export * from "./DescribeRepositoryCreationTemplatesCommand";
 export * from "./GetAccountSettingCommand";
@@ -35,6 +36,7 @@ export * from "./InitiateLayerUploadCommand";
 export * from "./ListImageReferrersCommand";
 export * from "./ListImagesCommand";
 export * from "./ListPullTimeUpdateExclusionsCommand";
+export * from "./ListReplicationBackfillsCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./PutAccountSettingCommand";
 export * from "./PutImageCommand";
@@ -49,6 +51,8 @@ export * from "./RegisterPullTimeUpdateExclusionCommand";
 export * from "./SetRepositoryPolicyCommand";
 export * from "./StartImageScanCommand";
 export * from "./StartLifecyclePolicyPreviewCommand";
+export * from "./StartReplicationBackfillCommand";
+export * from "./StopReplicationBackfillCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateImageStorageClassCommand";

package/dist-types/models/enums.d.ts

@@ -273,6 +273,34 @@ export declare const RepositoryFilterType: {
  * @public
  */
 export type RepositoryFilterType = (typeof RepositoryFilterType)[keyof typeof RepositoryFilterType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ReplicationBackfillResultStatus: {
+    readonly COMPLETE: "COMPLETE";
+    readonly FAILED: "FAILED";
+};
+/**
+ * @public
+ */
+export type ReplicationBackfillResultStatus = (typeof ReplicationBackfillResultStatus)[keyof typeof ReplicationBackfillResultStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ReplicationBackfillStatus: {
+    readonly COMPLETE: "COMPLETE";
+    readonly FAILED: "FAILED";
+    readonly IN_PROGRESS: "IN_PROGRESS";
+    readonly PREPARING: "PREPARING";
+    readonly STOPPED: "STOPPED";
+    readonly STOPPING: "STOPPING";
+};
+/**
+ * @public
+ */
+export type ReplicationBackfillStatus = (typeof ReplicationBackfillStatus)[keyof typeof ReplicationBackfillStatus];
 /**
  * @public
  * @enum

package/dist-types/models/errors.d.ts

@@ -430,6 +430,20 @@ export declare class ScanNotFoundException extends __BaseException {
      */
     constructor(opts: __ExceptionOptionType<ScanNotFoundException, __BaseException>);
 }
+/**
+ * <p>The specified replication backfill could not be found. Check the specified replication
+ *             backfill ID and ensure that you are operating on the correct registry.</p>
+ * @public
+ */
+export declare class ReplicationBackfillNotFoundException extends __BaseException {
+    static readonly shapeId: string;
+    readonly name: "ReplicationBackfillNotFoundException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReplicationBackfillNotFoundException, __BaseException>);
+}
 /**
  * <p>The specified layer is not available because it is not associated with an image.
  *             Unassociated image layers may be cleaned up at any time.</p>
@@ -621,6 +635,39 @@ export declare class LifecyclePolicyPreviewInProgressException extends __BaseExc
      */
     constructor(opts: __ExceptionOptionType<LifecyclePolicyPreviewInProgressException, __BaseException>);
 }
+/**
+ * <p>A replication backfill is already in progress for the specified destination Region.
+ *             This occurs because only one replication backfill can be in progress for a given
+ *             destination Region at a time. Wait for the in progress backfill to reach a terminal
+ *             status, or stop it with the <a>StopReplicationBackfill</a> operation, before
+ *             starting another one.</p>
+ * @public
+ */
+export declare class ReplicationBackfillInProgressException extends __BaseException {
+    static readonly shapeId: string;
+    readonly name: "ReplicationBackfillInProgressException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReplicationBackfillInProgressException, __BaseException>);
+}
+/**
+ * <p>The requested operation can't be performed on the replication backfill because it is
+ *             not in a valid status for that operation. For example, you can't stop a replication
+ *             backfill that has already reached a terminal status. Use the <a>DescribeReplicationBackfillResults</a> operation to check the current status
+ *             before retrying.</p>
+ * @public
+ */
+export declare class ReplicationBackfillInvalidStatusException extends __BaseException {
+    static readonly shapeId: string;
+    readonly name: "ReplicationBackfillInvalidStatusException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReplicationBackfillInvalidStatusException, __BaseException>);
+}
 /**
  * <p>The requested image storage class update is not supported.</p>
  * @public