@gradientedge/cdk-utils 10.7.0 → 11.0.0

package/dist/src/lib/aws/construct/api-to-eventbridge-target/main.js

@@ -1,442 +0,0 @@
-import { Fn, RemovalPolicy } from 'aws-cdk-lib';
-import { AccessLogFormat, BasePathMapping, Cors, EndpointType, Integration, IntegrationType, JsonSchemaType, JsonSchemaVersion, LogGroupLogDestination, MethodLoggingLevel, Model, PassthroughBehavior, Resource, RestApi, } from 'aws-cdk-lib/aws-apigateway';
-import { EventBus } from 'aws-cdk-lib/aws-events';
-import { CloudWatchLogGroup } from 'aws-cdk-lib/aws-events-targets';
-import { PolicyDocument, Role, ServicePrincipal } from 'aws-cdk-lib/aws-iam';
-import { CommonConstruct } from '../../common/index.js';
-import { ApiToEventbridgeTargetRestApi } from './api.js';
-import { ApiToEventbridgeTargetEvent } from './event.js';
-/**
- * @classdesc Provides a construct to create and deploy API Gateway invocations to EventBridge
- *
- * <b>Architecture</b><br/> ![Architecture](./ApiToEventBridgeTarget.jpg)
- * @example
- * import { ApiToEventBridgeTarget, ApiToEventBridgeTargetProps } '@gradientedge/cdk-utils'
- * import { Construct } from 'constructs'
- *
- * class CustomConstruct extends ApiToEventBridgeTarget {
- *   constructor(parent: Construct, id: string, props: ApiToEventBridgeTargetProps) {
- *     super(parent, id, props)
- *     this.props = props
- *     this.id = id
- *     this.initResources()
- *   }
- * }
- */
-export class ApiToEventBridgeTarget extends CommonConstruct {
-    props;
-    id;
-    /* application related resources */
-    applicationSecrets;
-    /* event related resources */
-    apiEvent;
-    /* rest restApi related resources */
-    apiToEventBridgeTargetRestApi;
-    apiResource;
-    constructor(parent, id, props) {
-        super(parent, id, props);
-        this.props = props;
-        this.id = id;
-        this.apiEvent = new ApiToEventbridgeTargetEvent();
-        this.apiToEventBridgeTargetRestApi = new ApiToEventbridgeTargetRestApi();
-        this.apiResource = 'notify';
-    }
-    initResources() {
-        /* application related resources */
-        this.resolveSecrets();
-        /* core resources */
-        this.resolveHostedZone();
-        this.resolveCertificate();
-        /* optional custom event bus */
-        this.createApiToEventBridgeTargetEventBus();
-        /* event related resources */
-        this.createApiToEventBridgeTargetLogGroup();
-        this.createApiToEventBridgeTargetRule();
-        this.createApiToEventBridgeTargetPolicy();
-        this.createApiToEventBridgeTargetRole();
-        /* restApi related resources */
-        this.createApiToEventBridgeTargetIntegrationRequestParameters();
-        this.createApiToEventBridgeTargetIntegrationRequestTemplates();
-        this.createApiToEventBridgeTargetIntegrationResponse();
-        this.createApiToEventBridgeTargetIntegrationErrorResponse();
-        this.createApiToEventBridgeTargetIntegration();
-        this.createApiToEventBridgeTargetRestApi();
-        this.createApiToEventBridgeTargetResource();
-        this.createApiToEventBridgeTargetResponseModel();
-        this.createApiToEventBridgeTargetErrorResponseModel();
-        this.createApiToEventBridgeTargetMethodResponse();
-        this.createApiToEventBridgeTargetMethodErrorResponse();
-        this.createApiToEventBridgeTargetResourceMethod();
-        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.apiToEventBridgeTargetRestApi.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.apiToEventBridgeTargetRestApi.certificate = this.acmManager.resolveCertificate(`${this.id}-certificate`, this, this.props.api.certificate);
-    }
-    /**
-     * @summary Method to create or use an existing event bus for api payload deliveries
-     */
-    createApiToEventBridgeTargetEventBus() {
-        if (this.props.api.useExisting) {
-            this.apiEvent.eventBus = EventBus.fromEventBusName(this, `${this.id}-event-bus`, this.resourceNameFormatter.format(this.props.event.eventBusName ?? 'default', this.props.resourceNameOptions?.eventbridgeBus));
-            return;
-        }
-        this.apiEvent.eventBus = this.eventManager.createEventBus(`${this.id}-event-bus`, this, {
-            eventBusName: this.props.event.eventBusName ?? 'default',
-        });
-    }
-    /**
-     * @summary Method to create a log group for successful api payload deliveries
-     */
-    createApiToEventBridgeTargetLogGroup() {
-        if (this.props.api.useExisting)
-            return;
-        this.apiEvent.logGroup = this.logManager.createLogGroup(`${this.id}-log`, this, {
-            ...{
-                logGroupName: `${this.id}-api-to-event-bridge-target-${this.props.stage}`,
-            },
-            ...this.props.event.logGroup,
-        });
-    }
-    /**
-     * Method to create EventBridge rule with lambda target for success
-     */
-    createApiToEventBridgeTargetRule() {
-        if (this.props.api.useExisting)
-            return;
-        if (!this.props.event.rule.ruleName)
-            throw `Event ruleName undefined for ${this.id}`;
-        this.props.event.rule = {
-            eventPattern: {
-                source: ['api-to-eventbridge-target'],
-            },
-            ...this.props.event.rule,
-        };
-        this.apiEvent.rule = this.eventManager.createRule(`${this.id}-api-to-eventbridge-target-rule`, this, this.props.event.rule, this.apiEvent.eventBus, [new CloudWatchLogGroup(this.apiEvent.logGroup)]);
-    }
-    createApiToEventBridgeTargetPolicy() {
-        this.apiToEventBridgeTargetRestApi.policy = new PolicyDocument({
-            statements: [this.iamManager.statementForPutEvents()],
-        });
-    }
-    /**
-     * @summary Method to create a role for api integration
-     */
-    createApiToEventBridgeTargetRole() {
-        if (!this.apiToEventBridgeTargetRestApi.policy)
-            throw 'Policy undefined';
-        this.apiToEventBridgeTargetRestApi.role = new Role(this, `${this.id}-rest-api-role`, {
-            assumedBy: new ServicePrincipal('apigateway.amazonaws.com'),
-            inlinePolicies: { policy: this.apiToEventBridgeTargetRestApi.policy },
-        });
-    }
-    /**
-     * @summary Method to create api integration request parameters
-     */
-    createApiToEventBridgeTargetIntegrationRequestParameters() {
-        if (!this.props.api.withResource)
-            return;
-        this.apiToEventBridgeTargetRestApi.integrationRequestParameters = {
-            'integration.request.header.Content-Type': "'application/x-www-form-urlencoded'",
-        };
-    }
-    /**
-     * @summary Method to create api integration request templates
-     */
-    createApiToEventBridgeTargetIntegrationRequestTemplates() {
-        if (!this.props.api.withResource)
-            return;
-        this.apiToEventBridgeTargetRestApi.integrationRequestTemplates = {
-            'application/json': [
-                '#set($context.requestOverride.header.X-Amz-Target = "AWSEvents.PutEvents")',
-                '#set($context.requestOverride.header.Content-Type = "application/x-amz-json-1.1")',
-                `{
-          "Entries": [
-            {
-              "EventBusName": "${this.apiEvent.eventBus.eventBusName}",
-              "Source": "api-to-eventbridge-target",
-              "DetailType": "$util.escapeJavaScript($context.domainName)$util.escapeJavaScript($context.resourcePath)",
-              "Detail": "$util.escapeJavaScript($input.body).replaceAll("\\\\'","'")"
-            }
-          ]
-        }`,
-            ].join('\r'),
-        };
-    }
-    /**
-     * @summary Method to create api integration response
-     */
-    createApiToEventBridgeTargetIntegrationResponse() {
-        if (!this.props.api.withResource)
-            return;
-        this.apiToEventBridgeTargetRestApi.integrationResponse = this.props.api.integrationResponse ?? {
-            responseTemplates: {
-                'application/json': JSON.stringify({ message: 'Payload Submitted' }),
-            },
-            statusCode: '200',
-        };
-    }
-    /**
-     * @summary Method to create api integration error response
-     */
-    createApiToEventBridgeTargetIntegrationErrorResponse() {
-        if (!this.props.api.withResource)
-            return;
-        this.apiToEventBridgeTargetRestApi.integrationErrorResponse = {
-            responseParameters: {
-                'method.response.header.Access-Control-Allow-Credentials': "'true'",
-                'method.response.header.Access-Control-Allow-Origin': "'*'",
-                'method.response.header.Content-Type': "'application/json'",
-            },
-            responseTemplates: {
-                'application/json': JSON.stringify({
-                    message: "$util.escapeJavaScript($input.path('$.errorMessage'))",
-                    state: 'error',
-                }),
-            },
-            selectionPattern: '^\\[Error\\].*',
-            statusCode: '400',
-            ...this.props.api.integrationErrorResponse,
-        };
-    }
-    /**
-     * @summary Method to create api integration
-     */
-    createApiToEventBridgeTargetIntegration() {
-        if (!this.props.api.withResource)
-            return;
-        this.apiToEventBridgeTargetRestApi.integration = new Integration({
-            integrationHttpMethod: 'POST',
-            options: {
-                credentialsRole: this.apiToEventBridgeTargetRestApi.role,
-                integrationResponses: [
-                    this.apiToEventBridgeTargetRestApi.integrationResponse,
-                    this.apiToEventBridgeTargetRestApi.integrationErrorResponse,
-                ],
-                passthroughBehavior: PassthroughBehavior.NEVER,
-                requestParameters: this.apiToEventBridgeTargetRestApi.integrationRequestParameters,
-                requestTemplates: this.apiToEventBridgeTargetRestApi.integrationRequestTemplates,
-                ...this.props.api.integrationOptions,
-            },
-            type: IntegrationType.AWS,
-            uri: `arn:aws:apigateway:${this.props.region}:events:path//`,
-        });
-    }
-    /**
-     * @summary Method to create api integration method response
-     */
-    createApiToEventBridgeTargetMethodResponse() {
-        if (!this.props.api.withResource)
-            return;
-        this.apiToEventBridgeTargetRestApi.methodResponse = {
-            responseModels: {
-                'application/json': this.apiToEventBridgeTargetRestApi.responseModel,
-            },
-            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
-     */
-    createApiToEventBridgeTargetMethodErrorResponse() {
-        if (!this.props.api.withResource)
-            return;
-        this.apiToEventBridgeTargetRestApi.methodErrorResponse = {
-            responseModels: {
-                'application/json': this.apiToEventBridgeTargetRestApi.errorResponseModel,
-            },
-            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,
-        };
-    }
-    /**
-     * @summary Method to create rest restApi for Api
-     */
-    createApiToEventBridgeTargetRestApi() {
-        if (this.props.api.useExisting && this.props.api.importedRestApiRef) {
-            this.apiToEventBridgeTargetRestApi.api = RestApi.fromRestApiId(this, `${this.id}-rest-api`, Fn.importValue(this.props.api.importedRestApiRef));
-            return;
-        }
-        if (!this.props.api.restApi?.restApiName)
-            throw `RestApi name undefined for ${this.id}`;
-        const restApiName = this.resourceNameFormatter.format(this.props.api.restApi?.restApiName, this.props.resourceNameOptions?.apigateway);
-        const restApiAccessLogName = this.resourceNameFormatter.format(`${this.props.api.restApi?.restApiName}-access`, this.props.resourceNameOptions?.apigateway);
-        this.apiToEventBridgeTargetRestApi.accessLogGroup = this.logManager.createLogGroup(`${this.id}-rest-api-access-log`, this, {
-            logGroupName: restApiAccessLogName,
-            removalPolicy: RemovalPolicy.DESTROY,
-        });
-        this.apiToEventBridgeTargetRestApi.api = new RestApi(this, `${this.id}-rest-api`, {
-            cloudWatchRole: this.props.api.restApi?.cloudWatchRole ?? true,
-            defaultCorsPreflightOptions: {
-                allowHeaders: Cors.DEFAULT_HEADERS,
-                allowMethods: ['POST'],
-                allowOrigins: Cors.ALL_ORIGINS,
-            },
-            defaultIntegration: this.apiToEventBridgeTargetRestApi.integration,
-            defaultMethodOptions: {
-                methodResponses: [
-                    this.apiToEventBridgeTargetRestApi.methodResponse,
-                    this.apiToEventBridgeTargetRestApi.methodErrorResponse,
-                ],
-            },
-            deploy: this.props.api.restApi?.deploy ?? true,
-            deployOptions: {
-                accessLogDestination: new LogGroupLogDestination(this.apiToEventBridgeTargetRestApi.accessLogGroup),
-                accessLogFormat: AccessLogFormat.jsonWithStandardFields(),
-                dataTraceEnabled: this.props.api.restApi?.deployOptions?.dataTraceEnabled,
-                description: `${this.id} - ${this.props.stage} stage`,
-                loggingLevel: MethodLoggingLevel.INFO,
-                metricsEnabled: true,
-                stageName: this.props.stage,
-                tracingEnabled: this.props.api.restApi?.deployOptions?.tracingEnabled,
-            },
-            endpointConfiguration: {
-                types: [EndpointType.REGIONAL],
-            },
-            ...this.props.api.restApi,
-            restApiName,
-        });
-        this.addCfnOutput(`${this.id}-restApiId`, this.apiToEventBridgeTargetRestApi.api.restApiId);
-        this.addCfnOutput(`${this.id}-restApiRootResourceId`, this.apiToEventBridgeTargetRestApi.api.root.resourceId);
-    }
-    /**
-     * @summary Method to create api integration response model
-     */
-    createApiToEventBridgeTargetResponseModel() {
-        if (!this.props.api.withResource)
-            return;
-        this.apiToEventBridgeTargetRestApi.responseModel = new Model(this, `${this.id}-response-model`, {
-            restApi: this.apiToEventBridgeTargetRestApi.api,
-            contentType: 'application/json',
-            modelName: 'ResponseModel',
-            schema: {
-                properties: { message: { type: JsonSchemaType.STRING } },
-                schema: JsonSchemaVersion.DRAFT4,
-                title: 'pollResponse',
-                type: JsonSchemaType.OBJECT,
-            },
-            ...this.props.api.responseModel,
-        });
-    }
-    /**
-     * @summary Method to create api integration error response model
-     */
-    createApiToEventBridgeTargetErrorResponseModel() {
-        if (!this.props.api.withResource)
-            return;
-        this.apiToEventBridgeTargetRestApi.errorResponseModel = new Model(this, `${this.id}-error-response-model`, {
-            restApi: this.apiToEventBridgeTargetRestApi.api,
-            contentType: 'application/json',
-            modelName: 'ErrorResponseModel',
-            schema: {
-                properties: {
-                    message: { type: JsonSchemaType.STRING },
-                    state: { type: JsonSchemaType.STRING },
-                },
-                schema: JsonSchemaVersion.DRAFT4,
-                title: 'errorResponse',
-                type: JsonSchemaType.OBJECT,
-            },
-            ...this.props.api.errorResponseModel,
-        });
-    }
-    /**
-     * @summary Method to create api integration resource
-     */
-    createApiToEventBridgeTargetResource() {
-        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.apiToEventBridgeTargetRestApi.api,
-            });
-        }
-        else {
-            rootResource = this.apiToEventBridgeTargetRestApi.api.root;
-        }
-        this.apiToEventBridgeTargetRestApi.resource = rootResource.addResource(this.props.api.resource ?? this.apiResource);
-    }
-    /**
-     * @summary Method to create api integration resource method
-     */
-    createApiToEventBridgeTargetResourceMethod() {
-        if (!this.props.api.withResource)
-            return;
-        this.apiToEventBridgeTargetRestApi.method = this.apiToEventBridgeTargetRestApi.resource.addMethod('POST', this.apiToEventBridgeTargetRestApi.integration, {
-            authorizer: this.apiToEventBridgeTargetRestApi.authoriser,
-            methodResponses: [
-                this.apiToEventBridgeTargetRestApi.methodResponse,
-                this.apiToEventBridgeTargetRestApi.methodErrorResponse,
-            ],
-        });
-    }
-    /**
-     * @summary Method to create custom restApi domain for Api
-     */
-    createApiDomain() {
-        if (this.props.api.useExisting)
-            return;
-        this.apiToEventBridgeTargetRestApi.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.apiToEventBridgeTargetRestApi.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.apiToEventBridgeTargetRestApi.domain,
-            restApi: this.apiToEventBridgeTargetRestApi.api,
-            stage: this.apiToEventBridgeTargetRestApi.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.apiToEventBridgeTargetRestApi.domain, this.apiToEventBridgeTargetRestApi.hostedZone, this.props.skipStageForARecords);
-    }
-}

