terraconstructs 0.0.8

package/lib/aws/cloudwatch/text.d.ts

@@ -0,0 +1,52 @@
+import { Construct } from "constructs";
+import { ConcreteWidget } from "./widget";
+/**
+ * Background types available
+ */
+export declare enum TextWidgetBackground {
+    /**
+     * Solid background
+     */
+    SOLID = "solid",
+    /**
+     * Transparent background
+     */
+    TRANSPARENT = "transparent"
+}
+/**
+ * Properties for a Text widget
+ */
+export interface TextWidgetProps {
+    /**
+     * The text to display, in MarkDown format
+     */
+    readonly markdown: string;
+    /**
+     * Width of the widget, in a grid of 24 units wide
+     *
+     * @default 6
+     */
+    readonly width?: number;
+    /**
+     * Height of the widget
+     *
+     * @default 2
+     */
+    readonly height?: number;
+    /**
+     * Background for the widget
+     *
+     * @default solid
+     */
+    readonly background?: TextWidgetBackground;
+}
+/**
+ * A dashboard widget that displays MarkDown
+ */
+export declare class TextWidget extends ConcreteWidget {
+    private readonly markdown;
+    private readonly background?;
+    constructor(scope: Construct, props: TextWidgetProps);
+    position(x: number, y: number): void;
+    toJson(): any[];
+}

package/lib/aws/cloudwatch/text.js

