@gradientedge/cdk-utils 8.120.0 → 8.122.0

package/src/lib/azure/services/storage/main.ts

@@ -0,0 +1,134 @@
+import { DataAzurermResourceGroup } from '@cdktf/provider-azurerm/lib/data-azurerm-resource-group'
+import { DataAzurermStorageAccount } from '@cdktf/provider-azurerm/lib/data-azurerm-storage-account'
+import { DataAzurermStorageContainer } from '@cdktf/provider-azurerm/lib/data-azurerm-storage-container'
+import { StorageAccount } from '@cdktf/provider-azurerm/lib/storage-account'
+import { StorageBlob } from '@cdktf/provider-azurerm/lib/storage-blob'
+import { StorageContainer } from '@cdktf/provider-azurerm/lib/storage-container'
+import { CommonAzureConstruct } from '../../common'
+import { createTfOutput } from '../../utils'
+import { StorageAccountProps, StorageBlobProps, StorageContainerProps } from './types'
+
+/**
+ * @classdesc Provides operations on Azure Storage
+ * - A new instance of this class is injected into {@link CommonAzureConstruct} constructor.
+ * - If a custom construct extends {@link CommonAzureConstruct}, an instance is available within the context.
+ * @example
+ * ```
+ * import { CommonAzureConstruct, CommonAzureStackProps } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonAzureConstruct {
+ *   constructor(parent: Construct, id: string, props: CommonAzureStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.storageManager.createStorageAccount('MyAccount', this, props)
+ *   }
+ * }
+ * @see [CDKTF S3 Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3-readme.html}
+ * ```
+ */
+export class AzureStorageManager {
+  /**
+   * @summary Method to create a new storage account
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props storage account properties
+   */
+  public createStorageAccount(id: string, scope: CommonAzureConstruct, props: StorageAccountProps) {
+    if (!props) throw `Props undefined for ${id}`
+
+    const resourceGroup = new DataAzurermResourceGroup(scope, `${id}-sc-rg`, {
+      name: scope.props.resourceGroupName
+        ? `${scope.props.resourceGroupName}-${scope.props.stage}`
+        : `${props.resourceGroupName}-${scope.props.stage}`,
+    })
+
+    if (!resourceGroup) throw `Resource group undefined for ${id}`
+
+    const storageAccount = new StorageAccount(scope, `${id}-sa`, {
+      ...props,
+      accountTier: props.accountTier ?? 'Standard',
+      location: props.location ?? resourceGroup.location,
+      name: `${props.name}-${scope.props.stage}`,
+      resourceGroupName: resourceGroup.name,
+      tags: props.tags ?? {
+        environment: scope.props.stage,
+      },
+    })
+
+    createTfOutput(`${id}-storageAccountName`, scope, storageAccount.name)
+    createTfOutput(`${id}-storageAccountFriendlyUniqueId`, scope, storageAccount.friendlyUniqueId)
+    createTfOutput(`${id}-storageAccountId`, scope, storageAccount.id)
+  }
+
+  /**
+   * @summary Method to create a new storage container
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props storage container properties
+   */
+  public createStorageContainer(id: string, scope: CommonAzureConstruct, props: StorageContainerProps) {
+    if (!props) throw `Props undefined for ${id}`
+
+    const resourceGroup = new DataAzurermResourceGroup(scope, `${id}-sc-rg`, {
+      name: scope.props.resourceGroupName
+        ? `${scope.props.resourceGroupName}-${scope.props.stage}`
+        : `${props.resourceGroupName}-${scope.props.stage}`,
+    })
+
+    if (!resourceGroup) throw `Resource group undefined for ${id}`
+
+    const storageAccount = new DataAzurermStorageAccount(scope, `${id}-sa`, {
+      name: `${props.storageAccountName}-${scope.props.stage}`,
+      resourceGroupName: resourceGroup.name,
+    })
+
+    const storageContainer = new StorageContainer(scope, `${id}-sc`, {
+      ...props,
+      name: `${props.name}-${scope.props.stage}`,
+      storageAccountName: storageAccount.name,
+    })
+
+    createTfOutput(`${id}-storageContainerName`, scope, storageContainer.name)
+    createTfOutput(`${id}-storageContainerFriendlyUniqueId`, scope, storageContainer.friendlyUniqueId)
+    createTfOutput(`${id}-storageContainerId`, scope, storageContainer.id)
+  }
+
+  /**
+   * @summary Method to create a new storage blob
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props storage blob properties
+   */
+  public createStorageBlob(id: string, scope: CommonAzureConstruct, props: StorageBlobProps) {
+    if (!props) throw `Props undefined for ${id}`
+
+    const resourceGroup = new DataAzurermResourceGroup(scope, `${id}-sb-rg`, {
+      name: scope.props.resourceGroupName
+        ? `${scope.props.resourceGroupName}-${scope.props.stage}`
+        : `${props.resourceGroupName}-${scope.props.stage}`,
+    })
+
+    if (!resourceGroup) throw `Resource group undefined for ${id}`
+
+    const storageAccount = new DataAzurermStorageAccount(scope, `${id}-sa`, {
+      name: `${props.storageAccountName}-${scope.props.stage}`,
+      resourceGroupName: resourceGroup.name,
+    })
+
+    const storageContainer = new DataAzurermStorageContainer(scope, `${id}-sc`, {
+      name: `${props.storageContainerName}-${scope.props.stage}`,
+      storageAccountName: storageAccount.name,
+    })
+
+    const storageBlob = new StorageBlob(scope, `${id}-sb`, {
+      ...props,
+      name: `${props.name}-${scope.props.stage}`,
+      storageAccountName: storageAccount.name,
+      storageContainerName: storageContainer.name,
+    })
+
+    createTfOutput(`${id}-storageBlobName`, scope, storageBlob.name)
+    createTfOutput(`${id}-storageBlobFriendlyUniqueId`, scope, storageBlob.friendlyUniqueId)
+    createTfOutput(`${id}-storageBlobId`, scope, storageBlob.id)
+  }
+}

