import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import * as C from "../category.js";
const svc = T.AwsApiService({
    sdkId: "ARC Region switch",
    serviceShapeName: "ArcRegionSwitch",
});
const auth = T.AwsAuthSigv4({ name: "arc-region-switch" });
const ver = T.ServiceVersion("2022-07-26");
const proto = T.AwsProtocolsAwsJson1_0();
const rules = T.EndpointResolver((p, _) => {
    const { UseFIPS = false, Endpoint, Region, UseControlPlaneEndpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    const _p0 = (_0) => ({
        authSchemes: [
            {
                name: "sigv4",
                signingName: "arc-region-switch",
                signingRegion: `${_.getAttr(_0, "implicitGlobalRegion")}`,
            },
        ],
    });
    {
        const PartitionResult = _.partition(Region);
        if (UseControlPlaneEndpoint != null &&
            UseControlPlaneEndpoint === true &&
            Region != null &&
            !(UseFIPS === true) &&
            !(Endpoint != null) &&
            PartitionResult != null &&
            PartitionResult !== false &&
            _.getAttr(PartitionResult, "name") === "aws-cn") {
            return e(`https://arc-region-switch-control-plane.cn-north-1.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`, {
                authSchemes: [
                    {
                        name: "sigv4",
                        signingName: "arc-region-switch",
                        signingRegion: "cn-north-1",
                    },
                ],
            }, {});
        }
    }
    {
        const PartitionResult = _.partition(Region);
        if (!(Endpoint != null) &&
            UseControlPlaneEndpoint != null &&
            UseControlPlaneEndpoint === true &&
            Region != null &&
            UseFIPS === true &&
            PartitionResult != null &&
            PartitionResult !== false) {
            if (_.getAttr(PartitionResult, "name") === "aws-cn") {
                return err("Invalid Configuration: FIPS is not supported in this partition");
            }
            return e(`https://arc-region-switch-control-plane-fips.${_.getAttr(PartitionResult, "implicitGlobalRegion")}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`, _p0(PartitionResult), {});
        }
    }
    {
        const PartitionResult = _.partition(Region);
        if (UseControlPlaneEndpoint != null &&
            UseControlPlaneEndpoint === true &&
            Region != null &&
            !(UseFIPS === true) &&
            !(Endpoint != null) &&
            PartitionResult != null &&
            PartitionResult !== false) {
            return e(`https://arc-region-switch-control-plane.${_.getAttr(PartitionResult, "implicitGlobalRegion")}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`, _p0(PartitionResult), {});
        }
    }
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true) {
                    return e(`https://arc-region-switch-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                }
                return e(`https://arc-region-switch.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const Approval = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ApprovePlanExecutionStepRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    planArn: S.String,
    executionId: S.String,
    stepName: S.String,
    approval: Approval,
    comment: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ApprovePlanExecutionStepRequest",
});
export const ApprovePlanExecutionStepResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "ApprovePlanExecutionStepResponse",
});
export const CancelPlanExecutionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    planArn: S.String,
    executionId: S.String,
    comment: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CancelPlanExecutionRequest",
});
export const CancelPlanExecutionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "CancelPlanExecutionResponse",
});
export const GetPlanEvaluationStatusRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    planArn: S.String,
    maxResults: S.optional(S.Number),
    nextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetPlanEvaluationStatusRequest",
});
export const EvaluationStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ExecutionAction = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const MinimalWorkflow = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ action: S.optional(ExecutionAction), name: S.optional(S.String) })).annotate({
    identifier: "MinimalWorkflow",
});
export const ResourceWarningStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ResourceWarning = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    workflow: S.optional(MinimalWorkflow),
    version: S.String,
    stepName: S.optional(S.String),
    resourceArn: S.optional(S.String),
    warningStatus: ResourceWarningStatus,
    warningUpdatedTime: S.Date.pipe(T.TimestampFormat("epoch-seconds")),
    warningMessage: S.String,
})).annotate({
    identifier: "ResourceWarning",
});
export const PlanWarnings = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ResourceWarning);
export const GetPlanEvaluationStatusResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    planArn: S.String,
    lastEvaluationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    lastEvaluatedVersion: S.optional(S.String),
    region: S.optional(S.String),
    evaluationState: S.optional(EvaluationStatus),
    warnings: S.optional(PlanWarnings),
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "GetPlanEvaluationStatusResponse",
});
export const GetPlanExecutionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    planArn: S.String,
    executionId: S.String,
    maxResults: S.optional(S.Number),
    nextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetPlanExecutionRequest",
});
export const ExecutionMode = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ExecutionState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const StepStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const StepState = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    status: S.optional(StepStatus),
    startTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    endTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    stepMode: S.optional(ExecutionMode),
})).annotate({ identifier: "StepState" });
export const StepStates = /*@__PURE__*/ /*#__PURE__*/ S.Array(StepState);
export const Lambdas = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    crossAccountRole: S.optional(S.String),
    externalId: S.optional(S.String),
    arn: S.optional(S.String),
})).annotate({ identifier: "Lambdas" });
export const LambdaList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Lambdas);
export const RegionToRunIn = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const LambdaUngracefulBehavior = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const LambdaUngraceful = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ behavior: S.optional(LambdaUngracefulBehavior) })).annotate({
    identifier: "LambdaUngraceful",
});
export const CustomActionLambdaConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    timeoutMinutes: S.optional(S.Number),
    lambdas: LambdaList,
    retryIntervalMinutes: S.Number,
    regionToRun: RegionToRunIn,
    ungraceful: S.optional(LambdaUngraceful),
})).annotate({
    identifier: "CustomActionLambdaConfiguration",
});
export const Asg = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    crossAccountRole: S.optional(S.String),
    externalId: S.optional(S.String),
    arn: S.optional(S.String),
})).annotate({ identifier: "Asg" });
export const AsgList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Asg);
export const Ec2Ungraceful = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ minimumSuccessPercentage: S.Number })).annotate({ identifier: "Ec2Ungraceful" });
export const Ec2AsgCapacityMonitoringApproach = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const Ec2AsgCapacityIncreaseConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    timeoutMinutes: S.optional(S.Number),
    asgs: AsgList,
    ungraceful: S.optional(Ec2Ungraceful),
    targetPercent: S.optional(S.Number),
    capacityMonitoringApproach: S.optional(Ec2AsgCapacityMonitoringApproach),
})).annotate({
    identifier: "Ec2AsgCapacityIncreaseConfiguration",
});
export const ExecutionApprovalConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ timeoutMinutes: S.optional(S.Number), approvalRole: S.String })).annotate({
    identifier: "ExecutionApprovalConfiguration",
});
export const RoutingControlStateChange = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ArcRoutingControlState = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ routingControlArn: S.String, state: RoutingControlStateChange })).annotate({
    identifier: "ArcRoutingControlState",
});
export const ArcRoutingControlStates = /*@__PURE__*/ /*#__PURE__*/ S.Array(ArcRoutingControlState);
export const RegionAndRoutingControls = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, ArcRoutingControlStates.pipe(S.optional));
export const ArcRoutingControlConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    timeoutMinutes: S.optional(S.Number),
    crossAccountRole: S.optional(S.String),
    externalId: S.optional(S.String),
    regionAndRoutingControls: RegionAndRoutingControls,
})).annotate({
    identifier: "ArcRoutingControlConfiguration",
});
export const GlobalAuroraDefaultBehavior = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const GlobalAuroraUngracefulBehavior = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const GlobalAuroraUngraceful = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ungraceful: S.optional(GlobalAuroraUngracefulBehavior) })).annotate({
    identifier: "GlobalAuroraUngraceful",
});
export const AuroraClusterArns = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const GlobalAuroraConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    timeoutMinutes: S.optional(S.Number),
    crossAccountRole: S.optional(S.String),
    externalId: S.optional(S.String),
    behavior: GlobalAuroraDefaultBehavior,
    ungraceful: S.optional(GlobalAuroraUngraceful),
    globalClusterIdentifier: S.String,
    databaseClusterArns: AuroraClusterArns,
})).annotate({
    identifier: "GlobalAuroraConfiguration",
});
export const ParallelExecutionBlockConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    steps: S.suspend(() => Steps).annotate({ identifier: "Steps" }),
})).annotate({
    identifier: "ParallelExecutionBlockConfiguration",
});
export const RegionSwitchPlanConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    crossAccountRole: S.optional(S.String),
    externalId: S.optional(S.String),
    arn: S.String,
})).annotate({
    identifier: "RegionSwitchPlanConfiguration",
});
export const Service = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    crossAccountRole: S.optional(S.String),
    externalId: S.optional(S.String),
    clusterArn: S.optional(S.String),
    serviceArn: S.optional(S.String),
})).annotate({ identifier: "Service" });
export const ServiceList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Service);
export const EcsUngraceful = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ minimumSuccessPercentage: S.Number })).annotate({ identifier: "EcsUngraceful" });
export const EcsCapacityMonitoringApproach = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const EcsCapacityIncreaseConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    timeoutMinutes: S.optional(S.Number),
    services: ServiceList,
    ungraceful: S.optional(EcsUngraceful),
    targetPercent: S.optional(S.Number),
    capacityMonitoringApproach: S.optional(EcsCapacityMonitoringApproach),
})).annotate({
    identifier: "EcsCapacityIncreaseConfiguration",
});
export const KubernetesResourceType = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ apiVersion: S.String, kind: S.String })).annotate({
    identifier: "KubernetesResourceType",
});
export const KubernetesScalingResource = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    namespace: S.String,
    name: S.String,
    hpaName: S.optional(S.String),
})).annotate({
    identifier: "KubernetesScalingResource",
});
export const RegionalScalingResource = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, KubernetesScalingResource.pipe(S.optional));
export const KubernetesScalingApplication = 
/*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, RegionalScalingResource.pipe(S.optional));
export const KubernetesScalingApps = /*@__PURE__*/ /*#__PURE__*/ S.Array(KubernetesScalingApplication);
export const EksCluster = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    crossAccountRole: S.optional(S.String),
    externalId: S.optional(S.String),
    clusterArn: S.String,
})).annotate({ identifier: "EksCluster" });
export const EksClusters = /*@__PURE__*/ /*#__PURE__*/ S.Array(EksCluster);
export const EksResourceScalingUngraceful = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ minimumSuccessPercentage: S.Number })).annotate({
    identifier: "EksResourceScalingUngraceful",
});
export const EksCapacityMonitoringApproach = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const EksResourceScalingConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    timeoutMinutes: S.optional(S.Number),
    kubernetesResourceType: KubernetesResourceType,
    scalingResources: S.optional(KubernetesScalingApps),
    eksClusters: S.optional(EksClusters),
    ungraceful: S.optional(EksResourceScalingUngraceful),
    targetPercent: S.optional(S.Number),
    capacityMonitoringApproach: S.optional(EksCapacityMonitoringApproach),
})).annotate({
    identifier: "EksResourceScalingConfiguration",
});
export const Route53ResourceRecordSet = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    recordSetIdentifier: S.optional(S.String),
    region: S.optional(S.String),
})).annotate({
    identifier: "Route53ResourceRecordSet",
});
export const Route53ResourceRecordSetList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Route53ResourceRecordSet);
export const Route53HealthCheckConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    timeoutMinutes: S.optional(S.Number),
    crossAccountRole: S.optional(S.String),
    externalId: S.optional(S.String),
    hostedZoneId: S.String,
    recordName: S.String,
    recordSets: S.optional(Route53ResourceRecordSetList),
})).annotate({
    identifier: "Route53HealthCheckConfiguration",
});
export const DocumentDbDefaultBehavior = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DocumentDbUngracefulBehavior = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const DocumentDbUngraceful = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ungraceful: S.optional(DocumentDbUngracefulBehavior) })).annotate({
    identifier: "DocumentDbUngraceful",
});
export const DocumentDbClusterArns = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const DocumentDbConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    timeoutMinutes: S.optional(S.Number),
    crossAccountRole: S.optional(S.String),
    externalId: S.optional(S.String),
    behavior: DocumentDbDefaultBehavior,
    ungraceful: S.optional(DocumentDbUngraceful),
    globalClusterIdentifier: S.String,
    databaseClusterArns: DocumentDbClusterArns,
})).annotate({
    identifier: "DocumentDbConfiguration",
});
export const RdsDbInstanceArnMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const RdsPromoteReadReplicaConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    timeoutMinutes: S.optional(S.Number),
    crossAccountRole: S.optional(S.String),
    externalId: S.optional(S.String),
    dbInstanceArnMap: RdsDbInstanceArnMap,
})).annotate({
    identifier: "RdsPromoteReadReplicaConfiguration",
});
export const RdsCreateCrossRegionReplicaConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    timeoutMinutes: S.optional(S.Number),
    crossAccountRole: S.optional(S.String),
    externalId: S.optional(S.String),
    dbInstanceArnMap: RdsDbInstanceArnMap,
})).annotate({
    identifier: "RdsCreateCrossRegionReplicaConfiguration",
});
export const ExecutionBlockConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.Union([
    S.Struct({ customActionLambdaConfig: CustomActionLambdaConfiguration }),
    S.Struct({
        ec2AsgCapacityIncreaseConfig: Ec2AsgCapacityIncreaseConfiguration,
    }),
    S.Struct({ executionApprovalConfig: ExecutionApprovalConfiguration }),
    S.Struct({ arcRoutingControlConfig: ArcRoutingControlConfiguration }),
    S.Struct({ globalAuroraConfig: GlobalAuroraConfiguration }),
    S.Struct({
        parallelConfig: S.suspend(() => ParallelExecutionBlockConfiguration).annotate({ identifier: "ParallelExecutionBlockConfiguration" }),
    }),
    S.Struct({ regionSwitchPlanConfig: RegionSwitchPlanConfiguration }),
    S.Struct({ ecsCapacityIncreaseConfig: EcsCapacityIncreaseConfiguration }),
    S.Struct({ eksResourceScalingConfig: EksResourceScalingConfiguration }),
    S.Struct({ route53HealthCheckConfig: Route53HealthCheckConfiguration }),
    S.Struct({ documentDbConfig: DocumentDbConfiguration }),
    S.Struct({ rdsPromoteReadReplicaConfig: RdsPromoteReadReplicaConfiguration }),
    S.Struct({
        rdsCreateCrossRegionReadReplicaConfig: RdsCreateCrossRegionReplicaConfiguration,
    }),
]);
export const ExecutionBlockType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Step = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.String,
    description: S.optional(S.String),
    executionBlockConfiguration: S.suspend(() => ExecutionBlockConfiguration).annotate({ identifier: "ExecutionBlockConfiguration" }),
    executionBlockType: ExecutionBlockType,
})).annotate({ identifier: "Step" });
export const Steps = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.suspend(() => Step).annotate({ identifier: "Step" }));
export const WorkflowTargetAction = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Workflow = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    steps: S.optional(Steps),
    workflowTargetAction: WorkflowTargetAction,
    workflowTargetRegion: S.optional(S.String),
    workflowDescription: S.optional(S.String),
})).annotate({ identifier: "Workflow" });
export const WorkflowList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Workflow);
export const AlarmType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const AssociatedAlarm = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    crossAccountRole: S.optional(S.String),
    externalId: S.optional(S.String),
    resourceIdentifier: S.String,
    alarmType: AlarmType,
})).annotate({
    identifier: "AssociatedAlarm",
});
export const AssociatedAlarmMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, AssociatedAlarm.pipe(S.optional));
export const AlarmCondition = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const TriggerCondition = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ associatedAlarmName: S.String, condition: AlarmCondition })).annotate({
    identifier: "TriggerCondition",
});
export const TriggerConditionList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(TriggerCondition);
export const Trigger = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    description: S.optional(S.String),
    targetRegion: S.String,
    action: WorkflowTargetAction,
    conditions: TriggerConditionList,
    minDelayMinutesBetweenExecutions: S.Number,
})).annotate({ identifier: "Trigger" });
export const TriggerList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Trigger);
export const S3ReportOutputConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    bucketPath: S.optional(S.String),
    bucketOwner: S.optional(S.String),
})).annotate({
    identifier: "S3ReportOutputConfiguration",
});
export const ReportOutputConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.Union([
    S.Struct({ s3Configuration: S3ReportOutputConfiguration }),
]);
export const ReportOutputList = /*@__PURE__*/ /*#__PURE__*/ S.Array(ReportOutputConfiguration);
export const ReportConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ reportOutput: S.optional(ReportOutputList) })).annotate({
    identifier: "ReportConfiguration",
});
export const RegionList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const RecoveryApproach = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Plan = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    description: S.optional(S.String),
    workflows: WorkflowList,
    executionRole: S.String,
    recoveryTimeObjectiveMinutes: S.optional(S.Number),
    associatedAlarms: S.optional(AssociatedAlarmMap),
    triggers: S.optional(TriggerList),
    reportConfiguration: S.optional(ReportConfiguration),
    name: S.String,
    regions: RegionList,
    recoveryApproach: RecoveryApproach,
    primaryRegion: S.optional(S.String),
    owner: S.String,
    version: S.optional(S.String),
    updatedAt: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({ identifier: "Plan" });
