@aws-sdk/client-scheduler 3.208.0

package/dist-cjs/endpoint/ruleset.js

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleSet = void 0;
+exports.ruleSet = {
+    version: "1.0",
+    parameters: {
+        Region: {
+            builtIn: "AWS::Region",
+            required: false,
+            documentation: "The AWS region used to dispatch the request.",
+            type: "String",
+        },
+        UseDualStack: {
+            builtIn: "AWS::UseDualStack",
+            required: true,
+            default: false,
+            documentation: "When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.",
+            type: "Boolean",
+        },
+        UseFIPS: {
+            builtIn: "AWS::UseFIPS",
+            required: true,
+            default: false,
+            documentation: "When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.",
+            type: "Boolean",
+        },
+        Endpoint: {
+            builtIn: "SDK::Endpoint",
+            required: false,
+            documentation: "Override the endpoint used to send this request",
+            type: "String",
+        },
+    },
+    rules: [
+        {
+            conditions: [
+                {
+                    fn: "aws.partition",
+                    argv: [
+                        {
+                            ref: "Region",
+                        },
+                    ],
+                    assign: "PartitionResult",
+                },
+            ],
+            type: "tree",
+            rules: [
+                {
+                    conditions: [
+                        {
+                            fn: "isSet",
+                            argv: [
+                                {
+                                    ref: "Endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            fn: "parseURL",
+                            argv: [
+                                {
+                                    ref: "Endpoint",
+                                },
+                            ],
+                            assign: "url",
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        {
+                                            ref: "UseFIPS",
+                                        },
+                                        true,
+                                    ],
+                                },
+                            ],
+                            error: "Invalid Configuration: FIPS and custom endpoint are not supported",
+                            type: "error",
+                        },
+                        {
+                            conditions: [],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [
+                                        {
+                                            fn: "booleanEquals",
+                                            argv: [
+                                                {
+                                                    ref: "UseDualStack",
+                                                },
+                                                true,
+                                            ],
+                                        },
+                                    ],
+                                    error: "Invalid Configuration: Dualstack and custom endpoint are not supported",
+                                    type: "error",
+                                },
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: {
+                                            ref: "Endpoint",
+                                        },
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseFIPS",
+                                },
+                                true,
+                            ],
+                        },
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseDualStack",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsFIPS",
+                                            ],
+                                        },
+                                    ],
+                                },
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsDualStack",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://scheduler-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "FIPS and DualStack are enabled, but this partition does not support one or both",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseFIPS",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsFIPS",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://scheduler-fips.{Region}.{PartitionResult#dnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "FIPS is enabled but this partition does not support FIPS",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseDualStack",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsDualStack",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://scheduler.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "DualStack is enabled but this partition does not support DualStack",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [],
+                    endpoint: {
+                        url: "https://scheduler.{Region}.{PartitionResult#dnsSuffix}",
+                        properties: {},
+                        headers: {},
+                    },
+                    type: "endpoint",
+                },
+            ],
+        },
+    ],
+};

package/dist-cjs/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchedulerServiceException = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./Scheduler"), exports);
+tslib_1.__exportStar(require("./SchedulerClient"), exports);
+tslib_1.__exportStar(require("./commands"), exports);
+tslib_1.__exportStar(require("./models"), exports);
+tslib_1.__exportStar(require("./pagination"), exports);
+var SchedulerServiceException_1 = require("./models/SchedulerServiceException");
+Object.defineProperty(exports, "SchedulerServiceException", { enumerable: true, get: function () { return SchedulerServiceException_1.SchedulerServiceException; } });

package/dist-cjs/models/SchedulerServiceException.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchedulerServiceException = void 0;
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+class SchedulerServiceException extends smithy_client_1.ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, SchedulerServiceException.prototype);
+    }
+}
+exports.SchedulerServiceException = SchedulerServiceException;

package/dist-cjs/models/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./models_0"), exports);

