@openhi/constructs 0.0.0 → 0.0.1

package/lib/chunk-LZOMFHX3.mjs

@@ -0,0 +1,38 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};
+//# sourceMappingURL=chunk-LZOMFHX3.mjs.map

package/lib/chunk-LZOMFHX3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/lib/index.d.mts

@@ -0,0 +1,664 @@
+import { OPEN_HI_STAGE, OPEN_HI_DEPLOYMENT_TARGET_ROLE, OpenHiEnvironmentConfig, OpenHiConfig } from '@openhi/config';
+import { Stage, StageProps, App, AppProps, Stack, StackProps, RemovalPolicy } from 'aws-cdk-lib';
+import { IConstruct, Construct } from 'constructs';
+import { HttpApiProps, HttpApi, IHttpApi } from 'aws-cdk-lib/aws-apigatewayv2';
+import { GraphqlApiProps } from 'aws-cdk-lib/aws-appsync';
+import { EventBusProps } from 'aws-cdk-lib/aws-events';
+import { StringParameterProps, StringParameter } from 'aws-cdk-lib/aws-ssm';
+import { UserPoolProps, IUserPool, IUserPoolClient, IUserPoolDomain } from 'aws-cdk-lib/aws-cognito';
+import { IKey } from 'aws-cdk-lib/aws-kms';
+import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager';
+import { HostedZoneAttributes, IHostedZone } from 'aws-cdk-lib/aws-route53';
+import { SetOptional } from 'type-fest';
+import { ITable } from 'aws-cdk-lib/aws-dynamodb';
+
+/**
+ * Properties for creating an OpenHiStage instance.
+ */
+interface OpenHiStageProps extends StageProps {
+    /**
+     * The type of the OpenHi stage.
+     */
+    readonly stageType: (typeof OPEN_HI_STAGE)[keyof typeof OPEN_HI_STAGE];
+}
+/**
+ * Represents a deployment stage in the OpenHi infrastructure hierarchy.
+ */
+declare class OpenHiStage extends Stage {
+    /**
+     * The OpenHiApp that this stage belongs to.
+     *
+     * @public
+     */
+    ohApp: OpenHiApp;
+    /**
+     * Properties for configuring the stage.
+     *
+     * @public
+     */
+    props: OpenHiStageProps;
+    /**
+     * Finds the OpenHiStage that contains the given construct.
+     */
+    static of(construct: IConstruct): OpenHiStage | undefined;
+    /**
+     * Type guard to check if a value is an OpenHiStage instance.
+     */
+    static isOpenHiStage(this: void, x: any): x is OpenHiStage;
+    /**
+     * The type of this OpenHi stage.
+     */
+    readonly stageType: (typeof OPEN_HI_STAGE)[keyof typeof OPEN_HI_STAGE];
+    /**
+     * Creates a new OpenHiStage instance.
+     */
+    constructor(
+    /**
+     * The OpenHiApp that this stage belongs to.
+     *
+     * @public
+     */
+    ohApp: OpenHiApp, 
+    /**
+     * Properties for configuring the stage.
+     *
+     * @public
+     */
+    props: OpenHiStageProps);
+    /**
+     * Gets all OpenHiEnvironment instances contained within this stage.
+     */
+    get environments(): Array<OpenHiEnvironment>;
+    /**
+     * Gets the primary OpenHiEnvironment for this stage, if one exists.
+     */
+    get primaryEnvironment(): OpenHiEnvironment | undefined;
+    /**
+     * Gets all secondary OpenHiEnvironment instances for this stage.
+     */
+    get secondaryEnvironments(): Array<OpenHiEnvironment>;
+}
+
+/**
+ * Properties for creating an OpenHiEnvironment.
+ */
+interface OpenHiEnvironmentProps extends StageProps {
+    /**
+     * The deployment target role for this (account, region).
+     */
+    readonly deploymentTargetRole: (typeof OPEN_HI_DEPLOYMENT_TARGET_ROLE)[keyof typeof OPEN_HI_DEPLOYMENT_TARGET_ROLE];
+    /**
+     * Configuration for this specific environment.
+     */
+    readonly config: OpenHiEnvironmentConfig;
+}
+/**
+ * Represents an OpenHi environment within an AWS CDK stage.
+ */
+declare class OpenHiEnvironment extends Stage {
+    /**
+     * The OpenHiStage that contains this environment.
+     */
+    ohStage: OpenHiStage;
+    /**
+     * Properties for creating the environment.
+     */
+    props: OpenHiEnvironmentProps;
+    /**
+     * Finds the OpenHiEnvironment that contains the given construct.
+     * ```
+     */
+    static of(construct: IConstruct): OpenHiEnvironment | undefined;
+    /**
+     * Type guard to check if a value is an OpenHiEnvironment instance.
+     */
+    static isOpenHiEnvironment(this: void, x: any): x is OpenHiEnvironment;
+    /**
+     * Configuration for this specific environment.
+     */
+    readonly config: OpenHiEnvironmentConfig;
+    /**
+     * The deployment target role for this (account, region).
+     */
+    readonly deploymentTargetRole: (typeof OPEN_HI_DEPLOYMENT_TARGET_ROLE)[keyof typeof OPEN_HI_DEPLOYMENT_TARGET_ROLE];
+    /**
+     * Creates a new OpenHiEnvironment.
+     */
+    constructor(
+    /**
+     * The OpenHiStage that contains this environment.
+     */
+    ohStage: OpenHiStage, 
+    /**
+     * Properties for creating the environment.
+     */
+    props: OpenHiEnvironmentProps);
+}
+
+/**
+ * Properties for creating an OpenHiApp instance.
+ */
+interface OpenHiAppProps extends AppProps {
+    /**
+     * Optional name for the application.
+     * ```
+     */
+    readonly appName?: string;
+    /**
+     * The OpenHi configuration object that defines stages, environments, and
+     * their associated AWS account and region settings.
+     */
+    readonly config: OpenHiConfig;
+}
+/**
+ * Root application construct for OpenHi CDK applications.
+ */
+declare class OpenHiApp extends App {
+    /**
+     * Finds the OpenHiApp instance that contains the given construct in its
+     * construct tree.
+     */
+    static of(construct: IConstruct): OpenHiApp | undefined;
+    /**
+     * Type guard that checks if a value is an OpenHiApp instance.
+     */
+    static isOpenHiApp(this: void, x: any): x is OpenHiApp;
+    /**
+     * Name for the application.
+     */
+    readonly appName: string;
+    /**
+     * The OpenHi configuration object for this application.
+     */
+    readonly config: OpenHiConfig;
+    /**
+     * Creates a new OpenHiApp instance.
+     */
+    constructor(props: OpenHiAppProps);
+    /*****************************************************************************
+     *
+     * Stages
+     *
+     ****************************************************************************/
+    /**
+     * Gets all OpenHiStage instances that are direct children of this app.
+  
+     */
+    get stages(): Array<OpenHiStage>;
+    /**
+     * Gets the development stage, if it exists.
+     */
+    get devStage(): OpenHiStage | undefined;
+    /**
+     * Gets the staging stage, if it exists.
+     */
+    get stageStage(): OpenHiStage | undefined;
+    /**
+     * Gets the production stage, if it exists.
+     */
+    get prodStage(): OpenHiStage | undefined;
+    /*****************************************************************************
+     *
+     * Environments
+     *
+     ****************************************************************************/
+    /**
+     * Gets all OpenHiEnvironment instances across all stages in this app.
+     */
+    get environments(): Array<OpenHiEnvironment>;
+    /**
+     * Gets all primary environments across all stages in this app.
+     */
+    get primaryEnvironments(): Array<OpenHiEnvironment>;
+    /**
+     * Gets all secondary environments across all stages in this app.
+     */
+    get secondaryEnvironments(): Array<OpenHiEnvironment>;
+}
+
+interface CoreProps {
+    /**
+     * Pass in options for an event bus, optional.
+     */
+    readonly dataEventBusProps?: EventBusProps;
+    /**
+     * Pass in options for an event bus, optional.
+     */
+    readonly opsEventBusProps?: EventBusProps;
+    /**
+     * Optional args for creating HTTP API.
+     */
+    readonly httpApiProps?: HttpApiProps;
+    /**
+     * Optional args for creating the core GraphQL API.
+     */
+    readonly graphqlApiProps?: GraphqlApiProps;
+}
+
+/**
+ * Service type identifiers for OpenHI services.
+ *
+ * @remarks
+ * These constants define the different types of services that can be deployed
+ * within the OpenHI platform. Each service type represents a distinct domain
+ * or functional area with its own data model, API endpoints, and business logic.
+ *
+ * Service types are used for:
+ * - Resource naming and tagging
+ * - Service discovery and routing
+ * - Deployment context calculations
+ * - Cross-service communication patterns
+ *
+ * @public
+ */
+declare const OPEN_HI_SERVICE_TYPE: {
+    /**
+     * Authentication service.
+     *   *
+     * Only one instance of the auth service should exist per environment.
+     */
+    readonly AUTH: "auth";
+    /**
+     * Root shared core services.
+     *
+     * Only one instance of the core service should exist per environment.
+     */
+    readonly CORE: "core";
+    /**
+     * Rest API service.
+     */
+    readonly REST_API: "rest-api";
+    /**
+     * Global Infrastructure stack (Route53, ACM).
+     */
+    readonly GLOBAL: "global";
+    /**
+     * Data service (DynamoDB, S3, persistence).
+     */
+    readonly DATA: "data";
+};
+/**
+ * Type representing valid OpenHI service type values. This is a union of the
+ * values from {@link OPEN_HI_SERVICE_TYPE}.
+ *
+ * @public
+ */
+type OpenHiServiceType = (typeof OPEN_HI_SERVICE_TYPE)[keyof typeof OPEN_HI_SERVICE_TYPE];
+/**
+ * Properties for creating an {@link OpenHiService} stack.
+ *
+ * @public
+ */
+interface OpenHiServiceProps extends StackProps {
+    /**
+     * Optional branch name override.
+     */
+    readonly branchName?: string;
+    /**
+     * Optional repository name override.
+     */
+    readonly repoName?: string;
+    /**
+     * Optional application name override.
+     */
+    readonly appName?: string;
+    /**
+     * Default release branch name.
+     */
+    readonly defaultReleaseBranch?: string;
+    /**
+     * The removal policy for persistent stack resources.
+     */
+    readonly removalPolicy?: RemovalPolicy;
+    /**
+     * Environment configuration for this service.
+     */
+    readonly config?: OpenHiEnvironmentConfig;
+    /**
+     * A constant that identifies the service type.
+     */
+    readonly serviceType?: OpenHiServiceType;
+    /**
+     * Optional props for the core construct.
+     */
+    readonly coreProps?: CoreProps;
+}
+/**
+ * Represents an OpenHI service stack within the OpenHI platform.
+ */
+declare class OpenHiService extends Stack {
+    ohEnv: OpenHiEnvironment;
+    props: OpenHiServiceProps;
+    /**
+     * The service/stack ID that was passed to the constructor.
+     */
+    readonly serviceId: string;
+    /**
+     * The deployment target role identifier.
+     */
+    readonly deploymentTargetRole: string;
+    /**
+     * Repository name used in resource tagging.
+     */
+    readonly repoName: string;
+    /**
+     * Application name identifier.
+     */
+    readonly appName: string;
+    /**
+     * Default release branch name.
+     */
+    readonly defaultReleaseBranch: string;
+    /**
+     * Branch name used when calculating resource names and hashes.
+     */
+    readonly branchName: string;
+    /**
+     * Short hash unique to the deployment target (app name, deployment target role, account, region).
+     */
+    readonly environmentHash: string;
+    /**
+     * Short hash unique to the environment and branch combination.
+     */
+    readonly branchHash: string;
+    /**
+     * Short hash unique to the specific stack/service.
+     */
+    readonly stackHash: string;
+    /**
+     * The removal policy for persistent stack resources.
+     */
+    readonly removalPolicy: RemovalPolicy;
+    /**
+     * Environment configuration for this service.
+     * This is either the value passed in or the default config
+     */
+    readonly config: OpenHiEnvironmentConfig;
+    /**
+     * A constant that identifies the service type.
+     */
+    readonly serviceType: (typeof OPEN_HI_SERVICE_TYPE)[keyof typeof OPEN_HI_SERVICE_TYPE] | string;
+    /**
+     * Core construct containing shared infrastructure.
+     */
+    /**
+     * Creates a new OpenHI service stack.
+     *
+     * @param ohEnv - The OpenHI environment (stage) this service belongs to
+     * @param id - Unique identifier for this service stack (e.g., "user-service")
+     * @param props - Optional properties for configuring the service
+     *
+     * @throws {Error} If account and region are not defined in props or environment
+     *
+     */
+    constructor(ohEnv: OpenHiEnvironment, id: string, props?: OpenHiServiceProps);
+    /**
+     * Creates or returns the core construct for shared infrastructure.
+     */
+    /**
+     * DNS prefix for this branche's child zone.
+     */
+    get childZonePrefix(): string;
+}
+
+/*******************************************************************************
+ *
+ * DiscoverableStringParameterProps: props for creating or looking up SSM
+ * parameters. Includes StringParameterProps (minus parameterName) plus
+ * name-building fields used by buildParameterName.
+ *
+ ******************************************************************************/
+interface DiscoverableStringParameterProps extends Omit<StringParameterProps, "parameterName"> {
+    /**
+     * SSM param name used to build the SSM parameter name via buildParameterName
+     * and stored as a tag on the parameter for discoverability.
+     */
+    readonly ssmParamName: string;
+    /**
+     * The environment hash the parameter belongs to.
+     * @default - the current stack's environment hash
+     */
+    readonly branchHash?: string;
+    /**
+     * The service type the parameter belongs to.
+     * @default - the current stack's service type
+     */
+    readonly serviceType?: string;
+    /**
+     * The AWS account the parameter belongs to.
+     * @default - the current stack's account
+     */
+    readonly account?: string;
+    /**
+     * The AWS region the parameter belongs to.
+     * @default - the current stack's region
+     */
+    readonly region?: string;
+}
+/**
+ * Props for buildParameterName and valueForLookupName.
+ * Includes ssmParamName (required) and optional overrides (branchHash, serviceType, account, region).
+ */
+type BuildParameterNameProps = Pick<DiscoverableStringParameterProps, "ssmParamName" | "branchHash" | "serviceType" | "account" | "region">;
+/**
+ * Discoverable SSM string parameter construct. Extends CDK StringParameter:
+ * builds parameterName from the given name via buildParameterName and tags
+ * the parameter with the name constant.
+ */
+declare class DiscoverableStringParameter extends StringParameter {
+    /**
+     * Build a param name based on predictable attributes found in services and
+     * constructs. Used for storage and retrieval of SSM values across services.
+     */
+    static buildParameterName(scope: Construct, props: BuildParameterNameProps): string;
+    /**
+     * Read the string value of an SSM parameter created with DiscoverableStringParameter,
+     * using props that include ssmParamName and optional overrides (e.g. serviceType).
+     */
+    static valueForLookupName(scope: Construct, props: BuildParameterNameProps): string;
+    constructor(scope: Construct, id: string, props: DiscoverableStringParameterProps);
+}
+
+interface OpenHiCoreServiceProps extends OpenHiServiceProps {
+}
+declare class OpenHiCoreService extends OpenHiService {
+    /*****************************************************************************
+     *
+     * PROPS
+     *
+     * Final props calculated from inputs combined with default values.
+     *
+     ****************************************************************************/
+    readonly props: OpenHiCoreServiceProps;
+    constructor(ohEnv: OpenHiEnvironment, props?: OpenHiCoreServiceProps);
+}
+
+interface AuthProps {
+    /**
+     * Optional props for creating the user pool.
+     */
+    readonly userPoolProps?: UserPoolProps;
+}
+/**
+ * Auth construct that manages Cognito authentication resources.
+ *
+ * @remarks
+ * The Auth construct provides authentication infrastructure including:
+ * - Cognito User Pool for user management and authentication
+ * - User Pool Client for application integration
+ * - User Pool Domain for hosting the Cognito hosted UI
+ * - KMS Key for Cognito User Pool encryption
+ *
+ * When created in the Auth service (`serviceType === OPEN_HI_SERVICE_TYPE.AUTH`),
+ * it creates concrete resources. Otherwise, it imports existing resources
+ * from SSM Parameter Store.
+ *
+ * Use {@link Auth.fromConstruct} to obtain an Auth instance (with resources
+ * imported from AUTH SSM parameters) when not in the Auth service, e.g. from
+ * the Core construct.
+ *
+ * @public
+ */
+declare class Auth extends Construct {
+    /**
+     * Returns an Auth instance that uses resources imported from AUTH SSM
+     * parameters. Use this when creating Core or other stacks that consume
+     * auth resources; the Auth stack must be deployed first.
+     *
+     * @param scope - Construct scope (e.g. Core); must be in a stack that has
+     *   access to the same account/region as the deployed Auth stack.
+     */
+    static fromConstruct(scope: Construct): Auth;
+    /**
+     * Is this construct being created in the auth service or elsewhere?
+     */
+    readonly isAuthService: boolean;
+    /**
+     * KMS Key used to encrypt the Cognito User Pool. We need a custom key so that
+     * we can decrypt tokens when sending emails using something other than SES.
+     */
+    readonly userPoolKmsKey: IKey;
+    /**
+     * Cognito User Pool for user management and authentication.
+     */
+    readonly userPool: IUserPool;
+    /**
+     * Cognito User Pool Client for application integration with the User Pool.
+     */
+    readonly userPoolClient: IUserPoolClient;
+    /**
+     * Cognito User Pool Domain for hosting the Cognito hosted UI.
+     */
+    readonly userPoolDomain: IUserPoolDomain;
+    constructor(scope: Construct, props?: AuthProps);
+    /*****************************************************************************
+     *
+     * Auth Support
+     *
+     ****************************************************************************/
+    protected createUserPoolKmsKey(): IKey;
+    protected createUserPool(props?: UserPoolProps): IUserPool;
+    protected createUserPoolClient(props: {
+        userPool: IUserPool;
+    }): IUserPoolClient;
+    protected createUserPoolDomain(props: {
+        userPool: IUserPool;
+    }): IUserPoolDomain;
+}
+
+interface OpenHiAuthServiceProps extends OpenHiServiceProps {
+    /**
+     * Optional props for the auth construct.
+     */
+    readonly authProps?: AuthProps;
+}
+/**
+ * OpenHI Auth Service stack.
+ *
+ * @remarks
+ * The Auth service manages authentication infrastructure including:
+ * - Cognito User Pool for user management and authentication
+ * - User Pool Client for application integration
+ * - User Pool Domain for hosting the Cognito hosted UI
+ * - KMS Key for Cognito User Pool encryption
+ *
+ * Only one instance of the auth service should exist per environment.
+ *
+ * @public
+ */
+declare class OpenHiAuthService extends OpenHiService {
+    props: OpenHiAuthServiceProps;
+    /**
+     * Auth construct containing authentication resources.
+     */
+    readonly auth: Auth;
+    constructor(ohEnv: OpenHiEnvironment, props?: OpenHiAuthServiceProps);
+}
+
+interface GlobalProps {
+    /**
+     * Root zone configuration attributes. Zone name is required, hosted zone ID
+     * is optional.
+     */
+    readonly rootHostedZoneAttributes: HostedZoneAttributes;
+    /**
+     * Child zone configuration attributes. Zone name is required, hosted zone ID
+     * is optional.
+     */
+    readonly childHostedZoneAttributes?: SetOptional<HostedZoneAttributes, "hostedZoneId">;
+}
+/**
+ * Global construct: owns global infrastructure (e.g. DNS and certificate resources).
+
+ */
+declare class Global extends Construct {
+    props: GlobalProps;
+    /**
+     * Root hosted zone when config provides zoneName.
+     */
+    readonly rootHostedZone: IHostedZone;
+    /**
+     * Child hosted zone when root zone exists.
+     */
+    readonly childHostedZone?: IHostedZone;
+    /**
+     * Root wildcard certificate.
+     */
+    readonly rootWildcardCertificate: ICertificate;
+    constructor(scope: Construct, id: string, props: GlobalProps);
+}
+
+interface OpenHiGlobalServiceProps extends OpenHiServiceProps {
+}
+/**
+ * Global Infrastructure stack: owns global DNS and certificates
+ */
+declare class OpenHiGlobalService extends OpenHiService {
+    /**
+     * Global construct.
+     */
+    readonly global: Global;
+    constructor(ohEnv: OpenHiEnvironment, props?: OpenHiGlobalServiceProps);
+}
+
+declare class CoreHttpApi extends HttpApi {
+    /**
+     * Used when storing the API ID in SSM.
+     */
+    static readonly SSM_PARAM_NAME = "CORE_HTTP_API";
+    static fromConstruct(scope: Construct): IHttpApi;
+    constructor(scope: Construct, props?: HttpApiProps);
+}
+
+interface OpenHiRestApiServiceProps extends OpenHiServiceProps {
+}
+/**
+ * SSM parameter name suffix for the REST API base URL.
+ * Full parameter name is built via buildParameterName with serviceType REST_API.
+ */
+declare const REST_API_BASE_URL_SSM_NAME = "REST_API_BASE_URL";
+/**
+ * REST API service stack: HTTP API, custom domain, and Lambda; exports base URL via SSM.
+ */
+declare class OpenHiRestApiService extends OpenHiService {
+    readonly coreHttpApi: CoreHttpApi;
+    constructor(ohEnv: OpenHiEnvironment, props?: OpenHiRestApiServiceProps);
+}
+
+interface OpenHiDataServiceProps extends OpenHiServiceProps {
+}
+/**
+ * Data storage service stack: centralizes DynamoDB, S3, and other persistence
+ * resources for OpenHI. Creates the single-table data store (CRM, CMS, ERP,
+ * EHR); add buckets or other resources as needed.
+ */
+declare class OpenHiDataService extends OpenHiService {
+    /**
+     * The single-table DynamoDB data store. Use {@link DynamoDbDataStore.fromConstruct}
+     * from other stacks to obtain an ITable reference by name.
+     */
+    readonly dataStore: ITable;
+    constructor(ohEnv: OpenHiEnvironment, props?: OpenHiDataServiceProps);
+}
+
+export { type BuildParameterNameProps, DiscoverableStringParameter, type DiscoverableStringParameterProps, OPEN_HI_SERVICE_TYPE, OpenHiApp, type OpenHiAppProps, OpenHiAuthService, type OpenHiAuthServiceProps, OpenHiCoreService, type OpenHiCoreServiceProps, OpenHiDataService, type OpenHiDataServiceProps, OpenHiEnvironment, type OpenHiEnvironmentProps, OpenHiGlobalService, type OpenHiGlobalServiceProps, OpenHiRestApiService, type OpenHiRestApiServiceProps, OpenHiService, type OpenHiServiceProps, type OpenHiServiceType, OpenHiStage, type OpenHiStageProps, REST_API_BASE_URL_SSM_NAME };