@gradientedge/cdk-utils-aws 1.0.0

package/dist/src/construct/api-to-lambda-target/main.d.ts

@@ -0,0 +1,70 @@
+import { ISecret } from 'aws-cdk-lib/aws-secretsmanager';
+import { Construct } from 'constructs';
+import { CommonConstruct } from '../../common/index.js';
+import { ApiToLambdaTargetProps, ApiToLambdaTargetRestApiType } from './types.js';
+/**
+ */
+export declare class ApiToLambdaTarget extends CommonConstruct {
+    props: ApiToLambdaTargetProps;
+    id: string;
+    applicationSecrets: ISecret[];
+    apiToLambdaTargetRestApi: ApiToLambdaTargetRestApiType;
+    apiResource: string;
+    constructor(parent: Construct, id: string, props: ApiToLambdaTargetProps);
+    initResources(): void;
+    /**
+     * @summary Method to resolve secrets from SecretsManager
+     * - To be implemented in the overriding method in the implementation class
+     */
+    protected resolveSecrets(): void;
+    /**
+     * @summary Method to resolve a hosted zone based on domain attributes
+     */
+    protected resolveHostedZone(): void;
+    /**
+     * @summary Method to resolve a certificate based on attributes
+     */
+    protected resolveCertificate(): void;
+    /**
+     * @summary Method to create api integration method response
+     */
+    protected createApiToLambdaTargetMethodResponse(): void;
+    /**
+     * @summary Method to create api integration method error response
+     */
+    protected createApiToLambdaTargetMethodErrorResponse(): void;
+    protected resolveApiToLambdaTargetFunction(): void;
+    /**
+     * @summary Method to create rest restApi for Api
+     */
+    protected createApiToLambdaTargetRestApi(): void;
+    /**
+     * @summary Method to create api integration resource
+     */
+    protected createApiToLambdaTargetResource(): void;
+    protected createApiToLambdaTargetPolicy(): void;
+    /**
+     * @summary Method to create a role for api integration
+     */
+    protected createApiToLambdaTargetRole(): void;
+    /**
+     * @summary Method to create api integration resource method
+     */
+    protected createApiToLambdaTargetIntegration(): void;
+    /**
+     * @summary Method to create api integration resource method
+     */
+    protected createApiToLambdaTargetResourceMethod(): void;
+    /**
+     * @summary Method to create custom restApi domain for Api
+     */
+    protected createApiDomain(): void;
+    /**
+     * @summary Method to create base path mappings for Api
+     */
+    protected createApiBasePathMapping(): void;
+    /**
+     * @summary Method to create route53 records for Api
+     */
+    protected createApiRouteAssets(): void;
+}

package/dist/src/construct/api-to-lambda-target/main.js