package/dist-cjs/models/models_0.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetScheduleGroupOutputFilterSensitiveLog = exports.GetScheduleGroupInputFilterSensitiveLog = exports.DeleteScheduleGroupOutputFilterSensitiveLog = exports.DeleteScheduleGroupInputFilterSensitiveLog = exports.CreateScheduleGroupOutputFilterSensitiveLog = exports.CreateScheduleGroupInputFilterSensitiveLog = exports.UpdateScheduleOutputFilterSensitiveLog = exports.UpdateScheduleInputFilterSensitiveLog = exports.ListSchedulesOutputFilterSensitiveLog = exports.ScheduleSummaryFilterSensitiveLog = exports.TargetSummaryFilterSensitiveLog = exports.ListSchedulesInputFilterSensitiveLog = exports.GetScheduleOutputFilterSensitiveLog = exports.GetScheduleInputFilterSensitiveLog = exports.DeleteScheduleOutputFilterSensitiveLog = exports.DeleteScheduleInputFilterSensitiveLog = exports.CreateScheduleOutputFilterSensitiveLog = exports.CreateScheduleInputFilterSensitiveLog = exports.TargetFilterSensitiveLog = exports.SqsParametersFilterSensitiveLog = exports.SageMakerPipelineParametersFilterSensitiveLog = exports.SageMakerPipelineParameterFilterSensitiveLog = exports.RetryPolicyFilterSensitiveLog = exports.KinesisParametersFilterSensitiveLog = exports.EventBridgeParametersFilterSensitiveLog = exports.EcsParametersFilterSensitiveLog = exports.PlacementStrategyFilterSensitiveLog = exports.PlacementConstraintFilterSensitiveLog = exports.NetworkConfigurationFilterSensitiveLog = exports.AwsVpcConfigurationFilterSensitiveLog = exports.CapacityProviderStrategyItemFilterSensitiveLog = exports.DeadLetterConfigFilterSensitiveLog = exports.FlexibleTimeWindowFilterSensitiveLog = exports.ListTagsForResourceOutputFilterSensitiveLog = exports.TagFilterSensitiveLog = exports.ListTagsForResourceInputFilterSensitiveLog = exports.ScheduleGroupState = exports.ServiceQuotaExceededException = exports.PropagateTags = exports.PlacementStrategyType = exports.PlacementConstraintType = exports.LaunchType = exports.ScheduleState = exports.FlexibleTimeWindowMode = exports.ConflictException = exports.ValidationException = exports.ThrottlingException = exports.ResourceNotFoundException = exports.InternalServerException = exports.AssignPublicIp = void 0;
+exports.UntagResourceOutputFilterSensitiveLog = exports.UntagResourceInputFilterSensitiveLog = exports.TagResourceOutputFilterSensitiveLog = exports.TagResourceInputFilterSensitiveLog = exports.ListScheduleGroupsOutputFilterSensitiveLog = exports.ScheduleGroupSummaryFilterSensitiveLog = exports.ListScheduleGroupsInputFilterSensitiveLog = void 0;
+const SchedulerServiceException_1 = require("./SchedulerServiceException");
+var AssignPublicIp;
+(function (AssignPublicIp) {
+    AssignPublicIp["DISABLED"] = "DISABLED";
+    AssignPublicIp["ENABLED"] = "ENABLED";
+})(AssignPublicIp = exports.AssignPublicIp || (exports.AssignPublicIp = {}));
+class InternalServerException extends SchedulerServiceException_1.SchedulerServiceException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+        this.Message = opts.Message;
+    }
+}
+exports.InternalServerException = InternalServerException;
+class ResourceNotFoundException extends SchedulerServiceException_1.SchedulerServiceException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.Message = opts.Message;
+    }
+}
+exports.ResourceNotFoundException = ResourceNotFoundException;
+class ThrottlingException extends SchedulerServiceException_1.SchedulerServiceException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+        this.Message = opts.Message;
+    }
+}
+exports.ThrottlingException = ThrottlingException;
+class ValidationException extends SchedulerServiceException_1.SchedulerServiceException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.Message = opts.Message;
+    }
+}
+exports.ValidationException = ValidationException;
+class ConflictException extends SchedulerServiceException_1.SchedulerServiceException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
+        this.Message = opts.Message;
+    }
+}
+exports.ConflictException = ConflictException;
+var FlexibleTimeWindowMode;
+(function (FlexibleTimeWindowMode) {
+    FlexibleTimeWindowMode["FLEXIBLE"] = "FLEXIBLE";
+    FlexibleTimeWindowMode["OFF"] = "OFF";
+})(FlexibleTimeWindowMode = exports.FlexibleTimeWindowMode || (exports.FlexibleTimeWindowMode = {}));
+var ScheduleState;
+(function (ScheduleState) {
+    ScheduleState["DISABLED"] = "DISABLED";
+    ScheduleState["ENABLED"] = "ENABLED";
+})(ScheduleState = exports.ScheduleState || (exports.ScheduleState = {}));
+var LaunchType;
+(function (LaunchType) {
+    LaunchType["EC2"] = "EC2";
+    LaunchType["EXTERNAL"] = "EXTERNAL";
+    LaunchType["FARGATE"] = "FARGATE";
+})(LaunchType = exports.LaunchType || (exports.LaunchType = {}));
+var PlacementConstraintType;
+(function (PlacementConstraintType) {
+    PlacementConstraintType["DISTINCT_INSTANCE"] = "distinctInstance";
+    PlacementConstraintType["MEMBER_OF"] = "memberOf";
+})(PlacementConstraintType = exports.PlacementConstraintType || (exports.PlacementConstraintType = {}));
+var PlacementStrategyType;
+(function (PlacementStrategyType) {
+    PlacementStrategyType["BINPACK"] = "binpack";
+    PlacementStrategyType["RANDOM"] = "random";
+    PlacementStrategyType["SPREAD"] = "spread";
+})(PlacementStrategyType = exports.PlacementStrategyType || (exports.PlacementStrategyType = {}));
+var PropagateTags;
+(function (PropagateTags) {
+    PropagateTags["TASK_DEFINITION"] = "TASK_DEFINITION";
+})(PropagateTags = exports.PropagateTags || (exports.PropagateTags = {}));
+class ServiceQuotaExceededException extends SchedulerServiceException_1.SchedulerServiceException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+var ScheduleGroupState;
+(function (ScheduleGroupState) {
+    ScheduleGroupState["ACTIVE"] = "ACTIVE";
+    ScheduleGroupState["DELETING"] = "DELETING";
+})(ScheduleGroupState = exports.ScheduleGroupState || (exports.ScheduleGroupState = {}));
+const ListTagsForResourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.ListTagsForResourceInputFilterSensitiveLog = ListTagsForResourceInputFilterSensitiveLog;
+const TagFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.TagFilterSensitiveLog = TagFilterSensitiveLog;
+const ListTagsForResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.ListTagsForResourceOutputFilterSensitiveLog = ListTagsForResourceOutputFilterSensitiveLog;
+const FlexibleTimeWindowFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.FlexibleTimeWindowFilterSensitiveLog = FlexibleTimeWindowFilterSensitiveLog;
+const DeadLetterConfigFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.DeadLetterConfigFilterSensitiveLog = DeadLetterConfigFilterSensitiveLog;
+const CapacityProviderStrategyItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.CapacityProviderStrategyItemFilterSensitiveLog = CapacityProviderStrategyItemFilterSensitiveLog;
+const AwsVpcConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.AwsVpcConfigurationFilterSensitiveLog = AwsVpcConfigurationFilterSensitiveLog;
+const NetworkConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.NetworkConfigurationFilterSensitiveLog = NetworkConfigurationFilterSensitiveLog;
+const PlacementConstraintFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.PlacementConstraintFilterSensitiveLog = PlacementConstraintFilterSensitiveLog;
+const PlacementStrategyFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.PlacementStrategyFilterSensitiveLog = PlacementStrategyFilterSensitiveLog;
+const EcsParametersFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.EcsParametersFilterSensitiveLog = EcsParametersFilterSensitiveLog;
+const EventBridgeParametersFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.EventBridgeParametersFilterSensitiveLog = EventBridgeParametersFilterSensitiveLog;
+const KinesisParametersFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.KinesisParametersFilterSensitiveLog = KinesisParametersFilterSensitiveLog;
+const RetryPolicyFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.RetryPolicyFilterSensitiveLog = RetryPolicyFilterSensitiveLog;
+const SageMakerPipelineParameterFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.SageMakerPipelineParameterFilterSensitiveLog = SageMakerPipelineParameterFilterSensitiveLog;
+const SageMakerPipelineParametersFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.SageMakerPipelineParametersFilterSensitiveLog = SageMakerPipelineParametersFilterSensitiveLog;
+const SqsParametersFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.SqsParametersFilterSensitiveLog = SqsParametersFilterSensitiveLog;
+const TargetFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.TargetFilterSensitiveLog = TargetFilterSensitiveLog;
+const CreateScheduleInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.CreateScheduleInputFilterSensitiveLog = CreateScheduleInputFilterSensitiveLog;
+const CreateScheduleOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.CreateScheduleOutputFilterSensitiveLog = CreateScheduleOutputFilterSensitiveLog;
+const DeleteScheduleInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.DeleteScheduleInputFilterSensitiveLog = DeleteScheduleInputFilterSensitiveLog;
+const DeleteScheduleOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.DeleteScheduleOutputFilterSensitiveLog = DeleteScheduleOutputFilterSensitiveLog;
+const GetScheduleInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.GetScheduleInputFilterSensitiveLog = GetScheduleInputFilterSensitiveLog;
+const GetScheduleOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.GetScheduleOutputFilterSensitiveLog = GetScheduleOutputFilterSensitiveLog;
+const ListSchedulesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.ListSchedulesInputFilterSensitiveLog = ListSchedulesInputFilterSensitiveLog;
+const TargetSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.TargetSummaryFilterSensitiveLog = TargetSummaryFilterSensitiveLog;
+const ScheduleSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.ScheduleSummaryFilterSensitiveLog = ScheduleSummaryFilterSensitiveLog;
+const ListSchedulesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.ListSchedulesOutputFilterSensitiveLog = ListSchedulesOutputFilterSensitiveLog;
+const UpdateScheduleInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.UpdateScheduleInputFilterSensitiveLog = UpdateScheduleInputFilterSensitiveLog;
+const UpdateScheduleOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.UpdateScheduleOutputFilterSensitiveLog = UpdateScheduleOutputFilterSensitiveLog;
+const CreateScheduleGroupInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.CreateScheduleGroupInputFilterSensitiveLog = CreateScheduleGroupInputFilterSensitiveLog;
+const CreateScheduleGroupOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.CreateScheduleGroupOutputFilterSensitiveLog = CreateScheduleGroupOutputFilterSensitiveLog;
+const DeleteScheduleGroupInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.DeleteScheduleGroupInputFilterSensitiveLog = DeleteScheduleGroupInputFilterSensitiveLog;
+const DeleteScheduleGroupOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.DeleteScheduleGroupOutputFilterSensitiveLog = DeleteScheduleGroupOutputFilterSensitiveLog;
+const GetScheduleGroupInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.GetScheduleGroupInputFilterSensitiveLog = GetScheduleGroupInputFilterSensitiveLog;
+const GetScheduleGroupOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.GetScheduleGroupOutputFilterSensitiveLog = GetScheduleGroupOutputFilterSensitiveLog;
+const ListScheduleGroupsInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.ListScheduleGroupsInputFilterSensitiveLog = ListScheduleGroupsInputFilterSensitiveLog;
+const ScheduleGroupSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.ScheduleGroupSummaryFilterSensitiveLog = ScheduleGroupSummaryFilterSensitiveLog;
+const ListScheduleGroupsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.ListScheduleGroupsOutputFilterSensitiveLog = ListScheduleGroupsOutputFilterSensitiveLog;
+const TagResourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.TagResourceInputFilterSensitiveLog = TagResourceInputFilterSensitiveLog;
+const TagResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.TagResourceOutputFilterSensitiveLog = TagResourceOutputFilterSensitiveLog;
+const UntagResourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.UntagResourceInputFilterSensitiveLog = UntagResourceInputFilterSensitiveLog;
+const UntagResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.UntagResourceOutputFilterSensitiveLog = UntagResourceOutputFilterSensitiveLog;

package/dist-cjs/pagination/Interfaces.js

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

package/dist-cjs/pagination/ListScheduleGroupsPaginator.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListScheduleGroups = void 0;
+const ListScheduleGroupsCommand_1 = require("../commands/ListScheduleGroupsCommand");
+const Scheduler_1 = require("../Scheduler");
+const SchedulerClient_1 = require("../SchedulerClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListScheduleGroupsCommand_1.ListScheduleGroupsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listScheduleGroups(input, ...args);
+};
+async function* paginateListScheduleGroups(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 Scheduler_1.Scheduler) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof SchedulerClient_1.SchedulerClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Scheduler | SchedulerClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}
+exports.paginateListScheduleGroups = paginateListScheduleGroups;