@aws-sdk/client-sfn 3.1068.0 → 3.1070.0

package/dist-cjs/index.js

@@ -1,18 +1,21 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var protocols = require('@smithy/core/protocols');
-var retry = require('@smithy/core/retry');
-var schema = require('@smithy/core/schema');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var runtimeConfig = require('./runtimeConfig');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var SFNServiceException = require('./models/SFNServiceException');
+var __exportStar = (m, e) => { Object.assign(e, m); };
+const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin, getLongPollPlugin } = require("@aws-sdk/core/client");
+const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
+const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
+exports.$Command = Command;
+exports.__Client = Client;
+const { resolveRegionConfig } = require("@smithy/core/config");
+const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveHttpAuthSchemeConfig, defaultSFNHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { CreateActivity$, CreateStateMachineAlias$, CreateStateMachine$, DeleteActivity$, DeleteStateMachineAlias$, DeleteStateMachine$, DeleteStateMachineVersion$, DescribeActivity$, DescribeExecution$, DescribeMapRun$, DescribeStateMachineAlias$, DescribeStateMachine$, DescribeStateMachineForExecution$, GetActivityTask$, GetExecutionHistory$, ListActivities$, ListExecutions$, ListMapRuns$, ListStateMachineAliases$, ListStateMachines$, ListStateMachineVersions$, ListTagsForResource$, PublishStateMachineVersion$, RedriveExecution$, SendTaskFailure$, SendTaskHeartbeat$, SendTaskSuccess$, StartExecution$, StartSyncExecution$, StopExecution$, TagResource$, TestState$, UntagResource$, UpdateMapRun$, UpdateStateMachineAlias$, UpdateStateMachine$, ValidateStateMachineDefinition$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { SFNServiceException } = require("./models/SFNServiceException");
+exports.SFNServiceException = SFNServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -68,502 +71,502 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class SFNClient extends client.Client {
+class SFNClient extends Client {
     config;
     constructor(...[configuration]) {
-        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        const _config_0 = getRuntimeConfig(configuration || {});
         super(_config_0);
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
-        const _config_2 = client$1.resolveUserAgentConfig(_config_1);
-        const _config_3 = retry.resolveRetryConfig(_config_2);
-        const _config_4 = config.resolveRegionConfig(_config_3);
-        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
-        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
-        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveRegionConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveEndpointConfig(_config_5);
+        const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
-        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
-        this.middlewareStack.use(client$1.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(retry.getRetryPlugin(this.config));
-        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
-        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
-        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
-            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultSFNHttpAuthSchemeParametersProvider,
-            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultSFNHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
                 "aws.auth#sigv4": config.credentials,
             }),
         }));
-        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
     }
     destroy() {
         super.destroy();
     }
 }
 
-class CreateActivityCommand extends client.Command
+class CreateActivityCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "CreateActivity", {})
     .n("SFNClient", "CreateActivityCommand")
-    .sc(schemas_0.CreateActivity$)
+    .sc(CreateActivity$)
     .build() {
 }
 
-class CreateStateMachineAliasCommand extends client.Command
+class CreateStateMachineAliasCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "CreateStateMachineAlias", {})
     .n("SFNClient", "CreateStateMachineAliasCommand")
-    .sc(schemas_0.CreateStateMachineAlias$)
+    .sc(CreateStateMachineAlias$)
     .build() {
 }
 
-class CreateStateMachineCommand extends client.Command
+class CreateStateMachineCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "CreateStateMachine", {})
     .n("SFNClient", "CreateStateMachineCommand")
-    .sc(schemas_0.CreateStateMachine$)
+    .sc(CreateStateMachine$)
     .build() {
 }
 
-class DeleteActivityCommand extends client.Command
+class DeleteActivityCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DeleteActivity", {})
     .n("SFNClient", "DeleteActivityCommand")
-    .sc(schemas_0.DeleteActivity$)
+    .sc(DeleteActivity$)
     .build() {
 }
 