@@ -0,0 +1,218 @@
+import { Fn } from 'aws-cdk-lib';
+import { BasePathMapping, LambdaIntegration, Resource, RestApi } from 'aws-cdk-lib/aws-apigateway';
+import { PolicyDocument, Role, ServicePrincipal } from 'aws-cdk-lib/aws-iam';
+import { Function } from 'aws-cdk-lib/aws-lambda';
+import { CommonConstruct } from '../../common/index.js';
+import { ApiToLambdaTargetRestApi } from './api.js';
+/**
+ */
+export class ApiToLambdaTarget extends CommonConstruct {
+    props;
+    id;
+    /* application related resources */
+    applicationSecrets;
+    /* rest restApi related resources */
+    apiToLambdaTargetRestApi;
+    apiResource;
+    constructor(parent, id, props) {
+        super(parent, id, props);
+        this.props = props;
+        this.id = id;
+        this.apiToLambdaTargetRestApi = new ApiToLambdaTargetRestApi();
+    }
+    initResources() {
+        this.resolveSecrets();
+        this.resolveHostedZone();
+        this.resolveCertificate();
+        this.createApiToLambdaTargetMethodResponse();
+        this.createApiToLambdaTargetMethodErrorResponse();
+        this.resolveApiToLambdaTargetFunction();
+        this.createApiToLambdaTargetRestApi();
+        this.createApiToLambdaTargetResource();
+        this.createApiToLambdaTargetPolicy();
+        this.createApiToLambdaTargetRole();
+        this.createApiToLambdaTargetIntegration();
+        this.createApiToLambdaTargetResourceMethod();
+        this.createApiDomain();
+        this.createApiBasePathMapping();
+        this.createApiRouteAssets();
+    }
+    /**
+     * @summary Method to resolve secrets from SecretsManager
+     * - To be implemented in the overriding method in the implementation class
+     */
+    resolveSecrets() {
+        this.applicationSecrets = [];
+    }
+    /**
+     * @summary Method to resolve a hosted zone based on domain attributes
+     */
+    resolveHostedZone() {
+        this.apiToLambdaTargetRestApi.hostedZone = this.route53Manager.withHostedZoneFromFullyQualifiedDomainName(`${this.id}-hosted-zone`, this, this.props.useExistingHostedZone);
+    }
+    /**
+     * @summary Method to resolve a certificate based on attributes
+     */
+    resolveCertificate() {
+        if (this.props.api.useExisting)
+            return;
+        if (this.props.api.certificate.useExistingCertificate &&
+            this.props.api.certificate.certificateSsmName &&
+            this.props.api.certificate.certificateRegion) {
+            this.props.api.certificate.certificateArn = this.ssmManager.readStringParameterFromRegion(`${this.id}-certificate-param`, this, this.props.api.certificate.certificateSsmName, this.props.api.certificate.certificateRegion);
+        }
+        this.apiToLambdaTargetRestApi.certificate = this.acmManager.resolveCertificate(`${this.id}-certificate`, this, this.props.api.certificate);
+    }
+    /**
+     * @summary Method to create api integration method response
+     */
+    createApiToLambdaTargetMethodResponse() {
+        if (!this.props.api.withResource)
+            return;
+        this.apiToLambdaTargetRestApi.methodResponse = {
+            ...{
+                responseParameters: {
+                    'method.response.header.Access-Control-Allow-Credentials': true,
+                    'method.response.header.Access-Control-Allow-Origin': true,
+                    'method.response.header.Content-Type': true,
+                },
+                statusCode: '200',
+            },
+            ...this.props.api.methodResponse,
+        };
+    }
+    /**
+     * @summary Method to create api integration method error response
+     */
+    createApiToLambdaTargetMethodErrorResponse() {
+        if (!this.props.api.withResource)
+            return;
+        this.apiToLambdaTargetRestApi.methodErrorResponse = {
+            ...{
+                responseParameters: {
+                    'method.response.header.Access-Control-Allow-Credentials': true,
+                    'method.response.header.Access-Control-Allow-Origin': true,
+                    'method.response.header.Content-Type': true,
+                },
+                statusCode: '400',
+            },
+            ...this.props.api.methodErrorResponse,
+        };
+    }
+    resolveApiToLambdaTargetFunction() {
+        this.apiToLambdaTargetRestApi.lambda = Function.fromFunctionName(this, `${this.id}-lambda`, this.resourceNameFormatter.format(this.props.lambdaFunctionName));
+    }
+    /**
+     * @summary Method to create rest restApi for Api
+     */
+    createApiToLambdaTargetRestApi() {
+        if (this.props.api.useExisting && this.props.api.importedRestApiRef) {
+            this.apiToLambdaTargetRestApi.api = RestApi.fromRestApiId(this, `${this.id}-rest-api`, Fn.importValue(this.props.api.importedRestApiRef));
+            return;
+        }
+        this.props.api.restApi = {
+            ...this.props.api.restApi,
+            defaultMethodOptions: {
+                methodResponses: [
+                    this.apiToLambdaTargetRestApi.methodResponse,
+                    this.apiToLambdaTargetRestApi.methodErrorResponse,
+                ],
+            },
+        };
+        this.apiToLambdaTargetRestApi.api = this.apiManager.createLambdaRestApi(`${this.id}-lambda-rest-api`, this, this.props.api.restApi, this.apiToLambdaTargetRestApi.lambda);
+        this.addCfnOutput(`${this.id}-restApiId`, this.apiToLambdaTargetRestApi.api.restApiId);
+        this.addCfnOutput(`${this.id}-restApiRootResourceId`, this.apiToLambdaTargetRestApi.api.root.resourceId);
+    }
+    /**
+     * @summary Method to create api integration resource
+     */
+    createApiToLambdaTargetResource() {
+        if (!this.props.api.withResource)
+            return;
+        let rootResource;
+        if (this.props.api.withResource && this.props.api.importedRestApiRootResourceRef) {
+            rootResource = Resource.fromResourceAttributes(this, `${this.id}-root-resource`, {
+                path: '/',
+                resourceId: Fn.importValue(this.props.api.importedRestApiRootResourceRef),
+                restApi: this.apiToLambdaTargetRestApi.api,
+            });
+        }
+        else {
+            rootResource = this.apiToLambdaTargetRestApi.api.root;
+        }
+        this.apiToLambdaTargetRestApi.resource = rootResource.addResource(this.props.api.resource ?? this.apiResource);
+    }
+    createApiToLambdaTargetPolicy() {
+        this.apiToLambdaTargetRestApi.policy = new PolicyDocument({
+            statements: [
+                this.iamManager.statementForPutEvents(),
+                this.iamManager.statementForInvokeLambda([this.apiToLambdaTargetRestApi.lambda.functionArn]),
+            ],
+        });
+    }
+    /**
+     * @summary Method to create a role for api integration
+     */
+    createApiToLambdaTargetRole() {
+        if (!this.apiToLambdaTargetRestApi.policy)
+            throw 'Policy undefined';
+        this.apiToLambdaTargetRestApi.role = new Role(this, `${this.id}-rest-api-role`, {
+            assumedBy: new ServicePrincipal('apigateway.amazonaws.com'),
+            inlinePolicies: { policy: this.apiToLambdaTargetRestApi.policy },
+        });
+    }
+    /**
+     * @summary Method to create api integration resource method
+     */
+    createApiToLambdaTargetIntegration() {
+        this.apiToLambdaTargetRestApi.integration = new LambdaIntegration(this.apiToLambdaTargetRestApi.lambda, {
+            allowTestInvoke: true,
+            credentialsRole: this.apiToLambdaTargetRestApi.role,
+        });
+    }
+    /**
+     * @summary Method to create api integration resource method
+     */
+    createApiToLambdaTargetResourceMethod() {
+        if (!this.props.api.withResource)
+            return;
+        this.apiToLambdaTargetRestApi.method = this.apiToLambdaTargetRestApi.resource.addMethod('POST', this.apiToLambdaTargetRestApi.integration, {
+            authorizer: this.apiToLambdaTargetRestApi.authoriser,
+            methodResponses: [
+                this.apiToLambdaTargetRestApi.methodResponse,
+                this.apiToLambdaTargetRestApi.methodErrorResponse,
+            ],
+        });
+    }
+    /**
+     * @summary Method to create custom restApi domain for Api
+     */
+    createApiDomain() {
+        if (this.props.api.useExisting)
+            return;
+        this.apiToLambdaTargetRestApi.domain = this.apiManager.createApiDomain(`${this.id}-api-domain`, this, this.isProductionStage() || this.props.skipStageForARecords
+            ? `${this.props.apiSubDomain}.${this.fullyQualifiedDomainName}`
+            : `${this.props.apiSubDomain}-${this.props.stage}.${this.fullyQualifiedDomainName}`, this.apiToLambdaTargetRestApi.certificate);
+    }
+    /**
+     * @summary Method to create base path mappings for Api
+     */
+    createApiBasePathMapping() {
+        if (this.props.api.useExisting)
+            return;
+        new BasePathMapping(this, `${this.id}-base-bath-mapping`, {
+            basePath: '',
+            domainName: this.apiToLambdaTargetRestApi.domain,
+            restApi: this.apiToLambdaTargetRestApi.api,
+            stage: this.apiToLambdaTargetRestApi.api.deploymentStage,
+        });
+    }
+    /**
+     * @summary Method to create route53 records for Api
+     */
+    createApiRouteAssets() {
+        if (this.props.api.useExisting)
+            return;
+        this.route53Manager.createApiGatewayARecord(`${this.id}-custom-domain-a-record`, this, this.props.apiSubDomain, this.apiToLambdaTargetRestApi.domain, this.apiToLambdaTargetRestApi.hostedZone, this.props.skipStageForARecords);
+    }
+}

