terraconstructs 0.0.8

package/lib/aws/compute/activity.js

@@ -0,0 +1,132 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Activity = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+// import { CustomerManagedEncryptionConfiguration } from "./customer-managed-key-encryption-configuration";
+// import { EncryptionConfiguration } from "./encryption-configuration";
+// import { buildEncryptionConfiguration } from "./private/util";
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const iam = require("../iam");
+/**
+ * Define a new Step Functions Activity
+ */
+class Activity extends aws_construct_1.AwsConstructBase {
+    /**
+     * Construct an Activity from an existing Activity ARN
+     */
+    static fromActivityArn(scope, id, activityArn) {
+        class Imported extends aws_construct_1.AwsConstructBase {
+            get activityOutputs() {
+                return {
+                    arn: this.activityArn,
+                };
+            }
+            get outputs() {
+                return this.activityOutputs;
+            }
+            get activityArn() {
+                return activityArn;
+            }
+            get activityName() {
+                return (this.stack.splitArn(activityArn, arn_1.ArnFormat.COLON_RESOURCE_NAME)
+                    .resourceName || "");
+            }
+        }
+        return new Imported(scope, id);
+    }
+    /**
+     * Construct an Activity from an existing Activity Name
+     */
+    static fromActivityName(scope, id, activityName) {
+        return Activity.fromActivityArn(scope, id, aws_stack_1.AwsStack.ofAwsConstruct(scope).formatArn({
+            service: "states",
+            resource: "activity",
+            resourceName: activityName,
+            arnFormat: arn_1.ArnFormat.COLON_RESOURCE_NAME,
+        }));
+    }
+    get activityOutputs() {
+        return {
+            arn: this.activityArn,
+        };
+    }
+    get outputs() {
+        return this.activityOutputs;
+    }
+    // /**
+    //  * @attribute
+    //  */
+    // public readonly encryptionConfiguration?: EncryptionConfiguration;
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        /**
+         * 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.
+         */
+        const resourceName = props.activityName ||
+            cdktf_1.Lazy.stringValue({
+                produce: () => this.stack.uniqueResourceName(this, {
+                    prefix: this.gridUUID + "-",
+                    maxLength: 80,
+                    allowedSpecialCharacters: "-_",
+                }),
+            });
+        // this.encryptionConfiguration = props.encryptionConfiguration;
+        // if (
+        //   props.encryptionConfiguration instanceof
+        //   CustomerManagedEncryptionConfiguration
+        // ) {
+        //   props.encryptionConfiguration.kmsKey.addToResourcePolicy(
+        //     new iam.PolicyStatement({
+        //       resources: ["*"],
+        //       actions: ["kms:Decrypt", "kms:GenerateDataKey"],
+        //       principals: [new iam.ServicePrincipal("states.amazonaws.com")],
+        //       condition: [
+        //         {
+        //           test: "StringEquals",
+        //           variable: "kms:EncryptionContext:aws:states:activityArn",
+        //           values: [
+        //             this.stack.formatArn({
+        //               service: "states",
+        //               resource: "activity",
+        //               sep: ":",
+        //               resourceName,
+        //             }),
+        //           ],
+        //         },
+        //       ],
+        //     }),
+        //   );
+        // }
+        this.resource = new provider_aws_1.sfnActivity.SfnActivity(this, "Resource", {
+            name: resourceName,
+            // encryptionConfiguration: buildEncryptionConfiguration(
+            //   props.encryptionConfiguration,
+            // ),
+        });
+        this.activityArn = this.resource.id;
+        this.activityName = this.resource.name;
+    }
+    /**
+     * Grant the given identity permissions on this Activity
+     *
+     * @param identity The principal
+     * @param actions The list of desired actions
+     */
+    grant(identity, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee: identity,
+            actions,
+            resourceArns: [this.activityArn],
+        });
+    }
+}
+exports.Activity = Activity;
+_a = JSII_RTTI_SYMBOL_1;
+Activity[_a] = { fqn: "terraconstructs.aws.compute.Activity", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"activity.js","sourceRoot":"","sources":["../../../src/aws/compute/activity.ts"],"names":[],"mappings":"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","sourcesContent":["import { sfnActivity } from \"@cdktf/provider-aws\";\nimport { Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\n// import { CustomerManagedEncryptionConfiguration } from \"./customer-managed-key-encryption-configuration\";\n// import { EncryptionConfiguration } from \"./encryption-configuration\";\n// import { buildEncryptionConfiguration } from \"./private/util\";\nimport {\n  // Arn,\n  ArnFormat,\n} from \"../arn\";\nimport {\n  AwsConstructBase,\n  IAwsConstruct,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport * as iam from \"../iam\";\n\n/**\n * Properties for defining a new Step Functions Activity\n */\nexport interface ActivityProps extends AwsConstructProps {\n  /**\n   * The name for this activity.\n   *\n   * This name must be unique for your AWS account and region for 90 days.\n   * For more information, see [Limits Related to State Machine Executions][1] in the AWS Step Functions Developer Guide.\n   *\n   * To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.\n   * Length Constraints: Minimum length of 1. Maximum length of 80.\n   *\n   * [1]: https://docs.aws.amazon.com/step-functions/latest/dg/limits.html#service-limits-state-machine-executions\n   *\n   * @default - If not supplied, a name is generated\n   */\n  readonly activityName?: string;\n\n  // /**\n  //  * The encryptionConfiguration object used for server-side encryption of the activity inputs.\n  //  *\n  //  * @default - data is transparently encrypted using an AWS owned key\n  //  */\n  // readonly encryptionConfiguration?: EncryptionConfiguration;\n}\n\nexport interface ActivityOutputs {\n  /**\n   * The Amazon Resource Name (ARN) that identifies the created activity.\n   */\n  readonly arn: string;\n}\n\n/**\n * Represents a Step Functions Activity\n * https://docs.aws.amazon.com/step-functions/latest/dg/concepts-activities.html\n */\nexport interface IActivity extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly activityOutputs: ActivityOutputs;\n\n  /**\n   * The ARN of the activity\n   *\n   * @attribute\n   */\n  readonly activityArn: string;\n\n  /**\n   * The name of the activity\n   *\n   * @attribute\n   */\n  readonly activityName: string;\n\n  // /**\n  //  * The encryptionConfiguration object used for server-side encryption of the activity inputs\n  //  *\n  //  * @attribute\n  //  */\n  // readonly encryptionConfiguration?: EncryptionConfiguration;\n}\n\n/**\n * Define a new Step Functions Activity\n */\nexport class Activity extends AwsConstructBase implements IActivity {\n  /**\n   * Construct an Activity from an existing Activity ARN\n   */\n  public static fromActivityArn(\n    scope: Construct,\n    id: string,\n    activityArn: string,\n  ): IActivity {\n    class Imported extends AwsConstructBase implements IActivity {\n      public get activityOutputs(): ActivityOutputs {\n        return {\n          arn: this.activityArn,\n        };\n      }\n      public get outputs(): Record<string, any> {\n        return this.activityOutputs;\n      }\n      public get activityArn() {\n        return activityArn;\n      }\n      public get activityName() {\n        return (\n          this.stack.splitArn(activityArn, ArnFormat.COLON_RESOURCE_NAME)\n            .resourceName || \"\"\n        );\n      }\n    }\n\n    return new Imported(scope, id);\n  }\n\n  /**\n   * Construct an Activity from an existing Activity Name\n   */\n  public static fromActivityName(\n    scope: Construct,\n    id: string,\n    activityName: string,\n  ): IActivity {\n    return Activity.fromActivityArn(\n      scope,\n      id,\n      AwsStack.ofAwsConstruct(scope).formatArn({\n        service: \"states\",\n        resource: \"activity\",\n        resourceName: activityName,\n        arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n      }),\n    );\n  }\n\n  public get activityOutputs(): ActivityOutputs {\n    return {\n      arn: this.activityArn,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.activityOutputs;\n  }\n  public readonly resource: sfnActivity.SfnActivity;\n\n  /**\n   * @attribute\n   */\n  public readonly activityArn: string;\n\n  /**\n   * @attribute\n   */\n  public readonly activityName: string;\n\n  // /**\n  //  * @attribute\n  //  */\n  // public readonly encryptionConfiguration?: EncryptionConfiguration;\n\n  constructor(scope: Construct, id: string, props: ActivityProps = {}) {\n    super(scope, id, props);\n\n    /**\n     * To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.\n     * Length Constraints: Minimum length of 1. Maximum length of 80.\n     */\n    const resourceName =\n      props.activityName ||\n      Lazy.stringValue({\n        produce: () =>\n          this.stack.uniqueResourceName(this, {\n            prefix: this.gridUUID + \"-\",\n            maxLength: 80,\n            allowedSpecialCharacters: \"-_\",\n          }),\n      });\n\n    // this.encryptionConfiguration = props.encryptionConfiguration;\n    // if (\n    //   props.encryptionConfiguration instanceof\n    //   CustomerManagedEncryptionConfiguration\n    // ) {\n    //   props.encryptionConfiguration.kmsKey.addToResourcePolicy(\n    //     new iam.PolicyStatement({\n    //       resources: [\"*\"],\n    //       actions: [\"kms:Decrypt\", \"kms:GenerateDataKey\"],\n    //       principals: [new iam.ServicePrincipal(\"states.amazonaws.com\")],\n    //       condition: [\n    //         {\n    //           test: \"StringEquals\",\n    //           variable: \"kms:EncryptionContext:aws:states:activityArn\",\n    //           values: [\n    //             this.stack.formatArn({\n    //               service: \"states\",\n    //               resource: \"activity\",\n    //               sep: \":\",\n    //               resourceName,\n    //             }),\n    //           ],\n    //         },\n    //       ],\n    //     }),\n    //   );\n    // }\n\n    this.resource = new sfnActivity.SfnActivity(this, \"Resource\", {\n      name: resourceName,\n      // encryptionConfiguration: buildEncryptionConfiguration(\n      //   props.encryptionConfiguration,\n      // ),\n    });\n\n    this.activityArn = this.resource.id;\n    this.activityName = this.resource.name;\n  }\n\n  /**\n   * Grant the given identity permissions on this Activity\n   *\n   * @param identity The principal\n   * @param actions The list of desired actions\n   */\n  public grant(identity: iam.IGrantable, ...actions: string[]) {\n    return iam.Grant.addToPrincipal({\n      grantee: identity,\n      actions,\n      resourceArns: [this.activityArn],\n    });\n  }\n}\n"]}

