@aws-sdk/client-sfn 3.354.0 → 3.358.0

package/dist-es/SFN.js

@@ -1,11 +1,15 @@
 import { createAggregatedClient } from "@aws-sdk/smithy-client";
 import { CreateActivityCommand, } from "./commands/CreateActivityCommand";
+import { CreateStateMachineAliasCommand, } from "./commands/CreateStateMachineAliasCommand";
 import { CreateStateMachineCommand, } from "./commands/CreateStateMachineCommand";
 import { DeleteActivityCommand, } from "./commands/DeleteActivityCommand";
+import { DeleteStateMachineAliasCommand, } from "./commands/DeleteStateMachineAliasCommand";
 import { DeleteStateMachineCommand, } from "./commands/DeleteStateMachineCommand";
+import { DeleteStateMachineVersionCommand, } from "./commands/DeleteStateMachineVersionCommand";
 import { DescribeActivityCommand, } from "./commands/DescribeActivityCommand";
 import { DescribeExecutionCommand, } from "./commands/DescribeExecutionCommand";
 import { DescribeMapRunCommand, } from "./commands/DescribeMapRunCommand";
+import { DescribeStateMachineAliasCommand, } from "./commands/DescribeStateMachineAliasCommand";
 import { DescribeStateMachineCommand, } from "./commands/DescribeStateMachineCommand";
 import { DescribeStateMachineForExecutionCommand, } from "./commands/DescribeStateMachineForExecutionCommand";
 import { GetActivityTaskCommand, } from "./commands/GetActivityTaskCommand";
@@ -13,8 +17,11 @@ import { GetExecutionHistoryCommand, } from "./commands/GetExecutionHistoryComma
 import { ListActivitiesCommand, } from "./commands/ListActivitiesCommand";
 import { ListExecutionsCommand, } from "./commands/ListExecutionsCommand";
 import { ListMapRunsCommand } from "./commands/ListMapRunsCommand";
+import { ListStateMachineAliasesCommand, } from "./commands/ListStateMachineAliasesCommand";
 import { ListStateMachinesCommand, } from "./commands/ListStateMachinesCommand";
+import { ListStateMachineVersionsCommand, } from "./commands/ListStateMachineVersionsCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
+import { PublishStateMachineVersionCommand, } from "./commands/PublishStateMachineVersionCommand";
 import { SendTaskFailureCommand, } from "./commands/SendTaskFailureCommand";
 import { SendTaskHeartbeatCommand, } from "./commands/SendTaskHeartbeatCommand";
 import { SendTaskSuccessCommand, } from "./commands/SendTaskSuccessCommand";
@@ -24,25 +31,33 @@ import { StopExecutionCommand, } from "./commands/StopExecutionCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateMapRunCommand, } from "./commands/UpdateMapRunCommand";
+import { UpdateStateMachineAliasCommand, } from "./commands/UpdateStateMachineAliasCommand";
 import { UpdateStateMachineCommand, } from "./commands/UpdateStateMachineCommand";
 import { SFNClient } from "./SFNClient";
 const commands = {
     CreateActivityCommand,
     CreateStateMachineCommand,
+    CreateStateMachineAliasCommand,
     DeleteActivityCommand,
     DeleteStateMachineCommand,
+    DeleteStateMachineAliasCommand,
+    DeleteStateMachineVersionCommand,
     DescribeActivityCommand,
     DescribeExecutionCommand,
     DescribeMapRunCommand,
     DescribeStateMachineCommand,
+    DescribeStateMachineAliasCommand,
     DescribeStateMachineForExecutionCommand,
     GetActivityTaskCommand,
     GetExecutionHistoryCommand,
     ListActivitiesCommand,
     ListExecutionsCommand,
     ListMapRunsCommand,
+    ListStateMachineAliasesCommand,
     ListStateMachinesCommand,
+    ListStateMachineVersionsCommand,
     ListTagsForResourceCommand,
+    PublishStateMachineVersionCommand,
     SendTaskFailureCommand,
     SendTaskHeartbeatCommand,
     SendTaskSuccessCommand,
@@ -53,6 +68,7 @@ const commands = {
     UntagResourceCommand,
     UpdateMapRunCommand,
     UpdateStateMachineCommand,
+    UpdateStateMachineAliasCommand,
 };
 export class SFN extends SFNClient {
 }

package/dist-es/commands/CreateStateMachineAliasCommand.js

@@ -0,0 +1,43 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateStateMachineAliasInputFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateStateMachineAliasCommand, se_CreateStateMachineAliasCommand } from "../protocols/Aws_json1_0";
+export { $Command };
+export class CreateStateMachineAliasCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateStateMachineAliasCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SFNClient";
+        const commandName = "CreateStateMachineAliasCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateStateMachineAliasInputFilterSensitiveLog,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateStateMachineAliasCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateStateMachineAliasCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteStateMachineAliasCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_DeleteStateMachineAliasCommand, se_DeleteStateMachineAliasCommand } from "../protocols/Aws_json1_0";
+export { $Command };
+export class DeleteStateMachineAliasCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteStateMachineAliasCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SFNClient";
+        const commandName = "DeleteStateMachineAliasCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteStateMachineAliasCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteStateMachineAliasCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteStateMachineVersionCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_DeleteStateMachineVersionCommand, se_DeleteStateMachineVersionCommand } from "../protocols/Aws_json1_0";
+export { $Command };
+export class DeleteStateMachineVersionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteStateMachineVersionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SFNClient";
+        const commandName = "DeleteStateMachineVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteStateMachineVersionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteStateMachineVersionCommand(output, context);
+    }
+}