-class DeleteStateMachineAliasCommand extends client.Command
+class DeleteStateMachineAliasCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DeleteStateMachineAlias", {})
     .n("SFNClient", "DeleteStateMachineAliasCommand")
-    .sc(schemas_0.DeleteStateMachineAlias$)
+    .sc(DeleteStateMachineAlias$)
     .build() {
 }
 
-class DeleteStateMachineCommand extends client.Command
+class DeleteStateMachineCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DeleteStateMachine", {})
     .n("SFNClient", "DeleteStateMachineCommand")
-    .sc(schemas_0.DeleteStateMachine$)
+    .sc(DeleteStateMachine$)
     .build() {
 }
 
-class DeleteStateMachineVersionCommand extends client.Command
+class DeleteStateMachineVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DeleteStateMachineVersion", {})
     .n("SFNClient", "DeleteStateMachineVersionCommand")
-    .sc(schemas_0.DeleteStateMachineVersion$)
+    .sc(DeleteStateMachineVersion$)
     .build() {
 }
 
-class DescribeActivityCommand extends client.Command
+class DescribeActivityCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DescribeActivity", {})
     .n("SFNClient", "DescribeActivityCommand")
-    .sc(schemas_0.DescribeActivity$)
+    .sc(DescribeActivity$)
     .build() {
 }
 
-class DescribeExecutionCommand extends client.Command
+class DescribeExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DescribeExecution", {})
     .n("SFNClient", "DescribeExecutionCommand")
-    .sc(schemas_0.DescribeExecution$)
+    .sc(DescribeExecution$)
     .build() {
 }
 
-class DescribeMapRunCommand extends client.Command
+class DescribeMapRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DescribeMapRun", {})
     .n("SFNClient", "DescribeMapRunCommand")
-    .sc(schemas_0.DescribeMapRun$)
+    .sc(DescribeMapRun$)
     .build() {
 }
 
-class DescribeStateMachineAliasCommand extends client.Command
+class DescribeStateMachineAliasCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DescribeStateMachineAlias", {})
     .n("SFNClient", "DescribeStateMachineAliasCommand")
-    .sc(schemas_0.DescribeStateMachineAlias$)
+    .sc(DescribeStateMachineAlias$)
     .build() {
 }
 
-class DescribeStateMachineCommand extends client.Command
+class DescribeStateMachineCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DescribeStateMachine", {})
     .n("SFNClient", "DescribeStateMachineCommand")
-    .sc(schemas_0.DescribeStateMachine$)
+    .sc(DescribeStateMachine$)
     .build() {
 }
 
-class DescribeStateMachineForExecutionCommand extends client.Command
+class DescribeStateMachineForExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DescribeStateMachineForExecution", {})
     .n("SFNClient", "DescribeStateMachineForExecutionCommand")
-    .sc(schemas_0.DescribeStateMachineForExecution$)
+    .sc(DescribeStateMachineForExecution$)
     .build() {
 }
 
-class GetActivityTaskCommand extends client.Command
+class GetActivityTaskCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-        client$1.getLongPollPlugin(config),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getLongPollPlugin(config),
     ];
 })
     .s("AWSStepFunctions", "GetActivityTask", {})
     .n("SFNClient", "GetActivityTaskCommand")
-    .sc(schemas_0.GetActivityTask$)
+    .sc(GetActivityTask$)
     .build() {
 }
 
-class GetExecutionHistoryCommand extends client.Command
+class GetExecutionHistoryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "GetExecutionHistory", {})
     .n("SFNClient", "GetExecutionHistoryCommand")
-    .sc(schemas_0.GetExecutionHistory$)
+    .sc(GetExecutionHistory$)
     .build() {
 }
 
-class ListActivitiesCommand extends client.Command
+class ListActivitiesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListActivities", {})
     .n("SFNClient", "ListActivitiesCommand")
-    .sc(schemas_0.ListActivities$)
+    .sc(ListActivities$)
     .build() {
 }
 
-class ListExecutionsCommand extends client.Command
+class ListExecutionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListExecutions", {})
     .n("SFNClient", "ListExecutionsCommand")
