terraconstructs 0.0.8

package/lib/aws/compute/state-graph.js

@@ -0,0 +1,177 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateGraph = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const iam = require("../iam");
+const distributed_map_1 = require("./states/distributed-map");
+/**
+ * A collection of connected states
+ *
+ * A StateGraph is used to keep track of all states that are connected (have
+ * transitions between them). It does not include the substatemachines in
+ * a Parallel's branches: those are their own StateGraphs, but the graphs
+ * themselves have a hierarchical relationship as well.
+ *
+ * By assigning states to a definitive StateGraph, we verify that no state
+ * machines are constructed. In particular:
+ *
+ * - Every state object can only ever be in 1 StateGraph, and not inadvertently
+ *   be used in two graphs.
+ * - Every stateId must be unique across all states in the entire state
+ *   machine.
+ *
+ * All policy statements in all states in all substatemachines are bubbled so
+ * that the top-level StateMachine instantiation can read them all and add
+ * them to the IAM Role.
+ *
+ * You do not need to instantiate this class; it is used internally.
+ */
+class StateGraph {
+    /**
+     * @param startState state that gets executed when the state machine is launched
+     * @param graphDescription description of the state machine
+     */
+    constructor(startState, graphDescription) {
+        this.startState = startState;
+        this.graphDescription = graphDescription;
+        /**
+         * The accumulated policy statements
+         */
+        this.policyStatements = new Array();
+        /**
+         * All states in this graph
+         */
+        this.allStates = new Set();
+        /**
+         * A mapping of stateId -> Graph for all states in this graph and subgraphs
+         */
+        this.allContainedStates = new Map();
+        this.allStates.add(startState);
+        startState.bindToGraph(this);
+    }
+    /**
+     * Register a state as part of this graph
+     *
+     * Called by State.bindToGraph().
+     */
+    registerState(state) {
+        this.registerContainedState(state.stateId, this);
+        this.allStates.add(state);
+    }
+    /**
+     * Register a Policy Statement used by states in this graph
+     */
+    registerPolicyStatement(statement) {
+        if (this.superGraph) {
+            this.superGraph.registerPolicyStatement(statement);
+        }
+        else {
+            this.policyStatements.push(statement);
+        }
+    }
+    /**
+     * Register this graph as a child of the given graph
+     *
+     * Resource changes will be bubbled up to the given graph.
+     */
+    registerSuperGraph(graph) {
+        if (this.superGraph === graph) {
+            return;
+        }
+        if (this.superGraph) {
+            throw new Error("Every StateGraph can only be registered into one other StateGraph");
+        }
+        this.superGraph = graph;
+        this.pushContainedStatesUp(graph);
+        this.pushPolicyStatementsUp(graph);
+    }
+    /**
+     * Return the Amazon States Language JSON for this graph
+     */
+    toGraphJson() {
+        const states = {};
+        for (const state of this.allStates) {
+            states[state.stateId] = state.toStateJson();
+        }
+        return {
+            StartAt: this.startState.stateId,
+            States: states,
+            TimeoutSeconds: this.timeout && this.timeout.toSeconds(),
+        };
+    }
+    /**
+     * Return a string description of this graph
+     */
+    toString() {
+        const someNodes = Array.from(this.allStates)
+            .slice(0, 3)
+            .map((x) => x.stateId);
+        if (this.allStates.size > 3) {
+            someNodes.push("...");
+        }
+        return `${this.graphDescription} (${someNodes.join(", ")})`;
+    }
+    /**
+     * Register a stateId and graph where it was registered
+     */
+    registerContainedState(stateId, graph) {
+        if (this.superGraph) {
+            this.superGraph.registerContainedState(stateId, graph);
+        }
+        else {
+            const existingGraph = this.allContainedStates.get(stateId);
+            if (existingGraph) {
+                throw new Error(`State with name '${stateId}' occurs in both ${graph} and ${existingGraph}. All states must have unique names.`);
+            }
+            this.allContainedStates.set(stateId, graph);
+        }
+    }
+    /**
+     * Push all contained state info up to the given super graph
+     */
+    pushContainedStatesUp(superGraph) {
+        for (const [stateId, graph] of this.allContainedStates) {
+            superGraph.registerContainedState(stateId, graph);
+        }
+    }
+    /**
+     * Push all policy statements to into the given super graph
+     */
+    pushPolicyStatementsUp(superGraph) {
+        for (const policyStatement of this.policyStatements) {
+            superGraph.registerPolicyStatement(policyStatement);
+        }
+    }
+    /**
+     * Binds this StateGraph to the StateMachine it defines and updates state machine permissions
+     */
+    bind(stateMachine) {
+        for (const state of this.allStates) {
+            if (distributed_map_1.DistributedMap.isDistributedMap(state)) {
+                stateMachine.role.attachInlinePolicy(new iam.Policy(stateMachine, "DistributedMapPolicy", {
+                    document: new iam.PolicyDocument(stateMachine, "DistributedMapPolicyDocument", {
+                        statement: [
+                            new iam.PolicyStatement({
+                                actions: ["states:StartExecution"],
+                                resources: [stateMachine.stateMachineArn],
+                            }),
+                            new iam.PolicyStatement({
+                                actions: [
+                                    "states:DescribeExecution",
+                                    "states:StopExecution",
+                                ],
+                                resources: [`${stateMachine.stateMachineArn}:*`],
+                            }),
+                        ],
+                    }),
+                }));
+                break;
+            }
+        }
+    }
+}
+exports.StateGraph = StateGraph;
+_a = JSII_RTTI_SYMBOL_1;
+StateGraph[_a] = { fqn: "terraconstructs.aws.compute.StateGraph", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state-graph.js","sourceRoot":"","sources":["../../../src/aws/compute/state-graph.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/state-graph.ts\nimport { StateMachine } from \"./state-machine\";\nimport { Duration } from \"../..\";\nimport * as iam from \"../iam\";\nimport { DistributedMap } from \"./states/distributed-map\";\nimport { State } from \"./states/state\";\n\n/**\n * A collection of connected states\n *\n * A StateGraph is used to keep track of all states that are connected (have\n * transitions between them). It does not include the substatemachines in\n * a Parallel's branches: those are their own StateGraphs, but the graphs\n * themselves have a hierarchical relationship as well.\n *\n * By assigning states to a definitive StateGraph, we verify that no state\n * machines are constructed. In particular:\n *\n * - Every state object can only ever be in 1 StateGraph, and not inadvertently\n *   be used in two graphs.\n * - Every stateId must be unique across all states in the entire state\n *   machine.\n *\n * All policy statements in all states in all substatemachines are bubbled so\n * that the top-level StateMachine instantiation can read them all and add\n * them to the IAM Role.\n *\n * You do not need to instantiate this class; it is used internally.\n */\nexport class StateGraph {\n  /**\n   * Set a timeout to render into the graph JSON.\n   *\n   * Read/write. Only makes sense on the top-level graph, subgraphs\n   * do not support this feature.\n   *\n   * @default No timeout\n   */\n  public timeout?: Duration;\n\n  /**\n   * The accumulated policy statements\n   */\n  public readonly policyStatements = new Array<iam.PolicyStatement>();\n\n  /**\n   * All states in this graph\n   */\n  private readonly allStates = new Set<State>();\n\n  /**\n   * A mapping of stateId -> Graph for all states in this graph and subgraphs\n   */\n  private readonly allContainedStates = new Map<string, StateGraph>();\n\n  /**\n   * Containing graph of this graph\n   */\n  private superGraph?: StateGraph;\n\n  /**\n   * @param startState state that gets executed when the state machine is launched\n   * @param graphDescription description of the state machine\n   */\n  constructor(\n    public readonly startState: State,\n    private readonly graphDescription: string,\n  ) {\n    this.allStates.add(startState);\n    startState.bindToGraph(this);\n  }\n\n  /**\n   * Register a state as part of this graph\n   *\n   * Called by State.bindToGraph().\n   */\n  public registerState(state: State) {\n    this.registerContainedState(state.stateId, this);\n    this.allStates.add(state);\n  }\n\n  /**\n   * Register a Policy Statement used by states in this graph\n   */\n  public registerPolicyStatement(statement: iam.PolicyStatement) {\n    if (this.superGraph) {\n      this.superGraph.registerPolicyStatement(statement);\n    } else {\n      this.policyStatements.push(statement);\n    }\n  }\n\n  /**\n   * Register this graph as a child of the given graph\n   *\n   * Resource changes will be bubbled up to the given graph.\n   */\n  public registerSuperGraph(graph: StateGraph) {\n    if (this.superGraph === graph) {\n      return;\n    }\n    if (this.superGraph) {\n      throw new Error(\n        \"Every StateGraph can only be registered into one other StateGraph\",\n      );\n    }\n    this.superGraph = graph;\n    this.pushContainedStatesUp(graph);\n    this.pushPolicyStatementsUp(graph);\n  }\n\n  /**\n   * Return the Amazon States Language JSON for this graph\n   */\n  public toGraphJson(): object {\n    const states: any = {};\n    for (const state of this.allStates) {\n      states[state.stateId] = state.toStateJson();\n    }\n\n    return {\n      StartAt: this.startState.stateId,\n      States: states,\n      TimeoutSeconds: this.timeout && this.timeout.toSeconds(),\n    };\n  }\n\n  /**\n   * Return a string description of this graph\n   */\n  public toString() {\n    const someNodes = Array.from(this.allStates)\n      .slice(0, 3)\n      .map((x) => x.stateId);\n    if (this.allStates.size > 3) {\n      someNodes.push(\"...\");\n    }\n    return `${this.graphDescription} (${someNodes.join(\", \")})`;\n  }\n\n  /**\n   * Register a stateId and graph where it was registered\n   */\n  private registerContainedState(stateId: string, graph: StateGraph) {\n    if (this.superGraph) {\n      this.superGraph.registerContainedState(stateId, graph);\n    } else {\n      const existingGraph = this.allContainedStates.get(stateId);\n      if (existingGraph) {\n        throw new Error(\n          `State with name '${stateId}' occurs in both ${graph} and ${existingGraph}. All states must have unique names.`,\n        );\n      }\n\n      this.allContainedStates.set(stateId, graph);\n    }\n  }\n\n  /**\n   * Push all contained state info up to the given super graph\n   */\n  private pushContainedStatesUp(superGraph: StateGraph) {\n    for (const [stateId, graph] of this.allContainedStates) {\n      superGraph.registerContainedState(stateId, graph);\n    }\n  }\n\n  /**\n   * Push all policy statements to into the given super graph\n   */\n  private pushPolicyStatementsUp(superGraph: StateGraph) {\n    for (const policyStatement of this.policyStatements) {\n      superGraph.registerPolicyStatement(policyStatement);\n    }\n  }\n\n  /**\n   * Binds this StateGraph to the StateMachine it defines and updates state machine permissions\n   */\n  public bind(stateMachine: StateMachine) {\n    for (const state of this.allStates) {\n      if (DistributedMap.isDistributedMap(state)) {\n        stateMachine.role.attachInlinePolicy(\n          new iam.Policy(stateMachine, \"DistributedMapPolicy\", {\n            document: new iam.PolicyDocument(\n              stateMachine,\n              \"DistributedMapPolicyDocument\",\n              {\n                statement: [\n                  new iam.PolicyStatement({\n                    actions: [\"states:StartExecution\"],\n                    resources: [stateMachine.stateMachineArn],\n                  }),\n                  new iam.PolicyStatement({\n                    actions: [\n                      \"states:DescribeExecution\",\n                      \"states:StopExecution\",\n                    ],\n                    resources: [`${stateMachine.stateMachineArn}:*`],\n                  }),\n                ],\n              },\n            ),\n          }),\n        );\n\n        break;\n      }\n    }\n  }\n}\n"]}

