@gradientedge/cdk-utils-aws 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Gradient Edge, https://github.com/gradientedge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/src/common/construct.d.ts

@@ -0,0 +1,85 @@
+import { CfnOutput } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { AcmManager, ApiManager, AppConfigManager, CloudFrontManager, CloudTrailManager, CloudWatchManager, CodeBuildManager, DynamodbManager, EcrManager, EcsManager, EfsManager, EksManager, ElastiCacheManager, EventManager, EventTargetManager, EvidentlyManager, IamManager, KmsManager, LambdaManager, LogManager, Route53Manager, S3Manager, SecretsManager, SfnManager, SnsManager, SqsManager, SsmManager, VpcManager, WafManager } from '../services/index.js';
+import { ResourceNameFormatter } from './resource-name-formatter.js';
+import { CommonStackProps } from './types.js';
+/**
+ * @subcategory Construct
+ * @classdesc Common construct to use as a base for all higher level constructs.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils';
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props);
+ *     this.props = props;
+ *   };
+ * };
+ */
+export declare class CommonConstruct extends Construct {
+    props: CommonStackProps;
+    resourceNameFormatter: ResourceNameFormatter;
+    acmManager: AcmManager;
+    apiManager: ApiManager;
+    appConfigManager: AppConfigManager;
+    codeBuildManager: CodeBuildManager;
+    cloudFrontManager: CloudFrontManager;
+    cloudTrailManager: CloudTrailManager;
+    cloudWatchManager: CloudWatchManager;
+    dynamodbManager: DynamodbManager;
+    ecrManager: EcrManager;
+    ecsManager: EcsManager;
+    efsManager: EfsManager;
+    eksManager: EksManager;
+    elasticacheManager: ElastiCacheManager;
+    eventManager: EventManager;
+    eventTargetManager: EventTargetManager;
+    evidentlyManager: EvidentlyManager;
+    iamManager: IamManager;
+    kmsManager: KmsManager;
+    lambdaManager: LambdaManager;
+    logManager: LogManager;
+    route53Manager: Route53Manager;
+    s3Manager: S3Manager;
+    secretsManager: SecretsManager;
+    sfnManager: SfnManager;
+    snsManager: SnsManager;
+    sqsManager: SqsManager;
+    ssmManager: SsmManager;
+    vpcManager: VpcManager;
+    wafManager: WafManager;
+    fullyQualifiedDomainName: string;
+    constructor(parent: Construct, id: string, props: CommonStackProps);
+    /**
+     * @summary Helper method to add CloudFormation outputs from the construct
+     * @param id scoped id of the resource
+     * @param value the value of the exported output
+     * @param description optional description for the output
+     * @param overrideId Flag which indicates whether to override the default logical id of the output
+     */
+    protected addCfnOutput(id: string, value: string, description?: string, overrideId?: boolean): CfnOutput;
+    /**
+     * @summary Determine the fully qualified domain name based on domainName & subDomain
+     */
+    protected determineFullyQualifiedDomain(): void;
+    /**
+     * @summary Utility method to determine if the initialisation is in development (dev) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isDevelopmentStage: () => boolean;
+    /**
+     * @summary Utility method to determine if the initialisation is in test (tst) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isTestStage: () => boolean;
+    /**
+     * @summary Utility method to determine if the initialisation is in uat (uat) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isUatStage: () => boolean;
+    /**
+     * @summary Utility method to determine if the initialisation is in production (prd) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isProductionStage: () => boolean;
+}

package/dist/src/common/construct.js

@@ -0,0 +1,125 @@
+import { Construct } from 'constructs';
+import { isDevStage, isPrdStage, isTestStage, isUatStage } from '@gradientedge/cdk-utils-common';
+import { AcmManager, ApiManager, AppConfigManager, CloudFrontManager, CloudTrailManager, CloudWatchManager, CodeBuildManager, DynamodbManager, EcrManager, EcsManager, EfsManager, EksManager, ElastiCacheManager, EventManager, EventTargetManager, EvidentlyManager, IamManager, KmsManager, LambdaManager, LogManager, Route53Manager, S3Manager, SecretsManager, SfnManager, SnsManager, SqsManager, SsmManager, VpcManager, WafManager, } from '../services/index.js';
+import { createCfnOutput } from '../utils/index.js';
+import { ResourceNameFormatter } from './resource-name-formatter.js';
+/**
+ * @subcategory Construct
+ * @classdesc Common construct to use as a base for all higher level constructs.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils';
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props);
+ *     this.props = props;
+ *   };
+ * };
+ */
+export class CommonConstruct extends Construct {
+    props;
+    resourceNameFormatter;
+    acmManager;
+    apiManager;
+    appConfigManager;
+    codeBuildManager;
+    cloudFrontManager;
+    cloudTrailManager;
+    cloudWatchManager;
+    dynamodbManager;
+    ecrManager;
+    ecsManager;
+    efsManager;
+    eksManager;
+    elasticacheManager;
+    eventManager;
+    eventTargetManager;
+    evidentlyManager;
+    iamManager;
+    kmsManager;
+    lambdaManager;
+    logManager;
+    route53Manager;
+    s3Manager;
+    secretsManager;
+    sfnManager;
+    snsManager;
+    sqsManager;
+    ssmManager;
+    vpcManager;
+    wafManager;
+    fullyQualifiedDomainName;
+    constructor(parent, id, props) {
+        super(parent, id);
+        this.props = props;
+        this.resourceNameFormatter = new ResourceNameFormatter(this, `${id}-rnf`, props);
+        this.acmManager = new AcmManager();
+        this.apiManager = new ApiManager();
+        this.appConfigManager = new AppConfigManager();
+        this.codeBuildManager = new CodeBuildManager();
+        this.cloudFrontManager = new CloudFrontManager();
+        this.cloudTrailManager = new CloudTrailManager();
+        this.cloudWatchManager = new CloudWatchManager();
+        this.dynamodbManager = new DynamodbManager();
+        this.ecrManager = new EcrManager();
+        this.ecsManager = new EcsManager();
+        this.efsManager = new EfsManager();
+        this.eksManager = new EksManager();
+        this.elasticacheManager = new ElastiCacheManager();
+        this.eventManager = new EventManager();
+        this.eventTargetManager = new EventTargetManager();
+        this.evidentlyManager = new EvidentlyManager();
+        this.iamManager = new IamManager();
+        this.kmsManager = new KmsManager();
+        this.lambdaManager = new LambdaManager();
+        this.logManager = new LogManager();
+        this.route53Manager = new Route53Manager();
+        this.s3Manager = new S3Manager();
+        this.secretsManager = new SecretsManager();
+        this.sfnManager = new SfnManager();
+        this.snsManager = new SnsManager();
+        this.sqsManager = new SqsManager();
+        this.ssmManager = new SsmManager();
+        this.vpcManager = new VpcManager();
+        this.wafManager = new WafManager();
+        this.determineFullyQualifiedDomain();
+    }
+    /**
+     * @summary Helper method to add CloudFormation outputs from the construct
+     * @param id scoped id of the resource
+     * @param value the value of the exported output
+     * @param description optional description for the output
+     * @param overrideId Flag which indicates whether to override the default logical id of the output
+     */
+    addCfnOutput(id, value, description, overrideId = true) {
+        return createCfnOutput(id, this, value, description, overrideId);
+    }
+    /**
+     * @summary Determine the fully qualified domain name based on domainName & subDomain
+     */
+    determineFullyQualifiedDomain() {
+        this.fullyQualifiedDomainName = this.props.subDomain
+            ? `${this.props.subDomain}.${this.props.domainName}`
+            : this.props.domainName;
+    }
+    /**
+     * @summary Utility method to determine if the initialisation is in development (dev) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isDevelopmentStage = () => isDevStage(this.props.stage);
+    /**
+     * @summary Utility method to determine if the initialisation is in test (tst) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isTestStage = () => isTestStage(this.props.stage);
+    /**
+     * @summary Utility method to determine if the initialisation is in uat (uat) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isUatStage = () => isUatStage(this.props.stage);
+    /**
+     * @summary Utility method to determine if the initialisation is in production (prd) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isProductionStage = () => isPrdStage(this.props.stage);
+}

package/dist/src/common/index.d.ts

@@ -0,0 +1,4 @@
+export * from './construct.js';
+export * from './resource-name-formatter.js';
+export * from './stack.js';
+export * from './types.js';

package/dist/src/common/index.js

@@ -0,0 +1,4 @@
+export * from './construct.js';
+export * from './resource-name-formatter.js';
+export * from './stack.js';
+export * from './types.js';

package/dist/src/common/resource-name-formatter.d.ts

@@ -0,0 +1,13 @@
+import { Construct } from 'constructs';
+import { CommonStackProps, ResourceNameFormatterProps } from './types.js';
+export declare class ResourceNameFormatter extends Construct {
+    props: CommonStackProps;
+    constructor(parent: Construct, id: string, props: CommonStackProps);
+    /**
+     * @summary Helper method to format a resource name based on the provided options
+     * @param resourceName the resource name to format
+     * @param options options to control the formatting of the resource name
+     * @returns The formatted resource name
+     */
+    format(resourceName: string, options?: ResourceNameFormatterProps): string;
+}

package/dist/src/common/resource-name-formatter.js

@@ -0,0 +1,30 @@
+import { Construct } from 'constructs';
+export class ResourceNameFormatter extends Construct {
+    props;
+    constructor(parent, id, props) {
+        super(parent, id);
+        this.props = props;
+    }
+    /**
+     * @summary Helper method to format a resource name based on the provided options
+     * @param resourceName the resource name to format
+     * @param options options to control the formatting of the resource name
+     * @returns The formatted resource name
+     */
+    format(resourceName, options) {
+        const elements = [];
+        if (!options?.exclude) {
+            if (options?.globalPrefix)
+                elements.push(this.props.globalPrefix);
+            elements.push(options?.prefix ?? this.props.resourcePrefix);
+        }
+        elements.push(resourceName);
+        if (!options?.exclude) {
+            elements.push(options?.suffix ?? this.props.resourceSuffix);
+            if (options?.globalSuffix)
+                elements.push(this.props.globalSuffix);
+        }
+        elements.push(this.props.stage);
+        return elements.filter(Boolean).join('-');
+    }
+}

package/dist/src/common/stack.d.ts

@@ -0,0 +1,62 @@
+import { App, Stack, StackProps } from 'aws-cdk-lib';
+import { Runtime } from 'aws-cdk-lib/aws-lambda';
+import { CommonConstruct } from './construct.js';
+import { CommonStackProps } from './types.js';
+/**
+ * @classdesc Common stack to use as a base for all higher level constructs.
+ * @example
+ * import { CommonStack } from '@gradientedge/cdk-utils'
+ *
+ * class CustomStack extends CommonStack {
+ *   constructor(parent: App, name: string, props: StackProps) {
+ *     super(parent, name, props)
+ *     // provision resources
+ *   }
+ * }
+ */
+export declare class CommonStack extends Stack {
+    static NODEJS_RUNTIME: Runtime;
+    construct: CommonConstruct;
+    props: CommonStackProps;
+    constructor(parent: App, name: string, props: StackProps);
+    /**
+     * @summary Method to determine the core CDK construct properties injected via context cdk.json
+     * @param props The stack properties
+     * @returns The stack properties
+     */
+    protected determineConstructProps(props: StackProps): {
+        domainName: any;
+        excludeDomainNameForBuckets: any;
+        excludeAccountNumberForBuckets: any;
+        extraContexts: any;
+        logRetention: any;
+        name: string;
+        nodejsRuntime: any;
+        region: any;
+        globalPrefix: any;
+        globalSuffix: any;
+        resourceNameOptions: any;
+        resourcePrefix: any;
+        resourceSuffix: any;
+        skipStageForARecords: any;
+        stackName: string | undefined;
+        stage: any;
+        subDomain: any;
+    };
+    /**
+     * @summary Method to determine extra cdk contexts apart from the main cdk.json
+     * - Sets the properties from the extra contexts into cdk node context
+     * - Primary use is to have layered config in separate files to enable easier maintenance and readability
+     */
+    protected determineExtraContexts(): void;
+    /**
+     * @summary Method to determine extra cdk stage contexts apart from the main cdk.json
+     * - Sets the properties from the extra stage contexts into cdk node context
+     * - Primary use is to have layered config for each environment which is injected into the context
+     */
+    protected determineStageContexts(): void;
+    /**
+     * @summary Determine the fully qualified domain name based on domainName & subDomain
+     */
+    protected fullyQualifiedDomain(): any;
+}

package/dist/src/common/stack.js

@@ -0,0 +1,139 @@
+import { Stack } from 'aws-cdk-lib';
+import { Runtime } from 'aws-cdk-lib/aws-lambda';
+import fs from 'fs';
+import path from 'path';
+import { CommonConstruct } from './construct.js';
+import appRoot from 'app-root-path';
+import _ from 'lodash';
+import { isDevStage } from '@gradientedge/cdk-utils-common';
+/**
+ * @classdesc Common stack to use as a base for all higher level constructs.
+ * @example
+ * import { CommonStack } from '@gradientedge/cdk-utils'
+ *
+ * class CustomStack extends CommonStack {
+ *   constructor(parent: App, name: string, props: StackProps) {
+ *     super(parent, name, props)
+ *     // provision resources
+ *   }
+ * }
+ */
+export class CommonStack extends Stack {
+    static NODEJS_RUNTIME = Runtime.NODEJS_24_X;
+    construct;
+    props;
+    constructor(parent, name, props) {
+        super(parent, name, props);
+        /* determine extra cdk contexts */
+        this.determineExtraContexts();
+        /* determine extra cdk stage contexts */
+        this.determineStageContexts();
+        this.props = this.determineConstructProps(props);
+        /* initialise the construct */
+        this.construct = new CommonConstruct(this, 'cdk-utils', this.props);
+    }
+    /**
+     * @summary Method to determine the core CDK construct properties injected via context cdk.json
+     * @param props The stack properties
+     * @returns The stack properties
+     */
+    determineConstructProps(props) {
+        return {
+            domainName: this.node.tryGetContext('domainName'),
+            excludeDomainNameForBuckets: this.node.tryGetContext('excludeDomainNameForBuckets'),
+            excludeAccountNumberForBuckets: this.node.tryGetContext('excludeAccountNumberForBuckets'),
+            extraContexts: this.node.tryGetContext('extraContexts'),
+            logRetention: this.node.tryGetContext('logRetention'),
+            name: props.stackName || 'cdk-utils',
+            nodejsRuntime: this.node.tryGetContext('nodejsRuntime') ?? CommonStack.NODEJS_RUNTIME,
+            region: this.node.tryGetContext('region'),
+            globalPrefix: this.node.tryGetContext('globalPrefix'),
+            globalSuffix: this.node.tryGetContext('globalSuffix'),
+            resourceNameOptions: this.node.tryGetContext('resourceNameOptions'),
+            resourcePrefix: this.node.tryGetContext('resourcePrefix'),
+            resourceSuffix: this.node.tryGetContext('resourceSuffix'),
+            skipStageForARecords: this.node.tryGetContext('skipStageForARecords'),
+            stackName: props.stackName,
+            stage: this.node.tryGetContext('stage'),
+            subDomain: this.node.tryGetContext('subDomain'),
+        };
+    }
+    /**
+     * @summary Method to determine extra cdk contexts apart from the main cdk.json
+     * - Sets the properties from the extra contexts into cdk node context
+     * - Primary use is to have layered config in separate files to enable easier maintenance and readability
+     */
+    determineExtraContexts() {
+        const extraContexts = this.node.tryGetContext('extraContexts');
+        const debug = this.node.tryGetContext('debug');
+        if (!extraContexts) {
+            if (debug)
+                console.debug(`No additional contexts provided. Using default context properties from cdk.json`);
+            return;
+        }
+        _.forEach(extraContexts, (context) => {
+            const extraContextPath = path.join(appRoot.path, context);
+            /* scenario where extra context is configured in cdk.json but absent in file system */
+            if (!fs.existsSync(extraContextPath))
+                throw `Extra context properties unavailable in path:${extraContextPath}`;
+            /* read the extra properties */
+            const extraContextPropsBuffer = fs.readFileSync(extraContextPath);
+            if (debug)
+                console.debug(`Adding additional contexts provided in ${extraContextPath}`);
+            /* parse as JSON properties */
+            const extraContextProps = JSON.parse(extraContextPropsBuffer.toString('utf-8'));
+            /* set each of the property into the cdk node context */
+            _.keys(extraContextProps).forEach((propKey) => {
+                this.node.setContext(propKey, extraContextProps[propKey]);
+            });
+        });
+    }
+    /**
+     * @summary Method to determine extra cdk stage contexts apart from the main cdk.json
+     * - Sets the properties from the extra stage contexts into cdk node context
+     * - Primary use is to have layered config for each environment which is injected into the context
+     */
+    determineStageContexts() {
+        const stage = this.node.tryGetContext('stage');
+        const stageContextPath = this.node.tryGetContext('stageContextPath') || 'cdkEnv';
+        const stageContextFilePath = path.join(appRoot.path, stageContextPath, `${stage}.json`);
+        const debug = this.node.tryGetContext('debug');
+        if (isDevStage(stage)) {
+            if (debug)
+                console.debug(`Development stage. Using default stage context properties`);
+        }
+        /* alert default context usage when extra stage config is missing */
+        if (!fs.existsSync(stageContextFilePath)) {
+            if (debug)
+                console.debug(`Stage specific context properties unavailable in path:${stageContextFilePath}`);
+            if (debug)
+                console.debug(`Using default stage context properties for ${stage} stage`);
+            return;
+        }
+        /* read the extra properties */
+        const stageContextPropsBuffer = fs.readFileSync(stageContextFilePath);
+        if (debug)
+            console.debug(`Adding additional stage contexts provided in ${stageContextFilePath}`);
+        /* parse as JSON properties */
+        const stageContextProps = JSON.parse(stageContextPropsBuffer.toString('utf-8'));
+        /* set each of the property into the cdk node context */
+        _.keys(stageContextProps).forEach((propKey) => {
+            /* handle object, array properties */
+            if (typeof stageContextProps[propKey] === 'object' && !Array.isArray(stageContextProps[propKey])) {
+                this.node.setContext(propKey, _.merge(this.node.tryGetContext(propKey), stageContextProps[propKey]));
+            }
+            else {
+                /* handle all other primitive properties */
+                this.node.setContext(propKey, stageContextProps[propKey]);
+            }
+        });
+    }
+    /**
+     * @summary Determine the fully qualified domain name based on domainName & subDomain
+     */
+    fullyQualifiedDomain() {
+        const domainName = this.node.tryGetContext('domainName');
+        const subDomain = this.node.tryGetContext('subDomain');
+        return subDomain ? `${subDomain}.${domainName}` : domainName;
+    }
+}

package/dist/src/common/types.d.ts

@@ -0,0 +1,30 @@
+import { StackProps } from 'aws-cdk-lib';
+import { Runtime, Tracing } from 'aws-cdk-lib/aws-lambda';
+import { RetentionDays } from 'aws-cdk-lib/aws-logs';
+import { BaseProps } from '@gradientedge/cdk-utils-common';
+/**
+ */
+export interface CommonStackProps extends BaseProps, StackProps {
+    region: string;
+    resourceProjectIdentifier?: string;
+    globalPrefix?: string;
+    globalSuffix?: string;
+    resourcePrefix?: string;
+    resourceSuffix?: string;
+    logRetention?: RetentionDays;
+    defaultReservedLambdaConcurrentExecutions?: number;
+    defaultTracing?: Tracing;
+    excludeDomainNameForBuckets?: boolean;
+    excludeAccountNumberForBuckets?: boolean;
+    nodejsRuntime?: Runtime;
+    resourceNameOptions?: {
+        [key: string]: ResourceNameFormatterProps;
+    };
+}
+export interface ResourceNameFormatterProps {
+    exclude?: boolean;
+    globalPrefix?: boolean;
+    globalSuffix?: boolean;
+    prefix?: string;
+    suffix?: string;
+}

package/dist/src/common/types.js

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

package/dist/src/construct/api-to-any-target/index.d.ts

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

package/dist/src/construct/api-to-any-target/index.js

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

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

@@ -0,0 +1,47 @@
+import { Resource } from 'aws-cdk-lib/aws-apigateway';
+import { ISecret } from 'aws-cdk-lib/aws-secretsmanager';
+import { Construct } from 'constructs';
+import { CommonConstruct } from '../../common/index.js';
+import { ApiToAnyTargetProps, ApiToAnyTargetRestApiResource, ApiToAnyTargetRestApiType } from './types.js';
+/**
+ * @classdesc Provides a construct to create and deploy a shallow API Gateway
+ * @example
+ * import { ApiToAnyTarget, ApiToAnyTargetProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends ApiToAnyTarget {
+ *   constructor(parent: Construct, id: string, props: ApiToAnyTargetProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export declare class ApiToAnyTarget extends CommonConstruct {
+    props: ApiToAnyTargetProps;
+    id: string;
+    applicationSecrets: ISecret[];
+    apiToAnyTargetRestApi: ApiToAnyTargetRestApiType;
+    apiResource: string;
+    constructor(parent: Construct, id: string, props: ApiToAnyTargetProps);
+    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;
+    protected createApiToAnyTargetRestApi(): void;
+    protected createApiToAnyTargetResource(apiResourceProps: ApiToAnyTargetRestApiResource): Resource | undefined;
+    protected createApiDomain(): void;
+    protected createApiBasePathMapping(): void;
+    protected createApiRouteAssets(): void;
+}