@aws-sdk/client-ssm 3.52.0 → 3.53.0

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

@@ -1,4 +1,5 @@
-import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { SSMServiceException as __BaseException } from "./SSMServiceException";
 
 export interface AccountSharingInfo {
     
@@ -76,37 +77,49 @@ export declare namespace AddTagsToResourceResult {
     const filterSensitiveLog: (obj: AddTagsToResourceResult) => any;
 }
 
-export interface InternalServerError extends __SmithyException, $MetadataBearer {
-    name: "InternalServerError";
-    $fault: "server";
+export declare class InternalServerError extends __BaseException {
+    readonly name: "InternalServerError";
+    readonly $fault: "server";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerError, __BaseException>);
 }
 
-export interface InvalidResourceId extends __SmithyException, $MetadataBearer {
-    name: "InvalidResourceId";
-    $fault: "client";
+export declare class InvalidResourceId extends __BaseException {
+    readonly name: "InvalidResourceId";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidResourceId, __BaseException>);
 }
 
-export interface InvalidResourceType extends __SmithyException, $MetadataBearer {
-    name: "InvalidResourceType";
-    $fault: "client";
+export declare class InvalidResourceType extends __BaseException {
+    readonly name: "InvalidResourceType";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidResourceType, __BaseException>);
 }
 
-export interface TooManyTagsError extends __SmithyException, $MetadataBearer {
-    name: "TooManyTagsError";
-    $fault: "client";
+export declare class TooManyTagsError extends __BaseException {
+    readonly name: "TooManyTagsError";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TooManyTagsError, __BaseException>);
 }
 
-export interface TooManyUpdates extends __SmithyException, $MetadataBearer {
-    name: "TooManyUpdates";
-    $fault: "client";
+export declare class TooManyUpdates extends __BaseException {
+    readonly name: "TooManyUpdates";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyUpdates, __BaseException>);
 }
 
-export interface AlreadyExistsException extends __SmithyException, $MetadataBearer {
-    name: "AlreadyExistsException";
-    $fault: "client";
+export declare class AlreadyExistsException extends __BaseException {
+    readonly name: "AlreadyExistsException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AlreadyExistsException, __BaseException>);
 }
 export interface AssociateOpsItemRelatedItemRequest {
     
@@ -131,34 +144,42 @@ export declare namespace AssociateOpsItemRelatedItemResponse {
     const filterSensitiveLog: (obj: AssociateOpsItemRelatedItemResponse) => any;
 }
 
-export interface OpsItemInvalidParameterException extends __SmithyException, $MetadataBearer {
-    name: "OpsItemInvalidParameterException";
-    $fault: "client";
+export declare class OpsItemInvalidParameterException extends __BaseException {
+    readonly name: "OpsItemInvalidParameterException";
+    readonly $fault: "client";
     ParameterNames?: string[];
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OpsItemInvalidParameterException, __BaseException>);
 }
 
-export interface OpsItemLimitExceededException extends __SmithyException, $MetadataBearer {
-    name: "OpsItemLimitExceededException";
-    $fault: "client";
+export declare class OpsItemLimitExceededException extends __BaseException {
+    readonly name: "OpsItemLimitExceededException";
+    readonly $fault: "client";
     ResourceTypes?: string[];
     Limit?: number;
     LimitType?: string;
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OpsItemLimitExceededException, __BaseException>);
 }
 
-export interface OpsItemNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "OpsItemNotFoundException";
-    $fault: "client";
+export declare class OpsItemNotFoundException extends __BaseException {
+    readonly name: "OpsItemNotFoundException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OpsItemNotFoundException, __BaseException>);
 }
 
-export interface OpsItemRelatedItemAlreadyExistsException extends __SmithyException, $MetadataBearer {
-    name: "OpsItemRelatedItemAlreadyExistsException";
-    $fault: "client";
+export declare class OpsItemRelatedItemAlreadyExistsException extends __BaseException {
+    readonly name: "OpsItemRelatedItemAlreadyExistsException";
+    readonly $fault: "client";
     Message?: string;
     ResourceUri?: string;
     OpsItemId?: string;
+    
+    constructor(opts: __ExceptionOptionType<OpsItemRelatedItemAlreadyExistsException, __BaseException>);
 }
 
 export interface CancelCommandRequest {
@@ -179,20 +200,26 @@ export declare namespace CancelCommandResult {
     const filterSensitiveLog: (obj: CancelCommandResult) => any;
 }
 
-export interface DuplicateInstanceId extends __SmithyException, $MetadataBearer {
-    name: "DuplicateInstanceId";
-    $fault: "client";
+export declare class DuplicateInstanceId extends __BaseException {
+    readonly name: "DuplicateInstanceId";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DuplicateInstanceId, __BaseException>);
 }
 
-export interface InvalidCommandId extends __SmithyException, $MetadataBearer {
-    name: "InvalidCommandId";
-    $fault: "client";
+export declare class InvalidCommandId extends __BaseException {
+    readonly name: "InvalidCommandId";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidCommandId, __BaseException>);
 }
 
-export interface InvalidInstanceId extends __SmithyException, $MetadataBearer {
-    name: "InvalidInstanceId";
-    $fault: "client";
+export declare class InvalidInstanceId extends __BaseException {
+    readonly name: "InvalidInstanceId";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidInstanceId, __BaseException>);
 }
 export interface CancelMaintenanceWindowExecutionRequest {
     
@@ -211,10 +238,12 @@ export declare namespace CancelMaintenanceWindowExecutionResult {
     const filterSensitiveLog: (obj: CancelMaintenanceWindowExecutionResult) => any;
 }
 
-export interface DoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "DoesNotExistException";
-    $fault: "client";
+export declare class DoesNotExistException extends __BaseException {
+    readonly name: "DoesNotExistException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DoesNotExistException, __BaseException>);
 }
 
 export interface RegistrationMetadataItem {
@@ -258,20 +287,26 @@ export declare namespace CreateActivationResult {
     const filterSensitiveLog: (obj: CreateActivationResult) => any;
 }
 
-export interface InvalidParameters extends __SmithyException, $MetadataBearer {
-    name: "InvalidParameters";
-    $fault: "client";
+export declare class InvalidParameters extends __BaseException {
+    readonly name: "InvalidParameters";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameters, __BaseException>);
 }
 
-export interface AssociationAlreadyExists extends __SmithyException, $MetadataBearer {
-    name: "AssociationAlreadyExists";
-    $fault: "client";
+export declare class AssociationAlreadyExists extends __BaseException {
+    readonly name: "AssociationAlreadyExists";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AssociationAlreadyExists, __BaseException>);
 }
 
-export interface AssociationLimitExceeded extends __SmithyException, $MetadataBearer {
-    name: "AssociationLimitExceeded";
-    $fault: "client";
+export declare class AssociationLimitExceeded extends __BaseException {
+    readonly name: "AssociationLimitExceeded";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AssociationLimitExceeded, __BaseException>);
 }
 export declare enum AssociationComplianceSeverity {
     Critical = "CRITICAL",
@@ -475,40 +510,52 @@ export declare namespace CreateAssociationResult {
     const filterSensitiveLog: (obj: CreateAssociationResult) => any;
 }
 
-export interface InvalidDocument extends __SmithyException, $MetadataBearer {
-    name: "InvalidDocument";
-    $fault: "client";
+export declare class InvalidDocument extends __BaseException {
+    readonly name: "InvalidDocument";
+    readonly $fault: "client";
     
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidDocument, __BaseException>);
 }
 
-export interface InvalidDocumentVersion extends __SmithyException, $MetadataBearer {
-    name: "InvalidDocumentVersion";
-    $fault: "client";
+export declare class InvalidDocumentVersion extends __BaseException {
+    readonly name: "InvalidDocumentVersion";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidDocumentVersion, __BaseException>);
 }
 
-export interface InvalidOutputLocation extends __SmithyException, $MetadataBearer {
-    name: "InvalidOutputLocation";
-    $fault: "client";
+export declare class InvalidOutputLocation extends __BaseException {
+    readonly name: "InvalidOutputLocation";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidOutputLocation, __BaseException>);
 }
 
-export interface InvalidSchedule extends __SmithyException, $MetadataBearer {
-    name: "InvalidSchedule";
-    $fault: "client";
+export declare class InvalidSchedule extends __BaseException {
+    readonly name: "InvalidSchedule";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidSchedule, __BaseException>);
 }
 
-export interface InvalidTarget extends __SmithyException, $MetadataBearer {
-    name: "InvalidTarget";
-    $fault: "client";
+export declare class InvalidTarget extends __BaseException {
+    readonly name: "InvalidTarget";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidTarget, __BaseException>);
 }
 
-export interface UnsupportedPlatformType extends __SmithyException, $MetadataBearer {
-    name: "UnsupportedPlatformType";
-    $fault: "client";
+export declare class UnsupportedPlatformType extends __BaseException {
+    readonly name: "UnsupportedPlatformType";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedPlatformType, __BaseException>);
 }
 
 export interface CreateAssociationBatchRequestEntry {
@@ -793,35 +840,45 @@ export declare namespace CreateDocumentResult {
     const filterSensitiveLog: (obj: CreateDocumentResult) => any;
 }
 
-export interface DocumentAlreadyExists extends __SmithyException, $MetadataBearer {
-    name: "DocumentAlreadyExists";
-    $fault: "client";
+export declare class DocumentAlreadyExists extends __BaseException {
+    readonly name: "DocumentAlreadyExists";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DocumentAlreadyExists, __BaseException>);
 }
 
-export interface DocumentLimitExceeded extends __SmithyException, $MetadataBearer {
-    name: "DocumentLimitExceeded";
-    $fault: "client";
+export declare class DocumentLimitExceeded extends __BaseException {
+    readonly name: "DocumentLimitExceeded";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DocumentLimitExceeded, __BaseException>);
 }
 
-export interface InvalidDocumentContent extends __SmithyException, $MetadataBearer {
-    name: "InvalidDocumentContent";
-    $fault: "client";
+export declare class InvalidDocumentContent extends __BaseException {
+    readonly name: "InvalidDocumentContent";
+    readonly $fault: "client";
     
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidDocumentContent, __BaseException>);
 }
 
-export interface InvalidDocumentSchemaVersion extends __SmithyException, $MetadataBearer {
-    name: "InvalidDocumentSchemaVersion";
-    $fault: "client";
+export declare class InvalidDocumentSchemaVersion extends __BaseException {
+    readonly name: "InvalidDocumentSchemaVersion";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidDocumentSchemaVersion, __BaseException>);
 }
 
-export interface MaxDocumentSizeExceeded extends __SmithyException, $MetadataBearer {
-    name: "MaxDocumentSizeExceeded";
-    $fault: "client";
+export declare class MaxDocumentSizeExceeded extends __BaseException {
+    readonly name: "MaxDocumentSizeExceeded";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<MaxDocumentSizeExceeded, __BaseException>);
 }
 export interface CreateMaintenanceWindowRequest {
     
@@ -862,16 +919,20 @@ export declare namespace CreateMaintenanceWindowResult {
     const filterSensitiveLog: (obj: CreateMaintenanceWindowResult) => any;
 }
 
-export interface IdempotentParameterMismatch extends __SmithyException, $MetadataBearer {
-    name: "IdempotentParameterMismatch";
-    $fault: "client";
+export declare class IdempotentParameterMismatch extends __BaseException {
+    readonly name: "IdempotentParameterMismatch";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<IdempotentParameterMismatch, __BaseException>);
 }
 
-export interface ResourceLimitExceededException extends __SmithyException, $MetadataBearer {
-    name: "ResourceLimitExceededException";
-    $fault: "client";
+export declare class ResourceLimitExceededException extends __BaseException {
+    readonly name: "ResourceLimitExceededException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceLimitExceededException, __BaseException>);
 }
 
 export interface OpsItemNotification {
@@ -953,11 +1014,13 @@ export declare namespace CreateOpsItemResponse {
     const filterSensitiveLog: (obj: CreateOpsItemResponse) => any;
 }
 
-export interface OpsItemAlreadyExistsException extends __SmithyException, $MetadataBearer {
-    name: "OpsItemAlreadyExistsException";
-    $fault: "client";
+export declare class OpsItemAlreadyExistsException extends __BaseException {
+    readonly name: "OpsItemAlreadyExistsException";
+    readonly $fault: "client";
     Message?: string;
     OpsItemId?: string;
+    
+    constructor(opts: __ExceptionOptionType<OpsItemAlreadyExistsException, __BaseException>);
 }
 
 export interface MetadataValue {
@@ -991,28 +1054,32 @@ export declare namespace CreateOpsMetadataResult {
     const filterSensitiveLog: (obj: CreateOpsMetadataResult) => any;
 }
 
-export interface OpsMetadataAlreadyExistsException extends __SmithyException, $MetadataBearer {
-    name: "OpsMetadataAlreadyExistsException";
-    $fault: "client";
-    message?: string;
+export declare class OpsMetadataAlreadyExistsException extends __BaseException {
+    readonly name: "OpsMetadataAlreadyExistsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OpsMetadataAlreadyExistsException, __BaseException>);
 }
 
-export interface OpsMetadataInvalidArgumentException extends __SmithyException, $MetadataBearer {
-    name: "OpsMetadataInvalidArgumentException";
-    $fault: "client";
-    message?: string;
+export declare class OpsMetadataInvalidArgumentException extends __BaseException {
+    readonly name: "OpsMetadataInvalidArgumentException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OpsMetadataInvalidArgumentException, __BaseException>);
 }
 
-export interface OpsMetadataLimitExceededException extends __SmithyException, $MetadataBearer {
-    name: "OpsMetadataLimitExceededException";
-    $fault: "client";
-    message?: string;
+export declare class OpsMetadataLimitExceededException extends __BaseException {
+    readonly name: "OpsMetadataLimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OpsMetadataLimitExceededException, __BaseException>);
 }
 
-export interface OpsMetadataTooManyUpdatesException extends __SmithyException, $MetadataBearer {
-    name: "OpsMetadataTooManyUpdatesException";
-    $fault: "client";
-    message?: string;
+export declare class OpsMetadataTooManyUpdatesException extends __BaseException {
+    readonly name: "OpsMetadataTooManyUpdatesException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OpsMetadataTooManyUpdatesException, __BaseException>);
 }
 export declare enum PatchComplianceLevel {
     Critical = "CRITICAL",
@@ -1248,22 +1315,28 @@ export declare namespace CreateResourceDataSyncResult {
     const filterSensitiveLog: (obj: CreateResourceDataSyncResult) => any;
 }
 
-export interface ResourceDataSyncAlreadyExistsException extends __SmithyException, $MetadataBearer {
-    name: "ResourceDataSyncAlreadyExistsException";
-    $fault: "client";
+export declare class ResourceDataSyncAlreadyExistsException extends __BaseException {
+    readonly name: "ResourceDataSyncAlreadyExistsException";
+    readonly $fault: "client";
     SyncName?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceDataSyncAlreadyExistsException, __BaseException>);
 }
 
-export interface ResourceDataSyncCountExceededException extends __SmithyException, $MetadataBearer {
-    name: "ResourceDataSyncCountExceededException";
-    $fault: "client";
+export declare class ResourceDataSyncCountExceededException extends __BaseException {
+    readonly name: "ResourceDataSyncCountExceededException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceDataSyncCountExceededException, __BaseException>);
 }
 
-export interface ResourceDataSyncInvalidConfigurationException extends __SmithyException, $MetadataBearer {
-    name: "ResourceDataSyncInvalidConfigurationException";
-    $fault: "client";
+export declare class ResourceDataSyncInvalidConfigurationException extends __BaseException {
+    readonly name: "ResourceDataSyncInvalidConfigurationException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceDataSyncInvalidConfigurationException, __BaseException>);
 }
 export interface DeleteActivationRequest {
     
@@ -1280,22 +1353,28 @@ export declare namespace DeleteActivationResult {
     const filterSensitiveLog: (obj: DeleteActivationResult) => any;
 }
 
-export interface InvalidActivation extends __SmithyException, $MetadataBearer {
-    name: "InvalidActivation";
-    $fault: "client";
+export declare class InvalidActivation extends __BaseException {
+    readonly name: "InvalidActivation";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidActivation, __BaseException>);
 }
 
-export interface InvalidActivationId extends __SmithyException, $MetadataBearer {
-    name: "InvalidActivationId";
-    $fault: "client";
+export declare class InvalidActivationId extends __BaseException {
+    readonly name: "InvalidActivationId";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidActivationId, __BaseException>);
 }
 
-export interface AssociationDoesNotExist extends __SmithyException, $MetadataBearer {
-    name: "AssociationDoesNotExist";
-    $fault: "client";
+export declare class AssociationDoesNotExist extends __BaseException {
+    readonly name: "AssociationDoesNotExist";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AssociationDoesNotExist, __BaseException>);
 }
 export interface DeleteAssociationRequest {
     
@@ -1316,9 +1395,11 @@ export declare namespace DeleteAssociationResult {
     const filterSensitiveLog: (obj: DeleteAssociationResult) => any;
 }
 
-export interface AssociatedInstances extends __SmithyException, $MetadataBearer {
-    name: "AssociatedInstances";
-    $fault: "client";
+export declare class AssociatedInstances extends __BaseException {
+    readonly name: "AssociatedInstances";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AssociatedInstances, __BaseException>);
 }
 export interface DeleteDocumentRequest {
     
@@ -1341,10 +1422,12 @@ export declare namespace DeleteDocumentResult {
     const filterSensitiveLog: (obj: DeleteDocumentResult) => any;
 }
 
-export interface InvalidDocumentOperation extends __SmithyException, $MetadataBearer {
-    name: "InvalidDocumentOperation";
-    $fault: "client";
+export declare class InvalidDocumentOperation extends __BaseException {
+    readonly name: "InvalidDocumentOperation";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidDocumentOperation, __BaseException>);
 }
 export declare enum InventorySchemaDeleteOption {
     DELETE_SCHEMA = "DeleteSchema",
@@ -1403,28 +1486,36 @@ export declare namespace DeleteInventoryResult {
     const filterSensitiveLog: (obj: DeleteInventoryResult) => any;
 }
 
-export interface InvalidDeleteInventoryParametersException extends __SmithyException, $MetadataBearer {
-    name: "InvalidDeleteInventoryParametersException";
-    $fault: "client";
+export declare class InvalidDeleteInventoryParametersException extends __BaseException {
+    readonly name: "InvalidDeleteInventoryParametersException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidDeleteInventoryParametersException, __BaseException>);
 }
 
-export interface InvalidInventoryRequestException extends __SmithyException, $MetadataBearer {
-    name: "InvalidInventoryRequestException";
-    $fault: "client";
+export declare class InvalidInventoryRequestException extends __BaseException {
+    readonly name: "InvalidInventoryRequestException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidInventoryRequestException, __BaseException>);
 }
 
-export interface InvalidOptionException extends __SmithyException, $MetadataBearer {
-    name: "InvalidOptionException";
-    $fault: "client";
+export declare class InvalidOptionException extends __BaseException {
+    readonly name: "InvalidOptionException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidOptionException, __BaseException>);
 }
 
-export interface InvalidTypeNameException extends __SmithyException, $MetadataBearer {
-    name: "InvalidTypeNameException";
-    $fault: "client";
+export declare class InvalidTypeNameException extends __BaseException {
+    readonly name: "InvalidTypeNameException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidTypeNameException, __BaseException>);
 }
 export interface DeleteMaintenanceWindowRequest {
     
@@ -1457,10 +1548,11 @@ export declare namespace DeleteOpsMetadataResult {
     const filterSensitiveLog: (obj: DeleteOpsMetadataResult) => any;
 }
 
-export interface OpsMetadataNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "OpsMetadataNotFoundException";
-    $fault: "client";
-    message?: string;
+export declare class OpsMetadataNotFoundException extends __BaseException {
+    readonly name: "OpsMetadataNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OpsMetadataNotFoundException, __BaseException>);
 }
 export interface DeleteParameterRequest {
     
@@ -1477,10 +1569,11 @@ export declare namespace DeleteParameterResult {
     const filterSensitiveLog: (obj: DeleteParameterResult) => any;
 }
 
-export interface ParameterNotFound extends __SmithyException, $MetadataBearer {
-    name: "ParameterNotFound";
-    $fault: "client";
-    message?: string;
+export declare class ParameterNotFound extends __BaseException {
+    readonly name: "ParameterNotFound";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ParameterNotFound, __BaseException>);
 }
 export interface DeleteParametersRequest {
     
@@ -1517,10 +1610,12 @@ export declare namespace DeletePatchBaselineResult {
     const filterSensitiveLog: (obj: DeletePatchBaselineResult) => any;
 }
 
-export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
-    name: "ResourceInUseException";
-    $fault: "client";
+export declare class ResourceInUseException extends __BaseException {
+    readonly name: "ResourceInUseException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceInUseException, __BaseException>);
 }
 export interface DeleteResourceDataSyncRequest {
     
@@ -1539,12 +1634,14 @@ export declare namespace DeleteResourceDataSyncResult {
     const filterSensitiveLog: (obj: DeleteResourceDataSyncResult) => any;
 }
 
-export interface ResourceDataSyncNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "ResourceDataSyncNotFoundException";
-    $fault: "client";
+export declare class ResourceDataSyncNotFoundException extends __BaseException {
+    readonly name: "ResourceDataSyncNotFoundException";
+    readonly $fault: "client";
     SyncName?: string;
     SyncType?: string;
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceDataSyncNotFoundException, __BaseException>);
 }
 export interface DeregisterManagedInstanceRequest {
     
@@ -1603,10 +1700,12 @@ export declare namespace DeregisterTargetFromMaintenanceWindowResult {
     const filterSensitiveLog: (obj: DeregisterTargetFromMaintenanceWindowResult) => any;
 }
 
-export interface TargetInUseException extends __SmithyException, $MetadataBearer {
-    name: "TargetInUseException";
-    $fault: "client";
+export declare class TargetInUseException extends __BaseException {
+    readonly name: "TargetInUseException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TargetInUseException, __BaseException>);
 }
 export interface DeregisterTaskFromMaintenanceWindowRequest {
     
@@ -1667,16 +1766,20 @@ export declare namespace DescribeActivationsResult {
     const filterSensitiveLog: (obj: DescribeActivationsResult) => any;
 }
 
-export interface InvalidFilter extends __SmithyException, $MetadataBearer {
-    name: "InvalidFilter";
-    $fault: "client";
+export declare class InvalidFilter extends __BaseException {
+    readonly name: "InvalidFilter";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidFilter, __BaseException>);
 }
 
-export interface InvalidNextToken extends __SmithyException, $MetadataBearer {
-    name: "InvalidNextToken";
-    $fault: "client";
+export declare class InvalidNextToken extends __BaseException {
+    readonly name: "InvalidNextToken";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidNextToken, __BaseException>);
 }
 export interface DescribeAssociationRequest {
     
@@ -1701,10 +1804,12 @@ export declare namespace DescribeAssociationResult {
     const filterSensitiveLog: (obj: DescribeAssociationResult) => any;
 }
 
-export interface InvalidAssociationVersion extends __SmithyException, $MetadataBearer {
-    name: "InvalidAssociationVersion";
-    $fault: "client";
+export declare class InvalidAssociationVersion extends __BaseException {
+    readonly name: "InvalidAssociationVersion";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidAssociationVersion, __BaseException>);
 }
 export declare enum AssociationExecutionFilterKey {
     CreatedTime = "CreatedTime",
@@ -1777,10 +1882,12 @@ export declare namespace DescribeAssociationExecutionsResult {
     const filterSensitiveLog: (obj: DescribeAssociationExecutionsResult) => any;
 }
 
-export interface AssociationExecutionDoesNotExist extends __SmithyException, $MetadataBearer {
-    name: "AssociationExecutionDoesNotExist";
-    $fault: "client";
+export declare class AssociationExecutionDoesNotExist extends __BaseException {
+    readonly name: "AssociationExecutionDoesNotExist";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AssociationExecutionDoesNotExist, __BaseException>);
 }
 export declare enum AssociationExecutionTargetsFilterKey {
     ResourceId = "ResourceId",
@@ -2042,21 +2149,27 @@ export declare namespace DescribeAutomationExecutionsResult {
     const filterSensitiveLog: (obj: DescribeAutomationExecutionsResult) => any;
 }
 
-export interface InvalidFilterKey extends __SmithyException, $MetadataBearer {
-    name: "InvalidFilterKey";
-    $fault: "client";
+export declare class InvalidFilterKey extends __BaseException {
+    readonly name: "InvalidFilterKey";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidFilterKey, __BaseException>);
 }
 
-export interface InvalidFilterValue extends __SmithyException, $MetadataBearer {
-    name: "InvalidFilterValue";
-    $fault: "client";
+export declare class InvalidFilterValue extends __BaseException {
+    readonly name: "InvalidFilterValue";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidFilterValue, __BaseException>);
 }
 
-export interface AutomationExecutionNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "AutomationExecutionNotFoundException";
-    $fault: "client";
+export declare class AutomationExecutionNotFoundException extends __BaseException {
+    readonly name: "AutomationExecutionNotFoundException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AutomationExecutionNotFoundException, __BaseException>);
 }
 export declare enum StepExecutionFilterKey {
     ACTION = "Action",
@@ -2311,10 +2424,12 @@ export declare namespace DescribeDocumentPermissionResponse {
     const filterSensitiveLog: (obj: DescribeDocumentPermissionResponse) => any;
 }
 
-export interface InvalidPermissionType extends __SmithyException, $MetadataBearer {
-    name: "InvalidPermissionType";
-    $fault: "client";
+export declare class InvalidPermissionType extends __BaseException {
+    readonly name: "InvalidPermissionType";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidPermissionType, __BaseException>);
 }
 export interface DescribeEffectiveInstanceAssociationsRequest {
     
@@ -2406,10 +2521,12 @@ export declare namespace DescribeEffectivePatchesForPatchBaselineResult {
     const filterSensitiveLog: (obj: DescribeEffectivePatchesForPatchBaselineResult) => any;
 }
 
-export interface UnsupportedOperatingSystem extends __SmithyException, $MetadataBearer {
-    name: "UnsupportedOperatingSystem";
-    $fault: "client";
+export declare class UnsupportedOperatingSystem extends __BaseException {
+    readonly name: "UnsupportedOperatingSystem";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedOperatingSystem, __BaseException>);
 }
 export interface DescribeInstanceAssociationsStatusRequest {
     
@@ -2616,10 +2733,11 @@ export declare namespace DescribeInstanceInformationResult {
     const filterSensitiveLog: (obj: DescribeInstanceInformationResult) => any;
 }
 
-export interface InvalidInstanceInformationFilterValue extends __SmithyException, $MetadataBearer {
-    name: "InvalidInstanceInformationFilterValue";
-    $fault: "client";
-    message?: string;
+export declare class InvalidInstanceInformationFilterValue extends __BaseException {
+    readonly name: "InvalidInstanceInformationFilterValue";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidInstanceInformationFilterValue, __BaseException>);
 }
 export interface DescribeInstancePatchesRequest {
     
@@ -2847,10 +2965,12 @@ export declare namespace DescribeInventoryDeletionsResult {
     const filterSensitiveLog: (obj: DescribeInventoryDeletionsResult) => any;
 }
 
-export interface InvalidDeletionIdException extends __SmithyException, $MetadataBearer {
-    name: "InvalidDeletionIdException";
-    $fault: "client";
+export declare class InvalidDeletionIdException extends __BaseException {
+    readonly name: "InvalidDeletionIdException";
+    readonly $fault: "client";
     Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidDeletionIdException, __BaseException>);
 }
 
 export interface MaintenanceWindowFilter {