package/lib/aws/compute/state-machine-fragment.d.ts

@@ -0,0 +1,61 @@
+import { Construct } from "constructs";
+import { Chain } from "./chain";
+import { Parallel, ParallelProps } from "./states/parallel";
+import { State } from "./states/state";
+import { IChainable, INextable } from "./types";
+/**
+ * Base class for reusable state machine fragments
+ */
+export declare abstract class StateMachineFragment extends Construct implements IChainable {
+    /**
+     * The start state of this state machine fragment
+     */
+    abstract readonly startState: State;
+    /**
+     * The states to chain onto if this fragment is used
+     */
+    abstract readonly endStates: INextable[];
+    get id(): string;
+    /**
+     * Prefix the IDs of all states in this state machine fragment
+     *
+     * Use this to avoid multiple copies of the state machine all having the
+     * same state IDs.
+     *
+     * @param prefix The prefix to add. Will use construct ID by default.
+     */
+    prefixStates(prefix?: string): StateMachineFragment;
+    /**
+     * Wrap all states in this state machine fragment up into a single state.
+     *
+     * This can be used to add retry or error handling onto this state
+     * machine fragment.
+     *
+     * Be aware that this changes the result of the inner state machine
+     * to be an array with the result of the state machine in it. Adjust
+     * your paths accordingly. For example, change 'outputPath' to
+     * '$[0]'.
+     */
+    toSingleState(options?: SingleStateOptions): Parallel;
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+}
+/**
+ * Options for creating a single state
+ */
+export interface SingleStateOptions extends ParallelProps {
+    /**
+     * ID of newly created containing state
+     *
+     * @default Construct ID of the StateMachineFragment
+     */
+    readonly stateId?: string;
+    /**
+     * String to prefix all stateIds in the state machine with
+     *
+     * @default stateId
+     */
+    readonly prefixStates?: string;
+}

