/**
 * Core type definitions for Bangstack workflows
 * Updated to support flexible, customizable stack components
 */
export interface Workflow {
    workflow: WorkflowMetadata;
    technology?: Technology;
    testing?: Testing;
    monitoring?: Monitoring;
    security?: Security;
    performance?: Performance;
    i18n?: Internationalization;
    feature_flags?: FeatureFlags;
    access_control?: AccessControl;
    api?: ApiConfiguration;
    deployment?: DeploymentConfiguration;
    analytics?: Analytics;
    stack: StackComponents;
    models?: Models;
    migrations?: Migrations;
    error_handling?: ErrorHandling;
    rate_limiting?: RateLimiting;
    email?: Email;
    background_jobs?: BackgroundJobs;
    workflows?: WorkflowDefinitions;
    events?: Events;
    stages?: Stages;
    documentation?: Documentation;
    environment?: Environment;
}
export interface WorkflowMetadata {
    id: string;
    version: string;
    name: string;
    description: string;
    domains?: string[];
    actors?: Actor[];
    relationships?: WorkflowRelationship[];
}
export interface Actor {
    type: 'customer' | 'developer' | 'internal' | 'partner' | string;
    role: string;
}
export interface WorkflowRelationship {
    workflow: string;
    type: 'prerequisite' | 'dependent' | 'related';
    reason: string;
}
export interface StackComponents {
    [componentName: string]: StackComponent;
}
export interface StackComponent {
    type: string;
    technology: string;
    config?: Record<string, any>;
    directory?: string;
    dependsOn?: string[];
    components?: Component[];
    endpoints?: Endpoint[];
    tables?: Table[];
    workflows?: ComponentWorkflow[];
    routing?: 'primary_only' | 'context_based' | 'load_balanced';
    primary?: string;
    services?: Record<string, any>;
    expected_dependencies?: ExpectedDependency[];
}
export interface ExpectedDependency {
    service: string;
    usage: string;
    required?: boolean;
}
export interface ComponentWorkflow {
    id: string;
    name: string;
    description: string;
    steps: Step[];
}
export interface Component {
    id: string;
    type: 'form-component' | 'list-component' | 'detail-component' | string;
    name: string;
    description: string;
    ui?: UISpec;
    state?: StateDefinition[];
    actions?: Action[];
    generate?: GenerateOptions;
}
export interface UISpec {
    layout?: string;
    fields?: Field[];
}
export interface Field {
    id: string;
    type: string;
    label: string;
    placeholder?: string;
    validation?: ValidationRule[];
}
export interface ValidationRule {
    required?: boolean;
    format?: string;
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    custom?: string;
}
export interface StateDefinition {
    name: string;
    type: string;
    initial: any;
}
export interface Action {
    id: string;
    trigger: string;
    description: string;
    steps: Step[];
}
export interface Step {
    id: string;
    action: string;
    depends_on?: string[];
    [key: string]: any;
}
export interface GenerateOptions {
    styling?: 'css-modules' | 'tailwind' | 'styled-components' | 'emotion' | string;
    testing?: boolean;
    storybook?: boolean;
    accessibility?: 'wcag-aa' | 'wcag-aaa' | string;
}
export interface Endpoint {
    id: string;
    path: string;
    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
    name: string;
    description: string;
    request?: RequestSpec;
    responses: ResponseSpec[];
    implementation?: Implementation;
    middleware?: Middleware[];
    generate?: GenerateOptions;
}
export interface RequestSpec {
    body?: Schema;
    query?: Schema;
    params?: Schema;
    headers?: Schema;
}
export interface Schema {
    type: string;
    required?: string[];
    properties?: Record<string, PropertySchema>;
}
export interface PropertySchema {
    type: string;
    format?: string;
    description?: string;
    example?: any;
    enum?: any[];
}
export interface ResponseSpec {
    status: number;
    description: string;
    body?: Schema;
}
export interface Implementation {
    steps: Step[];
}
export interface Middleware {
    [key: string]: any;
}
export interface Table {
    name: string;
    description: string;
    required_fields: Field_Definition[];
}
export interface Field_Definition {
    name: string;
    type: string;
    primary_key?: boolean;
    unique?: boolean;
    indexed?: boolean;
    foreign_key?: string;
    nullable?: boolean;
    default?: any;
}
/**
 * Documentation intent - declarative approach to generating documentation
 * Specifies WHAT documentation is needed, generators determine HOW to create it
 */