export const S3ReportOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ s3ObjectKey: S.optional(S.String) })).annotate({ identifier: "S3ReportOutput" });
export const FailedReportErrorCode = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const FailedReportOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    errorCode: S.optional(FailedReportErrorCode),
    errorMessage: S.optional(S.String),
})).annotate({
    identifier: "FailedReportOutput",
});
export const ReportOutput = /*@__PURE__*/ /*#__PURE__*/ S.Union([
    S.Struct({ s3ReportOutput: S3ReportOutput }),
    S.Struct({ failedReportOutput: FailedReportOutput }),
]);
export const GeneratedReport = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    reportGenerationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    reportOutput: S.optional(ReportOutput),
})).annotate({
    identifier: "GeneratedReport",
});
export const GeneratedReportDetails = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(GeneratedReport);
export const GetPlanExecutionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    planArn: S.String,
    executionId: S.String,
    version: S.optional(S.String),
    updatedAt: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    comment: S.optional(S.String),
    startTime: S.Date.pipe(T.TimestampFormat("epoch-seconds")),
    endTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    mode: ExecutionMode,
    executionState: ExecutionState,
    executionAction: ExecutionAction,
    executionRegion: S.String,
    recoveryExecutionId: S.optional(S.String),
    stepStates: S.optional(StepStates),
    plan: S.optional(Plan),
    actualRecoveryTime: S.optional(S.String),
    generatedReportDetails: S.optional(GeneratedReportDetails),
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "GetPlanExecutionResponse",
});
export const GetPlanInRegionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetPlanInRegionRequest",
});
export const GetPlanInRegionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ plan: S.optional(Plan) })).annotate({
    identifier: "GetPlanInRegionResponse",
});
export const ListPlanExecutionEventsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    planArn: S.String,
    executionId: S.String,
    maxResults: S.optional(S.Number),
    nextToken: S.optional(S.String),
    name: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListPlanExecutionEventsRequest",
});
export const ExecutionEventType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Resources = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const ExecutionEvent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    timestamp: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    type: S.optional(ExecutionEventType),
    stepName: S.optional(S.String),
    executionBlockType: S.optional(ExecutionBlockType),
    resources: S.optional(Resources),
    error: S.optional(S.String),
    description: S.optional(S.String),
    eventId: S.String,
    previousEventId: S.optional(S.String),
})).annotate({ identifier: "ExecutionEvent" });
export const ExecutionEventList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ExecutionEvent);
export const ListPlanExecutionEventsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    items: S.optional(ExecutionEventList),
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListPlanExecutionEventsResponse",
});
export const ListPlanExecutionsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    planArn: S.String,
    maxResults: S.optional(S.Number),
    nextToken: S.optional(S.String),
    state: S.optional(ExecutionState),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListPlanExecutionsRequest",
});
export const AbbreviatedExecution = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    planArn: S.String,
    executionId: S.String,
    version: S.optional(S.String),
    updatedAt: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    comment: S.optional(S.String),
    startTime: S.Date.pipe(T.TimestampFormat("epoch-seconds")),
    endTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    mode: ExecutionMode,
    executionState: ExecutionState,
    executionAction: ExecutionAction,
    executionRegion: S.String,
    recoveryExecutionId: S.optional(S.String),
    actualRecoveryTime: S.optional(S.String),
})).annotate({
    identifier: "AbbreviatedExecution",
});
export const AbbreviatedExecutionsList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(AbbreviatedExecution);
export const ListPlanExecutionsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    items: S.optional(AbbreviatedExecutionsList),
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListPlanExecutionsResponse",
});
export const ListPlansInRegionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    maxResults: S.optional(S.Number),
    nextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListPlansInRegionRequest",
});
export const AbbreviatedPlan = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    owner: S.String,
    name: S.String,
    regions: RegionList,
    recoveryApproach: RecoveryApproach,
    primaryRegion: S.optional(S.String),
    version: S.optional(S.String),
    updatedAt: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    description: S.optional(S.String),
    executionRole: S.optional(S.String),
    activePlanExecution: S.optional(S.String),
    recoveryTimeObjectiveMinutes: S.optional(S.Number),
})).annotate({
    identifier: "AbbreviatedPlan",
});
export const PlanList = /*@__PURE__*/ /*#__PURE__*/ S.Array(AbbreviatedPlan);
export const ListPlansInRegionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ plans: S.optional(PlanList), nextToken: S.optional(S.String) })).annotate({
    identifier: "ListPlansInRegionResponse",
});
export const ListRoute53HealthChecksRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    hostedZoneId: S.optional(S.String),
    recordName: S.optional(S.String),
    maxResults: S.optional(S.Number),
    nextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules, T.StaticContextParams({ UseControlPlaneEndpoint: { value: true } })))).annotate({
    identifier: "ListRoute53HealthChecksRequest",
});
export const Route53HealthCheckStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Route53HealthCheck = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    hostedZoneId: S.String,
    recordName: S.String,
    healthCheckId: S.optional(S.String),
    status: S.optional(Route53HealthCheckStatus),
    region: S.String,
})).annotate({
    identifier: "Route53HealthCheck",
});
export const Route53HealthCheckList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(Route53HealthCheck);
export const ListRoute53HealthChecksResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    healthChecks: S.optional(Route53HealthCheckList),
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListRoute53HealthChecksResponse",
});
export const ListRoute53HealthChecksInRegionRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    hostedZoneId: S.optional(S.String),
    recordName: S.optional(S.String),
    maxResults: S.optional(S.Number),
    nextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListRoute53HealthChecksInRegionRequest",
});
export const ListRoute53HealthChecksInRegionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    healthChecks: S.optional(Route53HealthCheckList),
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListRoute53HealthChecksInRegionResponse",
});
export const StartPlanExecutionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    planArn: S.String,
    targetRegion: S.String,
    action: ExecutionAction,
    mode: S.optional(ExecutionMode),
    comment: S.optional(S.String),
    latestVersion: S.optional(S.String),
    recoveryExecutionId: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartPlanExecutionRequest",
});
export const StartPlanExecutionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    executionId: S.optional(S.String),
    plan: S.optional(S.String),
    planVersion: S.optional(S.String),
    activateRegion: S.optional(S.String),
    deactivateRegion: S.optional(S.String),
})).annotate({
    identifier: "StartPlanExecutionResponse",
});
export const UpdatePlanExecutionAction = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const UpdatePlanExecutionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    planArn: S.String,
    executionId: S.String,
    action: UpdatePlanExecutionAction,
    comment: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdatePlanExecutionRequest",
});
export const UpdatePlanExecutionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "UpdatePlanExecutionResponse",
});
export const UpdatePlanExecutionStepAction = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const UpdatePlanExecutionStepRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    planArn: S.String,
    executionId: S.String,
    comment: S.String,
    stepName: S.String,
    actionToTake: UpdatePlanExecutionStepAction,
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdatePlanExecutionStepRequest",
});
export const UpdatePlanExecutionStepResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "UpdatePlanExecutionStepResponse",
});
export const Tags = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const CreatePlanRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    description: S.optional(S.String),
    workflows: WorkflowList,
    executionRole: S.String,
    recoveryTimeObjectiveMinutes: S.optional(S.Number),
    associatedAlarms: S.optional(AssociatedAlarmMap),
    triggers: S.optional(TriggerList),
    reportConfiguration: S.optional(ReportConfiguration),
    name: S.String,
    regions: RegionList,
    recoveryApproach: RecoveryApproach,
    primaryRegion: S.optional(S.String),
    tags: S.optional(Tags),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules, T.StaticContextParams({ UseControlPlaneEndpoint: { value: true } })))).annotate({
    identifier: "CreatePlanRequest",
});
export const CreatePlanResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ plan: S.optional(Plan) })).annotate({
    identifier: "CreatePlanResponse",
});
export const GetPlanRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules, T.StaticContextParams({ UseControlPlaneEndpoint: { value: true } })))).annotate({ identifier: "GetPlanRequest" });
export const GetPlanResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ plan: S.optional(Plan) })).annotate({
    identifier: "GetPlanResponse",
});
export const UpdatePlanRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    description: S.optional(S.String),
    workflows: WorkflowList,
    executionRole: S.String,
    recoveryTimeObjectiveMinutes: S.optional(S.Number),
    associatedAlarms: S.optional(AssociatedAlarmMap),
    triggers: S.optional(TriggerList),
    reportConfiguration: S.optional(ReportConfiguration),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules, T.StaticContextParams({ UseControlPlaneEndpoint: { value: true } })))).annotate({
    identifier: "UpdatePlanRequest",
});
export const UpdatePlanResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ plan: S.optional(Plan) })).annotate({
    identifier: "UpdatePlanResponse",
});
export const DeletePlanRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules, T.StaticContextParams({ UseControlPlaneEndpoint: { value: true } })))).annotate({
    identifier: "DeletePlanRequest",
});
export const DeletePlanResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeletePlanResponse",
});
export const ListPlansRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    maxResults: S.optional(S.Number),
    nextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules, T.StaticContextParams({ UseControlPlaneEndpoint: { value: true } })))).annotate({
    identifier: "ListPlansRequest",
});
export const ListPlansResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ plans: S.optional(PlanList), nextToken: S.optional(S.String) })).annotate({
    identifier: "ListPlansResponse",
});
export const ListTagsForResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules, T.StaticContextParams({ UseControlPlaneEndpoint: { value: true } })))).annotate({
    identifier: "ListTagsForResourceRequest",
});
export const ListTagsForResourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ resourceTags: S.optional(Tags) })).annotate({
    identifier: "ListTagsForResourceResponse",
});
export const TagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String, tags: Tags }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules, T.StaticContextParams({ UseControlPlaneEndpoint: { value: true } })))).annotate({
    identifier: "TagResourceRequest",
});
export const TagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "TagResourceResponse",
});
export const TagKeys = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const UntagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String, resourceTagKeys: TagKeys }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules, T.StaticContextParams({ UseControlPlaneEndpoint: { value: true } })))).annotate({
    identifier: "UntagResourceRequest",
});
export const UntagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "UntagResourceResponse",
});
//# Errors
export class AccessDeniedException extends S.TaggedErrorClass()("AccessDeniedException", { message: S.String }).pipe(C.withAuthError) {
}
export class ResourceNotFoundException extends S.TaggedErrorClass()("ResourceNotFoundException", { message: S.String }).pipe(C.withBadRequestError) {
}
export class InternalServerException extends S.TaggedErrorClass()("InternalServerException", { message: S.String }).pipe(C.withServerError) {
}
export class IllegalArgumentException extends S.TaggedErrorClass()("IllegalArgumentException", { message: S.String }).pipe(C.withBadRequestError) {
}
export class IllegalStateException extends S.TaggedErrorClass()("IllegalStateException", { message: S.String }).pipe(C.withBadRequestError) {
}
/**
 * Approves a step in a plan execution that requires manual approval. When you create a plan, you can include approval steps that require manual intervention before the execution can proceed. This operation allows you to provide that approval.
 *
 * You must specify the plan ARN, execution ID, step name, and approval status. You can also provide an optional comment explaining the approval decision.
 */