package/src/lib/azure/services/storage/types.ts

@@ -0,0 +1,10 @@
+import { StorageAccountConfig } from '@cdktf/provider-azurerm/lib/storage-account'
+import { StorageBlobConfig } from '@cdktf/provider-azurerm/lib/storage-blob'
+import { StorageContainerConfig } from '@cdktf/provider-azurerm/lib/storage-container'
+import { BaseConfigProps } from '../../types'
+
+export interface StorageAccountProps extends StorageAccountConfig {}
+
+export interface StorageContainerProps extends BaseConfigProps, StorageContainerConfig {}
+
+export interface StorageBlobProps extends BaseConfigProps, StorageBlobConfig {}

package/src/lib/azure/types/index.ts

@@ -0,0 +1,3 @@
+export interface BaseConfigProps {
+  resourceGroupName: string
+}

package/src/lib/azure/utils/index.ts

@@ -0,0 +1,23 @@
+import { TerraformOutput } from 'cdktf'
+import _ from 'lodash'
+import { CommonAzureConstruct } from '../common'
+
+export const createTfOutput = (
+  id: string,
+  scope: CommonAzureConstruct,
+  value?: string,
+  description?: string,
+  sensitive?: boolean,
+  overrideId = true
+) => {
+  const output = new TerraformOutput(scope, id, {
+    description,
+    sensitive,
+    value,
+  })
+
+  if (overrideId) {
+    output.overrideLogicalId(_.camelCase(id))
+  }
+  return output
+}

package/src/lib/common/construct.ts

@@ -1,175 +1,35 @@
-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'
-import { createCfnOutput, isDevStage, isPrdStage, isTestStage, isUatStage } from '../utils'
-import { CommonStackProps } from './types'
+import { BaseProps } from './types'
 