package/dist-es/commands/DescribeStateMachineAliasCommand.js

@@ -0,0 +1,43 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribeStateMachineAliasOutputFilterSensitiveLog, } from "../models/models_0";
+import { de_DescribeStateMachineAliasCommand, se_DescribeStateMachineAliasCommand } from "../protocols/Aws_json1_0";
+export { $Command };
+export class DescribeStateMachineAliasCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DescribeStateMachineAliasCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SFNClient";
+        const commandName = "DescribeStateMachineAliasCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: DescribeStateMachineAliasOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DescribeStateMachineAliasCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DescribeStateMachineAliasCommand(output, context);
+    }
+}

package/dist-es/commands/ListStateMachineAliasesCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_ListStateMachineAliasesCommand, se_ListStateMachineAliasesCommand } from "../protocols/Aws_json1_0";
+export { $Command };
+export class ListStateMachineAliasesCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListStateMachineAliasesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SFNClient";
+        const commandName = "ListStateMachineAliasesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListStateMachineAliasesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListStateMachineAliasesCommand(output, context);
+    }
+}

package/dist-es/commands/ListStateMachineVersionsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_ListStateMachineVersionsCommand, se_ListStateMachineVersionsCommand } from "../protocols/Aws_json1_0";
+export { $Command };
+export class ListStateMachineVersionsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListStateMachineVersionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SFNClient";
+        const commandName = "ListStateMachineVersionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListStateMachineVersionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListStateMachineVersionsCommand(output, context);
+    }
+}

package/dist-es/commands/PublishStateMachineVersionCommand.js

@@ -0,0 +1,43 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PublishStateMachineVersionInputFilterSensitiveLog, } from "../models/models_0";
+import { de_PublishStateMachineVersionCommand, se_PublishStateMachineVersionCommand } from "../protocols/Aws_json1_0";
+export { $Command };
+export class PublishStateMachineVersionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PublishStateMachineVersionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SFNClient";
+        const commandName = "PublishStateMachineVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: PublishStateMachineVersionInputFilterSensitiveLog,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_PublishStateMachineVersionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_PublishStateMachineVersionCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateStateMachineAliasCommand.js

@@ -0,0 +1,43 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateStateMachineAliasInputFilterSensitiveLog, } from "../models/models_0";
+import { de_UpdateStateMachineAliasCommand, se_UpdateStateMachineAliasCommand } from "../protocols/Aws_json1_0";
+export { $Command };
+export class UpdateStateMachineAliasCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateStateMachineAliasCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SFNClient";
+        const commandName = "UpdateStateMachineAliasCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateStateMachineAliasInputFilterSensitiveLog,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateStateMachineAliasCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateStateMachineAliasCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -1,10 +1,14 @@
 export * from "./CreateActivityCommand";
+export * from "./CreateStateMachineAliasCommand";
 export * from "./CreateStateMachineCommand";
 export * from "./DeleteActivityCommand";
+export * from "./DeleteStateMachineAliasCommand";
 export * from "./DeleteStateMachineCommand";
