@aws-sdk/client-arc-zonal-shift 3.461.0 → 3.464.0

package/dist-es/protocols/Aws_restJson1.js

@@ -18,6 +18,46 @@ export const se_CancelZonalShiftCommand = async (input, context) => {
         body,
     });
 };
+export const se_CreatePracticeRunConfigurationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configuration";
+    let body;
+    body = JSON.stringify(take(input, {
+        blockedDates: (_) => _json(_),
+        blockedWindows: (_) => _json(_),
+        blockingAlarms: (_) => _json(_),
+        outcomeAlarms: (_) => _json(_),
+        resourceIdentifier: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_DeletePracticeRunConfigurationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configuration/{resourceIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_GetManagedResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -34,6 +74,27 @@ export const se_GetManagedResourceCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListAutoshiftsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/autoshifts";
+    const query = map({
+        nextToken: [, input.nextToken],
+        status: [, input.status],
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_ListManagedResourcesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -62,6 +123,7 @@ export const se_ListZonalShiftsCommand = async (input, context) => {
         nextToken: [, input.nextToken],
         status: [, input.status],
         maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        resourceIdentifier: [, input.resourceIdentifier],
     });
     let body;
     return new __HttpRequest({
@@ -98,6 +160,51 @@ export const se_StartZonalShiftCommand = async (input, context) => {
         body,
     });
 };
+export const se_UpdatePracticeRunConfigurationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configuration/{resourceIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        blockedDates: (_) => _json(_),
+        blockedWindows: (_) => _json(_),
+        blockingAlarms: (_) => _json(_),
+        outcomeAlarms: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_UpdateZonalAutoshiftConfigurationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/managedresources/{resourceIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        zonalAutoshiftStatus: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_UpdateZonalShiftCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -174,6 +281,107 @@ const de_CancelZonalShiftCommandError = async (output, context) => {
             });
     }
 };
+export const de_CreatePracticeRunConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return de_CreatePracticeRunConfigurationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        arn: __expectString,
+        name: __expectString,
+        practiceRunConfiguration: _json,
+        zonalAutoshiftStatus: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CreatePracticeRunConfigurationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.arczonalshift#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.arczonalshift#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.arczonalshift#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.arczonalshift#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.arczonalshift#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.arczonalshift#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_DeletePracticeRunConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeletePracticeRunConfigurationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        arn: __expectString,
+        name: __expectString,
+        zonalAutoshiftStatus: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_DeletePracticeRunConfigurationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.arczonalshift#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.arczonalshift#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.arczonalshift#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.arczonalshift#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.arczonalshift#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.arczonalshift#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_GetManagedResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_GetManagedResourceCommandError(output, context);
@@ -185,7 +393,10 @@ export const de_GetManagedResourceCommand = async (output, context) => {
     const doc = take(data, {
         appliedWeights: (_) => de_AppliedWeights(_, context),
         arn: __expectString,
+        autoshifts: (_) => de_AutoshiftsInResource(_, context),
         name: __expectString,
+        practiceRunConfiguration: _json,
+        zonalAutoshiftStatus: __expectString,
         zonalShifts: (_) => de_ZonalShiftsInResource(_, context),
     });
     Object.assign(contents, doc);
@@ -222,6 +433,49 @@ const de_GetManagedResourceCommandError = async (output, context) => {
             });
     }
 };
+export const de_ListAutoshiftsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListAutoshiftsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        items: (_) => de_AutoshiftSummaries(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListAutoshiftsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.arczonalshift#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.arczonalshift#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.arczonalshift#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.arczonalshift#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListManagedResourcesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListManagedResourcesCommandError(output, context);
@@ -231,7 +485,7 @@ export const de_ListManagedResourcesCommand = async (output, context) => {
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        items: _json,
+        items: (_) => de_ManagedResourceSummaries(_, context),
         nextToken: __expectString,
     });
     Object.assign(contents, doc);
@@ -362,6 +616,106 @@ const de_StartZonalShiftCommandError = async (output, context) => {
             });
     }
 };