package/dist/src/construct/api-to-lambda-target/types.d.ts

@@ -0,0 +1,62 @@
+import { CommonStackProps } from '../../common/index.js';
+import { BasePathMapping, DomainName, IAuthorizer, Integration, IntegrationResponse, IRestApi, Method, MethodResponse, Model, Resource } from 'aws-cdk-lib/aws-apigateway';
+import { AcmProps, LambdaRestApiProps } from '../../services/index.js';
+import * as acm from 'aws-cdk-lib/aws-certificatemanager';
+import * as route53 from 'aws-cdk-lib/aws-route53';
+import { IFunction } from 'aws-cdk-lib/aws-lambda';
+import { ITopic } from 'aws-cdk-lib/aws-sns';
+import { PolicyDocument, Role } from 'aws-cdk-lib/aws-iam';
+/**
+ */
+export interface ApiToLambdaTargetRestApiType {
+    api: IRestApi;
+    authoriser?: IAuthorizer;
+    basePathMappings: BasePathMapping[];
+    certificate: acm.ICertificate;
+    domain: DomainName;
+    errorResponseModel: Model;
+    hostedZone: route53.IHostedZone;
+    integration: Integration;
+    integrationErrorResponse: IntegrationResponse;
+    integrationRequestParameters: {
+        [p: string]: string;
+    };
+    integrationRequestTemplates: {
+        [p: string]: string;
+    };
+    integrationResponse: IntegrationResponse;
+    lambda: IFunction;
+    method: Method;
+    methodErrorResponse: MethodResponse;
+    methodResponse: MethodResponse;
+    policy?: PolicyDocument;
+    resource: Resource;
+    responseModel: Model;
+    role?: Role;
+    topic?: ITopic;
+}
+/**
+ */
+export interface ApiToLambdaTargetRestApiProps {
+    certificate: AcmProps;
+    importedRestApiRef?: string;
+    importedRestApiRootResourceRef?: string;
+    methodErrorResponse: MethodResponse;
+    methodResponse: MethodResponse;
+    resource: string;
+    restApi: LambdaRestApiProps;
+    useExisting: boolean;
+    withResource?: boolean;
+}
+/**
+ */
+export interface ApiToLambdaTargetProps extends CommonStackProps {
+    api: ApiToLambdaTargetRestApiProps;
+    apiRootPaths?: string[];
+    apiSubDomain: string;
+    lambdaFunctionName: string;
+    logLevel: string;
+    nodeEnv: string;
+    timezone: string;
+    useExistingHostedZone: boolean;
+}