export interface DocumentationIntent {
    /** Type of documentation to generate */
    type: 'tutorial' | 'methodology' | 'troubleshooting' | 'api_reference' | 'setup_guide' | 'best_practices' | 'architecture';
    /** What to document (e.g., "authentication", "database", "api") */
    scope?: string;
    /** Specific topics to cover within the scope */
    topics?: string[];
    /** Include code examples */
    includeExamples?: boolean;
    /** Include common issues and solutions */
    includeCommonIssues?: boolean;
    /** Target audience */
    audience?: 'user' | 'developer' | 'both';
    /** How to handle regeneration */
    overwrite?: 'always' | 'if-missing' | 'never';
    /** Custom output path (relative to docs directory) */
    outputPath?: string;
}
/**
 * Main documentation configuration
 * Supports both intent-based (declarative) and literal (legacy) approaches
 */
export interface Documentation {
    /** Intent-based documentation (recommended) */
    intents?: DocumentationIntent[];
    /** Legacy literal documentation (deprecated, use intents instead) */
    user_docs?: DocSection[];
    developer_docs?: DocSection[];
    /** Custom documentation sections (escape hatch for unique content) */
    customSections?: DocSection[];
}
export interface DocSection {
    title: string;
    sections: DocContent[];
}
export interface DocContent {
    heading: string;
    content: string;
    steps?: string[];
    examples?: CodeExample[];
}
export interface CodeExample {
    language: string;
    code: string;
}
/**
 * Metadata about generated documentation files
 * Tracked in .bangstack/manifest.json for smart regeneration
 */
export interface GeneratedDocumentation {
    path: string;
    intentType?: string;
    generatedFrom: string[];
    lastUpdated: string;
    overwritePolicy: 'always' | 'if-missing' | 'never';
    userModified?: boolean;
    sourceStateHash?: string;
}
/**
 * Technology Configuration
 * Specifies technology choices for the application
 */
export interface Technology {
    backend?: {
        framework?: string;
        language?: string;
    };
    frontend?: {
        framework?: string;
        styling?: string;
    };
    database?: string;
    [key: string]: any;
}
/**
 * Testing Configuration
 * Affects: All components
 * Generator: testing-generator.ts
 */
export interface Testing {
    frameworks?: {
        unit?: TestFrameworkConfig;
        integration?: TestFrameworkConfig;
        e2e?: E2ETestConfig;
        component?: TestFrameworkConfig;
    };
    coverage?: {
        threshold?: {
            global?: CoverageThreshold;
            per_file?: CoverageThreshold;
        };
        exclude?: string[];
    };
    database?: {
        strategy: 'testcontainers' | 'sqlite' | 'dedicated' | 'mock';
        reset_strategy?: 'truncate' | 'drop_and_recreate';
        fixtures_path?: string;
    };
    workers?: {
        strategy: 'mock_queue' | 'test_redis' | 'in_memory';
        auto_process?: boolean;
    };
    external_apis?: {
        strategy: 'msw' | 'nock' | 'mock_server';
        handlers_path?: string;
        mock_definitions?: ExternalApiMock[];
    };
    ci_cd?: {
        provider?: 'github_actions' | 'gitlab_ci' | 'circle_ci';
        test_on_pr?: boolean;
        test_requirements?: {
            require_passing?: boolean;
            minimum_coverage?: number;
        };
    };
    fixtures?: TestFixtures;
    factories?: FactoryConfig;
    /** @deprecated Use frameworks.unit instead */
    unit_tests?: UnitTest[];
    /** @deprecated Use frameworks.integration instead */
    integration_tests?: IntegrationTest[];
    /** @deprecated Use frameworks.e2e instead */
    e2e_tests?: E2ETest[];
}
export interface UnitTest {
    component: string;
    scenarios: string[];
}
export interface IntegrationTest {
    name: string;
    description?: string;
    steps: string[];
}
export interface E2ETest {
    name: string;
    tool: 'playwright' | 'cypress' | string;
    steps: string[];
}
export interface TestFrameworkConfig {
    framework: 'vitest' | 'jest' | 'mocha' | string;
    config?: Record<string, any>;
}
export interface E2ETestConfig extends TestFrameworkConfig {
    framework: 'playwright' | 'cypress' | string;
    browsers?: string[];
    headless?: boolean;
    demo_mode?: DemoModeConfig;
}
export interface DemoModeConfig {
    enabled: boolean;
    narration?: boolean;
    slow_mo?: number;
    recording?: {
        output_path: string;
        formats?: string[];
    };
}
export interface CoverageThreshold {
    statements?: number;
    branches?: number;
    functions?: number;
    lines?: number;
}
export interface ExternalApiMock {
    service: string;
    base_url: string;
    handlers?: ApiHandler[];
    failure_scenarios?: FailureScenario[];
}
export interface ApiHandler {
    endpoint: string;
    response: {
        status: number;
        body: any;
        delay?: number;
    };
}
export interface FailureScenario {
    name: string;
    endpoint: string;
    response: {
        status: number;
        body: any;
    };
}
export interface TestFixtures {
    path: string;
    database_fixtures?: Record<string, any[]>;
    api_fixtures?: Record<string, any>;
}
export interface FactoryConfig {
    enabled: boolean;
    library?: 'fishery' | 'factory-bot' | string;
    definitions?: FactoryDefinition[];
}
export interface FactoryDefinition {
    model: string;
    factory: string;
}
/**
 * Monitoring Configuration
 * Affects: All components
 * Generator: monitoring-generator.ts
 */