package/dist/src/lib/aws/construct/api-to-eventbridge-target/types.d.ts

@@ -1,100 +0,0 @@
-import { DomainName, IAuthorizer, Integration, IntegrationOptions, IntegrationResponse, IRestApi, Method, MethodResponse, Model, ModelOptions, Resource } from 'aws-cdk-lib/aws-apigateway';
-import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager';
-import { IEventBus, Rule } from 'aws-cdk-lib/aws-events';
-import { PolicyDocument, Role } from 'aws-cdk-lib/aws-iam';
-import { AssetCode } from 'aws-cdk-lib/aws-lambda';
-import { LogGroup } from 'aws-cdk-lib/aws-logs';
-import { IHostedZone } from 'aws-cdk-lib/aws-route53';
-import { ITopic } from 'aws-cdk-lib/aws-sns';
-import { CommonStackProps } from '../../common/index.js';
-import { AcmProps, EventRuleProps, LambdaProps, LogProps, RestApigProps } from '../../services/index.js';
-/**
- */
-export interface ApiToEventBridgeTargetEventType {
-    eventBus: IEventBus;
-    logGroup: LogGroup;
-    logGroupFailure: LogGroup;
-    logGroupSuccess: LogGroup;
-    rule: Rule;
-    ruleFailure: Rule;
-    ruleSuccess: Rule;
-}
-/**
- */
-export interface ApiToEventBridgeTargetRestApiType {
-    accessLogGroup: LogGroup;
-    api: IRestApi;
-    authoriser?: IAuthorizer;
-    certificate: ICertificate;
-    domain: DomainName;
-    errorResponseModel: Model;
-    hostedZone: IHostedZone;
-    integration: Integration;
-    integrationErrorResponse: IntegrationResponse;
-    integrationRequestParameters: {
-        [p: string]: string;
-    };
-    integrationRequestTemplates: {
-        [p: string]: string;
-    };
-    integrationResponse: IntegrationResponse;
-    method: Method;
-    methodErrorResponse: MethodResponse;
-    methodResponse: MethodResponse;
-    policy?: PolicyDocument;
-    resource: Resource;
-    responseModel: Model;
-    role?: Role;
-    topic?: ITopic;
-}
-/**
- */
-export interface ApiToEventBridgeTargetRestApiProps {
-    certificate: AcmProps;
-    errorResponseModel?: ModelOptions;
-    importedRestApiRef?: string;
-    importedRestApiRootResourceRef?: string;
-    integrationErrorResponse?: IntegrationResponse;
-    integrationOptions?: IntegrationOptions;
-    integrationResponse?: IntegrationResponse;
-    methodErrorResponse?: MethodResponse;
-    methodResponse?: MethodResponse;
-    resource: string;
-    responseModel?: ModelOptions;
-    restApi?: RestApigProps;
-    useExisting: boolean;
-    withResource?: boolean;
-}
-/**
- */
-interface ApiToEventBridgeTargetLambdaProps {
-    function: LambdaProps;
-    handler?: string;
-    layerSource?: AssetCode;
-    source?: AssetCode;
-}
-/**
- */
-interface ApiToEventBridgeTargetEventProps {
-    eventBusName?: string;
-    logGroup?: LogProps;
-    logGroupFailure?: LogProps;
-    logGroupSuccess?: LogProps;
-    rule: EventRuleProps;
-    ruleFailure: EventRuleProps;
-    ruleSuccess: EventRuleProps;
-}
-/**
- */
-export interface ApiToEventBridgeTargetProps extends CommonStackProps {
-    api: ApiToEventBridgeTargetRestApiProps;
-    apiRootPaths?: string[];
-    apiSubDomain: string;
-    event: ApiToEventBridgeTargetEventProps;
-    lambda?: ApiToEventBridgeTargetLambdaProps;
-    logLevel: string;
-    nodeEnv: string;
-    timezone: string;
-    useExistingHostedZone: boolean;
-}
-export {};