+export * from "./DeleteStateMachineVersionCommand";
 export * from "./DescribeActivityCommand";
 export * from "./DescribeExecutionCommand";
 export * from "./DescribeMapRunCommand";
+export * from "./DescribeStateMachineAliasCommand";
 export * from "./DescribeStateMachineCommand";
 export * from "./DescribeStateMachineForExecutionCommand";
 export * from "./GetActivityTaskCommand";
@@ -12,8 +16,11 @@ export * from "./GetExecutionHistoryCommand";
 export * from "./ListActivitiesCommand";
 export * from "./ListExecutionsCommand";
 export * from "./ListMapRunsCommand";
+export * from "./ListStateMachineAliasesCommand";
+export * from "./ListStateMachineVersionsCommand";
 export * from "./ListStateMachinesCommand";
 export * from "./ListTagsForResourceCommand";
+export * from "./PublishStateMachineVersionCommand";
 export * from "./SendTaskFailureCommand";
 export * from "./SendTaskHeartbeatCommand";
 export * from "./SendTaskSuccessCommand";
@@ -23,4 +30,5 @@ export * from "./StopExecutionCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateMapRunCommand";
+export * from "./UpdateStateMachineAliasCommand";
 export * from "./UpdateStateMachineCommand";

package/dist-es/endpoint/ruleset.js