export interface Monitoring {
    apm?: {
        provider: 'datadog' | 'new_relic' | 'app_insights' | string;
        config?: Record<string, any>;
    };
    error_tracking?: {
        provider: 'sentry' | 'bugsnag' | 'rollbar' | string;
        config?: Record<string, any>;
        frontend?: boolean;
        backend?: boolean;
    };
    logging?: {
        provider: 'winston' | 'pino' | 'bunyan' | string;
        level: 'debug' | 'info' | 'warn' | 'error';
        transports?: LogTransport[];
    };
    tracing?: {
        provider: 'jaeger' | 'zipkin' | 'datadog' | string;
        sampling_rate?: number;
    };
    metrics?: {
        tracked: string[];
        custom_metrics?: MetricDefinition[];
    };
    alerts?: AlertDefinition[];
}
export interface LogTransport {
    type: 'console' | 'file' | 'http' | string;
    config?: Record<string, any>;
}
export interface MetricDefinition {
    name: string;
    type: 'counter' | 'gauge' | 'histogram';
    description: string;
}
export interface AlertDefinition {
    name: string;
    condition: string;
    channels: string[];
    severity?: 'info' | 'warning' | 'critical';
}
/**
 * Security & Compliance Configuration
 * Affects: Entire application
 * Generator: security-generator.ts
 */
export interface Security {
    compliance?: {
        regulations: ('gdpr' | 'ccpa' | 'hipaa' | 'soc2' | 'pci_dss')[];
        data_retention?: DataRetentionPolicy;
        gdpr?: GDPRConfig;
    };
    encryption?: {
        at_rest: boolean;
        in_transit: boolean;
        field_level?: string[];
    };
    audit_logging?: {
        enabled: boolean;
        retention: string;
        log_all_database_changes?: boolean;
        log_api_requests?: boolean;
    };
    csp?: {
        enabled: boolean;
        directives?: Record<string, string[]>;
    };
    rate_limiting?: RateLimitingConfig;
}
export interface DataRetentionPolicy {
    [dataType: string]: string;
}
export interface GDPRConfig {
    right_to_access?: boolean;
    right_to_erasure?: boolean;
    data_portability?: boolean;
    consent_management?: boolean;
}
export interface RateLimitingConfig {
    global?: RateLimit;
    per_user?: Record<string, string>;
    per_endpoint?: EndpointRateLimit[];
}
export interface RateLimit {
    requests_per_minute?: number;
    burst?: number;
}
export interface EndpointRateLimit {
    path: string;
    limit: string;
}
/**
 * Performance Configuration
 * Affects: Architecture decisions
 * Generator: performance-generator.ts
 */