-/**
- * @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: CommonStackProps
-  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) {
-    super(parent, id)
-    this.props = 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
-   */
-  protected addCfnOutput(id: string, value: string, description?: string, overrideId = true): CfnOutput {
-    return createCfnOutput(id, this, value, description, overrideId)
-  }
+export abstract class BaseConstruct extends Construct {
+  props: BaseProps
 
   /**
    * @summary Determine the fully qualified domain name based on domainName & subDomain
    */
-  protected determineFullyQualifiedDomain() {
-    this.fullyQualifiedDomainName = this.props.subDomain
-      ? `${this.props.subDomain}.${this.props.domainName}`
-      : this.props.domainName
-  }
+  public abstract 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
    */
-  public isDevelopmentStage = () => isDevStage(this.props.stage)
+  public abstract isDevelopmentStage(): void
 
   /**
    * @summary Utility method to determine if the initialisation is in test (tst) stage
    * This is determined by the stage property injected via cdk context
    */
-  public isTestStage = () => isTestStage(this.props.stage)
+  public abstract isTestStage(): void
 
   /**
    * @summary Utility method to determine if the initialisation is in uat (uat) stage
    * This is determined by the stage property injected via cdk context
    */
-  public isUatStage = () => isUatStage(this.props.stage)
+  public abstract isUatStage(): void
 
   /**
    * @summary Utility method to determine if the initialisation is in production (prd) stage
    * This is determined by the stage property injected via cdk context
    */
-  public isProductionStage = () => isPrdStage(this.props.stage)
-}
-
-export const applyMixins = (derivedCtor: any, constructors: any[]) => {
-  constructors.forEach(baseCtor => {
-    Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
-      Object.defineProperty(
-        derivedCtor.prototype,
-        name,
-        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || Object.create(null)
-      )
-    })
-  })
+  public abstract isProductionStage(): void
 }

package/src/lib/common/index.ts

@@ -1,3 +1,16 @@
 export * from './construct'
 export * from './stack'
 export * from './types'
+export * from './utils'
+
+export const applyMixins = (derivedCtor: any, constructors: any[]) => {
+  constructors.forEach(baseCtor => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
+      Object.defineProperty(
+        derivedCtor.prototype,
+        name,
+        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || Object.create(null)
+      )
+    })
+  })
+}

package/src/lib/common/stack.ts

@@ -1,150 +1,26 @@
-import { App, Stack, StackProps } from 'aws-cdk-lib'
-import { Runtime } from 'aws-cdk-lib/aws-lambda'
-import fs from 'fs'
-import { isDevStage } from '../utils'
-import { CommonConstruct } from './construct'
-import { CommonStackProps } from './types'
+import { Construct } from 'constructs'
+import { BaseProps } from './types'
 
-import appRoot from 'app-root-path'
-
-/**
- * @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 {
-  public static NODEJS_RUNTIME = Runtime.NODEJS_18_X
-
-  construct: CommonConstruct
-  props: CommonStackProps
-
-  constructor(parent: App, name: string, props: StackProps) {
-    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)
-  }
+export abstract class BaseStack extends Construct {
+  props: BaseProps
 
   /**
-   * @summary Method to determine the core CDK construct properties injected via context cdk.json
-   * @param props The stack properties
-   * @returns The stack properties
+   * @summary Method to determine the core CDK construct properties injected via context cdktf.json
    */
-  protected determineConstructProps(props: StackProps) {
-    return {
-      domainName: this.node.tryGetContext('domainName'),
-      excludeDomainNameForBuckets: this.node.tryGetContext('excludeDomainNameForBuckets'),
-      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'),
-      skipStageForARecords: this.node.tryGetContext('skipStageForARecords'),
-      stackName: props.stackName,
-      stage: this.node.tryGetContext('stage'),
-      subDomain: this.node.tryGetContext('subDomain'),
-    }
-  }
+  protected abstract determineConstructProps(props: BaseProps): void
 
   /**
-   * @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
+   * @summary Method to determine extra cdk contexts apart from the main cdktf.json
    */