-    .sc(schemas_0.ListExecutions$)
+    .sc(ListExecutions$)
     .build() {
 }
 
-class ListMapRunsCommand extends client.Command
+class ListMapRunsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListMapRuns", {})
     .n("SFNClient", "ListMapRunsCommand")
-    .sc(schemas_0.ListMapRuns$)
+    .sc(ListMapRuns$)
     .build() {
 }
 
-class ListStateMachineAliasesCommand extends client.Command
+class ListStateMachineAliasesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListStateMachineAliases", {})
     .n("SFNClient", "ListStateMachineAliasesCommand")
-    .sc(schemas_0.ListStateMachineAliases$)
+    .sc(ListStateMachineAliases$)
     .build() {
 }
 
-class ListStateMachinesCommand extends client.Command
+class ListStateMachinesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListStateMachines", {})
     .n("SFNClient", "ListStateMachinesCommand")
-    .sc(schemas_0.ListStateMachines$)
+    .sc(ListStateMachines$)
     .build() {
 }
 
-class ListStateMachineVersionsCommand extends client.Command
+class ListStateMachineVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListStateMachineVersions", {})
     .n("SFNClient", "ListStateMachineVersionsCommand")
-    .sc(schemas_0.ListStateMachineVersions$)
+    .sc(ListStateMachineVersions$)
     .build() {
 }
 
-class ListTagsForResourceCommand extends client.Command
+class ListTagsForResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListTagsForResource", {})
     .n("SFNClient", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class PublishStateMachineVersionCommand extends client.Command
+class PublishStateMachineVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "PublishStateMachineVersion", {})
     .n("SFNClient", "PublishStateMachineVersionCommand")
-    .sc(schemas_0.PublishStateMachineVersion$)
+    .sc(PublishStateMachineVersion$)
     .build() {
 }
 
-class RedriveExecutionCommand extends client.Command
+class RedriveExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "RedriveExecution", {})
     .n("SFNClient", "RedriveExecutionCommand")
-    .sc(schemas_0.RedriveExecution$)
+    .sc(RedriveExecution$)
     .build() {
 }
 
-class SendTaskFailureCommand extends client.Command
+class SendTaskFailureCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "SendTaskFailure", {})
     .n("SFNClient", "SendTaskFailureCommand")
-    .sc(schemas_0.SendTaskFailure$)
+    .sc(SendTaskFailure$)
     .build() {
 }
 
-class SendTaskHeartbeatCommand extends client.Command
+class SendTaskHeartbeatCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "SendTaskHeartbeat", {})
     .n("SFNClient", "SendTaskHeartbeatCommand")
-    .sc(schemas_0.SendTaskHeartbeat$)
+    .sc(SendTaskHeartbeat$)
     .build() {
 }
 
-class SendTaskSuccessCommand extends client.Command
+class SendTaskSuccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "SendTaskSuccess", {})
     .n("SFNClient", "SendTaskSuccessCommand")
-    .sc(schemas_0.SendTaskSuccess$)
+    .sc(SendTaskSuccess$)
     .build() {
 }
 
-class StartExecutionCommand extends client.Command
+class StartExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "StartExecution", {})
     .n("SFNClient", "StartExecutionCommand")
-    .sc(schemas_0.StartExecution$)
+    .sc(StartExecution$)
     .build() {
 }
 
-class StartSyncExecutionCommand extends client.Command
+class StartSyncExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "StartSyncExecution", {})
     .n("SFNClient", "StartSyncExecutionCommand")
-    .sc(schemas_0.StartSyncExecution$)
+    .sc(StartSyncExecution$)
     .build() {
 }
 
-class StopExecutionCommand extends client.Command
+class StopExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "StopExecution", {})
     .n("SFNClient", "StopExecutionCommand")
-    .sc(schemas_0.StopExecution$)
+    .sc(StopExecution$)
     .build() {
 }
 