export interface Performance {
    frontend?: {
        code_splitting?: 'route_based' | 'component_based' | 'manual';
        lazy_loading?: boolean;
        tree_shaking?: boolean;
        bundle_budget?: BundleBudget;
    };
    backend?: {
        caching?: CachingStrategy;
        connection_pooling?: ConnectionPooling;
        query_optimization?: boolean;
    };
    cdn?: {
        provider: 'cloudflare' | 'cloudfront' | 'fastly' | string;
        assets?: string[];
        cache_ttl?: number;
    };
    database?: {
        read_replicas?: number;
        sharding?: ShardingConfig;
        indexing_strategy?: 'auto' | 'manual';
    };
}
export interface BundleBudget {
    max_initial?: string;
    max_total?: string;
}
export interface CachingStrategy {
    strategy: 'redis' | 'memcached' | 'in_memory';
    ttl?: number;
    cache_keys?: string[];
}
export interface ConnectionPooling {
    min: number;
    max: number;
    idle_timeout?: number;
}
export interface ShardingConfig {
    strategy: 'by_tenant' | 'by_date' | 'by_hash';
    shard_count?: number;
}
/**
 * Internationalization Configuration
 * Affects: Entire UI
 * Generator: i18n-generator.ts
 */
export interface Internationalization {
    default_locale: string;
    supported_locales: string[];
    translation_files?: string;
    fallback_strategy?: 'cascade' | 'default';
    formatting?: {
        dates?: 'locale_specific' | 'iso';
        numbers?: 'locale_specific' | 'standard';
        currency?: 'locale_specific' | 'usd';
    };
    translation_management?: {
        provider?: 'lokalise' | 'crowdin' | 'phrase' | string;
        auto_sync?: boolean;
    };
}
/**
 * Feature Flags Configuration
 * Affects: Application behavior
 * Generator: feature-flags-generator.ts
 */
export interface FeatureFlags {
    provider: 'launchdarkly' | 'split' | 'unleash' | 'custom' | string;
    flags?: FeatureFlag[];
}
export interface FeatureFlag {
    name: string;
    enabled: boolean;
    rollout_percentage?: number;
    rollout_strategy?: 'gradual' | 'immediate';
    targeting?: {
        user_segments?: string[];
    };
    schedule?: RolloutSchedule[];
}
export interface RolloutSchedule {
    date: string;
    percentage: number;
}
/**
 * Access Control Configuration
 * Affects: Security across application
 * Generator: access-control-generator.ts
 */
export interface AccessControl {
    model: 'rbac' | 'abac' | 'rbac_with_abac';
    roles?: Role[];
    policies?: Policy[];
}
export interface Role {
    name: string;
    permissions: Permission[];
}
export interface Permission {
    resource: string;
    actions: string[];
    conditions?: Condition[];
}
export interface Condition {
    field: string;
    operator: 'equals' | 'contains' | 'gt' | 'lt';
    value: any;
}
export interface Policy {
    name: string;
    resource: string;
    action: string;
    rules: PolicyRule[];
}
export interface PolicyRule {
    role?: string;
    condition?: string;
}
/**
 * API Configuration
 * Affects: All API endpoints
 * Generator: api-generator.ts
 */
export interface ApiConfiguration {
    base_path?: string;
    documentation?: {
        format: 'openapi' | 'swagger' | 'graphql_schema';
        auto_generate: boolean;
        output?: string;
    };
    versioning?: {
        strategy: 'url_path' | 'header' | 'query_param';
        deprecation_policy?: DeprecationPolicy;
    };
    cors?: {
        enabled: boolean;
        origins?: string[];
        methods?: string[];
        credentials?: boolean;
    };
    middleware?: string[];
    endpoints?: Endpoint[];
}
export interface DeprecationPolicy {
    notice_period: string;
    sunset_headers: boolean;
}
/**
 * Deployment Configuration
 * Affects: Infrastructure
 * Generator: deployment-generator.ts
 */
export interface DeploymentConfiguration {
    strategy: 'single_region' | 'multi_region' | 'edge';
    regions?: Region[];
    edge_functions?: EdgeFunction[];
    geo_routing?: {
        enabled: boolean;
        strategy: 'lowest_latency' | 'closest_region' | 'manual';
    };
    disaster_recovery?: {
        rpo: string;
        rto: string;
        replica_regions?: string[];
        failover: 'automatic' | 'manual';
    };
}
export interface Region {
    name: string;
    primary?: boolean;
    services: string[];
    database_replica?: boolean;
}
export interface EdgeFunction {
    name: string;
    regions: 'all' | string[];
    provider?: 'cloudflare_workers' | 'lambda_edge' | string;
}
/**
 * Analytics Configuration
 * Affects: Event tracking across application
 * Generator: analytics-generator.ts
 */
