@aws-sdk/client-auto-scaling 3.933.0 → 3.935.0

package/dist-types/schemas/schemas_0.d.ts

@@ -98,7 +98,9 @@ export declare var FailedScheduledUpdateGroupActionRequest: StaticStructureSchem
 export declare var Filter: StaticStructureSchema;
 export declare var GetPredictiveScalingForecastAnswer: StaticStructureSchema;
 export declare var GetPredictiveScalingForecastType: StaticStructureSchema;
+export declare var IdempotentParameterMismatchError: StaticErrorSchema;
 export declare var Instance: StaticStructureSchema;
+export declare var InstanceCollection: StaticStructureSchema;
 export declare var InstanceMaintenancePolicy: StaticStructureSchema;
 export declare var InstanceMetadataOptions: StaticStructureSchema;
 export declare var InstanceMonitoring: StaticStructureSchema;
@@ -116,6 +118,9 @@ export declare var LaunchConfiguration: StaticStructureSchema;
 export declare var LaunchConfigurationNamesType: StaticStructureSchema;
 export declare var LaunchConfigurationNameType: StaticStructureSchema;
 export declare var LaunchConfigurationsType: StaticStructureSchema;
+export declare var LaunchInstancesError: StaticStructureSchema;
+export declare var LaunchInstancesRequest: StaticStructureSchema;
+export declare var LaunchInstancesResult: StaticStructureSchema;
 export declare var LaunchTemplate: StaticStructureSchema;
 export declare var LaunchTemplateOverrides: StaticStructureSchema;
 export declare var LaunchTemplateSpecification: StaticStructureSchema;
@@ -209,7 +214,9 @@ export declare var AutoScalingGroupNames: number;
 export declare var AutoScalingGroups: StaticListSchema;
 export declare var AutoScalingInstances: StaticListSchema;
 export declare var AutoScalingNotificationTypes: number;
+export declare var AvailabilityZoneIdsLimit1: number;
 export declare var AvailabilityZones: number;
+export declare var AvailabilityZonesLimit1: number;
 export declare var BlockDeviceMappings: StaticListSchema;
 export declare var CapacityReservationIds: number;
 export declare var CapacityReservationResourceGroupArns: number;
@@ -220,6 +227,7 @@ export declare var EnabledMetrics: StaticListSchema;
 export declare var ExcludedInstanceTypes: number;
 export declare var FailedScheduledUpdateGroupActionRequests: StaticListSchema;
 export declare var Filters: StaticListSchema;
+export declare var InstanceCollections: StaticListSchema;
 export declare var InstanceGenerations: number;
 export declare var InstanceIds: number;
 export declare var InstanceRefreshes: StaticListSchema;
@@ -227,6 +235,7 @@ export declare var InstanceRefreshIds: number;
 export declare var Instances: StaticListSchema;
 export declare var LaunchConfigurationNames: number;
 export declare var LaunchConfigurations: StaticListSchema;
+export declare var LaunchInstancesErrors: StaticListSchema;
 export declare var LifecycleHookNames: number;
 export declare var LifecycleHooks: StaticListSchema;
 export declare var LifecycleHookSpecifications: StaticListSchema;
@@ -256,6 +265,7 @@ export declare var ScheduledUpdateGroupActionRequests: StaticListSchema;
 export declare var ScheduledUpdateGroupActions: StaticListSchema;
 export declare var SecurityGroups: number;
 export declare var StepAdjustments: StaticListSchema;
+export declare var SubnetIdsLimit1: number;
 export declare var SuspendedProcesses: StaticListSchema;
 export declare var TagDescriptionList: StaticListSchema;
 export declare var Tags: StaticListSchema;
@@ -315,6 +325,7 @@ export declare var EnterStandby: StaticOperationSchema;
 export declare var ExecutePolicy: StaticOperationSchema;
 export declare var ExitStandby: StaticOperationSchema;
 export declare var GetPredictiveScalingForecast: StaticOperationSchema;