export const approvePlanExecutionStep = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ApprovePlanExecutionStepRequest,
    output: ApprovePlanExecutionStepResponse,
    errors: [AccessDeniedException, ResourceNotFoundException],
}));
/**
 * Cancels an in-progress plan execution. This operation stops the execution of the plan and prevents any further steps from being processed.
 *
 * You must specify the plan ARN and execution ID. You can also provide an optional comment explaining why the execution was canceled.
 */
export const cancelPlanExecution = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CancelPlanExecutionRequest,
    output: CancelPlanExecutionResponse,
    errors: [AccessDeniedException, ResourceNotFoundException],
}));
/**
 * Retrieves the evaluation status of a Region switch plan. The evaluation status provides information about the last time the plan was evaluated and any warnings or issues detected.
 */
export const getPlanEvaluationStatus = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: GetPlanEvaluationStatusRequest,
    output: GetPlanEvaluationStatusResponse,
    errors: [AccessDeniedException, ResourceNotFoundException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "warnings",
        pageSize: "maxResults",
    },
}));
/**
 * Retrieves detailed information about a specific plan execution. You must specify the plan ARN and execution ID.
 */
export const getPlanExecution = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: GetPlanExecutionRequest,
    output: GetPlanExecutionResponse,
    errors: [AccessDeniedException, ResourceNotFoundException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "stepStates",
        pageSize: "maxResults",
    },
}));
/**
 * Retrieves information about a Region switch plan in a specific Amazon Web Services Region. This operation is useful for getting Region-specific information about a plan.
 */