export interface Analytics {
    provider: 'mixpanel' | 'amplitude' | 'segment' | 'google_analytics' | string;
    tracking?: {
        auto_track?: string[];
        custom_events?: CustomEvent[];
    };
    events?: Array<{
        name: string;
        properties: Record<string, string>;
    }>;
    privacy?: {
        gdpr_compliance?: boolean;
        consent_required?: boolean;
        data_retention_days?: number;
    };
    sampling?: {
        enabled: boolean;
        rate: number;
    };
    funnels?: Funnel[];
    cohorts?: Cohort[];
}
export interface CustomEvent {
    name: string;
    properties: string[];
}
export interface Funnel {
    name: string;
    steps: FunnelStep[];
}
export interface FunnelStep {
    event: string;
    required?: boolean;
}
export interface Cohort {
    name: string;
    criteria: string;
}
/**
 * Models Configuration
 * Database models/schemas
 */
export interface Models {
    [modelName: string]: Model;
}
export interface Model {
    fields: ModelField[];
    relationships?: ModelRelationship[];
    validation_rules?: ValidationRuleDefinition[];
    [key: string]: any;
}
export interface ModelField {
    name: string;
    type: string;
    constraints?: Record<string, any>;
    [key: string]: any;
}
export interface ModelRelationship {
    type: 'hasMany' | 'belongsTo' | 'hasOne' | 'manyToMany';
    model: string;
    foreign_key?: string;
    [key: string]: any;
}
export interface ValidationRuleDefinition {
    name: string;
    condition: string;
    message?: string;
}
/**
 * Migrations Configuration
 */
export interface Migrations {
    strategy?: 'prisma_migrate' | 'knex' | 'typeorm' | 'drizzle' | 'custom';
    auto_generate?: boolean;
    version_control?: {
        naming?: 'timestamp' | 'sequential' | 'semantic';
    };
}
/**
 * Error Handling Configuration
 * Generator: enhanced-error-handling-generator.ts
 */
export interface ErrorHandling {
    middleware?: boolean;
    custom_errors?: CustomErrorClass[];
    logging?: {
        provider: 'winston' | 'pino' | 'bunyan' | string;
        level: 'debug' | 'info' | 'warn' | 'error';
    };
    tracking?: {
        provider: 'sentry' | 'bugsnag' | 'rollbar' | string;
        config?: Record<string, any>;
        frontend?: boolean;
        backend?: boolean;
    };
    error_boundaries?: {
        enabled: boolean;
        fallback_ui?: 'default' | 'custom';
    };
    api_formatting?: {
        format: 'json_api' | 'problem_json' | 'custom';
        include_stack?: boolean;
    };
    recovery_strategies?: ErrorRecoveryStrategy[];
}
export interface CustomErrorClass {
    name: string;
    base_class?: string;
    status_code?: number;
    default_message?: string;
}
export interface ErrorRecoveryStrategy {
    error_type: string;
    strategy: 'retry' | 'fallback' | 'circuit_breaker' | string;
    config?: Record<string, any>;
}
/**
 * Rate Limiting Configuration
 * Generator: enhanced-rate-limiting-generator.ts
 */
export interface RateLimiting {
    middleware?: boolean;
    storage?: {
        type: 'memory' | 'redis';
        redis_url?: string;
    };
    strategy?: 'sliding_window' | 'fixed_window' | 'token_bucket';
    per_user?: RateLimitRule;
    per_ip?: RateLimitRule;
    per_api_key?: RateLimitRule;
    endpoints?: EndpointRateLimitRule[];
    headers?: boolean;
    custom_response?: {
        status_code?: number;
        message?: string;
    };
    bypass?: {
        admin?: boolean;
        internal?: boolean;
        api_keys?: string[];
    };
}
export interface RateLimitRule {
    requests: number;
    window: string;
    burst?: number;
}
export interface EndpointRateLimitRule {
    path: string;
    method?: string;
    rule: RateLimitRule;
}
/**
 * Email Configuration
 * Generator: enhanced-email-generator.ts
 */
export interface Email {
    provider: 'sendgrid' | 'postmark' | 'resend' | 'ses' | string;
    config?: {
        api_key?: string;
        from_email?: string;
        from_name?: string;
    };
    templates?: EmailTemplate[];
    rendering?: {
        engine: 'handlebars' | 'react_email' | 'mjml' | string;
        templates_path?: string;
    };
    queue?: {
        enabled: boolean;
        redis_url?: string;
        concurrency?: number;
    };
    tracking?: {
        opens?: boolean;
        clicks?: boolean;
        provider?: 'internal' | 'sendgrid' | 'postmark';
    };
    unsubscribe?: {
        enabled: boolean;
        link_type?: 'one_click' | 'custom_page';
    };
    testing?: {
        mode?: 'real' | 'mock' | 'log';
        catch_all_email?: string;
    };
}
export interface EmailTemplate {
    name: string;
    subject: string;
    template_file?: string;
    variables?: string[];
}
/**
 * Background Jobs Configuration
 * Generator: enhanced-background-jobs-generator.ts
 */
