terraconstructs 0.0.8

package/lib/aws/notify/connection.js

@@ -0,0 +1,261 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMethod = exports.Connection = exports.HttpParameter = exports.Authorization = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+/**
+ * Authorization type for an API Destination Connection
+ */
+class Authorization {
+    /**
+     * Use API key authorization
+     *
+     * API key authorization has two components: an API key name and an API key value.
+     * What these are depends on the target of your connection.
+     */
+    static apiKey(apiKeyName, apiKeyValue) {
+        return new (class extends Authorization {
+            _bind() {
+                let authParameters = {
+                    apiKey: {
+                        key: apiKeyName,
+                        value: apiKeyValue, // TODO: Flag as sensitive?
+                    },
+                };
+                return {
+                    authorizationType: AuthorizationType.API_KEY,
+                    authParameters,
+                };
+            }
+        })();
+    }
+    /**
+     * Use username and password authorization
+     */
+    static basic(username, password) {
+        return new (class extends Authorization {
+            _bind() {
+                let authParameters = {
+                    basic: {
+                        username: username,
+                        password: password, // TODO: Flag as sensitive?
+                    },
+                };
+                return {
+                    authorizationType: AuthorizationType.BASIC,
+                    authParameters,
+                };
+            }
+        })();
+    }
+    /**
+     * Use OAuth authorization
+     */
+    static oauth(props) {
+        if (![HttpMethod.POST, HttpMethod.GET, HttpMethod.PUT].includes(props.httpMethod)) {
+            throw new Error("httpMethod must be one of GET, POST, PUT");
+        }
+        return new (class extends Authorization {
+            _bind() {
+                let authParameters = {
+                    oauth: {
+                        authorizationEndpoint: props.authorizationEndpoint,
+                        clientParameters: {
+                            clientId: props.clientId,
+                            clientSecret: props.clientSecret, // TODO: Flag as sensitive?
+                        },
+                        httpMethod: props.httpMethod,
+                        oauthHttpParameters: {
+                            body: renderHttpParameters(props.bodyParameters),
+                            header: renderHttpParameters(props.headerParameters),
+                            queryString: renderHttpParameters(props.queryStringParameters),
+                        },
+                    },
+                };
+                return {
+                    authorizationType: AuthorizationType.OAUTH_CLIENT_CREDENTIALS,
+                    authParameters,
+                };
+            }
+        })();
+    }
+}
+exports.Authorization = Authorization;
+_a = JSII_RTTI_SYMBOL_1;
+Authorization[_a] = { fqn: "terraconstructs.aws.notify.Authorization", version: "0.0.8" };
+/**
+ * An additional HTTP parameter to send along with the OAuth request
+ */
+class HttpParameter {
+    /**
+     * Make an OAuthParameter from a string value
+     *
+     * The value is not treated as a secret.
+     */
+    static fromString(value) {
+        return new (class extends HttpParameter {
+            _render(name) {
+                return {
+                    key: name,
+                    value,
+                    isValueSecret: false,
+                };
+            }
+        })();
+    }
+    /**
+     * Make an OAuthParameter from a secret
+     */
+    static fromSecret(value) {
+        return new (class extends HttpParameter {
+            _render(name) {
+                return {
+                    key: name,
+                    value, // TODO: Flag as secret
+                    isValueSecret: true,
+                };
+            }
+        })();
+    }
+}
+exports.HttpParameter = HttpParameter;
+_b = JSII_RTTI_SYMBOL_1;
+HttpParameter[_b] = { fqn: "terraconstructs.aws.notify.HttpParameter", version: "0.0.8" };
+/**
+ * Define an EventBridge Connection
+ *
+ * @resource aws_cloudwatch_event_connection
+ */
+class Connection extends aws_construct_1.AwsConstructBase {
+    /**
+     * Import an existing connection resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param connectionArn ARN of imported connection
+     */
+    static fromEventBusArn(scope, id, connectionArn, connectionSecretArn) {
+        const parts = aws_stack_1.AwsStack.ofAwsConstruct(scope).parseArn(connectionArn);
+        return new ImportedConnection(scope, id, {
+            connectionArn: connectionArn,
+            connectionName: parts.resourceName || "",
+            connectionSecretArn: connectionSecretArn,
+        });
+    }
+    /**
+     * Import an existing connection resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param attrs Imported connection properties
+     */
+    static fromConnectionAttributes(scope, id, attrs) {
+        return new ImportedConnection(scope, id, attrs);
+    }
+    get outputs() {
+        return this.connectionOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        /**
+         * Maximum of 64 characters consisting of numbers, lower/upper case letters, .,-,_.
+         */
+        const connectionName = props.connectionName ??
+            this.stack.uniqueResourceName(this, {
+                maxLength: 64,
+                allowedSpecialCharacters: ".-_",
+            });
+        const authBind = props.authorization._bind();
+        const invocationHttpParameters = !!props.headerParameters ||
+            !!props.queryStringParameters ||
+            !!props.bodyParameters
+            ? {
+                body: renderHttpParameters(props.bodyParameters),
+                header: renderHttpParameters(props.headerParameters),
+                queryString: renderHttpParameters(props.queryStringParameters),
+            }
+            : undefined;
+        this.resource = new provider_aws_1.cloudwatchEventConnection.CloudwatchEventConnection(this, "Resource", {
+            authorizationType: authBind.authorizationType,
+            authParameters: {
+                ...authBind.authParameters,
+                invocationHttpParameters: invocationHttpParameters,
+            },
+            description: props.description,
+            name: connectionName,
+        });
+        this.connectionName = this.resource.name;
+        this.connectionArn = this.resource.arn;
+        this.connectionSecretArn = this.resource.secretArn;
+        this.connectionOutputs = {
+            name: this.connectionName,
+            arn: this.connectionArn,
+            secretArn: this.connectionSecretArn,
+        };
+    }
+}
+exports.Connection = Connection;
+_c = JSII_RTTI_SYMBOL_1;
+Connection[_c] = { fqn: "terraconstructs.aws.notify.Connection", version: "0.0.8" };
+class ImportedConnection extends aws_construct_1.AwsConstructBase {
+    get connectionOutputs() {
+        return {
+            name: this.connectionName,
+            arn: this.connectionArn,
+            secretArn: this.connectionSecretArn,
+        };
+    }
+    get outputs() {
+        return this.connectionOutputs;
+    }
+    constructor(scope, id, attrs) {
+        const arnParts = aws_stack_1.AwsStack.ofAwsConstruct(scope).parseArn(attrs.connectionArn);
+        super(scope, id, {
+            account: arnParts.account,
+            region: arnParts.region,
+        });
+        this.connectionArn = attrs.connectionArn;
+        this.connectionName = attrs.connectionName;
+        this.connectionSecretArn = attrs.connectionSecretArn;
+    }
+}
+/**
+ * Supported HTTP operations.
+ */
+var HttpMethod;
+(function (HttpMethod) {
+    /** POST */
+    HttpMethod["POST"] = "POST";
+    /** GET */
+    HttpMethod["GET"] = "GET";
+    /** HEAD */
+    HttpMethod["HEAD"] = "HEAD";
+    /** OPTIONS */
+    HttpMethod["OPTIONS"] = "OPTIONS";
+    /** PUT */
+    HttpMethod["PUT"] = "PUT";
+    /** PATCH */
+    HttpMethod["PATCH"] = "PATCH";
+    /** DELETE */
+    HttpMethod["DELETE"] = "DELETE";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+/**
+ * Supported Authorization Types.
+ */
+var AuthorizationType;
+(function (AuthorizationType) {
+    /** API_KEY */
+    AuthorizationType["API_KEY"] = "API_KEY";
+    /** BASIC */
+    AuthorizationType["BASIC"] = "BASIC";
+    /** OAUTH_CLIENT_CREDENTIALS */
+    AuthorizationType["OAUTH_CLIENT_CREDENTIALS"] = "OAUTH_CLIENT_CREDENTIALS";
+})(AuthorizationType || (AuthorizationType = {}));
+function renderHttpParameters(ps) {
+    if (!ps || Object.keys(ps).length === 0) {
+        return undefined;
+    }
+    return Object.entries(ps).map(([name, p]) => p._render(name));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connection.js","sourceRoot":"","sources":["../../../src/aws/notify/connection.ts"],"names":[],"mappings":"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","sourcesContent":["import { cloudwatchEventConnection } from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport {\n  IAwsConstruct,\n  AwsConstructProps,\n  AwsConstructBase,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\n\n/**\n * An API Destination Connection\n *\n * A connection defines the authorization type and credentials to use for authorization with an API destination HTTP endpoint.\n */\nexport interface ConnectionProps extends AwsConstructProps {\n  /**\n   * The name of the connection.\n   *\n   * Maximum of 64 characters consisting of numbers, lower/upper case letters, .,-,_.\n   *\n   * @default - A name is automatically generated\n   */\n  readonly connectionName?: string;\n\n  /**\n   * The name of the connection.\n   *\n   * Maximum of 512 characters.\n   *\n   * @default - none\n   */\n  readonly description?: string;\n\n  /**\n   * The authorization type for the connection.\n   */\n  readonly authorization: Authorization;\n\n  /**\n   * Additional string parameters to add to the invocation bodies\n   *\n   * @default - No additional parameters\n   */\n  readonly bodyParameters?: Record<string, HttpParameter>;\n\n  /**\n   * Additional string parameters to add to the invocation headers\n   *\n   * @default - No additional parameters\n   */\n  readonly headerParameters?: Record<string, HttpParameter>;\n\n  /**\n   * Additional string parameters to add to the invocation query strings\n   *\n   * @default - No additional parameters\n   */\n  readonly queryStringParameters?: Record<string, HttpParameter>;\n}\n\n/**\n * Authorization type for an API Destination Connection\n */\nexport abstract class Authorization {\n  /**\n   * Use API key authorization\n   *\n   * API key authorization has two components: an API key name and an API key value.\n   * What these are depends on the target of your connection.\n   */\n  public static apiKey(apiKeyName: string, apiKeyValue: string): Authorization {\n    return new (class extends Authorization {\n      public _bind() {\n        let authParameters: cloudwatchEventConnection.CloudwatchEventConnectionAuthParameters =\n          {\n            apiKey: {\n              key: apiKeyName,\n              value: apiKeyValue, // TODO: Flag as sensitive?\n            },\n          };\n        return {\n          authorizationType: AuthorizationType.API_KEY,\n          authParameters,\n        };\n      }\n    })();\n  }\n\n  /**\n   * Use username and password authorization\n   */\n  public static basic(username: string, password: string): Authorization {\n    return new (class extends Authorization {\n      public _bind() {\n        let authParameters: cloudwatchEventConnection.CloudwatchEventConnectionAuthParameters =\n          {\n            basic: {\n              username: username,\n              password: password, // TODO: Flag as sensitive?\n            },\n          };\n        return {\n          authorizationType: AuthorizationType.BASIC,\n          authParameters,\n        };\n      }\n    })();\n  }\n\n  /**\n   * Use OAuth authorization\n   */\n  public static oauth(props: OAuthAuthorizationProps): Authorization {\n    if (\n      ![HttpMethod.POST, HttpMethod.GET, HttpMethod.PUT].includes(\n        props.httpMethod,\n      )\n    ) {\n      throw new Error(\"httpMethod must be one of GET, POST, PUT\");\n    }\n\n    return new (class extends Authorization {\n      public _bind() {\n        let authParameters: cloudwatchEventConnection.CloudwatchEventConnectionAuthParameters =\n          {\n            oauth: {\n              authorizationEndpoint: props.authorizationEndpoint,\n              clientParameters: {\n                clientId: props.clientId,\n                clientSecret: props.clientSecret, // TODO: Flag as sensitive?\n              },\n              httpMethod: props.httpMethod,\n              oauthHttpParameters: {\n                body: renderHttpParameters(props.bodyParameters),\n                header: renderHttpParameters(props.headerParameters),\n                queryString: renderHttpParameters(props.queryStringParameters),\n              },\n            },\n          };\n        return {\n          authorizationType: AuthorizationType.OAUTH_CLIENT_CREDENTIALS,\n          authParameters,\n        };\n      }\n    })();\n  }\n\n  /**\n   * Bind the authorization to the construct and return the authorization properties\n   *\n   * @internal\n   */\n  public abstract _bind(): AuthorizationBindResult;\n}\n\n/**\n * Properties for `Authorization.oauth()`\n */\nexport interface OAuthAuthorizationProps {\n  /**\n   * The URL to the authorization endpoint\n   */\n  readonly authorizationEndpoint: string;\n\n  /**\n   * The method to use for the authorization request.\n   *\n   * (Can only choose POST, GET or PUT).\n   */\n  readonly httpMethod: HttpMethod;\n\n  /**\n   * The client ID to use for OAuth authorization for the connection.\n   */\n  readonly clientId: string;\n\n  /**\n   * The client secret associated with the client ID to use for OAuth authorization for the connection.\n   */\n  readonly clientSecret: string;\n\n  /**\n   * Additional string parameters to add to the OAuth request body\n   *\n   * @default - No additional parameters\n   */\n  readonly bodyParameters?: Record<string, HttpParameter>;\n\n  /**\n   * Additional string parameters to add to the OAuth request header\n   *\n   * @default - No additional parameters\n   */\n  readonly headerParameters?: Record<string, HttpParameter>;\n\n  /**\n   * Additional string parameters to add to the OAuth request query string\n   *\n   * @default - No additional parameters\n   */\n  readonly queryStringParameters?: Record<string, HttpParameter>;\n}\n\n/**\n * An additional HTTP parameter to send along with the OAuth request\n */\nexport abstract class HttpParameter {\n  /**\n   * Make an OAuthParameter from a string value\n   *\n   * The value is not treated as a secret.\n   */\n  public static fromString(value: string): HttpParameter {\n    return new (class extends HttpParameter {\n      public _render(name: string) {\n        return {\n          key: name,\n          value,\n          isValueSecret: false,\n        };\n      }\n    })();\n  }\n\n  /**\n   * Make an OAuthParameter from a secret\n   */\n  public static fromSecret(value: string): HttpParameter {\n    return new (class extends HttpParameter {\n      public _render(name: string) {\n        return {\n          key: name,\n          value, // TODO: Flag as secret\n          isValueSecret: true,\n        };\n      }\n    })();\n  }\n\n  /**\n   * Render the paramter value\n   *\n   * @internal\n   */\n  public abstract _render(name: string): any;\n}\n\n/**\n * Result of the 'bind' operation of the 'Authorization' class\n *\n * @internal\n */\nexport interface AuthorizationBindResult {\n  /**\n   * The authorization type\n   */\n  readonly authorizationType: AuthorizationType;\n\n  /**\n   * The authorization parameters (depends on the type)\n   */\n  readonly authParameters: any;\n}\n\n/**\n * Outputs to register with the Grid\n */\nexport interface ConnectionOutputs {\n  /**\n   * The name of the connection.\n   */\n  readonly name: string;\n\n  /**\n   * The ARN of this connection resource\n   */\n  readonly arn: string;\n\n  /**\n   * The Amazon Resource Name (ARN) of the secret created from the authorization parameters specified for the connection.\n   */\n  readonly secretArn?: string;\n}\n\n/**\n * Interface for EventBus Connections\n */\nexport interface IConnection extends IAwsConstruct {\n  /**\n   * The Name for the connection.\n   * @attribute\n   */\n  readonly connectionName: string;\n\n  /**\n   * The ARN of the connection created.\n   * @attribute\n   */\n  readonly connectionArn: string;\n\n  /**\n   * The ARN for the secret created for the connection.\n   * @attribute\n   */\n  readonly connectionSecretArn: string;\n}\n\n/**\n * Interface with properties necessary to import a reusable Connection\n */\nexport interface ConnectionAttributes {\n  /**\n   * The Name for the connection.\n   */\n  readonly connectionName: string;\n\n  /**\n   * The ARN of the connection created.\n   */\n  readonly connectionArn: string;\n\n  /**\n   * The ARN for the secret created for the connection.\n   */\n  readonly connectionSecretArn: string;\n}\n\n/**\n * Define an EventBridge Connection\n *\n * @resource aws_cloudwatch_event_connection\n */\nexport class Connection extends AwsConstructBase implements IConnection {\n  /**\n   * Import an existing connection resource\n   * @param scope Parent construct\n   * @param id Construct ID\n   * @param connectionArn ARN of imported connection\n   */\n  public static fromEventBusArn(\n    scope: Construct,\n    id: string,\n    connectionArn: string,\n    connectionSecretArn: string,\n  ): IConnection {\n    const parts = AwsStack.ofAwsConstruct(scope).parseArn(connectionArn);\n\n    return new ImportedConnection(scope, id, {\n      connectionArn: connectionArn,\n      connectionName: parts.resourceName || \"\",\n      connectionSecretArn: connectionSecretArn,\n    });\n  }\n\n  /**\n   * Import an existing connection resource\n   * @param scope Parent construct\n   * @param id Construct ID\n   * @param attrs Imported connection properties\n   */\n  public static fromConnectionAttributes(\n    scope: Construct,\n    id: string,\n    attrs: ConnectionAttributes,\n  ): IConnection {\n    return new ImportedConnection(scope, id, attrs);\n  }\n\n  public readonly resource: cloudwatchEventConnection.CloudwatchEventConnection;\n\n  public readonly connectionOutputs: ConnectionOutputs;\n  public get outputs(): Record<string, any> {\n    return this.connectionOutputs;\n  }\n\n  /**\n   * The Name for the connection.\n   * @attribute\n   */\n  public readonly connectionName: string;\n\n  /**\n   * The ARN of the connection created.\n   * @attribute\n   */\n  public readonly connectionArn: string;\n\n  /**\n   * The ARN for the secret created for the connection.\n   * @attribute\n   */\n  public readonly connectionSecretArn: string;\n\n  constructor(scope: Construct, id: string, props: ConnectionProps) {\n    super(scope, id, props);\n\n    /**\n     * Maximum of 64 characters consisting of numbers, lower/upper case letters, .,-,_.\n     */\n    const connectionName =\n      props.connectionName ??\n      this.stack.uniqueResourceName(this, {\n        maxLength: 64,\n        allowedSpecialCharacters: \".-_\",\n      });\n\n    const authBind = props.authorization._bind();\n\n    const invocationHttpParameters:\n      | cloudwatchEventConnection.CloudwatchEventConnectionAuthParametersInvocationHttpParameters\n      | undefined =\n      !!props.headerParameters ||\n      !!props.queryStringParameters ||\n      !!props.bodyParameters\n        ? {\n            body: renderHttpParameters(props.bodyParameters),\n            header: renderHttpParameters(props.headerParameters),\n            queryString: renderHttpParameters(props.queryStringParameters),\n          }\n        : undefined;\n\n    this.resource = new cloudwatchEventConnection.CloudwatchEventConnection(\n      this,\n      \"Resource\",\n      {\n        authorizationType: authBind.authorizationType,\n        authParameters: {\n          ...authBind.authParameters,\n          invocationHttpParameters: invocationHttpParameters,\n        },\n        description: props.description,\n        name: connectionName,\n      },\n    );\n\n    this.connectionName = this.resource.name;\n    this.connectionArn = this.resource.arn;\n    this.connectionSecretArn = this.resource.secretArn;\n    this.connectionOutputs = {\n      name: this.connectionName,\n      arn: this.connectionArn,\n      secretArn: this.connectionSecretArn,\n    };\n  }\n}\n\nclass ImportedConnection extends AwsConstructBase {\n  public readonly connectionArn: string;\n  public readonly connectionName: string;\n  public readonly connectionSecretArn: string;\n  public get connectionOutputs(): ConnectionOutputs {\n    return {\n      name: this.connectionName,\n      arn: this.connectionArn,\n      secretArn: this.connectionSecretArn,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.connectionOutputs;\n  }\n  constructor(scope: Construct, id: string, attrs: ConnectionAttributes) {\n    const arnParts = AwsStack.ofAwsConstruct(scope).parseArn(\n      attrs.connectionArn,\n    );\n    super(scope, id, {\n      account: arnParts.account,\n      region: arnParts.region,\n    });\n\n    this.connectionArn = attrs.connectionArn;\n    this.connectionName = attrs.connectionName;\n    this.connectionSecretArn = attrs.connectionSecretArn;\n  }\n}\n\n/**\n * Supported HTTP operations.\n */\nexport enum HttpMethod {\n  /** POST */\n  POST = \"POST\",\n  /** GET */\n  GET = \"GET\",\n  /** HEAD */\n  HEAD = \"HEAD\",\n  /** OPTIONS */\n  OPTIONS = \"OPTIONS\",\n  /** PUT */\n  PUT = \"PUT\",\n  /** PATCH */\n  PATCH = \"PATCH\",\n  /** DELETE */\n  DELETE = \"DELETE\",\n}\n\n/**\n * Supported Authorization Types.\n */\nenum AuthorizationType {\n  /** API_KEY */\n  API_KEY = \"API_KEY\",\n  /** BASIC */\n  BASIC = \"BASIC\",\n  /** OAUTH_CLIENT_CREDENTIALS */\n  OAUTH_CLIENT_CREDENTIALS = \"OAUTH_CLIENT_CREDENTIALS\",\n}\n\nfunction renderHttpParameters<T>(\n  ps?: Record<string, HttpParameter>,\n): T[] | undefined {\n  if (!ps || Object.keys(ps).length === 0) {\n    return undefined;\n  }\n\n  return Object.entries(ps).map(([name, p]) => p._render(name));\n}\n"]}

package/lib/aws/notify/event-bus.d.ts

@@ -0,0 +1,298 @@
+import { cloudwatchEventBus, cloudwatchEventPermission } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import { Archive, BaseArchiveProps } from "./archive";
+import * as iam from "../iam";
+/**
+ * Outputs to register with the Grid
+ */
+export interface EventBusOutputs {
+    /**
+     * The physical ID of this event bus resource
+     */
+    readonly name: string;
+    /**
+     * The ARN of this event bus resource
+     */
+    readonly arn: string;
+    /**
+     * The partner event source to associate with this event bus resource
+     */
+    readonly eventSourceName?: string;
+}
+/**
+ * Interface which all EventBus based classes MUST implement
+ */
+export interface IEventBus extends iam.IAwsConstructWithPolicy {
+    /**
+     * The physical ID of this event bus resource
+     *
+     * @attribute
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-name
+     */
+    readonly eventBusName: string;
+    /**
+     * The ARN of this event bus resource
+     *
+     * @attribute
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#Arn-fn::getatt
+     */
+    readonly eventBusArn: string;
+    /**
+     * The partner event source to associate with this event bus resource
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-eventsourcename
+     */
+    readonly eventSourceName?: string;
+    /**
+     * Create an EventBridge archive to send events to.
+     * When you create an archive, incoming events might not immediately start being sent to the archive.
+     * Allow a short period of time for changes to take effect.
+     *
+     * @param props Properties of the archive
+     */
+    archive(id: string, props: BaseArchiveProps): Archive;
+    /**
+     * Grants an IAM Principal to send custom events to the eventBus
+     * so that they can be matched to rules.
+     *
+     * @param grantee The principal (no-op if undefined)
+     */
+    grantPutEventsTo(grantee: iam.IGrantable): iam.Grant;
+}
+/**
+ * Properties to define an event bus
+ */
+export interface EventBusProps extends AwsConstructProps {
+    /**
+     * The name of the event bus you are creating
+     * Note: If 'eventSourceName' is passed in, you cannot set this
+     *
+     * NOTE: the names of custom event buses can't contain the '/' character
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-name
+     * @default - automatically generated name
+     */
+    readonly eventBusName?: string;
+    /**
+     * The partner event source to associate with this event bus resource
+     * Note: If 'eventBusName' is passed in, you cannot set this
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-eventsourcename
+     * @default - no partner event source
+     */
+    readonly eventSourceName?: string;
+}
+/**
+ * Interface with properties necessary to import a reusable EventBus
+ */
+export interface EventBusAttributes {
+    /**
+     * The physical ID of this event bus resource
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-name
+     */
+    readonly eventBusName: string;
+    /**
+     * The ARN of this event bus resource
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#Arn-fn::getatt
+     */
+    readonly eventBusArn: string;
+    /**
+     * The partner event source to associate with this event bus resource
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-eventsourcename
+     * @default - no partner event source
+     */
+    readonly eventSourceName?: string;
+}
+declare abstract class EventBusBase extends AwsConstructBase implements IEventBus {
+    /**
+     * The physical ID of this event bus resource
+     */
+    abstract readonly eventBusName: string;
+    /**
+     * The ARN of the event bus, such as:
+     * arn:aws:events:us-east-2:123456789012:event-bus/aws.partner/PartnerName/acct1/repo1.
+     */
+    abstract readonly eventBusArn: string;
+    /**
+     * The name of the partner event source
+     */
+    abstract readonly eventSourceName?: string;
+    archive(id: string, props: BaseArchiveProps): Archive;
+    grantPutEventsTo(grantee: iam.IGrantable): iam.Grant;
+    abstract addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+}
+/**
+ * Define an EventBridge EventBus
+ *
+ * @resource aws_cloudwatch_event_bus
+ */
+export declare class EventBus extends EventBusBase {
+    /**
+     * Import an existing event bus resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param eventBusArn ARN of imported event bus
+     */
+    static fromEventBusArn(scope: Construct, id: string, eventBusArn: string): IEventBus;
+    /**
+     * Import an existing event bus resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param eventBusName Name of imported event bus
+     */
+    static fromEventBusName(scope: Construct, id: string, eventBusName: string): IEventBus;
+    /**
+     * Import an existing event bus resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param attrs Imported event bus properties
+     */
+    static fromEventBusAttributes(scope: Construct, id: string, attrs: EventBusAttributes): IEventBus;
+    /**
+     * Permits an IAM Principal to send custom events to EventBridge
+     * so that they can be matched to rules.
+     *
+     * @param grantee The principal (no-op if undefined)
+     * @deprecated use grantAllPutEvents instead
+     */
+    static grantPutEvents(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Permits an IAM Principal to send custom events to EventBridge
+     * so that they can be matched to rules.
+     *
+     * @param grantee The principal (no-op if undefined)
+     */
+    static grantAllPutEvents(grantee: iam.IGrantable): iam.Grant;
+    private static eventBusProps;
+    readonly resource: cloudwatchEventBus.CloudwatchEventBus;
+    readonly eventBusOutputs: EventBusOutputs;
+    get outputs(): Record<string, any>;
+    private policy?;
+    /**
+     * The physical ID of this event bus resource
+     */
+    get eventBusName(): string;
+    /**
+     * The ARN of the event bus, such as:
+     * arn:aws:events:us-east-2:123456789012:event-bus/aws.partner/PartnerName/acct1/repo1.
+     */
+    get eventBusArn(): string;
+    /**
+     * The name of the partner event source
+     */
+    readonly eventSourceName?: string;
+    constructor(scope: Construct, id: string, props?: EventBusProps);
+    /**
+     * Adds a statement to the IAM resource policy associated with this event bus.
+     */
+    addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+}
+/**
+ * Properties to associate Event Buses with a policy
+ */
+export interface EventBusPolicyProps extends AwsConstructProps {
+    /**
+     * The event bus to which the policy applies
+     */
+    readonly eventBus: IEventBus;
+}
+/**
+ * The policy for an Event Bus
+ *
+ * Policies define the operations that are allowed on this resource.
+ *
+ * You almost never need to define this construct directly.
+ *
+ * The EventBusPolicy resource (`aws_cloudwatch_event_bus_policy`)
+ * is incompatible with the EventBridgePermission resource (`aws_cloudwatch_event_permission`)
+ * and will overwrite permissions.
+ *
+ * All AWS resources that support resource policies have a method called
+ * `addToResourcePolicy()`, which will automatically create a new resource
+ * policy if one doesn't exist yet, otherwise it will add to the existing
+ * policy.
+ *
+ * Prefer to use `addToResourcePolicy()` instead.
+ *
+ * @resource aws_cloudwatch_event_bus_policy
+ */
+export declare class EventBusPolicy extends AwsConstructBase {
+    /**
+     * The IAM policy document for this policy.
+     */
+    readonly document: iam.PolicyDocument;
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: EventBusPolicyProps);
+}
+/**
+ * Properties to add permissions to an Event Bus
+ */
+export interface EventBridgePermissionProps extends AwsConstructProps {
+    /**
+     * The event bus to which the policy applies
+     */
+    readonly eventBus: IEventBus;
+    /**
+     * An identifier string for the external account that
+     * you are granting permissions to.
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/cloudwatch_event_permission#statement_id CloudwatchEventPermission#statement_id}
+     */
+    readonly statementId: string;
+    /**
+     * The action that you are enabling the other account to perform. Defaults to events:PutEvents
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/cloudwatch_event_permission#action CloudwatchEventPermission#action}
+     * @default "events:PutEvents"
+     */
+    readonly action?: string;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/cloudwatch_event_permission#event_bus_name CloudwatchEventPermission#event_bus_name}
+     */
+    readonly eventBusName?: string;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/cloudwatch_event_permission#id CloudwatchEventPermission#id}
+     *
+     * Please be aware that the id field is automatically added to all resources in Terraform providers using a Terraform provider SDK version below 2.
+     * If you experience problems setting this value it might not be settable. Please take a look at the provider documentation to ensure it should be settable.
+     */
+    readonly id?: string;
+    /**
+     * The 12-digit AWS account ID that you are permitting to put events to your default event bus.
+     * Specify * to permit any account to put events to your default event bus, optionally limited
+     * by condition.
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/cloudwatch_event_permission#principal CloudwatchEventPermission#principal}
+     */
+    readonly principal: string;
+    /**
+     * Configuration block to limit the event bus permissions you are granting to only accounts that
+     * fulfill the condition.condition block
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/cloudwatch_event_permission#condition CloudwatchEventPermission#condition}
+     */
+    readonly condition?: cloudwatchEventPermission.CloudwatchEventPermissionCondition;
+}
+/**
+ * A single permission for an Event Bus
+ *
+ * All AWS resources that support resource policies have a method called
+ * `addToResourcePolicy()`, which will automatically create a new resource
+ * policy if one doesn't exist yet, otherwise it will add to the existing
+ * policy.
+ *
+ * If `addToResourcePolicy()` was used on the event bus, The EventBusPolicy resource
+ * (`aws_cloudwatch_event_bus_policy`) is incompatible with this resource and
+ * will overwrite permissions.
+ *
+ * @resource aws_cloudwatch_event_permission
+ */
+export declare class EventBridgePermission extends AwsConstructBase {
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: EventBridgePermissionProps);
+}
+export {};