get and store last run time in ssm

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/AddTagsToResourceCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddTagsToResourceCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class AddTagsToResourceCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, AddTagsToResourceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "AddTagsToResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "AddTagsToResource",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_AddTagsToResourceCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_AddTagsToResourceCommand)(output, context);
+    }
+}
+exports.AddTagsToResourceCommand = AddTagsToResourceCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/AssociateOpsItemRelatedItemCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssociateOpsItemRelatedItemCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class AssociateOpsItemRelatedItemCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, AssociateOpsItemRelatedItemCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "AssociateOpsItemRelatedItemCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "AssociateOpsItemRelatedItem",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_AssociateOpsItemRelatedItemCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_AssociateOpsItemRelatedItemCommand)(output, context);
+    }
+}
+exports.AssociateOpsItemRelatedItemCommand = AssociateOpsItemRelatedItemCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/CancelCommandCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelCommandCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class CancelCommandCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CancelCommandCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "CancelCommandCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "CancelCommand",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_CancelCommandCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_CancelCommandCommand)(output, context);
+    }
+}
+exports.CancelCommandCommand = CancelCommandCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/CancelMaintenanceWindowExecutionCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelMaintenanceWindowExecutionCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class CancelMaintenanceWindowExecutionCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CancelMaintenanceWindowExecutionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "CancelMaintenanceWindowExecutionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "CancelMaintenanceWindowExecution",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_CancelMaintenanceWindowExecutionCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_CancelMaintenanceWindowExecutionCommand)(output, context);
+    }
+}
+exports.CancelMaintenanceWindowExecutionCommand = CancelMaintenanceWindowExecutionCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/CreateActivationCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateActivationCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class CreateActivationCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateActivationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "CreateActivationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "CreateActivation",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_CreateActivationCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_CreateActivationCommand)(output, context);
+    }
+}
+exports.CreateActivationCommand = CreateActivationCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/CreateAssociationBatchCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateAssociationBatchCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class CreateAssociationBatchCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateAssociationBatchCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "CreateAssociationBatchCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateAssociationBatchRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateAssociationBatchResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "CreateAssociationBatch",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_CreateAssociationBatchCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_CreateAssociationBatchCommand)(output, context);
+    }
+}
+exports.CreateAssociationBatchCommand = CreateAssociationBatchCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/CreateAssociationCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateAssociationCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class CreateAssociationCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateAssociationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "CreateAssociationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateAssociationRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateAssociationResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "CreateAssociation",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_CreateAssociationCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_CreateAssociationCommand)(output, context);
+    }
+}
+exports.CreateAssociationCommand = CreateAssociationCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/CreateDocumentCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDocumentCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class CreateDocumentCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateDocumentCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "CreateDocumentCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "CreateDocument",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_CreateDocumentCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_CreateDocumentCommand)(output, context);
+    }
+}
+exports.CreateDocumentCommand = CreateDocumentCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/CreateMaintenanceWindowCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateMaintenanceWindowCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class CreateMaintenanceWindowCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateMaintenanceWindowCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "CreateMaintenanceWindowCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateMaintenanceWindowRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "CreateMaintenanceWindow",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_CreateMaintenanceWindowCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_CreateMaintenanceWindowCommand)(output, context);
+    }
+}
+exports.CreateMaintenanceWindowCommand = CreateMaintenanceWindowCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/CreateOpsItemCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateOpsItemCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class CreateOpsItemCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateOpsItemCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "CreateOpsItemCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "CreateOpsItem",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_CreateOpsItemCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_CreateOpsItemCommand)(output, context);
+    }
+}
+exports.CreateOpsItemCommand = CreateOpsItemCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/CreateOpsMetadataCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateOpsMetadataCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class CreateOpsMetadataCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateOpsMetadataCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "CreateOpsMetadataCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "CreateOpsMetadata",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_CreateOpsMetadataCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_CreateOpsMetadataCommand)(output, context);
+    }
+}
+exports.CreateOpsMetadataCommand = CreateOpsMetadataCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/CreatePatchBaselineCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreatePatchBaselineCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class CreatePatchBaselineCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreatePatchBaselineCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "CreatePatchBaselineCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreatePatchBaselineRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "CreatePatchBaseline",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_CreatePatchBaselineCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_CreatePatchBaselineCommand)(output, context);
+    }
+}
+exports.CreatePatchBaselineCommand = CreatePatchBaselineCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/CreateResourceDataSyncCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateResourceDataSyncCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class CreateResourceDataSyncCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateResourceDataSyncCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "CreateResourceDataSyncCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "CreateResourceDataSync",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_CreateResourceDataSyncCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_CreateResourceDataSyncCommand)(output, context);
+    }
+}
+exports.CreateResourceDataSyncCommand = CreateResourceDataSyncCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeleteActivationCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteActivationCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeleteActivationCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteActivationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeleteActivationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeleteActivation",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeleteActivationCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeleteActivationCommand)(output, context);
+    }
+}
+exports.DeleteActivationCommand = DeleteActivationCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeleteAssociationCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteAssociationCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeleteAssociationCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteAssociationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeleteAssociationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeleteAssociation",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeleteAssociationCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeleteAssociationCommand)(output, context);
+    }
+}
+exports.DeleteAssociationCommand = DeleteAssociationCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeleteDocumentCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteDocumentCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeleteDocumentCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteDocumentCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeleteDocumentCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeleteDocument",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeleteDocumentCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeleteDocumentCommand)(output, context);
+    }
+}
+exports.DeleteDocumentCommand = DeleteDocumentCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeleteInventoryCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteInventoryCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeleteInventoryCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteInventoryCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeleteInventoryCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeleteInventory",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeleteInventoryCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeleteInventoryCommand)(output, context);
+    }
+}
+exports.DeleteInventoryCommand = DeleteInventoryCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeleteMaintenanceWindowCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteMaintenanceWindowCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeleteMaintenanceWindowCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteMaintenanceWindowCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeleteMaintenanceWindowCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeleteMaintenanceWindow",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeleteMaintenanceWindowCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeleteMaintenanceWindowCommand)(output, context);
+    }
+}
+exports.DeleteMaintenanceWindowCommand = DeleteMaintenanceWindowCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeleteOpsItemCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteOpsItemCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeleteOpsItemCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteOpsItemCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeleteOpsItemCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeleteOpsItem",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeleteOpsItemCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeleteOpsItemCommand)(output, context);
+    }
+}
+exports.DeleteOpsItemCommand = DeleteOpsItemCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeleteOpsMetadataCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteOpsMetadataCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeleteOpsMetadataCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteOpsMetadataCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeleteOpsMetadataCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeleteOpsMetadata",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeleteOpsMetadataCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeleteOpsMetadataCommand)(output, context);
+    }
+}
+exports.DeleteOpsMetadataCommand = DeleteOpsMetadataCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeleteParameterCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteParameterCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeleteParameterCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteParameterCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeleteParameterCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeleteParameter",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeleteParameterCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeleteParameterCommand)(output, context);
+    }
+}
+exports.DeleteParameterCommand = DeleteParameterCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeleteParametersCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteParametersCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeleteParametersCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteParametersCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeleteParametersCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeleteParameters",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeleteParametersCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeleteParametersCommand)(output, context);
+    }
+}
+exports.DeleteParametersCommand = DeleteParametersCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeletePatchBaselineCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeletePatchBaselineCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeletePatchBaselineCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeletePatchBaselineCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeletePatchBaselineCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeletePatchBaseline",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeletePatchBaselineCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeletePatchBaselineCommand)(output, context);
+    }
+}
+exports.DeletePatchBaselineCommand = DeletePatchBaselineCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeleteResourceDataSyncCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteResourceDataSyncCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeleteResourceDataSyncCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteResourceDataSyncCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeleteResourceDataSyncCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeleteResourceDataSync",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeleteResourceDataSyncCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeleteResourceDataSyncCommand)(output, context);
+    }
+}
+exports.DeleteResourceDataSyncCommand = DeleteResourceDataSyncCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeleteResourcePolicyCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteResourcePolicyCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeleteResourcePolicyCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteResourcePolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeleteResourcePolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeleteResourcePolicy",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeleteResourcePolicyCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeleteResourcePolicyCommand)(output, context);
+    }
+}
+exports.DeleteResourcePolicyCommand = DeleteResourcePolicyCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeregisterManagedInstanceCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeregisterManagedInstanceCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeregisterManagedInstanceCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeregisterManagedInstanceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeregisterManagedInstanceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeregisterManagedInstance",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeregisterManagedInstanceCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeregisterManagedInstanceCommand)(output, context);
+    }
+}
+exports.DeregisterManagedInstanceCommand = DeregisterManagedInstanceCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeregisterPatchBaselineForPatchGroupCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeregisterPatchBaselineForPatchGroupCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeregisterPatchBaselineForPatchGroupCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeregisterPatchBaselineForPatchGroupCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeregisterPatchBaselineForPatchGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeregisterPatchBaselineForPatchGroup",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeregisterPatchBaselineForPatchGroupCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeregisterPatchBaselineForPatchGroupCommand)(output, context);
+    }
+}
+exports.DeregisterPatchBaselineForPatchGroupCommand = DeregisterPatchBaselineForPatchGroupCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeregisterTargetFromMaintenanceWindowCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeregisterTargetFromMaintenanceWindowCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeregisterTargetFromMaintenanceWindowCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeregisterTargetFromMaintenanceWindowCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeregisterTargetFromMaintenanceWindowCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeregisterTargetFromMaintenanceWindow",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeregisterTargetFromMaintenanceWindowCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeregisterTargetFromMaintenanceWindowCommand)(output, context);
+    }
+}
+exports.DeregisterTargetFromMaintenanceWindowCommand = DeregisterTargetFromMaintenanceWindowCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DeregisterTaskFromMaintenanceWindowCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeregisterTaskFromMaintenanceWindowCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DeregisterTaskFromMaintenanceWindowCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeregisterTaskFromMaintenanceWindowCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DeregisterTaskFromMaintenanceWindowCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DeregisterTaskFromMaintenanceWindow",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DeregisterTaskFromMaintenanceWindowCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DeregisterTaskFromMaintenanceWindowCommand)(output, context);
+    }
+}
+exports.DeregisterTaskFromMaintenanceWindowCommand = DeregisterTaskFromMaintenanceWindowCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeActivationsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeActivationsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeActivationsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeActivationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeActivationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeActivations",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeActivationsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeActivationsCommand)(output, context);
+    }
+}
+exports.DescribeActivationsCommand = DescribeActivationsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeAssociationCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeAssociationCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeAssociationCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeAssociationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeAssociationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_0_1.DescribeAssociationResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeAssociation",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeAssociationCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeAssociationCommand)(output, context);
+    }
+}
+exports.DescribeAssociationCommand = DescribeAssociationCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeAssociationExecutionTargetsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeAssociationExecutionTargetsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeAssociationExecutionTargetsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeAssociationExecutionTargetsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeAssociationExecutionTargetsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeAssociationExecutionTargets",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeAssociationExecutionTargetsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeAssociationExecutionTargetsCommand)(output, context);
+    }
+}
+exports.DescribeAssociationExecutionTargetsCommand = DescribeAssociationExecutionTargetsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeAssociationExecutionsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeAssociationExecutionsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeAssociationExecutionsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeAssociationExecutionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeAssociationExecutionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeAssociationExecutions",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeAssociationExecutionsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeAssociationExecutionsCommand)(output, context);
+    }
+}
+exports.DescribeAssociationExecutionsCommand = DescribeAssociationExecutionsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeAutomationExecutionsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeAutomationExecutionsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeAutomationExecutionsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeAutomationExecutionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeAutomationExecutionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeAutomationExecutions",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeAutomationExecutionsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeAutomationExecutionsCommand)(output, context);
+    }
+}
+exports.DescribeAutomationExecutionsCommand = DescribeAutomationExecutionsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeAutomationStepExecutionsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeAutomationStepExecutionsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeAutomationStepExecutionsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeAutomationStepExecutionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeAutomationStepExecutionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeAutomationStepExecutions",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeAutomationStepExecutionsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeAutomationStepExecutionsCommand)(output, context);
+    }
+}
+exports.DescribeAutomationStepExecutionsCommand = DescribeAutomationStepExecutionsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeAvailablePatchesCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeAvailablePatchesCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeAvailablePatchesCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeAvailablePatchesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeAvailablePatchesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeAvailablePatches",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeAvailablePatchesCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeAvailablePatchesCommand)(output, context);
+    }
+}
+exports.DescribeAvailablePatchesCommand = DescribeAvailablePatchesCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeDocumentCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeDocumentCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeDocumentCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeDocumentCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeDocumentCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeDocument",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeDocumentCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeDocumentCommand)(output, context);
+    }
+}
+exports.DescribeDocumentCommand = DescribeDocumentCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeDocumentPermissionCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeDocumentPermissionCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeDocumentPermissionCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeDocumentPermissionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeDocumentPermissionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeDocumentPermission",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeDocumentPermissionCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeDocumentPermissionCommand)(output, context);
+    }
+}
+exports.DescribeDocumentPermissionCommand = DescribeDocumentPermissionCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeEffectiveInstanceAssociationsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeEffectiveInstanceAssociationsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeEffectiveInstanceAssociationsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeEffectiveInstanceAssociationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeEffectiveInstanceAssociationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeEffectiveInstanceAssociations",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeEffectiveInstanceAssociationsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeEffectiveInstanceAssociationsCommand)(output, context);
+    }
+}
+exports.DescribeEffectiveInstanceAssociationsCommand = DescribeEffectiveInstanceAssociationsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeEffectivePatchesForPatchBaselineCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeEffectivePatchesForPatchBaselineCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeEffectivePatchesForPatchBaselineCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeEffectivePatchesForPatchBaselineCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeEffectivePatchesForPatchBaselineCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeEffectivePatchesForPatchBaseline",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeEffectivePatchesForPatchBaselineCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeEffectivePatchesForPatchBaselineCommand)(output, context);
+    }
+}
+exports.DescribeEffectivePatchesForPatchBaselineCommand = DescribeEffectivePatchesForPatchBaselineCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeInstanceAssociationsStatusCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeInstanceAssociationsStatusCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeInstanceAssociationsStatusCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeInstanceAssociationsStatusCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeInstanceAssociationsStatusCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeInstanceAssociationsStatus",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeInstanceAssociationsStatusCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeInstanceAssociationsStatusCommand)(output, context);
+    }
+}
+exports.DescribeInstanceAssociationsStatusCommand = DescribeInstanceAssociationsStatusCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeInstanceInformationCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeInstanceInformationCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeInstanceInformationCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeInstanceInformationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeInstanceInformationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeInstanceInformation",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeInstanceInformationCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeInstanceInformationCommand)(output, context);
+    }
+}
+exports.DescribeInstanceInformationCommand = DescribeInstanceInformationCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeInstancePatchStatesCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeInstancePatchStatesCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeInstancePatchStatesCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeInstancePatchStatesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeInstancePatchStatesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_0_1.DescribeInstancePatchStatesResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeInstancePatchStates",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeInstancePatchStatesCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeInstancePatchStatesCommand)(output, context);
+    }
+}
+exports.DescribeInstancePatchStatesCommand = DescribeInstancePatchStatesCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeInstancePatchStatesForPatchGroupCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeInstancePatchStatesForPatchGroupCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeInstancePatchStatesForPatchGroupCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeInstancePatchStatesForPatchGroupCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeInstancePatchStatesForPatchGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_0_1.DescribeInstancePatchStatesForPatchGroupResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeInstancePatchStatesForPatchGroup",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeInstancePatchStatesForPatchGroupCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeInstancePatchStatesForPatchGroupCommand)(output, context);
+    }
+}
+exports.DescribeInstancePatchStatesForPatchGroupCommand = DescribeInstancePatchStatesForPatchGroupCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeInstancePatchesCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeInstancePatchesCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeInstancePatchesCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeInstancePatchesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeInstancePatchesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeInstancePatches",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeInstancePatchesCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeInstancePatchesCommand)(output, context);
+    }
+}
+exports.DescribeInstancePatchesCommand = DescribeInstancePatchesCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeInventoryDeletionsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeInventoryDeletionsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeInventoryDeletionsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeInventoryDeletionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeInventoryDeletionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeInventoryDeletions",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeInventoryDeletionsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeInventoryDeletionsCommand)(output, context);
+    }
+}
+exports.DescribeInventoryDeletionsCommand = DescribeInventoryDeletionsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeMaintenanceWindowExecutionTaskInvocationsCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeMaintenanceWindowExecutionTaskInvocationsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeMaintenanceWindowExecutionTaskInvocationsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeMaintenanceWindowExecutionTaskInvocationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeMaintenanceWindowExecutionTaskInvocationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_0_1.DescribeMaintenanceWindowExecutionTaskInvocationsResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeMaintenanceWindowExecutionTaskInvocations",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeMaintenanceWindowExecutionTaskInvocationsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeMaintenanceWindowExecutionTaskInvocationsCommand)(output, context);
+    }
+}
+exports.DescribeMaintenanceWindowExecutionTaskInvocationsCommand = DescribeMaintenanceWindowExecutionTaskInvocationsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeMaintenanceWindowExecutionTasksCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeMaintenanceWindowExecutionTasksCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeMaintenanceWindowExecutionTasksCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeMaintenanceWindowExecutionTasksCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeMaintenanceWindowExecutionTasksCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeMaintenanceWindowExecutionTasks",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeMaintenanceWindowExecutionTasksCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeMaintenanceWindowExecutionTasksCommand)(output, context);
+    }
+}
+exports.DescribeMaintenanceWindowExecutionTasksCommand = DescribeMaintenanceWindowExecutionTasksCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeMaintenanceWindowExecutionsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeMaintenanceWindowExecutionsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeMaintenanceWindowExecutionsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeMaintenanceWindowExecutionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeMaintenanceWindowExecutionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeMaintenanceWindowExecutions",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeMaintenanceWindowExecutionsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeMaintenanceWindowExecutionsCommand)(output, context);
+    }
+}
+exports.DescribeMaintenanceWindowExecutionsCommand = DescribeMaintenanceWindowExecutionsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeMaintenanceWindowScheduleCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeMaintenanceWindowScheduleCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeMaintenanceWindowScheduleCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeMaintenanceWindowScheduleCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeMaintenanceWindowScheduleCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeMaintenanceWindowSchedule",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeMaintenanceWindowScheduleCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeMaintenanceWindowScheduleCommand)(output, context);
+    }
+}
+exports.DescribeMaintenanceWindowScheduleCommand = DescribeMaintenanceWindowScheduleCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeMaintenanceWindowTargetsCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeMaintenanceWindowTargetsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeMaintenanceWindowTargetsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeMaintenanceWindowTargetsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeMaintenanceWindowTargetsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_0_1.DescribeMaintenanceWindowTargetsResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeMaintenanceWindowTargets",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeMaintenanceWindowTargetsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeMaintenanceWindowTargetsCommand)(output, context);
+    }
+}
+exports.DescribeMaintenanceWindowTargetsCommand = DescribeMaintenanceWindowTargetsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeMaintenanceWindowTasksCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeMaintenanceWindowTasksCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeMaintenanceWindowTasksCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeMaintenanceWindowTasksCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeMaintenanceWindowTasksCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_1_1.DescribeMaintenanceWindowTasksResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeMaintenanceWindowTasks",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeMaintenanceWindowTasksCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeMaintenanceWindowTasksCommand)(output, context);
+    }
+}
+exports.DescribeMaintenanceWindowTasksCommand = DescribeMaintenanceWindowTasksCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeMaintenanceWindowsCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeMaintenanceWindowsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeMaintenanceWindowsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeMaintenanceWindowsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeMaintenanceWindowsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_0_1.DescribeMaintenanceWindowsResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeMaintenanceWindows",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeMaintenanceWindowsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeMaintenanceWindowsCommand)(output, context);
+    }
+}
+exports.DescribeMaintenanceWindowsCommand = DescribeMaintenanceWindowsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeMaintenanceWindowsForTargetCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeMaintenanceWindowsForTargetCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeMaintenanceWindowsForTargetCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeMaintenanceWindowsForTargetCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeMaintenanceWindowsForTargetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeMaintenanceWindowsForTarget",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeMaintenanceWindowsForTargetCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeMaintenanceWindowsForTargetCommand)(output, context);
+    }
+}
+exports.DescribeMaintenanceWindowsForTargetCommand = DescribeMaintenanceWindowsForTargetCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeOpsItemsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeOpsItemsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeOpsItemsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeOpsItemsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeOpsItemsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeOpsItems",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeOpsItemsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeOpsItemsCommand)(output, context);
+    }
+}
+exports.DescribeOpsItemsCommand = DescribeOpsItemsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeParametersCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeParametersCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeParametersCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeParametersCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeParametersCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeParameters",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeParametersCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeParametersCommand)(output, context);
+    }
+}
+exports.DescribeParametersCommand = DescribeParametersCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribePatchBaselinesCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribePatchBaselinesCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribePatchBaselinesCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribePatchBaselinesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribePatchBaselinesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribePatchBaselines",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribePatchBaselinesCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribePatchBaselinesCommand)(output, context);
+    }
+}
+exports.DescribePatchBaselinesCommand = DescribePatchBaselinesCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribePatchGroupStateCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribePatchGroupStateCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribePatchGroupStateCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribePatchGroupStateCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribePatchGroupStateCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribePatchGroupState",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribePatchGroupStateCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribePatchGroupStateCommand)(output, context);
+    }
+}
+exports.DescribePatchGroupStateCommand = DescribePatchGroupStateCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribePatchGroupsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribePatchGroupsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribePatchGroupsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribePatchGroupsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribePatchGroupsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribePatchGroups",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribePatchGroupsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribePatchGroupsCommand)(output, context);
+    }
+}
+exports.DescribePatchGroupsCommand = DescribePatchGroupsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribePatchPropertiesCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribePatchPropertiesCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribePatchPropertiesCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribePatchPropertiesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribePatchPropertiesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribePatchProperties",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribePatchPropertiesCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribePatchPropertiesCommand)(output, context);
+    }
+}
+exports.DescribePatchPropertiesCommand = DescribePatchPropertiesCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DescribeSessionsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeSessionsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DescribeSessionsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeSessionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DescribeSessionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DescribeSessions",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DescribeSessionsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DescribeSessionsCommand)(output, context);
+    }
+}
+exports.DescribeSessionsCommand = DescribeSessionsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/DisassociateOpsItemRelatedItemCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisassociateOpsItemRelatedItemCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class DisassociateOpsItemRelatedItemCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DisassociateOpsItemRelatedItemCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "DisassociateOpsItemRelatedItemCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "DisassociateOpsItemRelatedItem",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_DisassociateOpsItemRelatedItemCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_DisassociateOpsItemRelatedItemCommand)(output, context);
+    }
+}
+exports.DisassociateOpsItemRelatedItemCommand = DisassociateOpsItemRelatedItemCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetAutomationExecutionCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetAutomationExecutionCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetAutomationExecutionCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetAutomationExecutionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetAutomationExecutionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetAutomationExecution",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetAutomationExecutionCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetAutomationExecutionCommand)(output, context);
+    }
+}
+exports.GetAutomationExecutionCommand = GetAutomationExecutionCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetCalendarStateCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetCalendarStateCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetCalendarStateCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetCalendarStateCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetCalendarStateCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetCalendarState",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetCalendarStateCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetCalendarStateCommand)(output, context);
+    }
+}
+exports.GetCalendarStateCommand = GetCalendarStateCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetCommandInvocationCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetCommandInvocationCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetCommandInvocationCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetCommandInvocationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetCommandInvocationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetCommandInvocation",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetCommandInvocationCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetCommandInvocationCommand)(output, context);
+    }
+}
+exports.GetCommandInvocationCommand = GetCommandInvocationCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetConnectionStatusCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetConnectionStatusCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetConnectionStatusCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetConnectionStatusCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetConnectionStatusCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetConnectionStatus",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetConnectionStatusCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetConnectionStatusCommand)(output, context);
+    }
+}
+exports.GetConnectionStatusCommand = GetConnectionStatusCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetDefaultPatchBaselineCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetDefaultPatchBaselineCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetDefaultPatchBaselineCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetDefaultPatchBaselineCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetDefaultPatchBaselineCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetDefaultPatchBaseline",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetDefaultPatchBaselineCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetDefaultPatchBaselineCommand)(output, context);
+    }
+}
+exports.GetDefaultPatchBaselineCommand = GetDefaultPatchBaselineCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetDeployablePatchSnapshotForInstanceCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetDeployablePatchSnapshotForInstanceCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetDeployablePatchSnapshotForInstanceCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetDeployablePatchSnapshotForInstanceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetDeployablePatchSnapshotForInstanceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_1_1.GetDeployablePatchSnapshotForInstanceRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetDeployablePatchSnapshotForInstance",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetDeployablePatchSnapshotForInstanceCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetDeployablePatchSnapshotForInstanceCommand)(output, context);
+    }
+}
+exports.GetDeployablePatchSnapshotForInstanceCommand = GetDeployablePatchSnapshotForInstanceCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetDocumentCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetDocumentCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetDocumentCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetDocumentCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetDocumentCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetDocument",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetDocumentCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetDocumentCommand)(output, context);
+    }
+}
+exports.GetDocumentCommand = GetDocumentCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetInventoryCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetInventoryCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetInventoryCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetInventoryCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetInventoryCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetInventory",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetInventoryCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetInventoryCommand)(output, context);
+    }
+}
+exports.GetInventoryCommand = GetInventoryCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetInventorySchemaCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetInventorySchemaCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetInventorySchemaCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetInventorySchemaCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetInventorySchemaCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetInventorySchema",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetInventorySchemaCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetInventorySchemaCommand)(output, context);
+    }
+}
+exports.GetInventorySchemaCommand = GetInventorySchemaCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetMaintenanceWindowCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMaintenanceWindowCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetMaintenanceWindowCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetMaintenanceWindowCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetMaintenanceWindowCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_1_1.GetMaintenanceWindowResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetMaintenanceWindow",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetMaintenanceWindowCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetMaintenanceWindowCommand)(output, context);
+    }
+}
+exports.GetMaintenanceWindowCommand = GetMaintenanceWindowCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetMaintenanceWindowExecutionCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMaintenanceWindowExecutionCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetMaintenanceWindowExecutionCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetMaintenanceWindowExecutionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetMaintenanceWindowExecutionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetMaintenanceWindowExecution",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetMaintenanceWindowExecutionCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetMaintenanceWindowExecutionCommand)(output, context);
+    }
+}
+exports.GetMaintenanceWindowExecutionCommand = GetMaintenanceWindowExecutionCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetMaintenanceWindowExecutionTaskCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMaintenanceWindowExecutionTaskCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetMaintenanceWindowExecutionTaskCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetMaintenanceWindowExecutionTaskCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetMaintenanceWindowExecutionTaskCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_1_1.GetMaintenanceWindowExecutionTaskResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetMaintenanceWindowExecutionTask",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetMaintenanceWindowExecutionTaskCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetMaintenanceWindowExecutionTaskCommand)(output, context);
+    }
+}
+exports.GetMaintenanceWindowExecutionTaskCommand = GetMaintenanceWindowExecutionTaskCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetMaintenanceWindowExecutionTaskInvocationCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMaintenanceWindowExecutionTaskInvocationCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetMaintenanceWindowExecutionTaskInvocationCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetMaintenanceWindowExecutionTaskInvocationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetMaintenanceWindowExecutionTaskInvocationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_1_1.GetMaintenanceWindowExecutionTaskInvocationResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetMaintenanceWindowExecutionTaskInvocation",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetMaintenanceWindowExecutionTaskInvocationCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetMaintenanceWindowExecutionTaskInvocationCommand)(output, context);
+    }
+}
+exports.GetMaintenanceWindowExecutionTaskInvocationCommand = GetMaintenanceWindowExecutionTaskInvocationCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetMaintenanceWindowTaskCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMaintenanceWindowTaskCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetMaintenanceWindowTaskCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetMaintenanceWindowTaskCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetMaintenanceWindowTaskCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_1_1.GetMaintenanceWindowTaskResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetMaintenanceWindowTask",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetMaintenanceWindowTaskCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetMaintenanceWindowTaskCommand)(output, context);
+    }
+}
+exports.GetMaintenanceWindowTaskCommand = GetMaintenanceWindowTaskCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetOpsItemCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetOpsItemCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetOpsItemCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetOpsItemCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetOpsItemCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetOpsItem",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetOpsItemCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetOpsItemCommand)(output, context);
+    }
+}
+exports.GetOpsItemCommand = GetOpsItemCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetOpsMetadataCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetOpsMetadataCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetOpsMetadataCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetOpsMetadataCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetOpsMetadataCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetOpsMetadata",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetOpsMetadataCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetOpsMetadataCommand)(output, context);
+    }
+}
+exports.GetOpsMetadataCommand = GetOpsMetadataCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetOpsSummaryCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetOpsSummaryCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetOpsSummaryCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetOpsSummaryCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetOpsSummaryCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetOpsSummary",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetOpsSummaryCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetOpsSummaryCommand)(output, context);
+    }
+}
+exports.GetOpsSummaryCommand = GetOpsSummaryCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetParameterCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetParameterCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetParameterCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetParameterCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetParameterCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_1_1.GetParameterResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetParameter",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetParameterCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetParameterCommand)(output, context);
+    }
+}
+exports.GetParameterCommand = GetParameterCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetParameterHistoryCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetParameterHistoryCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetParameterHistoryCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetParameterHistoryCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetParameterHistoryCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_1_1.GetParameterHistoryResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetParameterHistory",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetParameterHistoryCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetParameterHistoryCommand)(output, context);
+    }
+}
+exports.GetParameterHistoryCommand = GetParameterHistoryCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetParametersByPathCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetParametersByPathCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetParametersByPathCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetParametersByPathCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetParametersByPathCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_1_1.GetParametersByPathResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetParametersByPath",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetParametersByPathCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetParametersByPathCommand)(output, context);
+    }
+}
+exports.GetParametersByPathCommand = GetParametersByPathCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetParametersCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetParametersCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetParametersCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetParametersCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetParametersCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_1_1.GetParametersResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetParameters",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetParametersCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetParametersCommand)(output, context);
+    }
+}
+exports.GetParametersCommand = GetParametersCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetPatchBaselineCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPatchBaselineCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetPatchBaselineCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetPatchBaselineCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetPatchBaselineCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_1_1.GetPatchBaselineResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetPatchBaseline",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetPatchBaselineCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetPatchBaselineCommand)(output, context);
+    }
+}
+exports.GetPatchBaselineCommand = GetPatchBaselineCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetPatchBaselineForPatchGroupCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPatchBaselineForPatchGroupCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetPatchBaselineForPatchGroupCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetPatchBaselineForPatchGroupCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetPatchBaselineForPatchGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetPatchBaselineForPatchGroup",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetPatchBaselineForPatchGroupCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetPatchBaselineForPatchGroupCommand)(output, context);
+    }
+}
+exports.GetPatchBaselineForPatchGroupCommand = GetPatchBaselineForPatchGroupCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetResourcePoliciesCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetResourcePoliciesCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetResourcePoliciesCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetResourcePoliciesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetResourcePoliciesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetResourcePolicies",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetResourcePoliciesCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetResourcePoliciesCommand)(output, context);
+    }
+}
+exports.GetResourcePoliciesCommand = GetResourcePoliciesCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/GetServiceSettingCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetServiceSettingCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class GetServiceSettingCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetServiceSettingCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "GetServiceSettingCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "GetServiceSetting",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_GetServiceSettingCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_GetServiceSettingCommand)(output, context);
+    }
+}
+exports.GetServiceSettingCommand = GetServiceSettingCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/LabelParameterVersionCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LabelParameterVersionCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class LabelParameterVersionCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, LabelParameterVersionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "LabelParameterVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "LabelParameterVersion",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_LabelParameterVersionCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_LabelParameterVersionCommand)(output, context);
+    }
+}
+exports.LabelParameterVersionCommand = LabelParameterVersionCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/ListAssociationVersionsCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListAssociationVersionsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class ListAssociationVersionsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListAssociationVersionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "ListAssociationVersionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_1_1.ListAssociationVersionsResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "ListAssociationVersions",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_ListAssociationVersionsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_ListAssociationVersionsCommand)(output, context);
+    }
+}
+exports.ListAssociationVersionsCommand = ListAssociationVersionsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/ListAssociationsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListAssociationsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class ListAssociationsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListAssociationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "ListAssociationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "ListAssociations",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_ListAssociationsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_ListAssociationsCommand)(output, context);
+    }
+}
+exports.ListAssociationsCommand = ListAssociationsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/ListCommandInvocationsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListCommandInvocationsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class ListCommandInvocationsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListCommandInvocationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "ListCommandInvocationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "ListCommandInvocations",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_ListCommandInvocationsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_ListCommandInvocationsCommand)(output, context);
+    }
+}
+exports.ListCommandInvocationsCommand = ListCommandInvocationsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/ListCommandsCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListCommandsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class ListCommandsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListCommandsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "ListCommandsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: models_1_1.ListCommandsResultFilterSensitiveLog,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "ListCommands",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_ListCommandsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_ListCommandsCommand)(output, context);
+    }
+}
+exports.ListCommandsCommand = ListCommandsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/ListComplianceItemsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListComplianceItemsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class ListComplianceItemsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListComplianceItemsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "ListComplianceItemsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "ListComplianceItems",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_ListComplianceItemsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_ListComplianceItemsCommand)(output, context);
+    }
+}
+exports.ListComplianceItemsCommand = ListComplianceItemsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/ListComplianceSummariesCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListComplianceSummariesCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class ListComplianceSummariesCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListComplianceSummariesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "ListComplianceSummariesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "ListComplianceSummaries",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_ListComplianceSummariesCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_ListComplianceSummariesCommand)(output, context);
+    }
+}
+exports.ListComplianceSummariesCommand = ListComplianceSummariesCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/ListDocumentMetadataHistoryCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListDocumentMetadataHistoryCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class ListDocumentMetadataHistoryCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListDocumentMetadataHistoryCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "ListDocumentMetadataHistoryCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "ListDocumentMetadataHistory",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_ListDocumentMetadataHistoryCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_ListDocumentMetadataHistoryCommand)(output, context);
+    }
+}
+exports.ListDocumentMetadataHistoryCommand = ListDocumentMetadataHistoryCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/ListDocumentVersionsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListDocumentVersionsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class ListDocumentVersionsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListDocumentVersionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "ListDocumentVersionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "ListDocumentVersions",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_ListDocumentVersionsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_ListDocumentVersionsCommand)(output, context);
+    }
+}
+exports.ListDocumentVersionsCommand = ListDocumentVersionsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/ListDocumentsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListDocumentsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class ListDocumentsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListDocumentsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "ListDocumentsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "ListDocuments",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_ListDocumentsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_ListDocumentsCommand)(output, context);
+    }
+}
+exports.ListDocumentsCommand = ListDocumentsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/ListInventoryEntriesCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListInventoryEntriesCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class ListInventoryEntriesCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListInventoryEntriesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "ListInventoryEntriesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "ListInventoryEntries",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_ListInventoryEntriesCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_ListInventoryEntriesCommand)(output, context);
+    }
+}
+exports.ListInventoryEntriesCommand = ListInventoryEntriesCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/ListOpsItemEventsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListOpsItemEventsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class ListOpsItemEventsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListOpsItemEventsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "ListOpsItemEventsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "ListOpsItemEvents",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_ListOpsItemEventsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_ListOpsItemEventsCommand)(output, context);
+    }
+}
+exports.ListOpsItemEventsCommand = ListOpsItemEventsCommand;

node_modules/@aws-sdk/client-ssm/dist-cjs/commands/ListOpsItemRelatedItemsCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListOpsItemRelatedItemsCommand = exports.$Command = void 0;
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
+const types_1 = require("@smithy/types");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+class ListOpsItemRelatedItemsCommand extends smithy_client_1.Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListOpsItemRelatedItemsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SSMClient";
+        const commandName = "ListOpsItemRelatedItemsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [types_1.SMITHY_CONTEXT_KEY]: {
+                service: "AmazonSSM",
+                operation: "ListOpsItemRelatedItems",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_1_1.se_ListOpsItemRelatedItemsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_1_1.de_ListOpsItemRelatedItemsCommand)(output, context);
+    }
+}
+exports.ListOpsItemRelatedItemsCommand = ListOpsItemRelatedItemsCommand;