export const getPlanInRegion = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetPlanInRegionRequest,
    output: GetPlanInRegionResponse,
    errors: [AccessDeniedException, ResourceNotFoundException],
}));
/**
 * Lists the events that occurred during a plan execution. These events provide a detailed timeline of the execution process.
 */
export const listPlanExecutionEvents = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListPlanExecutionEventsRequest,
    output: ListPlanExecutionEventsResponse,
    errors: [AccessDeniedException, ResourceNotFoundException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "items",
        pageSize: "maxResults",
    },
}));
/**
 * Lists the executions of a Region switch plan. This operation returns information about both current and historical executions.
 */
export const listPlanExecutions = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListPlanExecutionsRequest,
    output: ListPlanExecutionsResponse,
    errors: [AccessDeniedException, ResourceNotFoundException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "items",
        pageSize: "maxResults",
    },
}));
/**
 * Lists all Region switch plans in your Amazon Web Services account that are available in the current Amazon Web Services Region.
 */
export const listPlansInRegion = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListPlansInRegionRequest,
    output: ListPlansInRegionResponse,
    errors: [AccessDeniedException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "plans",
        pageSize: "maxResults",
    },
}));
/**
 * List the Amazon Route 53 health checks.
 */
export const listRoute53HealthChecks = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListRoute53HealthChecksRequest,
    output: ListRoute53HealthChecksResponse,
    errors: [
        AccessDeniedException,
        InternalServerException,
        ResourceNotFoundException,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "healthChecks",
        pageSize: "maxResults",
    },
}));
/**
 * List the Amazon Route 53 health checks in a specific Amazon Web Services Region.
 */