-  protected 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
-    }
-
-    extraContexts.forEach((context: string) => {
-      const extraContextPath = `${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 */
-      Object.keys(extraContextProps).forEach((propKey: any) => {
-        this.node.setContext(propKey, extraContextProps[propKey])
-      })
-    })
-  }
+  public abstract 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
+   * @summary Method to determine extra cdk stage contexts apart from the main cdktf.json
    */
-  protected determineStageContexts() {
-    const stage = this.node.tryGetContext('stage')
-    const stageContextPath = this.node.tryGetContext('stageContextPath') || 'cdkEnv'
-    const stageContextFilePath = `${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 */
-    Object.keys(stageContextProps).forEach((propKey: any) => {
-      /* handle object, array properties */
-      if (typeof stageContextProps[propKey] === 'object' && !Array.isArray(stageContextProps[propKey])) {
-        this.node.setContext(propKey, {
-          ...this.node.tryGetContext(propKey),
-          ...stageContextProps[propKey],
-        })
-      } else {
-        /* handle all other primitive properties */
-        this.node.setContext(propKey, stageContextProps[propKey])
-      }
-    })
-  }
+  public abstract determineStageContexts(): void
 
   /**
    * @summary Determine the fully qualified domain name based on domainName & subDomain
    */
-  protected fullyQualifiedDomain() {
-    const domainName = this.node.tryGetContext('domainName')
-    const subDomain = this.node.tryGetContext('subDomain')
-    return subDomain ? `${subDomain}.${domainName}` : domainName
-  }
+  public abstract fullyQualifiedDomain(): void
 }

package/src/lib/common/types.ts

@@ -1,21 +1,9 @@
-import { StackProps } from 'aws-cdk-lib'
-import { Runtime, Tracing } from 'aws-cdk-lib/aws-lambda'
-import { RetentionDays } from 'aws-cdk-lib/aws-logs'
-
-/**
- */
-export interface CommonStackProps extends StackProps {
-  name: string
-  region: string
-  stage: string
+export interface BaseProps {
   domainName: string
-  subDomain?: string
   extraContexts?: string[]
-  stageContextPath?: string
+  name: string
   skipStageForARecords: boolean
-  logRetention?: RetentionDays
-  defaultReservedLambdaConcurrentExecutions?: number
-  defaultTracing?: Tracing
-  excludeDomainNameForBuckets?: boolean
-  nodejsRuntime?: Runtime
+  stage: string
+  stageContextPath?: string
+  subDomain?: string
 }

package/src/lib/common/utils.ts

@@ -0,0 +1,27 @@
+/**
+ */
+export enum LogLevel {
+  DEBUG = 'DEBUG',
+  INFO = 'INFO',
+  WARNING = 'WARNING',
+  TRACE = 'TRACE',
+  ERROR = 'ERROR',
+  CRITICAL = 'CRITICAL',
+}
+
+/**
+ * @param stage
+ */
+export const isDevStage = (stage: string) => stage === 'dev'
+/**
+ * @param stage
+ */
+export const isTestStage = (stage: string) => stage === 'tst'
+/**
+ * @param stage
+ */
+export const isUatStage = (stage: string) => stage === 'uat'
+/**
+ * @param stage
+ */
+export const isPrdStage = (stage: string) => stage === 'prd'

package/src/lib/index.ts

@@ -1,5 +1,3 @@
+export * from './aws'
+export * from './azure'
 export * from './common'
-export * from './construct'
-export * from './services'
-export * from './types'
-export * from './utils'

package/dist/src/lib/types/index.d.ts

@@ -1 +0,0 @@
-export * from './aws';

package/dist/src/lib/types/index.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./aws"), exports);

package/dist/src/lib/utils/index.d.ts

@@ -1,55 +0,0 @@
-export * from './aws';
-/**
- */
-export declare enum LogLevel {
-    DEBUG = "DEBUG",
-    INFO = "INFO",
-    WARNING = "WARNING",
-    TRACE = "TRACE",
-    ERROR = "ERROR",
-    CRITICAL = "CRITICAL"
-}
-/**
- * @param stage
- */
-export declare const isDevStage: (stage: string) => boolean;
-/**
- * @param stage
- */
-export declare const isTestStage: (stage: string) => boolean;
-/**
- * @param stage
- */
-export declare const isUatStage: (stage: string) => boolean;
-/**
- * @param stage
- */
-export declare const isPrdStage: (stage: string) => boolean;
-/**
- * @param error
- */
-export declare function redirectError(error: any): {
-    body: string;
-    headers: {
-        'Access-Control-Allow-Origin': string;
-    };
-    isBase64Encoded: boolean;
-    statusCode: number;
-} & {
-    body: string;
-    statusCode: number;
-};
-/**
- * @param message
- */
-export declare function redirectSuccess(message: any): {
-    body: string;
-    headers: {
-        'Access-Control-Allow-Origin': string;
-    };
-    isBase64Encoded: boolean;
-    statusCode: number;
-} & {
-    body: string;
-    statusCode: number;
-};