@@ -1,4 +1,4 @@
-const s = "fn", t = "argv", u = "ref";
-const a = true, b = false, c = "String", d = "PartitionResult", e = "tree", f = "error", g = "endpoint", h = { "required": true, "default": false, "type": "Boolean" }, i = { [u]: "Region" }, j = { [u]: "Endpoint" }, k = { [s]: "booleanEquals", [t]: [{ [u]: "UseFIPS" }, true] }, l = { [s]: "booleanEquals", [t]: [{ [u]: "UseDualStack" }, true] }, m = {}, n = { [s]: "booleanEquals", [t]: [true, { [s]: "getAttr", [t]: [{ [u]: d }, "supportsFIPS"] }] }, o = { [s]: "booleanEquals", [t]: [true, { [s]: "getAttr", [t]: [{ [u]: d }, "supportsDualStack"] }] }, p = [j], q = [k], r = [l];
-const _data = { version: "1.0", parameters: { Region: { required: a, type: c }, UseDualStack: h, UseFIPS: h, Endpoint: { required: b, type: c } }, rules: [{ conditions: [{ [s]: "aws.partition", [t]: [i], assign: d }], type: e, rules: [{ conditions: [{ [s]: "isSet", [t]: p }, { [s]: "parseURL", [t]: p, assign: "url" }], type: e, rules: [{ conditions: q, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: f }, { type: e, rules: [{ conditions: r, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: f }, { endpoint: { url: j, properties: m, headers: m }, type: g }] }] }, { conditions: [k, l], type: e, rules: [{ conditions: [n, o], type: e, rules: [{ endpoint: { url: "https://states-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: g }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: f }] }, { conditions: q, type: e, rules: [{ conditions: [n], type: e, rules: [{ type: e, rules: [{ conditions: [{ [s]: "stringEquals", [t]: [i, "us-gov-west-1"] }], endpoint: { url: "https://states.us-gov-west-1.amazonaws.com", properties: m, headers: m }, type: g }, { endpoint: { url: "https://states-fips.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: g }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: f }] }, { conditions: r, type: e, rules: [{ conditions: [o], type: e, rules: [{ endpoint: { url: "https://states.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: g }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: f }] }, { endpoint: { url: "https://states.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: g }] }] };
+const r = "required", s = "fn", t = "argv", u = "ref";
+const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = { [r]: false, "type": "String" }, g = { [r]: true, "default": false, "type": "Boolean" }, h = { [u]: "Endpoint" }, i = { [s]: "booleanEquals", [t]: [{ [u]: "UseFIPS" }, true] }, j = { [s]: "booleanEquals", [t]: [{ [u]: "UseDualStack" }, true] }, k = {}, l = { [u]: "Region" }, m = { [s]: "booleanEquals", [t]: [true, { [s]: "getAttr", [t]: [{ [u]: e }, "supportsFIPS"] }] }, n = { [s]: "booleanEquals", [t]: [true, { [s]: "getAttr", [t]: [{ [u]: e }, "supportsDualStack"] }] }, o = [i], p = [j], q = [l];
+const _data = { version: "1.0", parameters: { Region: f, UseDualStack: g, UseFIPS: g, Endpoint: f }, rules: [{ conditions: [{ [s]: a, [t]: [h] }], type: b, rules: [{ conditions: o, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: p, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: h, properties: k, headers: k }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [s]: a, [t]: q }], type: b, rules: [{ conditions: [{ [s]: "aws.partition", [t]: q, assign: e }], type: b, rules: [{ conditions: [i, j], type: b, rules: [{ conditions: [m, n], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://states-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [m], type: b, rules: [{ type: b, rules: [{ conditions: [{ [s]: "stringEquals", [t]: [l, "us-gov-west-1"] }], endpoint: { url: "https://states.us-gov-west-1.amazonaws.com", properties: k, headers: k }, type: d }, { endpoint: { url: "https://states-fips.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: p, type: b, rules: [{ conditions: [n], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://states.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ endpoint: { url: "https://states.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
 export const ruleSet = _data;

package/dist-es/models/models_0.js

@@ -61,6 +61,18 @@ export class TooManyTags extends __BaseException {
         this.resourceName = opts.resourceName;
     }
 }
+export class ConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
+    }
+}
 export const LogLevel = {
     ALL: "ALL",
     ERROR: "ERROR",
@@ -170,6 +182,7 @@ export class StateMachineTypeNotSupported extends __BaseException {
 export const ValidationExceptionReason = {
     API_DOES_NOT_SUPPORT_LABELED_ARNS: "API_DOES_NOT_SUPPORT_LABELED_ARNS",
     CANNOT_UPDATE_COMPLETED_MAP_RUN: "CANNOT_UPDATE_COMPLETED_MAP_RUN",
+    INVALID_ROUTING_CONFIGURATION: "INVALID_ROUTING_CONFIGURATION",
     MISSING_REQUIRED_PARAMETER: "MISSING_REQUIRED_PARAMETER",
 };
 export class ValidationException extends __BaseException {
@@ -185,6 +198,31 @@ export class ValidationException extends __BaseException {
         this.reason = opts.reason;
     }
 }
+export class ResourceNotFound extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFound",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFound";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFound.prototype);
+        this.resourceName = opts.resourceName;
+    }
+}
+export class ServiceQuotaExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+    }
+}
 export const ExecutionStatus = {
     ABORTED: "ABORTED",
     FAILED: "FAILED",
@@ -210,19 +248,6 @@ export const MapRunStatus = {
     RUNNING: "RUNNING",
     SUCCEEDED: "SUCCEEDED",
 };
-export class ResourceNotFound extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "ResourceNotFound",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "ResourceNotFound";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, ResourceNotFound.prototype);
-        this.resourceName = opts.resourceName;
-    }
-}
 export const StateMachineStatus = {
     ACTIVE: "ACTIVE",
     DELETING: "DELETING",
@@ -427,6 +452,11 @@ export const ActivityTimedOutEventDetailsFilterSensitiveLog = (obj) => ({
 export const CreateStateMachineInputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.definition && { definition: SENSITIVE_STRING }),
+    ...(obj.versionDescription && { versionDescription: SENSITIVE_STRING }),
+});
+export const CreateStateMachineAliasInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
 });
 export const DescribeExecutionOutputFilterSensitiveLog = (obj) => ({
     ...obj,
@@ -438,6 +468,11 @@ export const DescribeExecutionOutputFilterSensitiveLog = (obj) => ({
 export const DescribeStateMachineOutputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.definition && { definition: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const DescribeStateMachineAliasOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
 });
 export const DescribeStateMachineForExecutionOutputFilterSensitiveLog = (obj) => ({
     ...obj,
@@ -628,6 +663,10 @@ export const GetExecutionHistoryOutputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.events && { events: obj.events.map((item) => HistoryEventFilterSensitiveLog(item)) }),
 });
+export const PublishStateMachineVersionInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
 export const SendTaskFailureInputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.error && { error: SENSITIVE_STRING }),
@@ -660,4 +699,9 @@ export const StopExecutionInputFilterSensitiveLog = (obj) => ({
 export const UpdateStateMachineInputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.definition && { definition: SENSITIVE_STRING }),
+    ...(obj.versionDescription && { versionDescription: SENSITIVE_STRING }),
+});
+export const UpdateStateMachineAliasInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
 });