export const listRoute53HealthChecksInRegion = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListRoute53HealthChecksInRegionRequest,
    output: ListRoute53HealthChecksInRegionResponse,
    errors: [
        AccessDeniedException,
        IllegalArgumentException,
        InternalServerException,
        ResourceNotFoundException,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "healthChecks",
        pageSize: "maxResults",
    },
}));
/**
 * Starts the execution of a Region switch plan. You can execute a plan in either `graceful` or `ungraceful` mode.
 *
 * Specifing `ungraceful` mode either changes the behavior of the execution blocks in a workflow or skips specific execution blocks.
 */
export const startPlanExecution = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartPlanExecutionRequest,
    output: StartPlanExecutionResponse,
    errors: [
        AccessDeniedException,
        IllegalArgumentException,
        IllegalStateException,
        ResourceNotFoundException,
    ],
}));
/**
 * Updates an in-progress plan execution. This operation allows you to modify certain aspects of the execution, such as adding a comment or changing the action.
 */
export const updatePlanExecution = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdatePlanExecutionRequest,
    output: UpdatePlanExecutionResponse,
    errors: [
        AccessDeniedException,
        IllegalStateException,
        ResourceNotFoundException,
    ],
}));
/**
 * Updates a specific step in an in-progress plan execution. This operation allows you to modify the step's comment or action.
 */
