type Maybe<T> = T | undefined;
import type { MicroserviceDefinition } from './runtime-web/types';
/**
 * Enumeration representing configuration options for cloud bundles.
 *
 * The `CloudBundleConfig` enum defines supported configurations
 * for cloud bundles that can be used to specify the type or provider
 * of a cloud bundle.
 *
 * Enum members:
 * - Aws: Represents the AWS cloud bundle configuration.
 */
export declare enum CloudBundleConfigType {
    Aws = "aws_cloud_bundle_config"
}
/**
 * Represents the configuration settings for a cloud service bundle.
 *
 * This type defines a mapping where the key is a specific type of cloud service
 * configuration, such as AWS, and the value is the schema or settings for that
 * particular cloud service type.
 *
 * @typedef {Object} CloudBundleConfig
 * @property {CloudBundleConfigSchemaAws} [CloudBundleConfigType.Aws] - Configuration schema for AWS cloud bundle.
 */
export type CloudBundleConfig = {
    [CloudBundleConfigType.Aws]: CloudBundleConfigSchemaAws;
};
/**
 * A generic type that defines the schema for a cloud bundle configuration. This type combines
 * predefined optional properties for basic cloud configuration details with additional properties
 * as specified in the generic parameter `T`.
 *
 * @template T - A type parameter that extends the base schema, allowing additional custom properties
 *               to be included in the configuration.
 *
 * @property {string} [serviceName] - An optional property representing the name of the service.
 *                                    This can be used to identify the specific cloud service the
 *                                    configuration is associated with.
 *
 * @property {string} [stage] - An optional property indicating the deployment stage of the
 *                              configuration, such as "development", "staging", or "production".
 *                              This provides clarity on the lifecycle stage for the configuration.
 */
export type CloudBundleConfigSchema<T> = {
    serviceName: string;
    org?: string;
    app?: string;
    stage?: string;
} & T;
/**
 * Represents the configuration schema specifically tailored for AWS (Amazon Web Services)
 * within the context of a cloud bundle configuration. This type is derived from the
 * generic `CloudBundleConfigSchema` but is customized for use with AWS implementations.
 *
 * This type is used to define and enforce the structure of configuration data
 * related to AWS cloud environments in applications or systems leveraging the cloud bundle framework.
 */
export type CloudBundleConfigSchemaAws = CloudBundleConfigSchema<CloudBundleConfigSchemaRuntime>;
/**
 * Represents the schema configuration for a Cloud Bundle with Runtime integration.
 *
 * This type definition includes the configuration required for setting up
 * DynamoDB resources for the SEO engine and microservice registry for Runtime Web Core.
 *
 * @typedef {Object} CloudBundleConfigSchemaRuntime
 * @property {Object} dynamoDb - DynamoDB configuration details.
 * @property {Object} dynamoDb.seoEngine - SEO engine-specific configuration inside DynamoDB.
 * @property {string} dynamoDb.seoEngine.tableName - Name of the DynamoDB table used by the SEO engine.
 * @property {Record<string, MicroserviceDefinition>} register - Microservice registry for Runtime Web Core.
 */
export type CloudBundleConfigSchemaRuntime = {
    dynamoDb?: Maybe<{
        seoEngine?: Maybe<{
            tableName?: Maybe<string>;
        }>;
    }>;
    /**
     * Microservice registry for Runtime Web Core.
     *
     * Optional property that defines microservices and their Lambda handlers.
     * When provided, the runtime will process these definitions and create
     * Lambda handlers with proper dependency injection.
     *
     * @example
     * ```typescript
     * register: {
     *   payments: {
     *     ties: [PaymentsTies],
     *     lambdas: [chargeHandler, refundHandler]
     *   }
     * }
     * ```
     */
    register?: Maybe<Record<string, MicroserviceDefinition>>;
};
export {};