package/lib/aws/compute/architecture.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Architectures supported by AWS Lambda
+ */
+export declare class Architecture {
+    /**
+     * 64 bit architecture with x86 instruction set.
+     */
+    static readonly X86_64: Architecture;
+    /**
+     * 64 bit architecture with the ARM instruction set.
+     */
+    static readonly ARM_64: Architecture;
+    /**
+     * Used to specify a custom architecture name.
+     * Use this if the architecture name is not yet supported by the CDK.
+     * @param name the architecture name as recognized by AWS Lambda.
+     * @param [dockerPlatform=linux/amd64] the platform to use for this architecture when building with Docker
+     */
+    static custom(name: string, dockerPlatform?: string): Architecture;
+    /**
+     * The name of the architecture as recognized by the AWS Lambda service APIs.
+     */
+    readonly name: string;
+    /**
+     * The platform to use for this architecture when building with Docker.
+     */
+    readonly dockerPlatform: string;
+    private constructor();
+    /**
+     * Returns a string representation of the architecture using the name
+     */
+    toString(): string;
+}

package/lib/aws/compute/architecture.js

@@ -0,0 +1,42 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Architecture = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-lambda/lib/architecture.ts
+/**
+ * Architectures supported by AWS Lambda
+ */
+class Architecture {
+    /**
+     * Used to specify a custom architecture name.
+     * Use this if the architecture name is not yet supported by the CDK.
+     * @param name the architecture name as recognized by AWS Lambda.
+     * @param [dockerPlatform=linux/amd64] the platform to use for this architecture when building with Docker
+     */
+    static custom(name, dockerPlatform) {
+        return new Architecture(name, dockerPlatform ?? "linux/amd64");
+    }
+    constructor(archName, dockerPlatform) {
+        this.name = archName;
+        this.dockerPlatform = dockerPlatform;
+    }
+    /**
+     * Returns a string representation of the architecture using the name
+     */
+    toString() {
+        return this.name;
+    }
+}
+exports.Architecture = Architecture;
+_a = JSII_RTTI_SYMBOL_1;
+Architecture[_a] = { fqn: "terraconstructs.aws.compute.Architecture", version: "0.0.8" };
+/**
+ * 64 bit architecture with x86 instruction set.
+ */
+Architecture.X86_64 = new Architecture("x86_64", "linux/amd64");
+/**
+ * 64 bit architecture with the ARM instruction set.
+ */
+Architecture.ARM_64 = new Architecture("arm64", "linux/arm64");
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/chain.d.ts