export const updatePlanExecutionStep = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdatePlanExecutionStepRequest,
    output: UpdatePlanExecutionStepResponse,
    errors: [AccessDeniedException, ResourceNotFoundException],
}));
/**
 * Creates a new Region switch plan. A plan defines the steps required to shift traffic from one Amazon Web Services Region to another.
 *
 * You must specify a name for the plan, the primary Region, and at least one additional Region. You can also provide a description, execution role, recovery time objective, associated alarms, triggers, and workflows that define the steps to execute during a Region switch.
 */
export const createPlan = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreatePlanRequest,
    output: CreatePlanResponse,
    errors: [],
}));
/**
 * Retrieves detailed information about a Region switch plan. You must specify the ARN of the plan.
 */
export const getPlan = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetPlanRequest,
    output: GetPlanResponse,
    errors: [ResourceNotFoundException],
}));
/**
 * Updates an existing Region switch plan. You can modify the plan's description, workflows, execution role, recovery time objective, associated alarms, and triggers.
 */
export const updatePlan = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdatePlanRequest,
    output: UpdatePlanResponse,
    errors: [ResourceNotFoundException],
}));
/**
 * Deletes a Region switch plan. You must specify the ARN of the plan to delete.
 *
 * You cannot delete a plan that has an active execution in progress.
 */
export const deletePlan = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeletePlanRequest,
    output: DeletePlanResponse,
    errors: [IllegalStateException, ResourceNotFoundException],
}));
/**
 * Lists all Region switch plans in your Amazon Web Services account.
 */
export const listPlans = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListPlansRequest,
    output: ListPlansResponse,
    errors: [],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "plans",
        pageSize: "maxResults",
    },
}));
/**
 * Lists the tags attached to a Region switch resource.
 */
export const listTagsForResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListTagsForResourceRequest,
    output: ListTagsForResourceResponse,
    errors: [InternalServerException, ResourceNotFoundException],
}));
/**
 * Adds or updates tags for a Region switch resource. You can assign metadata to your resources in the form of tags, which are key-value pairs.
 */
export const tagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: TagResourceRequest,
    output: TagResourceResponse,
    errors: [InternalServerException, ResourceNotFoundException],
}));
/**
 * Removes tags from a Region switch resource.
 */
export const untagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UntagResourceRequest,
    output: UntagResourceResponse,
    errors: [InternalServerException, ResourceNotFoundException],
}));
//# sourceMappingURL=arc-region-switch.js.map