package/lib/aws/compute/state-machine-fragment.js

@@ -0,0 +1,56 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateMachineFragment = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/state-machine-fragment.ts
+const constructs_1 = require("constructs");
+const chain_1 = require("./chain");
+const parallel_1 = require("./states/parallel");
+const state_1 = require("./states/state");
+/**
+ * Base class for reusable state machine fragments
+ */
+class StateMachineFragment extends constructs_1.Construct {
+    get id() {
+        return this.node.id;
+    }
+    /**
+     * Prefix the IDs of all states in this state machine fragment
+     *
+     * Use this to avoid multiple copies of the state machine all having the
+     * same state IDs.
+     *
+     * @param prefix The prefix to add. Will use construct ID by default.
+     */
+    prefixStates(prefix) {
+        state_1.State.prefixStates(this, prefix || `${this.id}: `);
+        return this;
+    }
+    /**
+     * Wrap all states in this state machine fragment up into a single state.
+     *
+     * This can be used to add retry or error handling onto this state
+     * machine fragment.
+     *
+     * Be aware that this changes the result of the inner state machine
+     * to be an array with the result of the state machine in it. Adjust
+     * your paths accordingly. For example, change 'outputPath' to
+     * '$[0]'.
+     */
+    toSingleState(options = {}) {
+        const stateId = options.stateId || this.id;
+        this.prefixStates(options.prefixStates || `${stateId}: `);
+        return new parallel_1.Parallel(this, stateId, options).branch(this);
+    }
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next) {
+        return chain_1.Chain.start(this).next(next);
+    }
+}
+exports.StateMachineFragment = StateMachineFragment;
+_a = JSII_RTTI_SYMBOL_1;
+StateMachineFragment[_a] = { fqn: "terraconstructs.aws.compute.StateMachineFragment", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/state-machine.d.ts

@@ -0,0 +1,323 @@
+import { sfnStateMachine } from "@cdktf/provider-aws";
+import { IResolvable } from "cdktf";
+import { Construct } from "constructs";
+import { AwsConstructBase, IAwsConstruct, AwsConstructProps } from "..";
+import { StateGraph } from "./state-graph";
+import { IChainable } from "./types";
+import { Duration } from "../../";
+import * as iam from "../iam";
+/**
+ * Properties for defining a State Machine
+ */
+export interface StateMachineProps extends AwsConstructProps {
+    /**
+     * The name of the state machine.
+     *
+     * To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.
+     *
+     * Length Constraints: Minimum length of 1. Maximum length of 80.
+     *
+     * @default - Terraform will assign a random, unique suffix.
+     */
+    readonly stateMachineName?: string;
+    /**
+     * Creates a unique name beginning with the specified prefix. Conflicts with `stateMachineName`
+     *
+     * The name should only contain 0-9, A-Z, a-z, - and _
+     * Terraform Prefixes must reserve 26 characters for the terraform generated suffix.
+     *
+     * @default - GridUUID + Stack Unique Name
+     */
+    readonly namePrefix?: string;
+    /**
+     * Definition for this state machine
+     */
+    readonly definitionBody: DefinitionBody;
+    /**
+     * The execution role for the state machine service
+     *
+     * @default A role is automatically created
+     */
+    readonly role?: iam.IRole;
+    /**
+     * Maximum run time for this state machine
+     *
+     * @default No timeout
+     */
+    readonly timeout?: Duration;
+    /**
+     * Comment that describes this state machine
+     *
+     * @default - No comment
+     */
+    readonly comment?: string;
+    /**
+     * Type of the state machine
+     *
+     * @default StateMachineType.STANDARD
+     */
+    readonly stateMachineType?: StateMachineType;
+    /**
+     * Defines what execution history events are logged and where they are logged.
+     *
+     * @default No logging
+     */
+    readonly logs?: LogOptions;
+    /**
+     * Specifies whether Amazon X-Ray tracing is enabled for this state machine.
+     *
+     * @default false
+     */
+    readonly tracingEnabled?: boolean;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sfn_state_machine#tags SfnStateMachine#tags}
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sfn_state_machine#publish SfnStateMachine#publish}
+     */
+    readonly publish?: boolean | IResolvable;
+}
+export interface StateMachineOutputs {
+    /**
+     * State Machine arn
+     */
+    readonly arn: string;
+}
+/**
+ * A State Machine
+ */
+export interface IStateMachine extends IAwsConstruct {
+    /** Strongly typed outputs */
+    readonly stateMachineOutputs: StateMachineOutputs;
+    /**
+     * The ARN of the state machine
+     * @attribute
+     */
+    readonly stateMachineArn: string;
+    /**
+     * Grant the given identity permissions to start an execution of this state
+     * machine.
+     *
+     * @param identity The principal
+     */
+    grantStartExecution(identity: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity permissions to start a synchronous execution of
+     * this state machine.
+     *
+     * @param identity The principal
+     */
+    grantStartSyncExecution(identity: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity read permissions for this state machine
+     *
+     * @param identity The principal
+     */
+    grantRead(identity: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity read permissions for this state machine
+     *
+     * @param identity The principal
+     */
+    grantTaskResponse(identity: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity permissions for all executions of a state machine
+     *
+     * @param identity The principal
+     * @param actions The list of desired actions
+     */
+    grantExecution(identity: iam.IGrantable, ...actions: string[]): iam.Grant;
+    /**
+     * Grant the given identity custom permissions
+     *
+     * @param identity The principal
+     * @param actions The list of desired actions
+     */
+    grant(identity: iam.IGrantable, ...actions: string[]): iam.Grant;
+}
+/**
+ * A new or imported state machine.
+ */
+declare abstract class StateMachineBase extends AwsConstructBase implements IStateMachine {
+    /**
+     * Import a state machine
+     */
+    static fromStateMachineArn(scope: Construct, id: string, stateMachineArn: string): IStateMachine;
+    /**
+     * Import a state machine via resource name
+     */
+    static fromStateMachineName(scope: Construct, id: string, stateMachineName: string): IStateMachine;
+    abstract readonly stateMachineArn: string;
+    get stateMachineOutputs(): StateMachineOutputs;
+    get outputs(): Record<string, any>;
+    /**
+     * The principal this state machine is running as
+     */
+    abstract readonly grantPrincipal: iam.IPrincipal;
+    /**
+     * Grant the given identity permissions to start an execution of this state
+     * machine.
+     */
+    grantStartExecution(identity: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity permissions to start a synchronous execution of
+     * this state machine.
+     */
+    grantStartSyncExecution(identity: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity permissions to read results from state
+     * machine.
+     */
+    grantRead(identity: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity task response permissions on a state machine
+     */
+    grantTaskResponse(identity: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity permissions on all executions of the state machine
+     */
+    grantExecution(identity: iam.IGrantable, ...actions: string[]): iam.Grant;
+    /**
+     * Grant the given identity custom permissions
+     */
+    grant(identity: iam.IGrantable, ...actions: string[]): iam.Grant;
+    /**
+     * Returns the pattern for the execution ARN's of the state machine
+     */
+    private executionArn;
+}
+/**
+ * Define a StepFunctions State Machine
+ */
+export declare class StateMachine extends StateMachineBase {
+    /**
+     * Execution role of this state machine
+     */
+    readonly role: iam.IRole;
+    readonly resource: sfnStateMachine.SfnStateMachine;
+    /**
+     * The name of the state machine
+     * @attribute
+     */
+    get stateMachineName(): string;
+    /**
+     * The ARN of the state machine
+     */
+    get stateMachineArn(): string;
+    /**
+     * Type of the state machine
+     * @attribute
+     */
+    readonly stateMachineType: StateMachineType;
+    /**
+     * Identifier for the state machine revision, which is an immutable, read-only snapshot of a state machine’s definition and configuration.
+     * @attribute
+     */
+    readonly stateMachineRevisionId: string;
+    constructor(scope: Construct, id: string, props: StateMachineProps);
+    /**
+     * The principal this state machine is running as
+     */
+    get grantPrincipal(): iam.IPrincipal;
+    /**
+     * Add the given statement to the role's policy
+     */
+    addToRolePolicy(statement: iam.PolicyStatement): void;
+    private validateStateMachineName;
+    private buildLoggingConfiguration;
+    private buildTracingConfiguration;
+}
+/**
+ * Partial object from the StateMachine L1 construct properties containing definition information
+ */
+export interface DefinitionConfig {
+    readonly definition: string;
+}
+export declare abstract class DefinitionBody {
+    static fromString(definition: string): DefinitionBody;
+    static fromChainable(chainable: IChainable): DefinitionBody;
+    abstract bind(scope: Construct, sfnPrincipal: iam.IPrincipal, sfnProps: StateMachineProps, graph?: StateGraph): DefinitionConfig;
+}
+export declare class StringDefinitionBody extends DefinitionBody {
+    readonly body: string;
+    constructor(body: string);
+    bind(_scope: Construct, _sfnPrincipal: iam.IPrincipal, _sfnProps: StateMachineProps, _graph?: StateGraph): DefinitionConfig;
+}
+export declare class ChainDefinitionBody extends DefinitionBody {
+    readonly chainable: IChainable;
+    constructor(chainable: IChainable);
+    bind(scope: Construct, _sfnPrincipal: iam.IPrincipal, sfnProps: StateMachineProps, graph?: StateGraph): DefinitionConfig;
+}
+/**
+ * Two types of state machines are available in AWS Step Functions: EXPRESS AND STANDARD.
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html
+ *
+ * @default STANDARD
+ */
+export declare enum StateMachineType {
+    /**
+     * Express Workflows are ideal for high-volume, event processing workloads.
+     */
+    EXPRESS = "EXPRESS",
+    /**
+     * Standard Workflows are ideal for long-running, durable, and auditable workflows.
+     */
+    STANDARD = "STANDARD"
+}
+/**
+ * Defines which category of execution history events are logged.
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/cloudwatch-log-level.html
+ *
+ * @default ERROR
+ */
+export declare enum LogLevel {
+    /**
+     * No Logging
+     */
+    OFF = "OFF",
+    /**
+     * Log everything
+     */
+    ALL = "ALL",
+    /**
+     * Log all errors
+     */
+    ERROR = "ERROR",
+    /**
+     * Log fatal errors
+     */
+    FATAL = "FATAL"
+}
+export interface LogOptions {
+    /**
+     * Determines whether execution data is included in your log.
+     *
+     * When set to false, data is excluded.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sfn_state_machine#include_execution_data SfnStateMachine#include_execution_data}
+     * @default false
+     */
+    readonly includeExecutionData?: boolean | IResolvable;
+    /**
+     * Defines which category of execution history events are logged.
+     *
+     * @default ERROR
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sfn_state_machine#level SfnStateMachine#level}
+     */
+    readonly level?: LogLevel;
+    /**
+     * The log group where the execution history events will be logged.
+     *
+     * Amazon Resource Name (ARN) of a CloudWatch log group.
+     * Make sure the State Machine has the correct IAM policies for logging.
+     * The ARN must end with `:*`
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sfn_state_machine#log_destination SfnStateMachine#log_destination}
+     */
+    readonly logDestination?: string;
+}
+export {};