package/dist/src/construct/api-to-lambda-target/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/construct/application-configuration/index.d.ts

@@ -0,0 +1,2 @@
+export * from './main.js';
+export * from './types.js';

package/dist/src/construct/application-configuration/index.js

@@ -0,0 +1,2 @@
+export * from './main.js';
+export * from './types.js';

package/dist/src/construct/application-configuration/main.d.ts

@@ -0,0 +1,23 @@
+import { CfnApplication, CfnConfigurationProfile, CfnEnvironment, CfnHostedConfigurationVersion, IDeploymentStrategy } from 'aws-cdk-lib/aws-appconfig';
+import { Construct } from 'constructs';
+import { CommonConstruct } from '../../common/index.js';
+import { ApplicationConfigurationProps } from './types.js';
+export declare class ApplicationConfiguration extends CommonConstruct {
+    props: ApplicationConfigurationProps;
+    id: string;
+    appConfigApplication: CfnApplication;
+    appConfigEnvironment: CfnEnvironment;
+    appConfigProfile: CfnConfigurationProfile;
+    appConfigVersion: CfnHostedConfigurationVersion;
+    appConfigDeploymentStrategy: IDeploymentStrategy;
+    constructor(parent: Construct, id: string, props: ApplicationConfigurationProps);
+    initResources(): void;
+    protected createConfiguration(): void;
+    protected createAppConfigApplication(): void;
+    protected createAppConfigEnvironment(): void;
+    protected createAppConfigProfile(): void;
+    protected createAppConfigVersion(): void;
+    protected createAppConfigDeploymentStrategy(): void;
+    protected createAppConfigDeployment(): void;
+    resolveEnvironmentVariables(): any;
+}

package/dist/src/construct/application-configuration/main.js

