get and store last run time in ssm

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeActivationsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeActivations = void 0;
+const DescribeActivationsCommand_1 = require("../commands/DescribeActivationsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeActivationsCommand_1.DescribeActivationsCommand(input), ...args);
+};
+async function* paginateDescribeActivations(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeActivations = paginateDescribeActivations;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeAssociationExecutionTargetsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeAssociationExecutionTargets = void 0;
+const DescribeAssociationExecutionTargetsCommand_1 = require("../commands/DescribeAssociationExecutionTargetsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeAssociationExecutionTargetsCommand_1.DescribeAssociationExecutionTargetsCommand(input), ...args);
+};
+async function* paginateDescribeAssociationExecutionTargets(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeAssociationExecutionTargets = paginateDescribeAssociationExecutionTargets;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeAssociationExecutionsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeAssociationExecutions = void 0;
+const DescribeAssociationExecutionsCommand_1 = require("../commands/DescribeAssociationExecutionsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeAssociationExecutionsCommand_1.DescribeAssociationExecutionsCommand(input), ...args);
+};
+async function* paginateDescribeAssociationExecutions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeAssociationExecutions = paginateDescribeAssociationExecutions;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeAutomationExecutionsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeAutomationExecutions = void 0;
+const DescribeAutomationExecutionsCommand_1 = require("../commands/DescribeAutomationExecutionsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeAutomationExecutionsCommand_1.DescribeAutomationExecutionsCommand(input), ...args);
+};
+async function* paginateDescribeAutomationExecutions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeAutomationExecutions = paginateDescribeAutomationExecutions;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeAutomationStepExecutionsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeAutomationStepExecutions = void 0;
+const DescribeAutomationStepExecutionsCommand_1 = require("../commands/DescribeAutomationStepExecutionsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeAutomationStepExecutionsCommand_1.DescribeAutomationStepExecutionsCommand(input), ...args);
+};
+async function* paginateDescribeAutomationStepExecutions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeAutomationStepExecutions = paginateDescribeAutomationStepExecutions;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeAvailablePatchesPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeAvailablePatches = void 0;
+const DescribeAvailablePatchesCommand_1 = require("../commands/DescribeAvailablePatchesCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeAvailablePatchesCommand_1.DescribeAvailablePatchesCommand(input), ...args);
+};
+async function* paginateDescribeAvailablePatches(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeAvailablePatches = paginateDescribeAvailablePatches;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeEffectiveInstanceAssociationsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeEffectiveInstanceAssociations = void 0;
+const DescribeEffectiveInstanceAssociationsCommand_1 = require("../commands/DescribeEffectiveInstanceAssociationsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeEffectiveInstanceAssociationsCommand_1.DescribeEffectiveInstanceAssociationsCommand(input), ...args);
+};
+async function* paginateDescribeEffectiveInstanceAssociations(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeEffectiveInstanceAssociations = paginateDescribeEffectiveInstanceAssociations;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeEffectivePatchesForPatchBaselinePaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeEffectivePatchesForPatchBaseline = void 0;
+const DescribeEffectivePatchesForPatchBaselineCommand_1 = require("../commands/DescribeEffectivePatchesForPatchBaselineCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeEffectivePatchesForPatchBaselineCommand_1.DescribeEffectivePatchesForPatchBaselineCommand(input), ...args);
+};
+async function* paginateDescribeEffectivePatchesForPatchBaseline(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeEffectivePatchesForPatchBaseline = paginateDescribeEffectivePatchesForPatchBaseline;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeInstanceAssociationsStatusPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeInstanceAssociationsStatus = void 0;
+const DescribeInstanceAssociationsStatusCommand_1 = require("../commands/DescribeInstanceAssociationsStatusCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeInstanceAssociationsStatusCommand_1.DescribeInstanceAssociationsStatusCommand(input), ...args);
+};
+async function* paginateDescribeInstanceAssociationsStatus(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeInstanceAssociationsStatus = paginateDescribeInstanceAssociationsStatus;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeInstanceInformationPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeInstanceInformation = void 0;
+const DescribeInstanceInformationCommand_1 = require("../commands/DescribeInstanceInformationCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeInstanceInformationCommand_1.DescribeInstanceInformationCommand(input), ...args);
+};
+async function* paginateDescribeInstanceInformation(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeInstanceInformation = paginateDescribeInstanceInformation;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeInstancePatchStatesForPatchGroupPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeInstancePatchStatesForPatchGroup = void 0;
+const DescribeInstancePatchStatesForPatchGroupCommand_1 = require("../commands/DescribeInstancePatchStatesForPatchGroupCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeInstancePatchStatesForPatchGroupCommand_1.DescribeInstancePatchStatesForPatchGroupCommand(input), ...args);
+};
+async function* paginateDescribeInstancePatchStatesForPatchGroup(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeInstancePatchStatesForPatchGroup = paginateDescribeInstancePatchStatesForPatchGroup;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeInstancePatchStatesPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeInstancePatchStates = void 0;
+const DescribeInstancePatchStatesCommand_1 = require("../commands/DescribeInstancePatchStatesCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeInstancePatchStatesCommand_1.DescribeInstancePatchStatesCommand(input), ...args);
+};
+async function* paginateDescribeInstancePatchStates(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeInstancePatchStates = paginateDescribeInstancePatchStates;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeInstancePatchesPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeInstancePatches = void 0;
+const DescribeInstancePatchesCommand_1 = require("../commands/DescribeInstancePatchesCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeInstancePatchesCommand_1.DescribeInstancePatchesCommand(input), ...args);
+};
+async function* paginateDescribeInstancePatches(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeInstancePatches = paginateDescribeInstancePatches;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeInventoryDeletionsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeInventoryDeletions = void 0;
+const DescribeInventoryDeletionsCommand_1 = require("../commands/DescribeInventoryDeletionsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeInventoryDeletionsCommand_1.DescribeInventoryDeletionsCommand(input), ...args);
+};
+async function* paginateDescribeInventoryDeletions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeInventoryDeletions = paginateDescribeInventoryDeletions;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeMaintenanceWindowExecutionTaskInvocationsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeMaintenanceWindowExecutionTaskInvocations = void 0;
+const DescribeMaintenanceWindowExecutionTaskInvocationsCommand_1 = require("../commands/DescribeMaintenanceWindowExecutionTaskInvocationsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeMaintenanceWindowExecutionTaskInvocationsCommand_1.DescribeMaintenanceWindowExecutionTaskInvocationsCommand(input), ...args);
+};
+async function* paginateDescribeMaintenanceWindowExecutionTaskInvocations(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeMaintenanceWindowExecutionTaskInvocations = paginateDescribeMaintenanceWindowExecutionTaskInvocations;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeMaintenanceWindowExecutionTasksPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeMaintenanceWindowExecutionTasks = void 0;
+const DescribeMaintenanceWindowExecutionTasksCommand_1 = require("../commands/DescribeMaintenanceWindowExecutionTasksCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeMaintenanceWindowExecutionTasksCommand_1.DescribeMaintenanceWindowExecutionTasksCommand(input), ...args);
+};
+async function* paginateDescribeMaintenanceWindowExecutionTasks(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeMaintenanceWindowExecutionTasks = paginateDescribeMaintenanceWindowExecutionTasks;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeMaintenanceWindowExecutionsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeMaintenanceWindowExecutions = void 0;
+const DescribeMaintenanceWindowExecutionsCommand_1 = require("../commands/DescribeMaintenanceWindowExecutionsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeMaintenanceWindowExecutionsCommand_1.DescribeMaintenanceWindowExecutionsCommand(input), ...args);
+};
+async function* paginateDescribeMaintenanceWindowExecutions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeMaintenanceWindowExecutions = paginateDescribeMaintenanceWindowExecutions;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeMaintenanceWindowSchedulePaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeMaintenanceWindowSchedule = void 0;
+const DescribeMaintenanceWindowScheduleCommand_1 = require("../commands/DescribeMaintenanceWindowScheduleCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeMaintenanceWindowScheduleCommand_1.DescribeMaintenanceWindowScheduleCommand(input), ...args);
+};
+async function* paginateDescribeMaintenanceWindowSchedule(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeMaintenanceWindowSchedule = paginateDescribeMaintenanceWindowSchedule;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeMaintenanceWindowTargetsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeMaintenanceWindowTargets = void 0;
+const DescribeMaintenanceWindowTargetsCommand_1 = require("../commands/DescribeMaintenanceWindowTargetsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeMaintenanceWindowTargetsCommand_1.DescribeMaintenanceWindowTargetsCommand(input), ...args);
+};
+async function* paginateDescribeMaintenanceWindowTargets(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeMaintenanceWindowTargets = paginateDescribeMaintenanceWindowTargets;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeMaintenanceWindowTasksPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeMaintenanceWindowTasks = void 0;
+const DescribeMaintenanceWindowTasksCommand_1 = require("../commands/DescribeMaintenanceWindowTasksCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeMaintenanceWindowTasksCommand_1.DescribeMaintenanceWindowTasksCommand(input), ...args);
+};
+async function* paginateDescribeMaintenanceWindowTasks(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeMaintenanceWindowTasks = paginateDescribeMaintenanceWindowTasks;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeMaintenanceWindowsForTargetPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeMaintenanceWindowsForTarget = void 0;
+const DescribeMaintenanceWindowsForTargetCommand_1 = require("../commands/DescribeMaintenanceWindowsForTargetCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeMaintenanceWindowsForTargetCommand_1.DescribeMaintenanceWindowsForTargetCommand(input), ...args);
+};
+async function* paginateDescribeMaintenanceWindowsForTarget(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeMaintenanceWindowsForTarget = paginateDescribeMaintenanceWindowsForTarget;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeMaintenanceWindowsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeMaintenanceWindows = void 0;
+const DescribeMaintenanceWindowsCommand_1 = require("../commands/DescribeMaintenanceWindowsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeMaintenanceWindowsCommand_1.DescribeMaintenanceWindowsCommand(input), ...args);
+};
+async function* paginateDescribeMaintenanceWindows(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeMaintenanceWindows = paginateDescribeMaintenanceWindows;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeOpsItemsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeOpsItems = void 0;
+const DescribeOpsItemsCommand_1 = require("../commands/DescribeOpsItemsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeOpsItemsCommand_1.DescribeOpsItemsCommand(input), ...args);
+};
+async function* paginateDescribeOpsItems(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeOpsItems = paginateDescribeOpsItems;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeParametersPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeParameters = void 0;
+const DescribeParametersCommand_1 = require("../commands/DescribeParametersCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeParametersCommand_1.DescribeParametersCommand(input), ...args);
+};
+async function* paginateDescribeParameters(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeParameters = paginateDescribeParameters;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribePatchBaselinesPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribePatchBaselines = void 0;
+const DescribePatchBaselinesCommand_1 = require("../commands/DescribePatchBaselinesCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribePatchBaselinesCommand_1.DescribePatchBaselinesCommand(input), ...args);
+};
+async function* paginateDescribePatchBaselines(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribePatchBaselines = paginateDescribePatchBaselines;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribePatchGroupsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribePatchGroups = void 0;
+const DescribePatchGroupsCommand_1 = require("../commands/DescribePatchGroupsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribePatchGroupsCommand_1.DescribePatchGroupsCommand(input), ...args);
+};
+async function* paginateDescribePatchGroups(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribePatchGroups = paginateDescribePatchGroups;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribePatchPropertiesPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribePatchProperties = void 0;
+const DescribePatchPropertiesCommand_1 = require("../commands/DescribePatchPropertiesCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribePatchPropertiesCommand_1.DescribePatchPropertiesCommand(input), ...args);
+};
+async function* paginateDescribePatchProperties(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribePatchProperties = paginateDescribePatchProperties;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/DescribeSessionsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateDescribeSessions = void 0;
+const DescribeSessionsCommand_1 = require("../commands/DescribeSessionsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeSessionsCommand_1.DescribeSessionsCommand(input), ...args);
+};
+async function* paginateDescribeSessions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateDescribeSessions = paginateDescribeSessions;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/GetInventoryPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateGetInventory = void 0;
+const GetInventoryCommand_1 = require("../commands/GetInventoryCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetInventoryCommand_1.GetInventoryCommand(input), ...args);
+};
+async function* paginateGetInventory(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateGetInventory = paginateGetInventory;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/GetInventorySchemaPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateGetInventorySchema = void 0;
+const GetInventorySchemaCommand_1 = require("../commands/GetInventorySchemaCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetInventorySchemaCommand_1.GetInventorySchemaCommand(input), ...args);
+};
+async function* paginateGetInventorySchema(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateGetInventorySchema = paginateGetInventorySchema;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/GetOpsSummaryPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateGetOpsSummary = void 0;
+const GetOpsSummaryCommand_1 = require("../commands/GetOpsSummaryCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetOpsSummaryCommand_1.GetOpsSummaryCommand(input), ...args);
+};
+async function* paginateGetOpsSummary(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateGetOpsSummary = paginateGetOpsSummary;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/GetParameterHistoryPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateGetParameterHistory = void 0;
+const GetParameterHistoryCommand_1 = require("../commands/GetParameterHistoryCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetParameterHistoryCommand_1.GetParameterHistoryCommand(input), ...args);
+};
+async function* paginateGetParameterHistory(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateGetParameterHistory = paginateGetParameterHistory;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/GetParametersByPathPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateGetParametersByPath = void 0;
+const GetParametersByPathCommand_1 = require("../commands/GetParametersByPathCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetParametersByPathCommand_1.GetParametersByPathCommand(input), ...args);
+};
+async function* paginateGetParametersByPath(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateGetParametersByPath = paginateGetParametersByPath;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/GetResourcePoliciesPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateGetResourcePolicies = void 0;
+const GetResourcePoliciesCommand_1 = require("../commands/GetResourcePoliciesCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetResourcePoliciesCommand_1.GetResourcePoliciesCommand(input), ...args);
+};
+async function* paginateGetResourcePolicies(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateGetResourcePolicies = paginateGetResourcePolicies;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/Interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListAssociationVersionsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListAssociationVersions = void 0;
+const ListAssociationVersionsCommand_1 = require("../commands/ListAssociationVersionsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListAssociationVersionsCommand_1.ListAssociationVersionsCommand(input), ...args);
+};
+async function* paginateListAssociationVersions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListAssociationVersions = paginateListAssociationVersions;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListAssociationsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListAssociations = void 0;
+const ListAssociationsCommand_1 = require("../commands/ListAssociationsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListAssociationsCommand_1.ListAssociationsCommand(input), ...args);
+};
+async function* paginateListAssociations(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListAssociations = paginateListAssociations;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListCommandInvocationsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListCommandInvocations = void 0;
+const ListCommandInvocationsCommand_1 = require("../commands/ListCommandInvocationsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListCommandInvocationsCommand_1.ListCommandInvocationsCommand(input), ...args);
+};
+async function* paginateListCommandInvocations(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListCommandInvocations = paginateListCommandInvocations;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListCommandsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListCommands = void 0;
+const ListCommandsCommand_1 = require("../commands/ListCommandsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListCommandsCommand_1.ListCommandsCommand(input), ...args);
+};
+async function* paginateListCommands(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListCommands = paginateListCommands;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListComplianceItemsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListComplianceItems = void 0;
+const ListComplianceItemsCommand_1 = require("../commands/ListComplianceItemsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListComplianceItemsCommand_1.ListComplianceItemsCommand(input), ...args);
+};
+async function* paginateListComplianceItems(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListComplianceItems = paginateListComplianceItems;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListComplianceSummariesPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListComplianceSummaries = void 0;
+const ListComplianceSummariesCommand_1 = require("../commands/ListComplianceSummariesCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListComplianceSummariesCommand_1.ListComplianceSummariesCommand(input), ...args);
+};
+async function* paginateListComplianceSummaries(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListComplianceSummaries = paginateListComplianceSummaries;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListDocumentVersionsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListDocumentVersions = void 0;
+const ListDocumentVersionsCommand_1 = require("../commands/ListDocumentVersionsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDocumentVersionsCommand_1.ListDocumentVersionsCommand(input), ...args);
+};
+async function* paginateListDocumentVersions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListDocumentVersions = paginateListDocumentVersions;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListDocumentsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListDocuments = void 0;
+const ListDocumentsCommand_1 = require("../commands/ListDocumentsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDocumentsCommand_1.ListDocumentsCommand(input), ...args);
+};
+async function* paginateListDocuments(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListDocuments = paginateListDocuments;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListOpsItemEventsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListOpsItemEvents = void 0;
+const ListOpsItemEventsCommand_1 = require("../commands/ListOpsItemEventsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListOpsItemEventsCommand_1.ListOpsItemEventsCommand(input), ...args);
+};
+async function* paginateListOpsItemEvents(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListOpsItemEvents = paginateListOpsItemEvents;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListOpsItemRelatedItemsPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListOpsItemRelatedItems = void 0;
+const ListOpsItemRelatedItemsCommand_1 = require("../commands/ListOpsItemRelatedItemsCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListOpsItemRelatedItemsCommand_1.ListOpsItemRelatedItemsCommand(input), ...args);
+};
+async function* paginateListOpsItemRelatedItems(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListOpsItemRelatedItems = paginateListOpsItemRelatedItems;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListOpsMetadataPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListOpsMetadata = void 0;
+const ListOpsMetadataCommand_1 = require("../commands/ListOpsMetadataCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListOpsMetadataCommand_1.ListOpsMetadataCommand(input), ...args);
+};
+async function* paginateListOpsMetadata(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListOpsMetadata = paginateListOpsMetadata;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListResourceComplianceSummariesPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListResourceComplianceSummaries = void 0;
+const ListResourceComplianceSummariesCommand_1 = require("../commands/ListResourceComplianceSummariesCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListResourceComplianceSummariesCommand_1.ListResourceComplianceSummariesCommand(input), ...args);
+};
+async function* paginateListResourceComplianceSummaries(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListResourceComplianceSummaries = paginateListResourceComplianceSummaries;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/ListResourceDataSyncPaginator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListResourceDataSync = void 0;
+const ListResourceDataSyncCommand_1 = require("../commands/ListResourceDataSyncCommand");
+const SSMClient_1 = require("../SSMClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListResourceDataSyncCommand_1.ListResourceDataSyncCommand(input), ...args);
+};
+async function* paginateListResourceDataSync(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof SSMClient_1.SSMClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SSM | SSMClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListResourceDataSync = paginateListResourceDataSync;

node_modules/@aws-sdk/client-ssm/dist-cjs/pagination/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./DescribeActivationsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeAssociationExecutionTargetsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeAssociationExecutionsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeAutomationExecutionsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeAutomationStepExecutionsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeAvailablePatchesPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeEffectiveInstanceAssociationsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeEffectivePatchesForPatchBaselinePaginator"), exports);
+tslib_1.__exportStar(require("./DescribeInstanceAssociationsStatusPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeInstanceInformationPaginator"), exports);
+tslib_1.__exportStar(require("./Interfaces"), exports);
+tslib_1.__exportStar(require("./DescribeInstancePatchStatesForPatchGroupPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeInstancePatchStatesPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeInstancePatchesPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeInventoryDeletionsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeMaintenanceWindowExecutionTaskInvocationsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeMaintenanceWindowExecutionTasksPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeMaintenanceWindowExecutionsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeMaintenanceWindowSchedulePaginator"), exports);
+tslib_1.__exportStar(require("./DescribeMaintenanceWindowTargetsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeMaintenanceWindowTasksPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeMaintenanceWindowsForTargetPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeMaintenanceWindowsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeOpsItemsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeParametersPaginator"), exports);
+tslib_1.__exportStar(require("./DescribePatchBaselinesPaginator"), exports);
+tslib_1.__exportStar(require("./DescribePatchGroupsPaginator"), exports);
+tslib_1.__exportStar(require("./DescribePatchPropertiesPaginator"), exports);
+tslib_1.__exportStar(require("./DescribeSessionsPaginator"), exports);
+tslib_1.__exportStar(require("./GetInventoryPaginator"), exports);
+tslib_1.__exportStar(require("./GetInventorySchemaPaginator"), exports);
+tslib_1.__exportStar(require("./GetOpsSummaryPaginator"), exports);
+tslib_1.__exportStar(require("./GetParameterHistoryPaginator"), exports);
+tslib_1.__exportStar(require("./GetParametersByPathPaginator"), exports);
+tslib_1.__exportStar(require("./GetResourcePoliciesPaginator"), exports);
+tslib_1.__exportStar(require("./ListAssociationVersionsPaginator"), exports);
+tslib_1.__exportStar(require("./ListAssociationsPaginator"), exports);
+tslib_1.__exportStar(require("./ListCommandInvocationsPaginator"), exports);
+tslib_1.__exportStar(require("./ListCommandsPaginator"), exports);
+tslib_1.__exportStar(require("./ListComplianceItemsPaginator"), exports);
+tslib_1.__exportStar(require("./ListComplianceSummariesPaginator"), exports);
+tslib_1.__exportStar(require("./ListDocumentVersionsPaginator"), exports);
+tslib_1.__exportStar(require("./ListDocumentsPaginator"), exports);
+tslib_1.__exportStar(require("./ListOpsItemEventsPaginator"), exports);
+tslib_1.__exportStar(require("./ListOpsItemRelatedItemsPaginator"), exports);
+tslib_1.__exportStar(require("./ListOpsMetadataPaginator"), exports);
+tslib_1.__exportStar(require("./ListResourceComplianceSummariesPaginator"), exports);
+tslib_1.__exportStar(require("./ListResourceDataSyncPaginator"), exports);