+export const de_UpdatePracticeRunConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_UpdatePracticeRunConfigurationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        arn: __expectString,
+        name: __expectString,
+        practiceRunConfiguration: _json,
+        zonalAutoshiftStatus: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdatePracticeRunConfigurationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.arczonalshift#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.arczonalshift#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.arczonalshift#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.arczonalshift#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.arczonalshift#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.arczonalshift#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UpdateZonalAutoshiftConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_UpdateZonalAutoshiftConfigurationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        resourceIdentifier: __expectString,
+        zonalAutoshiftStatus: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateZonalAutoshiftConfigurationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.arczonalshift#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.arczonalshift#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.arczonalshift#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.arczonalshift#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.arczonalshift#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.arczonalshift#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_UpdateZonalShiftCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_UpdateZonalShiftCommandError(output, context);
@@ -507,12 +861,64 @@ const de_AppliedWeights = (output, context) => {
         return acc;
     }, {});
 };
+const de_AutoshiftInResource = (output, context) => {
+    return take(output, {
+        appliedStatus: __expectString,
+        awayFrom: __expectString,
+        startTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+    });
+};
+const de_AutoshiftsInResource = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_AutoshiftInResource(entry, context);
+    });
+    return retVal;
+};
+const de_AutoshiftSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_AutoshiftSummary(entry, context);
+    });
+    return retVal;
+};
+const de_AutoshiftSummary = (output, context) => {
+    return take(output, {
+        awayFrom: __expectString,
+        endTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        startTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        status: __expectString,
+    });
+};
+const de_ManagedResourceSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ManagedResourceSummary(entry, context);
+    });
+    return retVal;
+};
+const de_ManagedResourceSummary = (output, context) => {
+    return take(output, {
+        appliedWeights: (_) => de_AppliedWeights(_, context),
+        arn: __expectString,
+        autoshifts: (_) => de_AutoshiftsInResource(_, context),
+        availabilityZones: _json,
+        name: __expectString,
+        practiceRunStatus: __expectString,
+        zonalAutoshiftStatus: __expectString,
+        zonalShifts: (_) => de_ZonalShiftsInResource(_, context),
+    });
+};
 const de_ZonalShiftInResource = (output, context) => {
     return take(output, {
         appliedStatus: __expectString,
         awayFrom: __expectString,
         comment: __expectString,
         expiryTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        practiceRunOutcome: __expectString,
         resourceIdentifier: __expectString,
         startTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
         zonalShiftId: __expectString,
@@ -539,6 +945,7 @@ const de_ZonalShiftSummary = (output, context) => {
         awayFrom: __expectString,
         comment: __expectString,
         expiryTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        practiceRunOutcome: __expectString,
         resourceIdentifier: __expectString,
         startTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
         status: __expectString,

package/dist-types/ARCZonalShift.d.ts

@@ -1,10 +1,15 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
 import { ARCZonalShiftClient } from "./ARCZonalShiftClient";
 import { CancelZonalShiftCommandInput, CancelZonalShiftCommandOutput } from "./commands/CancelZonalShiftCommand";
+import { CreatePracticeRunConfigurationCommandInput, CreatePracticeRunConfigurationCommandOutput } from "./commands/CreatePracticeRunConfigurationCommand";
+import { DeletePracticeRunConfigurationCommandInput, DeletePracticeRunConfigurationCommandOutput } from "./commands/DeletePracticeRunConfigurationCommand";
 import { GetManagedResourceCommandInput, GetManagedResourceCommandOutput } from "./commands/GetManagedResourceCommand";
+import { ListAutoshiftsCommandInput, ListAutoshiftsCommandOutput } from "./commands/ListAutoshiftsCommand";
 import { ListManagedResourcesCommandInput, ListManagedResourcesCommandOutput } from "./commands/ListManagedResourcesCommand";
 import { ListZonalShiftsCommandInput, ListZonalShiftsCommandOutput } from "./commands/ListZonalShiftsCommand";
 import { StartZonalShiftCommandInput, StartZonalShiftCommandOutput } from "./commands/StartZonalShiftCommand";
+import { UpdatePracticeRunConfigurationCommandInput, UpdatePracticeRunConfigurationCommandOutput } from "./commands/UpdatePracticeRunConfigurationCommand";
+import { UpdateZonalAutoshiftConfigurationCommandInput, UpdateZonalAutoshiftConfigurationCommandOutput } from "./commands/UpdateZonalAutoshiftConfigurationCommand";
 import { UpdateZonalShiftCommandInput, UpdateZonalShiftCommandOutput } from "./commands/UpdateZonalShiftCommand";
 export interface ARCZonalShift {
     /**
@@ -13,12 +18,30 @@ export interface ARCZonalShift {
     cancelZonalShift(args: CancelZonalShiftCommandInput, options?: __HttpHandlerOptions): Promise<CancelZonalShiftCommandOutput>;
     cancelZonalShift(args: CancelZonalShiftCommandInput, cb: (err: any, data?: CancelZonalShiftCommandOutput) => void): void;
     cancelZonalShift(args: CancelZonalShiftCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CancelZonalShiftCommandOutput) => void): void;
+    /**
+     * @see {@link CreatePracticeRunConfigurationCommand}
+     */
+    createPracticeRunConfiguration(args: CreatePracticeRunConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<CreatePracticeRunConfigurationCommandOutput>;
+    createPracticeRunConfiguration(args: CreatePracticeRunConfigurationCommandInput, cb: (err: any, data?: CreatePracticeRunConfigurationCommandOutput) => void): void;
+    createPracticeRunConfiguration(args: CreatePracticeRunConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreatePracticeRunConfigurationCommandOutput) => void): void;
+    /**
+     * @see {@link DeletePracticeRunConfigurationCommand}
+     */
+    deletePracticeRunConfiguration(args: DeletePracticeRunConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<DeletePracticeRunConfigurationCommandOutput>;
+    deletePracticeRunConfiguration(args: DeletePracticeRunConfigurationCommandInput, cb: (err: any, data?: DeletePracticeRunConfigurationCommandOutput) => void): void;
+    deletePracticeRunConfiguration(args: DeletePracticeRunConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeletePracticeRunConfigurationCommandOutput) => void): void;
     /**
      * @see {@link GetManagedResourceCommand}
      */
     getManagedResource(args: GetManagedResourceCommandInput, options?: __HttpHandlerOptions): Promise<GetManagedResourceCommandOutput>;
     getManagedResource(args: GetManagedResourceCommandInput, cb: (err: any, data?: GetManagedResourceCommandOutput) => void): void;
     getManagedResource(args: GetManagedResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetManagedResourceCommandOutput) => void): void;
+    /**
+     * @see {@link ListAutoshiftsCommand}
+     */
+    listAutoshifts(args: ListAutoshiftsCommandInput, options?: __HttpHandlerOptions): Promise<ListAutoshiftsCommandOutput>;
+    listAutoshifts(args: ListAutoshiftsCommandInput, cb: (err: any, data?: ListAutoshiftsCommandOutput) => void): void;
+    listAutoshifts(args: ListAutoshiftsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListAutoshiftsCommandOutput) => void): void;
     /**
      * @see {@link ListManagedResourcesCommand}
      */
@@ -37,6 +60,18 @@ export interface ARCZonalShift {
     startZonalShift(args: StartZonalShiftCommandInput, options?: __HttpHandlerOptions): Promise<StartZonalShiftCommandOutput>;
     startZonalShift(args: StartZonalShiftCommandInput, cb: (err: any, data?: StartZonalShiftCommandOutput) => void): void;
     startZonalShift(args: StartZonalShiftCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartZonalShiftCommandOutput) => void): void;
+    /**
+     * @see {@link UpdatePracticeRunConfigurationCommand}
+     */
+    updatePracticeRunConfiguration(args: UpdatePracticeRunConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<UpdatePracticeRunConfigurationCommandOutput>;
+    updatePracticeRunConfiguration(args: UpdatePracticeRunConfigurationCommandInput, cb: (err: any, data?: UpdatePracticeRunConfigurationCommandOutput) => void): void;
+    updatePracticeRunConfiguration(args: UpdatePracticeRunConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdatePracticeRunConfigurationCommandOutput) => void): void;
+    /**
+     * @see {@link UpdateZonalAutoshiftConfigurationCommand}
+     */
+    updateZonalAutoshiftConfiguration(args: UpdateZonalAutoshiftConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<UpdateZonalAutoshiftConfigurationCommandOutput>;
+    updateZonalAutoshiftConfiguration(args: UpdateZonalAutoshiftConfigurationCommandInput, cb: (err: any, data?: UpdateZonalAutoshiftConfigurationCommandOutput) => void): void;
+    updateZonalAutoshiftConfiguration(args: UpdateZonalAutoshiftConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateZonalAutoshiftConfigurationCommandOutput) => void): void;
     /**
      * @see {@link UpdateZonalShiftCommand}
      */
@@ -46,21 +81,33 @@ export interface ARCZonalShift {
 }
 /**
  * @public
- * <p>This is the API Reference Guide for the zonal shift feature of Amazon Route 53 Application Recovery Controller. This guide is for developers who need detailed information about
- * 			zonal shift API actions, data types, and errors.</p>
- * 		       <p>Zonal shift is in preview release for Amazon Route 53 Application Recovery Controller and is subject to change.</p>
- * 		       <p>Zonal shift in Route 53 ARC enables you to move traffic for a load balancer resource away from an Availability Zone. Starting
- * 			a zonal shift helps your application recover immediately, for example, from a developer's bad code deployment
- * 			or from an AWS infrastructure failure in a single Availability Zone, reducing the impact and time lost from an issue
- * 			in one zone. </p>
- * 		       <p>Supported AWS resources are automatically registered with Route 53 ARC. Resources that are registered for zonal shifts
- * 			in Route 53 ARC are managed resources in Route 53 ARC. You can start a zonal shift for any managed resource in your account in a Region.
- * 			At this time, you can only start a zonal shift for Network Load Balancers and Application Load Balancers with cross-zone load balancing turned off.</p>
- * 		       <p>Zonal shifts are temporary. You must specify an expiration when you start a zonal shift, of up to three days initially.
- * 			If you want to still keep traffic away from an Availability Zone, you can update the zonal shift and set a new expiration.
- * 			You can also cancel a zonal shift, before it expires, for example, if you're ready to restore traffic to the Availability Zone.</p>
- * 		       <p>For more information about using zonal shift, see the
- * 			<a href="https://docs.aws.amazon.com/r53recovery/latest/dg/what-is-route53-recovery.html">Amazon Route 53 Application Recovery Controller Developer Guide</a>.</p>
+ * <p>Welcome to the Zonal Shift API Reference Guide for Amazon Route 53 Application Recovery Controller (Route 53 ARC).</p>
+ *          <p>You can start a zonal shift to move traffic for a load balancer resource away from an Availability Zone to
+ * 			help your application recover quickly from an impairment in an Availability Zone. For example,
+ * 			you can recover your application from a developer's bad code deployment or from an
+ * 			Amazon Web Services infrastructure failure in a single Availability Zone.</p>
+ *          <p>You can also configure zonal autoshift for a load balancer resource. Zonal autoshift
+ * 			is a capability in Route 53 ARC where Amazon Web Services shifts away application resource
+ * 			traffic from an Availability Zone, on your behalf, to help reduce your time to recovery during events.
+ * 			Amazon Web Services shifts away traffic for resources that are enabled for zonal autoshift whenever Amazon Web Services
+ * 			determines that there's an issue in the Availability Zone that could potentially affect
+ * 			customers.</p>
+ *          <p>To ensure that zonal autoshift is safe for your application, you must
+ * 			also configure practice runs when you enable zonal autoshift for a resource. Practice runs start
+ * 			weekly zonal shifts for a resource, to shift
+ * 			traffic for the resource out of an Availability Zone. Practice runs make sure, on a regular basis,
+ * 			that you have enough capacity in all the Availability Zones in an Amazon Web Services Region
+ * 			for your application to continue to operate normally
+ * 			when traffic for a resource is shifted away from one Availability Zone.</p>
+ *          <important>
+ *             <p>You must prescale resource capacity in all Availability Zones in the Region
+ * 			where your application is deployed, before you configure practice runs or enable zonal autoshift
+ * 			for a resource. You should not rely on scaling on demand when an autoshift or practice run
+ * 			starts. </p>
+ *          </important>
+ *          <p>For more information about using zonal shift and zonal autoshift, see the
+ * 			<a href="https://docs.aws.amazon.com/r53recovery/latest/dg/what-is-route53-recovery.html">Amazon Route 53 Application Recovery Controller
+ * 				Developer Guide</a>.</p>
  */
 export declare class ARCZonalShift extends ARCZonalShiftClient implements ARCZonalShift {
 }