package/dist/src/lib/aws/construct/api-to-eventbridge-target/types.js

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

package/dist/src/lib/aws/construct/api-to-eventbridge-target-with-sns/api-destined-lambda.d.ts

@@ -1,16 +0,0 @@
-import { PolicyDocument, Role } from 'aws-cdk-lib/aws-iam';
-import { IFunction, LayerVersion } from 'aws-cdk-lib/aws-lambda';
-import { EventBridgeDestination } from 'aws-cdk-lib/aws-lambda-destinations';
-import { ApiDestinedLambdaEnvironment, ApiDestinedLambdaType } from './types.js';
-/**
- * @classdesc Provides a construct to contain lambda resources for ApiToEventBridgeTargetWithSns
- */
-export declare class ApiDestinedLambda implements ApiDestinedLambdaType {
-    destinationFailure: EventBridgeDestination;
-    destinationSuccess: EventBridgeDestination;
-    environment: ApiDestinedLambdaEnvironment;
-    function: IFunction;
-    layers: LayerVersion[];
-    policy: PolicyDocument;
-    role: Role;
-}

package/dist/src/lib/aws/construct/api-to-eventbridge-target-with-sns/api-destined-lambda.js

@@ -1,12 +0,0 @@
-/**
- * @classdesc Provides a construct to contain lambda resources for ApiToEventBridgeTargetWithSns
- */
-export class ApiDestinedLambda {
-    destinationFailure;
-    destinationSuccess;
-    environment;
-    function;
-    layers;
-    policy;
-    role;
-}

package/dist/src/lib/aws/construct/api-to-eventbridge-target-with-sns/index.d.ts

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

package/dist/src/lib/aws/construct/api-to-eventbridge-target-with-sns/index.js

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