export interface BackgroundJobs {
    provider: 'bull' | 'bullmq' | 'bee' | string;
    redis?: {
        url?: string;
        host?: string;
        port?: number;
        password?: string;
    };
    jobs?: JobDefinition[];
    cron_jobs?: CronJobDefinition[];
    queue_config?: {
        default_concurrency?: number;
        remove_on_complete?: boolean | number;
        remove_on_fail?: boolean | number;
    };
    retry?: {
        attempts?: number;
        backoff?: {
            type: 'fixed' | 'exponential';
            delay?: number;
        };
    };
    progress_tracking?: boolean;
    dashboard?: {
        enabled: boolean;
        port?: number;
        auth?: {
            username: string;
            password: string;
        };
    };
    dead_letter_queue?: {
        enabled: boolean;
        retention?: string;
    };
    priority_levels?: string[];
}
export interface JobDefinition {
    name: string;
    handler: string;
    concurrency?: number;
    priority?: number;
    retry_attempts?: number;
}
export interface CronJobDefinition {
    name: string;
    schedule: string;
    handler: string;
    timezone?: string;
}
/**
 * Workflow Definitions (Business Logic)
 */
export interface WorkflowDefinitions {
    [workflowName: string]: WorkflowDefinition;
}
export interface WorkflowDefinition {
    id: string;
    name: string;
    description?: string;
    trigger?: string;
    steps: Step[];
    [key: string]: any;
}
/**
 * Events Configuration
 */
export interface Events {
    [eventName: string]: EventDefinition;
}
export interface EventDefinition {
    payload: Record<string, string>;
    handlers?: EventHandler[];
    [key: string]: any;
}
export interface EventHandler {
    action: string;
    [key: string]: any;
}
export interface Environment {
    [environment: string]: EnvironmentConfig;
}
export interface EnvironmentConfig {
    [componentName: string]: Record<string, string>;
}
export interface Deployment {
    [componentName: string]: DeploymentConfig;
}
export interface DeploymentConfig {
    build_command?: string;
    start_command?: string;
    output_directory?: string;
    health_check?: HealthCheck;
    environment_variables?: string[];
}
export interface HealthCheck {
    path: string;
    interval?: string;
}
export type StackComponentsByType<T extends string> = {
    [K in keyof StackComponents]: StackComponents[K]['type'] extends T ? StackComponents[K] : never;
};
export interface Stages {
    [stageName: string]: Stage;
}
export interface Stage {
    description?: string;
    infrastructure: StageInfrastructure;
    config?: StageConfig;
    env?: Record<string, string>;
}
export interface StageInfrastructure {
    domains?: {
        web?: string;
        api?: string;
        docs?: string;
        portal?: string;
        admin?: string;
        marketing?: string;
        custom?: Record<string, string>;
    };
    databases: {
        primary: string;
        analytics?: string;
        cache?: string;
        custom?: Record<string, string>;
    };
    services?: {
        redis?: ServiceInstance;
        queue?: ServiceInstance;
        storage?: ServiceInstance;
        search?: ServiceInstance;
        email?: ServiceInstance;
        cdn?: ServiceInstance;
        monitoring?: ServiceInstance;
        custom?: Record<string, ServiceInstance>;
    };
    workers?: WorkerConfig;
}
export interface ServiceInstance {
    provider: string;
    connection: string;
    config?: Record<string, any>;
}
export interface WorkerConfig {
    enabled?: boolean;
    concurrency?: number;
    queues?: string[];
    config?: Record<string, any>;
}
export interface StageConfig {
    log_level?: 'debug' | 'info' | 'warn' | 'error';
    development_tools?: boolean;
    error_details?: boolean;
    cors?: {
        enabled?: boolean;
        origins?: string[];
    };
    rate_limiting?: {
        enabled?: boolean;
        requests_per_minute?: number;
    };
    custom?: Record<string, any>;
}
//# sourceMappingURL=workflow.d.ts.map