@aws-sdk/client-arc-region-switch 3.933.0 → 3.935.0

package/dist-es/models/models_0.js

@@ -1,199 +1 @@
-import { ARCRegionSwitchServiceException as __BaseException } from "./ARCRegionSwitchServiceException";
-export const ExecutionAction = {
-    ACTIVATE: "activate",
-    DEACTIVATE: "deactivate",
-};
-export const ExecutionState = {
-    CANCELLED: "canceled",
-    COMPLETED: "completed",
-    COMPLETED_MONITORING_APPLICATION_HEALTH: "completedMonitoringApplicationHealth",
-    COMPLETED_WITH_EXCEPTIONS: "completedWithExceptions",
-    FAILED: "failed",
-    IN_PROGRESS: "inProgress",
-    PAUSED_BY_FAILED_STEP: "pausedByFailedStep",
-    PAUSED_BY_OPERATOR: "pausedByOperator",
-    PENDING: "pending",
-    PENDING_MANUAL_APPROVAL: "pendingManualApproval",
-    PLAN_EXECUTION_TIMED_OUT: "planExecutionTimedOut",
-};
-export const ExecutionMode = {
-    GRACEFUL: "graceful",
-    UNGRACEFUL: "ungraceful",
-};
-export const RecoveryApproach = {
-    ACTIVE_ACTIVE: "activeActive",
-    ACTIVE_PASSIVE: "activePassive",
-};
-export class AccessDeniedException extends __BaseException {
-    name = "AccessDeniedException";
-    $fault = "client";
-    constructor(opts) {
-        super({
-            name: "AccessDeniedException",
-            $fault: "client",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, AccessDeniedException.prototype);
-    }
-}
-export const AlarmCondition = {
-    GREEN: "green",
-    RED: "red",
-};
-export const AlarmType = {
-    APPLICATION_HEALTH: "applicationHealth",
-    TRIGGER: "trigger",
-};
-export const Approval = {
-    APPROVE: "approve",
-    DECLINE: "decline",
-};
-export class ResourceNotFoundException extends __BaseException {
-    name = "ResourceNotFoundException";
-    $fault = "client";
-    constructor(opts) {
-        super({
-            name: "ResourceNotFoundException",
-            $fault: "client",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
-    }
-}
-export const EvaluationStatus = {
-    ACTION_REQUIRED: "actionRequired",
-    PASSED: "passed",
-    PENDING_EVALUATION: "pendingEvaluation",
-    UNKNOWN: "unknown",
-};
-export const ResourceWarningStatus = {
-    ACTIVE: "active",
-    RESOLVED: "resolved",
-};
-export const WorkflowTargetAction = {
-    ACTIVATE: "activate",
-    DEACTIVATE: "deactivate",
-};
-export const RoutingControlStateChange = {
-    OFF: "Off",
-    ON: "On",
-};
-export const RegionToRunIn = {
-    ACTIVATING_REGION: "activatingRegion",
-    DEACTIVATING_REGION: "deactivatingRegion",
-};
-export const LambdaUngracefulBehavior = {
-    SKIP: "skip",
-};
-export const Ec2AsgCapacityMonitoringApproach = {
-    AUTOSCALING_MAX_IN_LAST_24_HOURS: "autoscalingMaxInLast24Hours",
-    SAMPLED_MAX_IN_LAST_24_HOURS: "sampledMaxInLast24Hours",
-};
-export const EcsCapacityMonitoringApproach = {
-    CONTAINER_INSIGHTS_MAX_IN_LAST_24_HOURS: "containerInsightsMaxInLast24Hours",
-    SAMPLED_MAX_IN_LAST_24_HOURS: "sampledMaxInLast24Hours",
-};
-export const EksCapacityMonitoringApproach = {
-    SAMPLED_MAX_IN_LAST_24_HOURS: "sampledMaxInLast24Hours",
-};
-export const GlobalAuroraDefaultBehavior = {
-    FAILOVER: "failover",
-    SWITCHOVER_ONLY: "switchoverOnly",
-};
-export const GlobalAuroraUngracefulBehavior = {
-    FAILOVER: "failover",
-};
-export const ExecutionBlockType = {
-    AURORA: "AuroraGlobalDatabase",
-    CUSTOM_ACTION_LAMBDA: "CustomActionLambda",
-    EC2_ASG: "EC2AutoScaling",
-    ECS: "ECSServiceScaling",
-    EKS_RESOURCE_SCALING: "EKSResourceScaling",
-    EXECUTION_APPROVAL: "ManualApproval",
-    PARALLEL: "Parallel",
-    REGION_SWITCH: "ARCRegionSwitchPlan",
-    ROUTE53_HEALTH_CHECK: "Route53HealthCheck",
-    ROUTING_CONTROL: "ARCRoutingControl",
-};
-export const StepStatus = {
-    CANCELLED: "canceled",
-    COMPLETED: "completed",
-    FAILED: "failed",
-    NOT_STARTED: "notStarted",
-    PENDING_APPROVAL: "pendingApproval",
-    RUNNING: "running",
-    SKIPPED: "skipped",
-};
-export const ExecutionEventType = {
-    EXECUTION_BEHAVIOR_CHANGED_TO_GRACEFUL: "executionBehaviorChangedToGraceful",
-    EXECUTION_BEHAVIOR_CHANGED_TO_UNGRACEFUL: "executionBehaviorChangedToUngraceful",
-    EXECUTION_CANCELED: "executionCanceled",
-    EXECUTION_CANCELING: "executionCanceling",
-    EXECUTION_FAILED: "executionFailed",
-    EXECUTION_PAUSED: "executionPaused",
-    EXECUTION_PAUSING: "executionPausing",
-    EXECUTION_PENDING: "executionPending",
-    EXECUTION_PENDING_APPROVAL: "executionPendingApproval",
-    EXECUTION_PENDING_CHILD_PLAN_MANUAL_APPROVAL: "executionPendingChildPlanManualApproval",
-    EXECUTION_STARTED: "executionStarted",
-    EXECUTION_SUCCEEDED: "executionSucceeded",
-    EXECUTION_SUCCESS_MONITORING_APPLICATION_HEALTH: "executionSuccessMonitoringApplicationHealth",
-    STEP_CANCELED: "stepCanceled",
-    STEP_EXECUTION_BEHAVIOR_CHANGED_TO_UNGRACEFUL: "stepExecutionBehaviorChangedToUngraceful",
-    STEP_FAILED: "stepFailed",
-    STEP_PAUSED_BY_ERROR: "stepPausedByError",
-    STEP_PAUSED_BY_OPERATOR: "stepPausedByOperator",
-    STEP_PENDING_APPLICATION_HEALTH_MONITOR: "stepPendingApplicationHealthMonitor",
-    STEP_PENDING_APPROVAL: "stepPendingApproval",
-    STEP_SKIPPED: "stepSkipped",
-    STEP_STARTED: "stepStarted",
-    STEP_SUCCEEDED: "stepSucceeded",
-    STEP_UPDATE: "stepUpdate",
-    UNKNOWN: "unknown",
-};
-export class InternalServerException extends __BaseException {
-    name = "InternalServerException";
-    $fault = "server";
-    constructor(opts) {
-        super({
-            name: "InternalServerException",
-            $fault: "server",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, InternalServerException.prototype);
-    }
-}
-export class IllegalStateException extends __BaseException {
-    name = "IllegalStateException";
-    $fault = "client";
-    constructor(opts) {
-        super({
-            name: "IllegalStateException",
-            $fault: "client",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, IllegalStateException.prototype);
-    }
-}
-export class IllegalArgumentException extends __BaseException {
-    name = "IllegalArgumentException";
-    $fault = "client";
-    constructor(opts) {
-        super({
-            name: "IllegalArgumentException",
-            $fault: "client",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, IllegalArgumentException.prototype);
-    }
-}
-export const UpdatePlanExecutionAction = {
-    PAUSE: "pause",
-    RESUME: "resume",
-    SWITCH_TO_GRACEFUL: "switchToGraceful",
-    SWITCH_TO_UNGRACEFUL: "switchToUngraceful",
-};
-export const UpdatePlanExecutionStepAction = {
-    SKIP: "skip",
-    SWITCH_TO_UNGRACEFUL: "switchToUngraceful",
-};
+export {};

package/dist-es/schemas/schemas_0.js

@@ -246,7 +246,7 @@ const _wo = "workflow";
 const n0 = "com.amazonaws.arcregionswitch";
 import { TypeRegistry } from "@smithy/core/schema";
 import { ARCRegionSwitchServiceException as __ARCRegionSwitchServiceException } from "../models/ARCRegionSwitchServiceException";
-import { AccessDeniedException as __AccessDeniedException, IllegalArgumentException as __IllegalArgumentException, IllegalStateException as __IllegalStateException, InternalServerException as __InternalServerException, ResourceNotFoundException as __ResourceNotFoundException, } from "../models/index";
+import { AccessDeniedException as __AccessDeniedException, IllegalArgumentException as __IllegalArgumentException, IllegalStateException as __IllegalStateException, InternalServerException as __InternalServerException, ResourceNotFoundException as __ResourceNotFoundException, } from "../models/errors";
 export var AbbreviatedExecution = [
     3,
     n0,

package/dist-types/index.d.ts

@@ -11,5 +11,7 @@ export type { ARCRegionSwitchExtensionConfiguration } from "./extensionConfigura
 export * from "./commands";
 export * from "./pagination";
 export * from "./waiters";
-export * from "./models";
+export * from "./models/enums";
+export * from "./models/errors";
+export type * from "./models/models_0";
 export { ARCRegionSwitchServiceException } from "./models/ARCRegionSwitchServiceException";

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

@@ -0,0 +1,322 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const ExecutionAction: {
+    readonly ACTIVATE: "activate";
+    readonly DEACTIVATE: "deactivate";
+};
+/**
+ * @public
+ */
+export type ExecutionAction = (typeof ExecutionAction)[keyof typeof ExecutionAction];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExecutionState: {
+    readonly CANCELLED: "canceled";
+    readonly COMPLETED: "completed";
+    readonly COMPLETED_MONITORING_APPLICATION_HEALTH: "completedMonitoringApplicationHealth";
+    readonly COMPLETED_WITH_EXCEPTIONS: "completedWithExceptions";
+    readonly FAILED: "failed";
+    readonly IN_PROGRESS: "inProgress";
+    readonly PAUSED_BY_FAILED_STEP: "pausedByFailedStep";
+    readonly PAUSED_BY_OPERATOR: "pausedByOperator";
+    readonly PENDING: "pending";
+    readonly PENDING_MANUAL_APPROVAL: "pendingManualApproval";
+    readonly PLAN_EXECUTION_TIMED_OUT: "planExecutionTimedOut";
+};
+/**
+ * @public
+ */
+export type ExecutionState = (typeof ExecutionState)[keyof typeof ExecutionState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExecutionMode: {
+    readonly GRACEFUL: "graceful";
+    readonly UNGRACEFUL: "ungraceful";
+};
+/**
+ * @public
+ */
+export type ExecutionMode = (typeof ExecutionMode)[keyof typeof ExecutionMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const RecoveryApproach: {
+    readonly ACTIVE_ACTIVE: "activeActive";
+    readonly ACTIVE_PASSIVE: "activePassive";
+};
+/**
+ * @public
+ */
+export type RecoveryApproach = (typeof RecoveryApproach)[keyof typeof RecoveryApproach];
+/**
+ * @public
+ * @enum
+ */
+export declare const AlarmCondition: {
+    readonly GREEN: "green";
+    readonly RED: "red";
+};
+/**
+ * @public
+ */
+export type AlarmCondition = (typeof AlarmCondition)[keyof typeof AlarmCondition];
+/**
+ * @public
+ * @enum
+ */
+export declare const AlarmType: {
+    readonly APPLICATION_HEALTH: "applicationHealth";
+    readonly TRIGGER: "trigger";
+};
+/**
+ * @public
+ */
+export type AlarmType = (typeof AlarmType)[keyof typeof AlarmType];
+/**
+ * @public
+ * @enum
+ */
+export declare const Approval: {
+    readonly APPROVE: "approve";
+    readonly DECLINE: "decline";
+};
+/**
+ * @public
+ */
+export type Approval = (typeof Approval)[keyof typeof Approval];
+/**
+ * @public
+ * @enum
+ */
+export declare const EvaluationStatus: {
+    readonly ACTION_REQUIRED: "actionRequired";
+    readonly PASSED: "passed";
+    readonly PENDING_EVALUATION: "pendingEvaluation";
+    readonly UNKNOWN: "unknown";
+};
+/**
+ * @public
+ */
+export type EvaluationStatus = (typeof EvaluationStatus)[keyof typeof EvaluationStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ResourceWarningStatus: {
+    readonly ACTIVE: "active";
+    readonly RESOLVED: "resolved";
+};
+/**
+ * @public
+ */
+export type ResourceWarningStatus = (typeof ResourceWarningStatus)[keyof typeof ResourceWarningStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const WorkflowTargetAction: {
+    readonly ACTIVATE: "activate";
+    readonly DEACTIVATE: "deactivate";
+};
+/**
+ * @public
+ */
+export type WorkflowTargetAction = (typeof WorkflowTargetAction)[keyof typeof WorkflowTargetAction];
+/**
+ * @public
+ * @enum
+ */
+export declare const RoutingControlStateChange: {
+    readonly OFF: "Off";
+    readonly ON: "On";
+};
+/**
+ * @public
+ */
+export type RoutingControlStateChange = (typeof RoutingControlStateChange)[keyof typeof RoutingControlStateChange];
+/**
+ * @public
+ * @enum
+ */
+export declare const RegionToRunIn: {
+    readonly ACTIVATING_REGION: "activatingRegion";
+    readonly DEACTIVATING_REGION: "deactivatingRegion";
+};
+/**
+ * @public
+ */
+export type RegionToRunIn = (typeof RegionToRunIn)[keyof typeof RegionToRunIn];
+/**
+ * @public
+ * @enum
+ */
+export declare const LambdaUngracefulBehavior: {
+    readonly SKIP: "skip";
+};
+/**
+ * @public
+ */
+export type LambdaUngracefulBehavior = (typeof LambdaUngracefulBehavior)[keyof typeof LambdaUngracefulBehavior];
+/**
+ * @public
+ * @enum
+ */
+export declare const Ec2AsgCapacityMonitoringApproach: {
+    readonly AUTOSCALING_MAX_IN_LAST_24_HOURS: "autoscalingMaxInLast24Hours";
+    readonly SAMPLED_MAX_IN_LAST_24_HOURS: "sampledMaxInLast24Hours";
+};
+/**
+ * @public
+ */
+export type Ec2AsgCapacityMonitoringApproach = (typeof Ec2AsgCapacityMonitoringApproach)[keyof typeof Ec2AsgCapacityMonitoringApproach];
+/**
+ * @public
+ * @enum
+ */
+export declare const EcsCapacityMonitoringApproach: {
+    readonly CONTAINER_INSIGHTS_MAX_IN_LAST_24_HOURS: "containerInsightsMaxInLast24Hours";
+    readonly SAMPLED_MAX_IN_LAST_24_HOURS: "sampledMaxInLast24Hours";
+};
+/**
+ * @public
+ */
+export type EcsCapacityMonitoringApproach = (typeof EcsCapacityMonitoringApproach)[keyof typeof EcsCapacityMonitoringApproach];
+/**
+ * @public
+ * @enum
+ */
+export declare const EksCapacityMonitoringApproach: {
+    readonly SAMPLED_MAX_IN_LAST_24_HOURS: "sampledMaxInLast24Hours";
+};
+/**
+ * @public
+ */
+export type EksCapacityMonitoringApproach = (typeof EksCapacityMonitoringApproach)[keyof typeof EksCapacityMonitoringApproach];
+/**
+ * @public
+ * @enum
+ */
+export declare const GlobalAuroraDefaultBehavior: {
+    readonly FAILOVER: "failover";
+    readonly SWITCHOVER_ONLY: "switchoverOnly";
+};
+/**
+ * @public
+ */
+export type GlobalAuroraDefaultBehavior = (typeof GlobalAuroraDefaultBehavior)[keyof typeof GlobalAuroraDefaultBehavior];
+/**
+ * @public
+ * @enum
+ */
+export declare const GlobalAuroraUngracefulBehavior: {
+    readonly FAILOVER: "failover";
+};
+/**
+ * @public
+ */
+export type GlobalAuroraUngracefulBehavior = (typeof GlobalAuroraUngracefulBehavior)[keyof typeof GlobalAuroraUngracefulBehavior];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExecutionBlockType: {
+    readonly AURORA: "AuroraGlobalDatabase";
+    readonly CUSTOM_ACTION_LAMBDA: "CustomActionLambda";
+    readonly EC2_ASG: "EC2AutoScaling";
+    readonly ECS: "ECSServiceScaling";
+    readonly EKS_RESOURCE_SCALING: "EKSResourceScaling";
+    readonly EXECUTION_APPROVAL: "ManualApproval";
+    readonly PARALLEL: "Parallel";
+    readonly REGION_SWITCH: "ARCRegionSwitchPlan";
+    readonly ROUTE53_HEALTH_CHECK: "Route53HealthCheck";
+    readonly ROUTING_CONTROL: "ARCRoutingControl";
+};
+/**
+ * @public
+ */
+export type ExecutionBlockType = (typeof ExecutionBlockType)[keyof typeof ExecutionBlockType];
+/**
+ * @public
+ * @enum
+ */
+export declare const StepStatus: {
+    readonly CANCELLED: "canceled";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+    readonly NOT_STARTED: "notStarted";
+    readonly PENDING_APPROVAL: "pendingApproval";
+    readonly RUNNING: "running";
+    readonly SKIPPED: "skipped";
+};
+/**
+ * @public
+ */
+export type StepStatus = (typeof StepStatus)[keyof typeof StepStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExecutionEventType: {
+    readonly EXECUTION_BEHAVIOR_CHANGED_TO_GRACEFUL: "executionBehaviorChangedToGraceful";
+    readonly EXECUTION_BEHAVIOR_CHANGED_TO_UNGRACEFUL: "executionBehaviorChangedToUngraceful";
+    readonly EXECUTION_CANCELED: "executionCanceled";
+    readonly EXECUTION_CANCELING: "executionCanceling";
+    readonly EXECUTION_FAILED: "executionFailed";
+    readonly EXECUTION_PAUSED: "executionPaused";
+    readonly EXECUTION_PAUSING: "executionPausing";
+    readonly EXECUTION_PENDING: "executionPending";
+    readonly EXECUTION_PENDING_APPROVAL: "executionPendingApproval";
+    readonly EXECUTION_PENDING_CHILD_PLAN_MANUAL_APPROVAL: "executionPendingChildPlanManualApproval";
+    readonly EXECUTION_STARTED: "executionStarted";
+    readonly EXECUTION_SUCCEEDED: "executionSucceeded";
+    readonly EXECUTION_SUCCESS_MONITORING_APPLICATION_HEALTH: "executionSuccessMonitoringApplicationHealth";
+    readonly STEP_CANCELED: "stepCanceled";
+    readonly STEP_EXECUTION_BEHAVIOR_CHANGED_TO_UNGRACEFUL: "stepExecutionBehaviorChangedToUngraceful";
+    readonly STEP_FAILED: "stepFailed";
+    readonly STEP_PAUSED_BY_ERROR: "stepPausedByError";
+    readonly STEP_PAUSED_BY_OPERATOR: "stepPausedByOperator";
+    readonly STEP_PENDING_APPLICATION_HEALTH_MONITOR: "stepPendingApplicationHealthMonitor";
+    readonly STEP_PENDING_APPROVAL: "stepPendingApproval";
+    readonly STEP_SKIPPED: "stepSkipped";
+    readonly STEP_STARTED: "stepStarted";
+    readonly STEP_SUCCEEDED: "stepSucceeded";
+    readonly STEP_UPDATE: "stepUpdate";
+    readonly UNKNOWN: "unknown";
+};
+/**
+ * @public
+ */
+export type ExecutionEventType = (typeof ExecutionEventType)[keyof typeof ExecutionEventType];
+/**
+ * @public
+ * @enum
+ */
+export declare const UpdatePlanExecutionAction: {
+    readonly PAUSE: "pause";
+    readonly RESUME: "resume";
+    readonly SWITCH_TO_GRACEFUL: "switchToGraceful";
+    readonly SWITCH_TO_UNGRACEFUL: "switchToUngraceful";
+};
+/**
+ * @public
+ */
+export type UpdatePlanExecutionAction = (typeof UpdatePlanExecutionAction)[keyof typeof UpdatePlanExecutionAction];
+/**
+ * @public
+ * @enum
+ */
+export declare const UpdatePlanExecutionStepAction: {
+    readonly SKIP: "skip";
+    readonly SWITCH_TO_UNGRACEFUL: "switchToUngraceful";
+};
+/**
+ * @public
+ */
+export type UpdatePlanExecutionStepAction = (typeof UpdatePlanExecutionStepAction)[keyof typeof UpdatePlanExecutionStepAction];

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

@@ -0,0 +1,62 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { ARCRegionSwitchServiceException as __BaseException } from "./ARCRegionSwitchServiceException";
+/**
+ * <p>You do not have sufficient access to perform this action.</p> <p>HTTP Status Code: 403</p>
+ * @public
+ */
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+/**
+ * <p>The specified resource was not found.</p> <p>HTTP Status Code: 404</p>
+ * @public
+ */
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+/**
+ * <p>The request processing has failed because of an unknown error, exception, or failure.</p> <p>HTTP Status Code: 500</p>
+ * @public
+ */
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+/**
+ * <p>The operation failed because the current state of the resource doesn't allow the operation to proceed.</p> <p>HTTP Status Code: 400</p>
+ * @public
+ */
+export declare class IllegalStateException extends __BaseException {
+    readonly name: "IllegalStateException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<IllegalStateException, __BaseException>);
+}
+/**
+ * <p>The request processing has an invalid argument.</p>
+ * @public
+ */
+export declare class IllegalArgumentException extends __BaseException {
+    readonly name: "IllegalArgumentException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<IllegalArgumentException, __BaseException>);
+}