-class TagResourceCommand extends client.Command
+class TagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "TagResource", {})
     .n("SFNClient", "TagResourceCommand")
-    .sc(schemas_0.TagResource$)
+    .sc(TagResource$)
     .build() {
 }
 
-class TestStateCommand extends client.Command
+class TestStateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "TestState", {})
     .n("SFNClient", "TestStateCommand")
-    .sc(schemas_0.TestState$)
+    .sc(TestState$)
     .build() {
 }
 
-class UntagResourceCommand extends client.Command
+class UntagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "UntagResource", {})
     .n("SFNClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateMapRunCommand extends client.Command
+class UpdateMapRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "UpdateMapRun", {})
     .n("SFNClient", "UpdateMapRunCommand")
-    .sc(schemas_0.UpdateMapRun$)
+    .sc(UpdateMapRun$)
     .build() {
 }
 
-class UpdateStateMachineAliasCommand extends client.Command
+class UpdateStateMachineAliasCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "UpdateStateMachineAlias", {})
     .n("SFNClient", "UpdateStateMachineAliasCommand")
-    .sc(schemas_0.UpdateStateMachineAlias$)
+    .sc(UpdateStateMachineAlias$)
     .build() {
 }
 
-class UpdateStateMachineCommand extends client.Command
+class UpdateStateMachineCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "UpdateStateMachine", {})
     .n("SFNClient", "UpdateStateMachineCommand")
-    .sc(schemas_0.UpdateStateMachine$)
+    .sc(UpdateStateMachine$)
     .build() {
 }
 
-class ValidateStateMachineDefinitionCommand extends client.Command
+class ValidateStateMachineDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ValidateStateMachineDefinition", {})
     .n("SFNClient", "ValidateStateMachineDefinitionCommand")
-    .sc(schemas_0.ValidateStateMachineDefinition$)
+    .sc(ValidateStateMachineDefinition$)
     .build() {
 }
 
-const paginateGetExecutionHistory = core.createPaginator(SFNClient, GetExecutionHistoryCommand, "nextToken", "nextToken", "maxResults");
+const paginateGetExecutionHistory = createPaginator(SFNClient, GetExecutionHistoryCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListActivities = core.createPaginator(SFNClient, ListActivitiesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListActivities = createPaginator(SFNClient, ListActivitiesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListExecutions = core.createPaginator(SFNClient, ListExecutionsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListExecutions = createPaginator(SFNClient, ListExecutionsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListMapRuns = core.createPaginator(SFNClient, ListMapRunsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListMapRuns = createPaginator(SFNClient, ListMapRunsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListStateMachines = core.createPaginator(SFNClient, ListStateMachinesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListStateMachines = createPaginator(SFNClient, ListStateMachinesCommand, "nextToken", "nextToken", "maxResults");
 
 const commands = {
     CreateActivityCommand,
@@ -613,7 +616,7 @@ const paginators = {
 };
 class SFN extends SFNClient {
 }
-client.createAggregatedClient(commands, SFN, { paginators });
+createAggregatedClient(commands, SFN, { paginators });
 
 const EncryptionType = {
     AWS_OWNED_KEY: "AWS_OWNED_KEY",
@@ -767,9 +770,6 @@ const ValidateStateMachineDefinitionResultCode = {
     OK: "OK",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.SFNServiceException = SFNServiceException.SFNServiceException;
 exports.CreateActivityCommand = CreateActivityCommand;
 exports.CreateStateMachineAliasCommand = CreateStateMachineAliasCommand;
 exports.CreateStateMachineCommand = CreateStateMachineCommand;
@@ -832,23 +832,3 @@ exports.paginateListActivities = paginateListActivities;
 exports.paginateListExecutions = paginateListExecutions;
 exports.paginateListMapRuns = paginateListMapRuns;
 exports.paginateListStateMachines = paginateListStateMachines;
-Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: schemas_0['__proto__']
-    });
-
-Object.keys(schemas_0).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
-});
-Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: errors['__proto__']
-    });
-
-Object.keys(errors).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
-});