@@ -0,0 +1,79 @@
+import { Duration, Fn } from 'aws-cdk-lib';
+import { CfnDeployment, CfnHostedConfigurationVersion, DeploymentStrategy, RolloutStrategy, } from 'aws-cdk-lib/aws-appconfig';
+import { CommonConstruct } from '../../common/index.js';
+export class ApplicationConfiguration extends CommonConstruct {
+    id;
+    appConfigApplication;
+    appConfigEnvironment;
+    appConfigProfile;
+    appConfigVersion;
+    appConfigDeploymentStrategy;
+    constructor(parent, id, props) {
+        super(parent, id, props);
+        this.props = props;
+        this.id = id;
+    }
+    initResources() {
+        this.createConfiguration();
+        this.resolveEnvironmentVariables();
+    }
+    createConfiguration() {
+        this.createAppConfigApplication();
+        this.createAppConfigEnvironment();
+        this.createAppConfigProfile();
+        this.createAppConfigVersion();
+        this.createAppConfigDeploymentStrategy();
+        this.createAppConfigDeployment();
+    }
+    createAppConfigApplication() {
+        this.appConfigApplication = this.appConfigManager.createApplication(`${this.id}-ac-application`, this, this.props.appConfig);
+    }
+    createAppConfigEnvironment() {
+        this.appConfigEnvironment = this.appConfigManager.createEnvironment(`${this.id}-ac-environment`, this, Fn.ref(this.appConfigApplication.logicalId), this.props.appConfig);
+    }
+    createAppConfigProfile() {
+        this.appConfigProfile = this.appConfigManager.createConfigurationProfile(`${this.id}-ac-profile`, this, Fn.ref(this.appConfigApplication.logicalId), this.props.appConfig);
+    }
+    createAppConfigVersion() {
+        this.appConfigVersion = new CfnHostedConfigurationVersion(this, `${this.id}-ac-configuration`, {
+            applicationId: Fn.ref(this.appConfigApplication.logicalId),
+            configurationProfileId: Fn.ref(this.appConfigProfile.logicalId),
+            content: JSON.stringify(this.props.appConfigContent),
+            contentType: 'application/json',
+        });
+    }
+    createAppConfigDeploymentStrategy() {
+        if (!this.props.appConfig.deploymentStrategy)
+            return;
+        if (this.props.appConfig.deploymentStrategy?.deploymentStrategyArn) {
+            this.appConfigDeploymentStrategy = DeploymentStrategy.fromDeploymentStrategyArn(this, `${this.id}-ac-deployment-strategy`, this.props.appConfig.deploymentStrategy?.deploymentStrategyArn);
+            return;
+        }
+        this.appConfigDeploymentStrategy = new DeploymentStrategy(this, `${this.id}-ac-deployment-strategy`, {
+            ...this.props.appConfig.deploymentStrategy,
+            rolloutStrategy: this.props.appConfig.deploymentStrategy?.rolloutStrategy ??
+                RolloutStrategy.linear({
+                    growthFactor: 100,
+                    deploymentDuration: Duration.minutes(0),
+                    finalBakeTime: Duration.minutes(0),
+                }),
+            deploymentStrategyName: this.resourceNameFormatter.format(this.props.appConfig.deploymentStrategy.deploymentStrategyName ?? 'common-deployment-strategy', this.props.resourceNameOptions?.appconfig),
+        });
+    }
+    createAppConfigDeployment() {
+        new CfnDeployment(this, `${this.id}-app-config-deployment`, {
+            applicationId: Fn.ref(this.appConfigApplication.logicalId),
+            configurationProfileId: Fn.ref(this.appConfigProfile.logicalId),
+            configurationVersion: Fn.ref(this.appConfigVersion.logicalId),
+            deploymentStrategyId: this.appConfigDeploymentStrategy.deploymentStrategyId,
+            environmentId: Fn.ref(this.appConfigEnvironment.logicalId),
+        });
+    }
+    resolveEnvironmentVariables() {
+        return {
+            APP_CONFIG_APPLICATION_ID: Fn.ref(this.appConfigApplication.logicalId),
+            APP_CONFIG_CONFIGURATION_PROFILE_ID: Fn.ref(this.appConfigProfile.logicalId),
+            APP_CONFIG_ENVIRONMENT_ID: Fn.ref(this.appConfigEnvironment.logicalId),
+        };
+    }
+}

package/dist/src/construct/application-configuration/types.d.ts

@@ -0,0 +1,6 @@
+import { CommonStackProps } from '../../common/index.js';
+import { AppConfigProps } from '../../services/index.js';
+export interface ApplicationConfigurationProps extends CommonStackProps {
+    appConfig: AppConfigProps;
+    appConfigContent: any;
+}

package/dist/src/construct/application-configuration/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/construct/event-handler/handler.d.ts