+export declare var LaunchInstances: StaticOperationSchema;
 export declare var PutLifecycleHook: StaticOperationSchema;
 export declare var PutNotificationConfiguration: StaticOperationSchema;
 export declare var PutScalingPolicy: StaticOperationSchema;

package/dist-types/ts3.4/AutoScaling.d.ts

@@ -200,6 +200,10 @@ import {
   GetPredictiveScalingForecastCommandInput,
   GetPredictiveScalingForecastCommandOutput,
 } from "./commands/GetPredictiveScalingForecastCommand";
+import {
+  LaunchInstancesCommandInput,
+  LaunchInstancesCommandOutput,
+} from "./commands/LaunchInstancesCommand";
 import {
   PutLifecycleHookCommandInput,
   PutLifecycleHookCommandOutput,
@@ -944,6 +948,19 @@ export interface AutoScaling {
     options: __HttpHandlerOptions,
     cb: (err: any, data?: GetPredictiveScalingForecastCommandOutput) => void
   ): void;
+  launchInstances(
+    args: LaunchInstancesCommandInput,
+    options?: __HttpHandlerOptions
+  ): Promise<LaunchInstancesCommandOutput>;
+  launchInstances(
+    args: LaunchInstancesCommandInput,
+    cb: (err: any, data?: LaunchInstancesCommandOutput) => void
+  ): void;
+  launchInstances(
+    args: LaunchInstancesCommandInput,
+    options: __HttpHandlerOptions,
+    cb: (err: any, data?: LaunchInstancesCommandOutput) => void
+  ): void;
   putLifecycleHook(
     args: PutLifecycleHookCommandInput,
     options?: __HttpHandlerOptions

package/dist-types/ts3.4/AutoScalingClient.d.ts

@@ -248,6 +248,10 @@ import {
   GetPredictiveScalingForecastCommandInput,
   GetPredictiveScalingForecastCommandOutput,
 } from "./commands/GetPredictiveScalingForecastCommand";
+import {
+  LaunchInstancesCommandInput,
+  LaunchInstancesCommandOutput,
+} from "./commands/LaunchInstancesCommand";
 import {
   PutLifecycleHookCommandInput,
   PutLifecycleHookCommandOutput,
@@ -366,6 +370,7 @@ export type ServiceInputTypes =
   | ExecutePolicyCommandInput
   | ExitStandbyCommandInput
   | GetPredictiveScalingForecastCommandInput
+  | LaunchInstancesCommandInput
   | PutLifecycleHookCommandInput
   | PutNotificationConfigurationCommandInput
   | PutScalingPolicyCommandInput
@@ -432,6 +437,7 @@ export type ServiceOutputTypes =
   | ExecutePolicyCommandOutput
   | ExitStandbyCommandOutput
   | GetPredictiveScalingForecastCommandOutput
+  | LaunchInstancesCommandOutput
   | PutLifecycleHookCommandOutput
   | PutNotificationConfigurationCommandOutput
   | PutScalingPolicyCommandOutput

package/dist-types/ts3.4/commands/LaunchInstancesCommand.d.ts

@@ -0,0 +1,50 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import {
+  AutoScalingClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../AutoScalingClient";
+import {
+  LaunchInstancesRequest,
+  LaunchInstancesResult,
+} from "../models/models_0";
+export { __MetadataBearer };
+export { $Command };
+export interface LaunchInstancesCommandInput extends LaunchInstancesRequest {}
+export interface LaunchInstancesCommandOutput
+  extends LaunchInstancesResult,
+    __MetadataBearer {}
+declare const LaunchInstancesCommand_base: {
+  new (
+    input: LaunchInstancesCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    LaunchInstancesCommandInput,
+    LaunchInstancesCommandOutput,
+    AutoScalingClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  new (
+    input: LaunchInstancesCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    LaunchInstancesCommandInput,
+    LaunchInstancesCommandOutput,
+    AutoScalingClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class LaunchInstancesCommand extends LaunchInstancesCommand_base {
+  protected static __types: {
+    api: {
+      input: LaunchInstancesRequest;
+      output: LaunchInstancesResult;
+    };
+    sdk: {
+      input: LaunchInstancesCommandInput;
+      output: LaunchInstancesCommandOutput;
+    };
+  };
+}

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

@@ -48,6 +48,7 @@ export * from "./EnterStandbyCommand";
 export * from "./ExecutePolicyCommand";
 export * from "./ExitStandbyCommand";
 export * from "./GetPredictiveScalingForecastCommand";
+export * from "./LaunchInstancesCommand";
 export * from "./PutLifecycleHookCommand";
 export * from "./PutNotificationConfigurationCommand";
 export * from "./PutScalingPolicyCommand";

package/dist-types/ts3.4/index.d.ts

@@ -6,5 +6,7 @@ export { AutoScalingExtensionConfiguration } from "./extensionConfiguration";
 export * from "./commands";
 export * from "./pagination";
 export * from "./waiters";
-export * from "./models";
+export * from "./models/enums";
+export * from "./models/errors";
+export * from "./models/models_0";
 export { AutoScalingServiceException } from "./models/AutoScalingServiceException";

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

@@ -0,0 +1,242 @@
+export declare const AcceleratorManufacturer: {
+  readonly AMAZON_WEB_SERVICES: "amazon-web-services";
+  readonly AMD: "amd";
+  readonly NVIDIA: "nvidia";
+  readonly XILINX: "xilinx";
+};
+export type AcceleratorManufacturer =
+  (typeof AcceleratorManufacturer)[keyof typeof AcceleratorManufacturer];
+export declare const AcceleratorName: {
+  readonly A100: "a100";
+  readonly K80: "k80";
+  readonly M60: "m60";
+  readonly RADEON_PRO_V520: "radeon-pro-v520";
+  readonly T4: "t4";
+  readonly V100: "v100";
+  readonly VU9P: "vu9p";
+};
+export type AcceleratorName =
+  (typeof AcceleratorName)[keyof typeof AcceleratorName];
+export declare const AcceleratorType: {
+  readonly FPGA: "fpga";
+  readonly GPU: "gpu";
+  readonly INFERENCE: "inference";
+};
+export type AcceleratorType =
+  (typeof AcceleratorType)[keyof typeof AcceleratorType];
+export declare const ScalingActivityStatusCode: {
+  readonly Cancelled: "Cancelled";
+  readonly Failed: "Failed";
+  readonly InProgress: "InProgress";
+  readonly MidLifecycleAction: "MidLifecycleAction";
+  readonly PendingSpotBidPlacement: "PendingSpotBidPlacement";
+  readonly PreInService: "PreInService";
+  readonly Successful: "Successful";
+  readonly WaitingForConnectionDraining: "WaitingForConnectionDraining";
+  readonly WaitingForELBConnectionDraining: "WaitingForELBConnectionDraining";
+  readonly WaitingForInstanceId: "WaitingForInstanceId";
+  readonly WaitingForInstanceWarmup: "WaitingForInstanceWarmup";
+  readonly WaitingForSpotInstanceId: "WaitingForSpotInstanceId";
+  readonly WaitingForSpotInstanceRequestId: "WaitingForSpotInstanceRequestId";
+};
+export type ScalingActivityStatusCode =
+  (typeof ScalingActivityStatusCode)[keyof typeof ScalingActivityStatusCode];
+export declare const CapacityDistributionStrategy: {
+  readonly BALANCED_BEST_EFFORT: "balanced-best-effort";
+  readonly BALANCED_ONLY: "balanced-only";
+};
+export type CapacityDistributionStrategy =
+  (typeof CapacityDistributionStrategy)[keyof typeof CapacityDistributionStrategy];
+export declare const ImpairedZoneHealthCheckBehavior: {
+  readonly IgnoreUnhealthy: "IgnoreUnhealthy";
+  readonly ReplaceUnhealthy: "ReplaceUnhealthy";
+};
+export type ImpairedZoneHealthCheckBehavior =
+  (typeof ImpairedZoneHealthCheckBehavior)[keyof typeof ImpairedZoneHealthCheckBehavior];
+export declare const CapacityReservationPreference: {
+  readonly CapacityReservationsFirst: "capacity-reservations-first";
+  readonly CapacityReservationsOnly: "capacity-reservations-only";
+  readonly Default: "default";
+  readonly None: "none";
+};
+export type CapacityReservationPreference =
+  (typeof CapacityReservationPreference)[keyof typeof CapacityReservationPreference];
+export declare const BareMetal: {
+  readonly EXCLUDED: "excluded";
+  readonly INCLUDED: "included";
+  readonly REQUIRED: "required";
+};
+export type BareMetal = (typeof BareMetal)[keyof typeof BareMetal];
+export declare const BurstablePerformance: {
+  readonly EXCLUDED: "excluded";
+  readonly INCLUDED: "included";
+  readonly REQUIRED: "required";
+};
+export type BurstablePerformance =
+  (typeof BurstablePerformance)[keyof typeof BurstablePerformance];
+export declare const CpuManufacturer: {
+  readonly AMAZON_WEB_SERVICES: "amazon-web-services";
+  readonly AMD: "amd";
+  readonly APPLE: "apple";
+  readonly INTEL: "intel";
+};
+export type CpuManufacturer =
+  (typeof CpuManufacturer)[keyof typeof CpuManufacturer];
+export declare const InstanceGeneration: {
+  readonly CURRENT: "current";
+  readonly PREVIOUS: "previous";
+};
+export type InstanceGeneration =
+  (typeof InstanceGeneration)[keyof typeof InstanceGeneration];
+export declare const LocalStorage: {
+  readonly EXCLUDED: "excluded";
+  readonly INCLUDED: "included";
+  readonly REQUIRED: "required";
+};
+export type LocalStorage = (typeof LocalStorage)[keyof typeof LocalStorage];
+export declare const LocalStorageType: {
+  readonly HDD: "hdd";
+  readonly SSD: "ssd";
+};
+export type LocalStorageType =
+  (typeof LocalStorageType)[keyof typeof LocalStorageType];
+export declare const InstanceMetadataEndpointState: {
+  readonly Disabled: "disabled";
+  readonly Enabled: "enabled";
+};
+export type InstanceMetadataEndpointState =
+  (typeof InstanceMetadataEndpointState)[keyof typeof InstanceMetadataEndpointState];
+export declare const InstanceMetadataHttpTokensState: {
+  readonly Optional: "optional";
+  readonly Required: "required";
+};
+export type InstanceMetadataHttpTokensState =
+  (typeof InstanceMetadataHttpTokensState)[keyof typeof InstanceMetadataHttpTokensState];
+export declare const LifecycleState: {
+  readonly DETACHED: "Detached";
+  readonly DETACHING: "Detaching";
+  readonly ENTERING_STANDBY: "EnteringStandby";
+  readonly IN_SERVICE: "InService";
+  readonly PENDING: "Pending";
+  readonly PENDING_PROCEED: "Pending:Proceed";
+  readonly PENDING_WAIT: "Pending:Wait";
+  readonly QUARANTINED: "Quarantined";
+  readonly STANDBY: "Standby";
+  readonly TERMINATED: "Terminated";
+  readonly TERMINATING: "Terminating";
+  readonly TERMINATING_PROCEED: "Terminating:Proceed";
+  readonly TERMINATING_WAIT: "Terminating:Wait";
+  readonly WARMED_HIBERNATED: "Warmed:Hibernated";
+  readonly WARMED_PENDING: "Warmed:Pending";
+  readonly WARMED_PENDING_PROCEED: "Warmed:Pending:Proceed";
+  readonly WARMED_PENDING_WAIT: "Warmed:Pending:Wait";
+  readonly WARMED_RUNNING: "Warmed:Running";
+  readonly WARMED_STOPPED: "Warmed:Stopped";
+  readonly WARMED_TERMINATED: "Warmed:Terminated";
+  readonly WARMED_TERMINATING: "Warmed:Terminating";
+  readonly WARMED_TERMINATING_PROCEED: "Warmed:Terminating:Proceed";
+  readonly WARMED_TERMINATING_WAIT: "Warmed:Terminating:Wait";
+};
+export type LifecycleState =
+  (typeof LifecycleState)[keyof typeof LifecycleState];
+export declare const WarmPoolState: {
+  readonly Hibernated: "Hibernated";
+  readonly Running: "Running";
+  readonly Stopped: "Stopped";
+};
+export type WarmPoolState = (typeof WarmPoolState)[keyof typeof WarmPoolState];
+export declare const WarmPoolStatus: {
+  readonly PendingDelete: "PendingDelete";
+};
+export type WarmPoolStatus =
+  (typeof WarmPoolStatus)[keyof typeof WarmPoolStatus];
+export declare const ScaleInProtectedInstances: {
+  readonly Ignore: "Ignore";
+  readonly Refresh: "Refresh";
+  readonly Wait: "Wait";
+};
+export type ScaleInProtectedInstances =
+  (typeof ScaleInProtectedInstances)[keyof typeof ScaleInProtectedInstances];
+export declare const StandbyInstances: {
+  readonly Ignore: "Ignore";
+  readonly Terminate: "Terminate";
+  readonly Wait: "Wait";
+};
+export type StandbyInstances =
+  (typeof StandbyInstances)[keyof typeof StandbyInstances];
+export declare const InstanceRefreshStatus: {
+  readonly Baking: "Baking";
+  readonly Cancelled: "Cancelled";
+  readonly Cancelling: "Cancelling";
+  readonly Failed: "Failed";
+  readonly InProgress: "InProgress";
+  readonly Pending: "Pending";
+  readonly RollbackFailed: "RollbackFailed";
+  readonly RollbackInProgress: "RollbackInProgress";
+  readonly RollbackSuccessful: "RollbackSuccessful";
+  readonly Successful: "Successful";
+};
+export type InstanceRefreshStatus =
+  (typeof InstanceRefreshStatus)[keyof typeof InstanceRefreshStatus];
+export declare const PredictiveScalingMaxCapacityBreachBehavior: {
+  readonly HonorMaxCapacity: "HonorMaxCapacity";
+  readonly IncreaseMaxCapacity: "IncreaseMaxCapacity";
+};
+export type PredictiveScalingMaxCapacityBreachBehavior =
+  (typeof PredictiveScalingMaxCapacityBreachBehavior)[keyof typeof PredictiveScalingMaxCapacityBreachBehavior];
+export declare const PredefinedLoadMetricType: {
+  readonly ALBTargetGroupRequestCount: "ALBTargetGroupRequestCount";
+  readonly ASGTotalCPUUtilization: "ASGTotalCPUUtilization";
+  readonly ASGTotalNetworkIn: "ASGTotalNetworkIn";
+  readonly ASGTotalNetworkOut: "ASGTotalNetworkOut";
+};
+export type PredefinedLoadMetricType =
+  (typeof PredefinedLoadMetricType)[keyof typeof PredefinedLoadMetricType];
+export declare const PredefinedMetricPairType: {
+  readonly ALBRequestCount: "ALBRequestCount";
+  readonly ASGCPUUtilization: "ASGCPUUtilization";
+  readonly ASGNetworkIn: "ASGNetworkIn";
+  readonly ASGNetworkOut: "ASGNetworkOut";
+};
+export type PredefinedMetricPairType =
+  (typeof PredefinedMetricPairType)[keyof typeof PredefinedMetricPairType];
+export declare const PredefinedScalingMetricType: {
+  readonly ALBRequestCountPerTarget: "ALBRequestCountPerTarget";
+  readonly ASGAverageCPUUtilization: "ASGAverageCPUUtilization";
+  readonly ASGAverageNetworkIn: "ASGAverageNetworkIn";
+  readonly ASGAverageNetworkOut: "ASGAverageNetworkOut";
+};
+export type PredefinedScalingMetricType =
+  (typeof PredefinedScalingMetricType)[keyof typeof PredefinedScalingMetricType];
+export declare const PredictiveScalingMode: {
+  readonly ForecastAndScale: "ForecastAndScale";
+  readonly ForecastOnly: "ForecastOnly";
+};
+export type PredictiveScalingMode =
+  (typeof PredictiveScalingMode)[keyof typeof PredictiveScalingMode];
+export declare const MetricStatistic: {
+  readonly Average: "Average";
+  readonly Maximum: "Maximum";
+  readonly Minimum: "Minimum";
+  readonly SampleCount: "SampleCount";
+  readonly Sum: "Sum";
+};
+export type MetricStatistic =
+  (typeof MetricStatistic)[keyof typeof MetricStatistic];
+export declare const MetricType: {
+  readonly ALBRequestCountPerTarget: "ALBRequestCountPerTarget";
+  readonly ASGAverageCPUUtilization: "ASGAverageCPUUtilization";
+  readonly ASGAverageNetworkIn: "ASGAverageNetworkIn";
+  readonly ASGAverageNetworkOut: "ASGAverageNetworkOut";
+};
+export type MetricType = (typeof MetricType)[keyof typeof MetricType];
+export declare const RetryStrategy: {
+  readonly NONE: "none";
+  readonly RETRY_WITH_GROUP_CONFIGURATION: "retry-with-group-configuration";
+};
+export type RetryStrategy = (typeof RetryStrategy)[keyof typeof RetryStrategy];
+export declare const RefreshStrategy: {
+  readonly Rolling: "Rolling";
+};
+export type RefreshStrategy =
+  (typeof RefreshStrategy)[keyof typeof RefreshStrategy];

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

@@ -0,0 +1,81 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { AutoScalingServiceException as __BaseException } from "./AutoScalingServiceException";
+export declare class ActiveInstanceRefreshNotFoundFault extends __BaseException {
+  readonly name: "ActiveInstanceRefreshNotFoundFault";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<
+      ActiveInstanceRefreshNotFoundFault,
+      __BaseException
+    >
+  );
+}
+export declare class AlreadyExistsFault extends __BaseException {
+  readonly name: "AlreadyExistsFault";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<AlreadyExistsFault, __BaseException>);
+}
+export declare class ResourceContentionFault extends __BaseException {
+  readonly name: "ResourceContentionFault";
+  readonly $fault: "server";
+  constructor(
+    opts: __ExceptionOptionType<ResourceContentionFault, __BaseException>
+  );
+}
+export declare class ServiceLinkedRoleFailure extends __BaseException {
+  readonly name: "ServiceLinkedRoleFailure";
+  readonly $fault: "server";
+  constructor(
+    opts: __ExceptionOptionType<ServiceLinkedRoleFailure, __BaseException>
+  );
+}
+export declare class LimitExceededFault extends __BaseException {
+  readonly name: "LimitExceededFault";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<LimitExceededFault, __BaseException>);
+}
+export declare class ResourceInUseFault extends __BaseException {
+  readonly name: "ResourceInUseFault";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<ResourceInUseFault, __BaseException>);
+}
+export declare class ScalingActivityInProgressFault extends __BaseException {
+  readonly name: "ScalingActivityInProgressFault";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ScalingActivityInProgressFault, __BaseException>
+  );
+}
+export declare class InvalidNextToken extends __BaseException {
+  readonly name: "InvalidNextToken";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<InvalidNextToken, __BaseException>);
+}
+export declare class IdempotentParameterMismatchError extends __BaseException {
+  readonly name: "IdempotentParameterMismatchError";
+  readonly $fault: "client";
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<
+      IdempotentParameterMismatchError,
+      __BaseException
+    >
+  );
+}
+export declare class IrreversibleInstanceRefreshFault extends __BaseException {
+  readonly name: "IrreversibleInstanceRefreshFault";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<
+      IrreversibleInstanceRefreshFault,
+      __BaseException
+    >
+  );
+}
+export declare class InstanceRefreshInProgressFault extends __BaseException {
+  readonly name: "InstanceRefreshInProgressFault";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<InstanceRefreshInProgressFault, __BaseException>
+  );
+}