@@ -0,0 +1,52 @@
+import { Parallel, ParallelProps } from "./states/parallel";
+import { State } from "./states/state";
+import { IChainable, INextable } from "./types";
+/**
+ * A collection of states to chain onto
+ *
+ * A Chain has a start and zero or more chainable ends. If there are
+ * zero ends, calling next() on the Chain will fail.
+ */
+export declare class Chain implements IChainable {
+    private readonly lastAdded;
+    /**
+     * Begin a new Chain from one chainable
+     */
+    static start(state: IChainable): Chain;
+    /**
+     * Make a Chain with the start from one chain and the ends from another
+     */
+    static sequence(start: IChainable, next: IChainable): Chain;
+    /**
+     * Make a Chain with specific start and end states, and a last-added Chainable
+     */
+    static custom(startState: State, endStates: INextable[], lastAdded: IChainable): Chain;
+    /**
+     * Identify this Chain
+     */
+    readonly id: string;
+    /**
+     * The start state of this chain
+     */
+    readonly startState: State;
+    /**
+     * The chainable end state(s) of this chain
+     */
+    readonly endStates: INextable[];
+    private constructor();
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+    /**
+     * Return a single state that encompasses all states in the chain
+     *
+     * This can be used to add error handling to a sequence of states.
+     *
+     * 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(id: string, props?: ParallelProps): Parallel;
+}

package/lib/aws/compute/chain.js

@@ -0,0 +1,68 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chain = 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/chain.ts
+const parallel_1 = require("./states/parallel");
+/**
+ * A collection of states to chain onto
+ *
+ * A Chain has a start and zero or more chainable ends. If there are
+ * zero ends, calling next() on the Chain will fail.
+ */
+class Chain {
+    /**
+     * Begin a new Chain from one chainable
+     */
+    static start(state) {
+        return new Chain(state.startState, state.endStates, state);
+    }
+    /**
+     * Make a Chain with the start from one chain and the ends from another
+     */
+    static sequence(start, next) {
+        return new Chain(start.startState, next.endStates, next);
+    }
+    /**
+     * Make a Chain with specific start and end states, and a last-added Chainable
+     */
+    static custom(startState, endStates, lastAdded) {
+        return new Chain(startState, endStates, lastAdded);
+    }
+    constructor(startState, endStates, lastAdded) {
+        this.lastAdded = lastAdded;
+        this.id = lastAdded.id;
+        this.startState = startState;
+        this.endStates = endStates;
+    }
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next) {
+        if (this.endStates.length === 0) {
+            throw new Error(`Cannot add to chain: last state in chain (${this.lastAdded.id}) does not allow it`);
+        }
+        for (const endState of this.endStates) {
+            endState.next(next);
+        }
+        return new Chain(this.startState, next.endStates, next);
+    }
+    /**
+     * Return a single state that encompasses all states in the chain
+     *
+     * This can be used to add error handling to a sequence of states.
+     *
+     * 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(id, props = {}) {
+        return new parallel_1.Parallel(this.startState, id, props).branch(this);
+    }
+}
+exports.Chain = Chain;
+_a = JSII_RTTI_SYMBOL_1;
+Chain[_a] = { fqn: "terraconstructs.aws.compute.Chain", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXdzL2NvbXB1dGUvY2hhaW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxtR0FBbUc7QUFFbkcsZ0RBQTREO0FBSTVEOzs7OztHQUtHO0FBQ0gsTUFBYSxLQUFLO0lBQ2hCOztPQUVHO0lBQ0ksTUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFpQjtRQUNuQyxPQUFPLElBQUksS0FBSyxDQUFDLEtBQUssQ0FBQyxVQUFVLEVBQUUsS0FBSyxDQUFDLFNBQVMsRUFBRSxLQUFLLENBQUMsQ0FBQztJQUM3RCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxNQUFNLENBQUMsUUFBUSxDQUFDLEtBQWlCLEVBQUUsSUFBZ0I7UUFDeEQsT0FBTyxJQUFJLEtBQUssQ0FBQyxLQUFLLENBQUMsVUFBVSxFQUFFLElBQUksQ0FBQyxTQUFTLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDM0QsQ0FBQztJQUVEOztPQUVHO0lBQ0ksTUFBTSxDQUFDLE1BQU0sQ0FDbEIsVUFBaUIsRUFDakIsU0FBc0IsRUFDdEIsU0FBcUI7UUFFckIsT0FBTyxJQUFJLEtBQUssQ0FBQyxVQUFVLEVBQUUsU0FBUyxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQ3JELENBQUM7SUFpQkQsWUFDRSxVQUFpQixFQUNqQixTQUFzQixFQUNMLFNBQXFCO1FBQXJCLGNBQVMsR0FBVCxTQUFTLENBQVk7UUFFdEMsSUFBSSxDQUFDLEVBQUUsR0FBRyxTQUFTLENBQUMsRUFBRSxDQUFDO1FBQ3ZCLElBQUksQ0FBQyxVQUFVLEdBQUcsVUFBVSxDQUFDO1FBQzdCLElBQUksQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDO0lBQzdCLENBQUM7SUFFRDs7T0FFRztJQUNJLElBQUksQ0FBQyxJQUFnQjtRQUMxQixJQUFJLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ2hDLE1BQU0sSUFBSSxLQUFLLENBQ2IsNkNBQTZDLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRSxxQkFBcUIsQ0FDcEYsQ0FBQztRQUNKLENBQUM7UUFFRCxLQUFLLE1BQU0sUUFBUSxJQUFJLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztZQUN0QyxRQUFRLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3RCLENBQUM7UUFFRCxPQUFPLElBQUksS0FBSyxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsSUFBSSxDQUFDLFNBQVMsRUFBRSxJQUFJLENBQUMsQ0FBQztJQUMxRCxDQUFDO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ0ksYUFBYSxDQUFDLEVBQVUsRUFBRSxRQUF1QixFQUFFO1FBQ3hELE9BQU8sSUFBSSxtQkFBUSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsRUFBRSxFQUFFLEtBQUssQ0FBQyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUMvRCxDQUFDOztBQWhGSCxzQkFpRkMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBodHRwczovL2dpdGh1Yi5jb20vYXdzL2F3cy1jZGsvYmxvYi92Mi4xNjAuMC9wYWNrYWdlcy9hd3MtY2RrLWxpYi9hd3Mtc3RlcGZ1bmN0aW9ucy9saWIvY2hhaW4udHNcblxuaW1wb3J0IHsgUGFyYWxsZWwsIFBhcmFsbGVsUHJvcHMgfSBmcm9tIFwiLi9zdGF0ZXMvcGFyYWxsZWxcIjtcbmltcG9ydCB7IFN0YXRlIH0gZnJvbSBcIi4vc3RhdGVzL3N0YXRlXCI7XG5pbXBvcnQgeyBJQ2hhaW5hYmxlLCBJTmV4dGFibGUgfSBmcm9tIFwiLi90eXBlc1wiO1xuXG4vKipcbiAqIEEgY29sbGVjdGlvbiBvZiBzdGF0ZXMgdG8gY2hhaW4gb250b1xuICpcbiAqIEEgQ2hhaW4gaGFzIGEgc3RhcnQgYW5kIHplcm8gb3IgbW9yZSBjaGFpbmFibGUgZW5kcy4gSWYgdGhlcmUgYXJlXG4gKiB6ZXJvIGVuZHMsIGNhbGxpbmcgbmV4dCgpIG9uIHRoZSBDaGFpbiB3aWxsIGZhaWwuXG4gKi9cbmV4cG9ydCBjbGFzcyBDaGFpbiBpbXBsZW1lbnRzIElDaGFpbmFibGUge1xuICAvKipcbiAgICogQmVnaW4gYSBuZXcgQ2hhaW4gZnJvbSBvbmUgY2hhaW5hYmxlXG4gICAqL1xuICBwdWJsaWMgc3RhdGljIHN0YXJ0KHN0YXRlOiBJQ2hhaW5hYmxlKSB7XG4gICAgcmV0dXJuIG5ldyBDaGFpbihzdGF0ZS5zdGFydFN0YXRlLCBzdGF0ZS5lbmRTdGF0ZXMsIHN0YXRlKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBNYWtlIGEgQ2hhaW4gd2l0aCB0aGUgc3RhcnQgZnJvbSBvbmUgY2hhaW4gYW5kIHRoZSBlbmRzIGZyb20gYW5vdGhlclxuICAgKi9cbiAgcHVibGljIHN0YXRpYyBzZXF1ZW5jZShzdGFydDogSUNoYWluYWJsZSwgbmV4dDogSUNoYWluYWJsZSkge1xuICAgIHJldHVybiBuZXcgQ2hhaW4oc3RhcnQuc3RhcnRTdGF0ZSwgbmV4dC5lbmRTdGF0ZXMsIG5leHQpO1xuICB9XG5cbiAgLyoqXG4gICAqIE1ha2UgYSBDaGFpbiB3aXRoIHNwZWNpZmljIHN0YXJ0IGFuZCBlbmQgc3RhdGVzLCBhbmQgYSBsYXN0LWFkZGVkIENoYWluYWJsZVxuICAgKi9cbiAgcHVibGljIHN0YXRpYyBjdXN0b20oXG4gICAgc3RhcnRTdGF0ZTogU3RhdGUsXG4gICAgZW5kU3RhdGVzOiBJTmV4dGFibGVbXSxcbiAgICBsYXN0QWRkZWQ6IElDaGFpbmFibGUsXG4gICkge1xuICAgIHJldHVybiBuZXcgQ2hhaW4oc3RhcnRTdGF0ZSwgZW5kU3RhdGVzLCBsYXN0QWRkZWQpO1xuICB9XG5cbiAgLyoqXG4gICAqIElkZW50aWZ5IHRoaXMgQ2hhaW5cbiAgICovXG4gIHB1YmxpYyByZWFkb25seSBpZDogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBUaGUgc3RhcnQgc3RhdGUgb2YgdGhpcyBjaGFpblxuICAgKi9cbiAgcHVibGljIHJlYWRvbmx5IHN0YXJ0U3RhdGU6IFN0YXRlO1xuXG4gIC8qKlxuICAgKiBUaGUgY2hhaW5hYmxlIGVuZCBzdGF0ZShzKSBvZiB0aGlzIGNoYWluXG4gICAqL1xuICBwdWJsaWMgcmVhZG9ubHkgZW5kU3RhdGVzOiBJTmV4dGFibGVbXTtcblxuICBwcml2YXRlIGNvbnN0cnVjdG9yKFxuICAgIHN0YXJ0U3RhdGU6IFN0YXRlLFxuICAgIGVuZFN0YXRlczogSU5leHRhYmxlW10sXG4gICAgcHJpdmF0ZSByZWFkb25seSBsYXN0QWRkZWQ6IElDaGFpbmFibGUsXG4gICkge1xuICAgIHRoaXMuaWQgPSBsYXN0QWRkZWQuaWQ7XG4gICAgdGhpcy5zdGFydFN0YXRlID0gc3RhcnRTdGF0ZTtcbiAgICB0aGlzLmVuZFN0YXRlcyA9IGVuZFN0YXRlcztcbiAgfVxuXG4gIC8qKlxuICAgKiBDb250aW51ZSBub3JtYWwgZXhlY3V0aW9uIHdpdGggdGhlIGdpdmVuIHN0YXRlXG4gICAqL1xuICBwdWJsaWMgbmV4dChuZXh0OiBJQ2hhaW5hYmxlKTogQ2hhaW4ge1xuICAgIGlmICh0aGlzLmVuZFN0YXRlcy5sZW5ndGggPT09IDApIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgICAgYENhbm5vdCBhZGQgdG8gY2hhaW46IGxhc3Qgc3RhdGUgaW4gY2hhaW4gKCR7dGhpcy5sYXN0QWRkZWQuaWR9KSBkb2VzIG5vdCBhbGxvdyBpdGAsXG4gICAgICApO1xuICAgIH1cblxuICAgIGZvciAoY29uc3QgZW5kU3RhdGUgb2YgdGhpcy5lbmRTdGF0ZXMpIHtcbiAgICAgIGVuZFN0YXRlLm5leHQobmV4dCk7XG4gICAgfVxuXG4gICAgcmV0dXJuIG5ldyBDaGFpbih0aGlzLnN0YXJ0U3RhdGUsIG5leHQuZW5kU3RhdGVzLCBuZXh0KTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZXR1cm4gYSBzaW5nbGUgc3RhdGUgdGhhdCBlbmNvbXBhc3NlcyBhbGwgc3RhdGVzIGluIHRoZSBjaGFpblxuICAgKlxuICAgKiBUaGlzIGNhbiBiZSB1c2VkIHRvIGFkZCBlcnJvciBoYW5kbGluZyB0byBhIHNlcXVlbmNlIG9mIHN0YXRlcy5cbiAgICpcbiAgICogQmUgYXdhcmUgdGhhdCB0aGlzIGNoYW5nZXMgdGhlIHJlc3VsdCBvZiB0aGUgaW5uZXIgc3RhdGUgbWFjaGluZVxuICAgKiB0byBiZSBhbiBhcnJheSB3aXRoIHRoZSByZXN1bHQgb2YgdGhlIHN0YXRlIG1hY2hpbmUgaW4gaXQuIEFkanVzdFxuICAgKiB5b3VyIHBhdGhzIGFjY29yZGluZ2x5LiBGb3IgZXhhbXBsZSwgY2hhbmdlICdvdXRwdXRQYXRoJyB0b1xuICAgKiAnJFswXScuXG4gICAqL1xuICBwdWJsaWMgdG9TaW5nbGVTdGF0ZShpZDogc3RyaW5nLCBwcm9wczogUGFyYWxsZWxQcm9wcyA9IHt9KTogUGFyYWxsZWwge1xuICAgIHJldHVybiBuZXcgUGFyYWxsZWwodGhpcy5zdGFydFN0YXRlLCBpZCwgcHJvcHMpLmJyYW5jaCh0aGlzKTtcbiAgfVxufVxuIl19

package/lib/aws/compute/condition.d.ts

@@ -0,0 +1,202 @@
+/**
+ * A Condition for use in a Choice state branch
+ */
+export declare abstract class Condition {
+    /**
+     * Matches if variable is present
+     */
+    static isPresent(variable: string): Condition;
+    /**
+     * Matches if variable is not present
+     */
+    static isNotPresent(variable: string): Condition;
+    /**
+     * Matches if variable is a string
+     */
+    static isString(variable: string): Condition;
+    /**
+     * Matches if variable is not a string
+     */
+    static isNotString(variable: string): Condition;
+    /**
+     * Matches if variable is numeric
+     */
+    static isNumeric(variable: string): Condition;
+    /**
+     * Matches if variable is not numeric
+     */
+    static isNotNumeric(variable: string): Condition;
+    /**
+     * Matches if variable is boolean
+     */
+    static isBoolean(variable: string): Condition;
+    /**
+     * Matches if variable is not boolean
+     */
+    static isNotBoolean(variable: string): Condition;
+    /**
+     * Matches if variable is a timestamp
+     */
+    static isTimestamp(variable: string): Condition;
+    /**
+     * Matches if variable is not a timestamp
+     */
+    static isNotTimestamp(variable: string): Condition;
+    /**
+     * Matches if variable is not null
+     */
+    static isNotNull(variable: string): Condition;
+    /**
+     * Matches if variable is Null
+     */
+    static isNull(variable: string): Condition;
+    /**
+     * Matches if a boolean field has the given value
+     */
+    static booleanEquals(variable: string, value: boolean): Condition;
+    /**
+     * Matches if a boolean field equals to a value at a given mapping path
+     */
+    static booleanEqualsJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a string field equals to a value at a given mapping path
+     */
+    static stringEqualsJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a string field has the given value
+     */
+    static stringEquals(variable: string, value: string): Condition;
+    /**
+     * Matches if a string field sorts before a given value
+     */
+    static stringLessThan(variable: string, value: string): Condition;
+    /**
+     * Matches if a string field sorts before a given value at a particular mapping
+     */
+    static stringLessThanJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a string field sorts equal to or before a given value
+     */
+    static stringLessThanEquals(variable: string, value: string): Condition;
+    /**
+     * Matches if a string field sorts equal to or before a given mapping
+     */
+    static stringLessThanEqualsJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a string field sorts after a given value
+     */
+    static stringGreaterThan(variable: string, value: string): Condition;
+    /**
+     * Matches if a string field sorts after a value at a given mapping path
+     */
+    static stringGreaterThanJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a string field sorts after or equal to value at a given mapping path
+     */
+    static stringGreaterThanEqualsJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a string field sorts after or equal to a given value
+     */
+    static stringGreaterThanEquals(variable: string, value: string): Condition;
+    /**
+     * Matches if a numeric field has the given value
+     */
+    static numberEquals(variable: string, value: number): Condition;
+    /**
+     * Matches if a numeric field has the value in a given mapping path
+     */
+    static numberEqualsJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a numeric field is less than the given value
+     */
+    static numberLessThan(variable: string, value: number): Condition;
+    /**
+     * Matches if a numeric field is less than the value at the given mapping path
+     */
+    static numberLessThanJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a numeric field is less than or equal to the given value
+     */
+    static numberLessThanEquals(variable: string, value: number): Condition;
+    /**
+     * Matches if a numeric field is less than or equal to the numeric value at given mapping path
+     */
+    static numberLessThanEqualsJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a numeric field is greater than the given value
+     */
+    static numberGreaterThan(variable: string, value: number): Condition;
+    /**
+     * Matches if a numeric field is greater than the value at a given mapping path
+     */
+    static numberGreaterThanJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a numeric field is greater than or equal to the given value
+     */
+    static numberGreaterThanEquals(variable: string, value: number): Condition;
+    /**
+     * Matches if a numeric field is greater than or equal to the value at a given mapping path
+     */
+    static numberGreaterThanEqualsJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a timestamp field is the same time as the given timestamp
+     */
+    static timestampEquals(variable: string, value: string): Condition;
+    /**
+     * Matches if a timestamp field is the same time as the timestamp at a given mapping path
+     */
+    static timestampEqualsJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a timestamp field is before the given timestamp
+     */
+    static timestampLessThan(variable: string, value: string): Condition;
+    /**
+     * Matches if a timestamp field is before the timestamp at a given mapping path
+     */
+    static timestampLessThanJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a timestamp field is before or equal to the given timestamp
+     */
+    static timestampLessThanEquals(variable: string, value: string): Condition;
+    /**
+     * Matches if a timestamp field is before or equal to the timestamp at a given mapping path
+     */
+    static timestampLessThanEqualsJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a timestamp field is after the given timestamp
+     */
+    static timestampGreaterThan(variable: string, value: string): Condition;
+    /**
+     * Matches if a timestamp field is after the timestamp at a given mapping path
+     */
+    static timestampGreaterThanJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a timestamp field is after or equal to the given timestamp
+     */
+    static timestampGreaterThanEquals(variable: string, value: string): Condition;
+    /**
+     * Matches if a timestamp field is after or equal to the timestamp at a given mapping path
+     */
+    static timestampGreaterThanEqualsJsonPath(variable: string, value: string): Condition;
+    /**
+     * Matches if a field matches a string pattern that can contain a wild card (*) e.g: log-*.txt or *LATEST*.
+     * No other characters other than "*" have any special meaning - * can be escaped: \\*
+     */
+    static stringMatches(variable: string, value: string): Condition;
+    /**
+     * Combine two or more conditions with a logical AND
+     */
+    static and(...conditions: Condition[]): Condition;
+    /**
+     * Combine two or more conditions with a logical OR
+     */
+    static or(...conditions: Condition[]): Condition;
+    /**
+     * Negate a condition
+     */
+    static not(condition: Condition): Condition;
+    /**
+     * Render Amazon States Language JSON for the condition
+     */
+    abstract renderCondition(): any;
+}