@@ -0,0 +1,29 @@
+import { Archive, IEventBus, IRuleTarget, Rule } from 'aws-cdk-lib/aws-events';
+import { CloudWatchLogGroup, EcsTask, LambdaFunction, SfnStateMachine, SqsQueue } from 'aws-cdk-lib/aws-events-targets';
+import { PolicyDocument, Role } from 'aws-cdk-lib/aws-iam';
+import { IFunction } from 'aws-cdk-lib/aws-lambda';
+import { LogGroup } from 'aws-cdk-lib/aws-logs';
+import { Queue } from 'aws-cdk-lib/aws-sqs';
+import { Chain, Map, StateMachine } from 'aws-cdk-lib/aws-stepfunctions';
+import { EventHandlerType } from './types.js';
+export declare class Handler implements EventHandlerType {
+    archive: Archive;
+    ecsTargets: EcsTask[];
+    eventBus: IEventBus;
+    eventWorkflowDefinition: Chain;
+    lambdaFunctions: IFunction[];
+    lambdaTargets: LambdaFunction[];
+    logTargets: CloudWatchLogGroup[];
+    queue: Queue;
+    rule: Rule;
+    rulePattern: any;
+    sqsTargets: SqsQueue[];
+    stepFunctionTargets: SfnStateMachine[];
+    targets: IRuleTarget[];
+    workflow: StateMachine;
+    workflowDefinition: Chain;
+    workflowLogGroup: LogGroup;
+    workflowMapState: Map;
+    workflowPolicy: PolicyDocument;
+    workflowRole: Role;
+}

package/dist/src/construct/event-handler/handler.js

@@ -0,0 +1,21 @@
+export class Handler {
+    archive;
+    ecsTargets = [];
+    eventBus;
+    eventWorkflowDefinition;
+    lambdaFunctions = [];
+    lambdaTargets = [];
+    logTargets = [];
+    queue;
+    rule;
+    rulePattern;
+    sqsTargets = [];
+    stepFunctionTargets = [];
+    targets = [];
+    workflow;
+    workflowDefinition;
+    workflowLogGroup;
+    workflowMapState;
+    workflowPolicy;
+    workflowRole;
+}

package/dist/src/construct/event-handler/index.d.ts

@@ -0,0 +1,3 @@
+export * from './handler.js';
+export * from './main.js';
+export * from './types.js';

package/dist/src/construct/event-handler/index.js

@@ -0,0 +1,3 @@
+export * from './handler.js';
+export * from './main.js';
+export * from './types.js';

package/dist/src/construct/event-handler/main.d.ts

@@ -0,0 +1,91 @@
+import { ISecurityGroup, IVpc } from 'aws-cdk-lib/aws-ec2';
+import { Construct } from 'constructs';
+import { CommonConstruct } from '../../common/index.js';
+import { Handler } from './handler.js';
+import { EventHandlerProps } from './types.js';
+/**
+ * @classdesc Provides a construct to create and deploy an EventBridge Event Handler
+ * @example
+ * import { EventHandler, EventHandlerProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends EventHandler {
+ *   constructor(parent: Construct, id: string, props: EventHandlerProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export declare class EventHandler extends CommonConstruct {
+    props: EventHandlerProps;
+    id: string;
+    handler: Handler;
+    provisionTarget: boolean;
+    securityGroup: ISecurityGroup;
+    useMapState: boolean;
+    vpc: IVpc;
+    constructor(parent: Construct, id: string, props: EventHandlerProps);
+    initResources(): void;
+    /**
+     * @summary Method to resolve common vpc  or create a new one.
+     */
+    protected resolveVpc(): void;
+    /**
+     * @summary Method to resolve the exported security group.
+     */
+    protected resolveSecurityGroup(): void;
+    /**
+     * @summary Method to create sqs event source if queue targets are defined.
+     */
+    protected createSQSEventSource(): void;
+    /**
+     * @summary Method to create the event rule pattern.
+     */
+    protected createEventRulePattern(): void;
+    /**
+     * @summary Method to create the event rule targets.
+     */
+    protected createEventRuleTargets(): void;
+    /**
+     * @summary Method to resolve the event bus name or use the default bus.
+     */
+    protected resolveEventBus(): void;
+    /**
+     * @summary Method to create an event archive if the event rule is not a scheduled one.
+     */
+    protected createEventArchive(): void;
+    /**
+     * @summary Method to create the event rule.
+     */
+    protected createEventRule(): void;
+    /**
+     * @summary Method to create the workflow steps.
+     */
+    protected createWorkflowSteps(): void;
+    /**
+     * @summary Method to create the workflow definition.
+     */
+    protected createWorkflowDefinition(): void;
+    /**
+     * @summary Method to create the workflow policy.
+     */
+    protected createWorkflowPolicy(): void;
+    /**
+     * @summary Method to create the workflow role.
+     */
+    protected createWorkflowRole(): void;
+    /**
+     * @summary Method to create the workflow log group.
+     */
+    protected createWorkflowLogGroup(): void;
+    /**
+     * @summary Method to create the workflow state machine.
+     */
+    protected createWorkflowStateMachine(): void;
+    /**
+     * @summary Method to create the workflow.
+     */
+    protected createWorkflow(): void;
+}