@@ -0,0 +1,53 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextWidget = exports.TextWidgetBackground = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const widget_1 = require("./widget");
+/**
+ * Background types available
+ */
+var TextWidgetBackground;
+(function (TextWidgetBackground) {
+    /**
+     * Solid background
+     */
+    TextWidgetBackground["SOLID"] = "solid";
+    /**
+     * Transparent background
+     */
+    TextWidgetBackground["TRANSPARENT"] = "transparent";
+})(TextWidgetBackground || (exports.TextWidgetBackground = TextWidgetBackground = {}));
+/**
+ * A dashboard widget that displays MarkDown
+ */
+class TextWidget extends widget_1.ConcreteWidget {
+    constructor(scope, props) {
+        super(scope, props.width || 6, props.height || 2);
+        this.markdown = props.markdown;
+        this.background = props.background;
+    }
+    position(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    toJson() {
+        return [
+            {
+                type: "text",
+                width: this.width,
+                height: this.height,
+                x: this.x,
+                y: this.y,
+                properties: {
+                    markdown: this.markdown,
+                    background: this.background,
+                },
+            },
+        ];
+    }
+}
+exports.TextWidget = TextWidget;
+_a = JSII_RTTI_SYMBOL_1;
+TextWidget[_a] = { fqn: "terraconstructs.aws.cloudwatch.TextWidget", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/cloudwatch/variable.d.ts

@@ -0,0 +1,156 @@
+export declare enum VariableInputType {
+    /**
+     * Freeform text input box
+     */
+    INPUT = "input",
+    /**
+     * A dropdown of pre-defined values, or values filled in from a metric search query
+     */
+    RADIO = "radio",
+    /**
+     * A set of pre-defined radio buttons, which can also be defined from a metric search query
+     */
+    SELECT = "select"
+}
+export declare enum VariableType {
+    /**
+     * A property variable changes the values of all instances of a property in the list of widgets in the dashboard.
+     */
+    PROPERTY = "property",
+    /**
+     * A pattern variable is one that changes a regex pattern across the dashboard JSON
+     */
+    PATTERN = "pattern"
+}
+/**
+ * A single dashboard variable
+ */
+export interface IVariable {
+    /**
+     * Return the variable JSON for use in the dashboard
+     */
+    toJson(): any;
+}
+export interface VariableValue {
+    /**
+     * Optional label for the selected item
+     *
+     * @default - the variable's value
+     */
+    readonly label?: string;
+    /**
+     * Value of the selected item
+     */
+    readonly value: string;
+}
+/**
+ * Search components for use with {@link Values.fromSearchComponents}
+ */
+export interface SearchComponents {
+    /**
+     * The namespace to be used in the search expression
+     */
+    readonly namespace: string;
+    /**
+     * The list of dimensions to be used in the search expression
+     */
+    readonly dimensions: string[];
+    /**
+     * The metric name to be used in the search expression
+     */
+    readonly metricName: string;
+    /**
+     * The dimension name, that the search expression retrieves, whose values will be used to populate the values to choose from
+     */
+    readonly populateFrom: string;
+}
+/**
+ * A class for providing values for use with {@link VariableInputType.SELECT} and {@link VariableInputType.RADIO} dashboard variables
+ */
+export declare abstract class Values {
+    /**
+     * Create values from the components of search expression
+     */
+    static fromSearchComponents(components: SearchComponents): Values;
+    /**
+     * Create values from a search expression
+     *
+     * @param expression search expression that specifies a namespace, dimension name(s) and a metric name. For example `{AWS/EC2,InstanceId} MetricName=\"CPUUtilization\"`
+     * @param populateFrom dimension the dimension name, that the search expression retrieves, whose values will be used to populate the values to choose from. For example `InstanceId`
+     */
+    static fromSearch(expression: string, populateFrom: string): Values;
+    /**
+     * Create values from an array of possible variable values
+     */
+    static fromValues(...values: VariableValue[]): Values;
+    abstract toJson(): any;
+}
+/**
+ * Default value for use in {@link DashboardVariableOptions}
+ */
+export declare class DefaultValue {
+    readonly val: any;
+    /**
+     * A special value for use with search expressions to have the default value be the first value returned from search
+     */
+    static readonly FIRST: DefaultValue;
+    /**
+     * Create a default value
+     * @param value the value to be used as default
+     */
+    static value(value: any): DefaultValue;
+    private constructor();
+}
+/**
+ * Options for {@link DashboardVariable}
+ */
+export interface DashboardVariableOptions {
+    /**
+     * Type of the variable
+     */
+    readonly type: VariableType;
+    /**
+     * The way the variable value is selected
+     */
+    readonly inputType: VariableInputType;
+    /**
+     * Pattern or property value to replace
+     */
+    readonly value: string;
+    /**
+     * Unique id
+     */
+    readonly id: string;
+    /**
+     * Optional label in the toolbar
+     *
+     * @default - the variable's value
+     */
+    readonly label?: string;
+    /**
+     * Optional values (required for {@link VariableInputType.RADIO} and {@link VariableInputType.SELECT} dashboard variables).
+     *
+     * @default - no values
+     */
+    readonly values?: Values;
+    /**
+     * Optional default value
+     *
+     * @default - no default value is set
+     */
+    readonly defaultValue?: DefaultValue;
+    /**
+     * Whether the variable is visible
+     *
+     * @default - true
+     */
+    readonly visible?: boolean;
+}
+/**
+ * Dashboard Variable
+ */
+export declare class DashboardVariable implements IVariable {
+    private readonly options;
+    constructor(options: DashboardVariableOptions);
+    toJson(): any;
+}

package/lib/aws/cloudwatch/variable.js

@@ -0,0 +1,156 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardVariable = exports.DefaultValue = exports.Values = exports.VariableType = exports.VariableInputType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/variable.ts
+var VariableInputType;
+(function (VariableInputType) {
+    /**
+     * Freeform text input box
+     */
+    VariableInputType["INPUT"] = "input";
+    /**
+     * A dropdown of pre-defined values, or values filled in from a metric search query
+     */
+    VariableInputType["RADIO"] = "radio";
+    /**
+     * A set of pre-defined radio buttons, which can also be defined from a metric search query
+     */
+    VariableInputType["SELECT"] = "select";
+})(VariableInputType || (exports.VariableInputType = VariableInputType = {}));
+var VariableType;
+(function (VariableType) {
+    /**
+     * A property variable changes the values of all instances of a property in the list of widgets in the dashboard.
+     */
+    VariableType["PROPERTY"] = "property";
+    /**
+     * A pattern variable is one that changes a regex pattern across the dashboard JSON
+     */
+    VariableType["PATTERN"] = "pattern";
+})(VariableType || (exports.VariableType = VariableType = {}));
+/**
+ * A class for providing values for use with {@link VariableInputType.SELECT} and {@link VariableInputType.RADIO} dashboard variables
+ */
+class Values {
+    /**
+     * Create values from the components of search expression
+     */
+    static fromSearchComponents(components) {
+        if (components.dimensions.length === 0) {
+            throw new Error("Empty dimensions provided. Please specify one dimension at least");
+        }
+        if (!components.dimensions.includes(components.populateFrom)) {
+            throw new Error(`populateFrom (${components.populateFrom}) is not present in dimensions`);
+        }
+        const metricSchema = [components.namespace, ...components.dimensions];
+        return Values.fromSearch(`{${metricSchema.join(",")}} MetricName=\"${components.metricName}\"`, components.populateFrom);
+    }
+    /**
+     * Create values from a search expression
+     *
+     * @param expression search expression that specifies a namespace, dimension name(s) and a metric name. For example `{AWS/EC2,InstanceId} MetricName=\"CPUUtilization\"`
+     * @param populateFrom dimension the dimension name, that the search expression retrieves, whose values will be used to populate the values to choose from. For example `InstanceId`
+     */
+    static fromSearch(expression, populateFrom) {
+        return new SearchValues(expression, populateFrom);
+    }
+    /**
+     * Create values from an array of possible variable values
+     */
+    static fromValues(...values) {
+        if (values.length == 0) {
+            throw new Error("Empty values is not allowed");
+        }
+        return new StaticValues(values);
+    }
+}
+exports.Values = Values;
+_a = JSII_RTTI_SYMBOL_1;
+Values[_a] = { fqn: "terraconstructs.aws.cloudwatch.Values", version: "0.0.8" };
+class StaticValues extends Values {
+    constructor(values) {
+        super();
+        this.values = values;
+    }
+    toJson() {
+        return {
+            values: this.values.map((value) => ({
+                label: value.label,
+                value: value.value,
+            })),
+        };
+    }
+}
+class SearchValues extends Values {
+    /**
+     * Create a search expression for use
+     *
+     * @param expression search expression that specifies a namespace, dimension name(s) and a metric name. For example `{AWS/EC2,InstanceId} MetricName=\"CPUUtilization\"`
+     * @param populateFrom dimension the dimension name, that the search expression retrieves, whose values will be used to populate the values to choose from. For example `InstanceId`
+     */
+    constructor(expression, populateFrom) {
+        super();
+        this.expression = expression;
+        this.populateFrom = populateFrom;
+    }
+    toJson() {
+        return {
+            search: this.expression,
+            populateFrom: this.populateFrom,
+        };
+    }
+}
+/**
+ * Default value for use in {@link DashboardVariableOptions}
+ */
+class DefaultValue {
+    /**
+     * Create a default value
+     * @param value the value to be used as default
+     */
+    static value(value) {
+        return new DefaultValue(value);
+    }
+    constructor(val) {
+        this.val = val;
+    }
+}
+exports.DefaultValue = DefaultValue;
+_b = JSII_RTTI_SYMBOL_1;
+DefaultValue[_b] = { fqn: "terraconstructs.aws.cloudwatch.DefaultValue", version: "0.0.8" };
+/**
+ * A special value for use with search expressions to have the default value be the first value returned from search
+ */
+DefaultValue.FIRST = new DefaultValue("__FIRST");
+/**
+ * Dashboard Variable
+ */
+class DashboardVariable {
+    constructor(options) {
+        this.options = options;
+        if (options.inputType !== VariableInputType.INPUT && !options.values) {
+            throw new Error(`Variable with inputType (${options.inputType}) requires values to be set`);
+        }
+        if (options.inputType == VariableInputType.INPUT && options.values) {
+            throw new Error("inputType INPUT cannot be combined with values. Please choose either SELECT or RADIO or remove 'values' from options.");
+        }
+    }
+    toJson() {
+        return {
+            [this.options.type]: this.options.value,
+            type: this.options.type,
+            inputType: this.options.inputType,
+            id: this.options.id,
+            defaultValue: this.options.defaultValue?.val,
+            visible: this.options.visible,
+            label: this.options.label,
+            ...this.options.values?.toJson(),
+        };
+    }
+}
+exports.DashboardVariable = DashboardVariable;
+_c = JSII_RTTI_SYMBOL_1;
+DashboardVariable[_c] = { fqn: "terraconstructs.aws.cloudwatch.DashboardVariable", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"variable.js","sourceRoot":"","sources":["../../../src/aws/cloudwatch/variable.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/variable.ts\n\nexport enum VariableInputType {\n  /**\n   * Freeform text input box\n   */\n  INPUT = \"input\",\n\n  /**\n   * A dropdown of pre-defined values, or values filled in from a metric search query\n   */\n  RADIO = \"radio\",\n\n  /**\n   * A set of pre-defined radio buttons, which can also be defined from a metric search query\n   */\n  SELECT = \"select\",\n}\n\nexport enum VariableType {\n  /**\n   * A property variable changes the values of all instances of a property in the list of widgets in the dashboard.\n   */\n  PROPERTY = \"property\",\n\n  /**\n   * A pattern variable is one that changes a regex pattern across the dashboard JSON\n   */\n  PATTERN = \"pattern\",\n}\n\n/**\n * A single dashboard variable\n */\nexport interface IVariable {\n  /**\n   * Return the variable JSON for use in the dashboard\n   */\n  toJson(): any;\n}\n\nexport interface VariableValue {\n  /**\n   * Optional label for the selected item\n   *\n   * @default - the variable's value\n   */\n  readonly label?: string;\n\n  /**\n   * Value of the selected item\n   */\n  readonly value: string;\n}\n\n/**\n * Search components for use with {@link Values.fromSearchComponents}\n */\nexport interface SearchComponents {\n  /**\n   * The namespace to be used in the search expression\n   */\n  readonly namespace: string;\n\n  /**\n   * The list of dimensions to be used in the search expression\n   */\n  readonly dimensions: string[];\n\n  /**\n   * The metric name to be used in the search expression\n   */\n  readonly metricName: string;\n\n  /**\n   * The dimension name, that the search expression retrieves, whose values will be used to populate the values to choose from\n   */\n  readonly populateFrom: string;\n}\n\n/**\n * A class for providing values for use with {@link VariableInputType.SELECT} and {@link VariableInputType.RADIO} dashboard variables\n */\nexport abstract class Values {\n  /**\n   * Create values from the components of search expression\n   */\n  public static fromSearchComponents(components: SearchComponents): Values {\n    if (components.dimensions.length === 0) {\n      throw new Error(\n        \"Empty dimensions provided. Please specify one dimension at least\",\n      );\n    }\n    if (!components.dimensions.includes(components.populateFrom)) {\n      throw new Error(\n        `populateFrom (${components.populateFrom}) is not present in dimensions`,\n      );\n    }\n    const metricSchema = [components.namespace, ...components.dimensions];\n    return Values.fromSearch(\n      `{${metricSchema.join(\",\")}} MetricName=\\\"${components.metricName}\\\"`,\n      components.populateFrom,\n    );\n  }\n\n  /**\n   * Create values from a search expression\n   *\n   * @param expression search expression that specifies a namespace, dimension name(s) and a metric name. For example `{AWS/EC2,InstanceId} MetricName=\\\"CPUUtilization\\\"`\n   * @param populateFrom dimension the dimension name, that the search expression retrieves, whose values will be used to populate the values to choose from. For example `InstanceId`\n   */\n  public static fromSearch(expression: string, populateFrom: string): Values {\n    return new SearchValues(expression, populateFrom);\n  }\n\n  /**\n   * Create values from an array of possible variable values\n   */\n  public static fromValues(...values: VariableValue[]): Values {\n    if (values.length == 0) {\n      throw new Error(\"Empty values is not allowed\");\n    }\n    return new StaticValues(values);\n  }\n\n  public abstract toJson(): any;\n}\n\nclass StaticValues extends Values {\n  constructor(private readonly values: VariableValue[]) {\n    super();\n  }\n\n  toJson(): any {\n    return {\n      values: this.values.map((value) => ({\n        label: value.label,\n        value: value.value,\n      })),\n    };\n  }\n}\n\nclass SearchValues extends Values {\n  /**\n   * Create a search expression for use\n   *\n   * @param expression search expression that specifies a namespace, dimension name(s) and a metric name. For example `{AWS/EC2,InstanceId} MetricName=\\\"CPUUtilization\\\"`\n   * @param populateFrom dimension the dimension name, that the search expression retrieves, whose values will be used to populate the values to choose from. For example `InstanceId`\n   */\n  public constructor(\n    public readonly expression: string,\n    public readonly populateFrom: string,\n  ) {\n    super();\n  }\n\n  toJson(): any {\n    return {\n      search: this.expression,\n      populateFrom: this.populateFrom,\n    };\n  }\n}\n\n/**\n * Default value for use in {@link DashboardVariableOptions}\n */\nexport class DefaultValue {\n  /**\n   * A special value for use with search expressions to have the default value be the first value returned from search\n   */\n  public static readonly FIRST = new DefaultValue(\"__FIRST\");\n\n  /**\n   * Create a default value\n   * @param value the value to be used as default\n   */\n  public static value(value: any) {\n    return new DefaultValue(value);\n  }\n\n  private constructor(public readonly val: any) {}\n}\n\n/**\n * Options for {@link DashboardVariable}\n */\nexport interface DashboardVariableOptions {\n  /**\n   * Type of the variable\n   */\n  readonly type: VariableType;\n\n  /**\n   * The way the variable value is selected\n   */\n  readonly inputType: VariableInputType;\n\n  /**\n   * Pattern or property value to replace\n   */\n  readonly value: string;\n\n  /**\n   * Unique id\n   */\n  readonly id: string;\n\n  /**\n   * Optional label in the toolbar\n   *\n   * @default - the variable's value\n   */\n  readonly label?: string;\n\n  /**\n   * Optional values (required for {@link VariableInputType.RADIO} and {@link VariableInputType.SELECT} dashboard variables).\n   *\n   * @default - no values\n   */\n  readonly values?: Values;\n\n  /**\n   * Optional default value\n   *\n   * @default - no default value is set\n   */\n  readonly defaultValue?: DefaultValue;\n\n  /**\n   * Whether the variable is visible\n   *\n   * @default - true\n   */\n  readonly visible?: boolean;\n}\n\n/**\n * Dashboard Variable\n */\nexport class DashboardVariable implements IVariable {\n  public constructor(private readonly options: DashboardVariableOptions) {\n    if (options.inputType !== VariableInputType.INPUT && !options.values) {\n      throw new Error(\n        `Variable with inputType (${options.inputType}) requires values to be set`,\n      );\n    }\n    if (options.inputType == VariableInputType.INPUT && options.values) {\n      throw new Error(\n        \"inputType INPUT cannot be combined with values. Please choose either SELECT or RADIO or remove 'values' from options.\",\n      );\n    }\n  }\n\n  toJson(): any {\n    return {\n      [this.options.type]: this.options.value,\n      type: this.options.type,\n      inputType: this.options.inputType,\n      id: this.options.id,\n      defaultValue: this.options.defaultValue?.val,\n      visible: this.options.visible,\n      label: this.options.label,\n      ...this.options.values?.toJson(),\n    };\n  }\n}\n"]}

package/lib/aws/cloudwatch/widget.d.ts

@@ -0,0 +1,62 @@
+import { Construct } from "constructs";
+import { AwsStack } from "../";
+import { IMetric } from "./metric-types";
+/**
+ * The width of the grid we're filling
+ */
+export declare const GRID_WIDTH = 24;
+/**
+ * A single dashboard widget
+ */
+export interface IWidget {
+    /**
+     * The amount of horizontal grid units the widget will take up
+     */
+    readonly width: number;
+    /**
+     * The amount of vertical grid units the widget will take up
+     */
+    readonly height: number;
+    /**
+     * Any warnings that are produced as a result of putting together this widget
+     * @deprecated - use warningsV2
+     */
+    readonly warnings?: string[];
+    /**
+     * Any warnings that are produced as a result of putting together this widget
+     */
+    readonly warningsV2?: {
+        [id: string]: string;
+    };
+    /**
+     * Place the widget at a given position
+     */
+    position(x: number, y: number): void;
+    /**
+     * Return the widget JSON for use in the dashboard
+     */
+    toJson(): any[];
+}
+/**
+ * A real CloudWatch widget that has its own fixed size and remembers its position
+ *
+ * This is in contrast to other widgets which exist for layout purposes.
+ */
+export declare abstract class ConcreteWidget implements IWidget {
+    readonly width: number;
+    readonly height: number;
+    protected x?: number;
+    protected y?: number;
+    protected stack: AwsStack;
+    readonly warnings: string[] | undefined;
+    readonly warningsV2: {
+        [id: string]: string;
+    } | undefined;
+    constructor(scope: Construct, width: number, height: number);
+    position(x: number, y: number): void;
+    abstract toJson(): any[];
+    /**
+     * Copy the warnings from the given metric
+     */
+    protected copyMetricWarnings(...ms: IMetric[]): void;
+}

package/lib/aws/cloudwatch/widget.js

@@ -0,0 +1,45 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConcreteWidget = exports.GRID_WIDTH = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const __1 = require("../");
+/**
+ * The width of the grid we're filling
+ */
+exports.GRID_WIDTH = 24;
+/**
+ * A real CloudWatch widget that has its own fixed size and remembers its position
+ *
+ * This is in contrast to other widgets which exist for layout purposes.
+ */
+class ConcreteWidget {
+    constructor(scope, width, height) {
+        this.warnings = [];
+        this.warningsV2 = {};
+        this.width = width;
+        this.height = height;
+        this.stack = __1.AwsStack.ofAwsConstruct(scope);
+        if (this.width > exports.GRID_WIDTH) {
+            throw new Error(`Widget is too wide, max ${exports.GRID_WIDTH} units allowed`);
+        }
+    }
+    position(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    /**
+     * Copy the warnings from the given metric
+     */
+    copyMetricWarnings(...ms) {
+        ms.forEach((m) => {
+            for (const [id, message] of Object.entries(m.warningsV2 ?? {})) {
+                this.warningsV2[id] = message;
+            }
+        });
+    }
+}
+exports.ConcreteWidget = ConcreteWidget;
+_a = JSII_RTTI_SYMBOL_1;
+ConcreteWidget[_a] = { fqn: "terraconstructs.aws.cloudwatch.ConcreteWidget", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,81 @@
+import { sfnActivity } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructBase, IAwsConstruct, AwsConstructProps } from "../aws-construct";
+import * as iam from "../iam";
+/**
+ * Properties for defining a new Step Functions Activity
+ */
+export interface ActivityProps extends AwsConstructProps {
+    /**
+     * The name for this activity.
+     *
+     * This name must be unique for your AWS account and region for 90 days.
+     * For more information, see [Limits Related to State Machine Executions][1] in the AWS Step Functions Developer Guide.
+     *
+     * 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.
+     *
+     * [1]: https://docs.aws.amazon.com/step-functions/latest/dg/limits.html#service-limits-state-machine-executions
+     *
+     * @default - If not supplied, a name is generated
+     */
+    readonly activityName?: string;
+}
+export interface ActivityOutputs {
+    /**
+     * The Amazon Resource Name (ARN) that identifies the created activity.
+     */
+    readonly arn: string;
+}
+/**
+ * Represents a Step Functions Activity
+ * https://docs.aws.amazon.com/step-functions/latest/dg/concepts-activities.html
+ */
+export interface IActivity extends IAwsConstruct {
+    /** Strongly typed outputs */
+    readonly activityOutputs: ActivityOutputs;
+    /**
+     * The ARN of the activity
+     *
+     * @attribute
+     */
+    readonly activityArn: string;
+    /**
+     * The name of the activity
+     *
+     * @attribute
+     */
+    readonly activityName: string;
+}
+/**
+ * Define a new Step Functions Activity
+ */
+export declare class Activity extends AwsConstructBase implements IActivity {
+    /**
+     * Construct an Activity from an existing Activity ARN
+     */
+    static fromActivityArn(scope: Construct, id: string, activityArn: string): IActivity;
+    /**
+     * Construct an Activity from an existing Activity Name
+     */
+    static fromActivityName(scope: Construct, id: string, activityName: string): IActivity;
+    get activityOutputs(): ActivityOutputs;
+    get outputs(): Record<string, any>;
+    readonly resource: sfnActivity.SfnActivity;
+    /**
+     * @attribute
+     */
+    readonly activityArn: string;
+    /**
+     * @attribute
+     */
+    readonly activityName: string;
+    constructor(scope: Construct, id: string, props?: ActivityProps);
+    /**
+     * Grant the given identity permissions on this Activity
+     *
+     * @param identity The principal
+     * @param actions The list of desired actions
+     */
+    grant(identity: iam.IGrantable, ...actions: string[]): iam.Grant;
+}