import { Logger } from 'pino';
import * as valleyed from 'valleyed';
import { PipeOutput, ConditionalObjectKeys, PipeInput, Pipe } from 'valleyed';
import { E as EquippedError } from '../requestError-C2PNWUrt.js';
import { K as KafkaEventBus, E as EventBus } from '../kafka-Cf-TUJgv.js';
import { RabbitMQEventBus } from '../events/index.js';
import { A as AuthUser } from '../overrides-6Hxg764S.js';
import { E as ExpressServer, F as FastifyServer, B as BaseRequestAuthMethod } from '../fastify-DLPUK3vD.js';
import { InMemoryCache, RedisCache } from '../cache/index.js';
import { M as MongoDb } from '../db-Dj1SGto0.js';
import { RedisJob } from '../jobs/index.js';
import '../types/index.js';
import 'node:http2';
import 'node:stream';
import '@fastify/cookie';
import 'express';
import 'fastify';
import 'supertest/lib/agent';
import 'node:http';
import '@fastify/cors';
import 'cors';
import 'supertest';
import 'socket.io';
import '../core-BrkNSwvc.js';
import 'mongodb';
import 'ioredis';
import '../db-C8YY1yTO.js';

type HookEvent = 'setup' | 'start' | 'close';
type HookCb = Promise<unknown | void> | (() => void | unknown | Promise<void | unknown>);

declare const instanceSettingsPipe: () => valleyed.Pipe<{
    app: {
        name: string;
    };
    log: {
        level: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "silent" | undefined;
    } | undefined;
    utils: {
        hashSaltRounds: number | undefined;
        paginationDefaultLimit: number | undefined;
        maxFileUploadSizeInMb: number | undefined;
    } | undefined;
}, {
    app: {
        name: string;
    };
    log: {
        level: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "silent";
    };
    utils: {
        hashSaltRounds: number;
        paginationDefaultLimit: number;
        maxFileUploadSizeInMb: number;
    };
}>;
type Settings = PipeOutput<ReturnType<typeof instanceSettingsPipe>>;
type SettingsInput = ConditionalObjectKeys<PipeInput<ReturnType<typeof instanceSettingsPipe>>>;
type CacheTypes = {
    'in-memory': InMemoryCache;
    redis: RedisCache;
};
declare const cachePipe: () => valleyed.Pipe<{
    type: "in-memory";
} | ({
    host: string;
    port: number | undefined;
    password: string | undefined;
    username: string | undefined;
    tls: boolean | undefined;
    cluster: boolean | undefined;
} & {
    type: "redis";
}), InMemoryCache | RedisCache>;
type JobTypes = {
    redis: RedisJob;
};
declare const jobsPipe: () => valleyed.Pipe<{
    redisConfig: {
        host: string;
        port: number | undefined;
        password: string | undefined;
        username: string | undefined;
        tls: boolean | undefined;
        cluster: boolean | undefined;
    };
    queueName: string;
} & {
    type: "redis";
}, RedisJob>;
type EventBusTypes = {
    kafka: KafkaEventBus;
    rabbitmq: RabbitMQEventBus;
};
declare const eventBusPipe: () => valleyed.Pipe<({
    brokers: string[];
    ssl: boolean | undefined;
    sasl: {
        mechanism: "plain";
        username: string;
        password: string;
    } | undefined;
    clientId: string | undefined;
} & {
    type: "kafka";
}) | ({
    uri: string;
    eventColumnName: string;
} & {
    type: "rabbitmq";
}), KafkaEventBus | RabbitMQEventBus>;
type DbTypes = {
    mongo: MongoDb;
};
declare const dbPipe: () => valleyed.Pipe<{
    db: {
        uri: string;
    } & {
        type: "mongo";
    };
    changes: {
        debeziumUrl: string;
        eventBus: KafkaEventBus;
    } | undefined;
}, MongoDb>;
type ServerTypes = {
    express: ExpressServer;
    fastify: FastifyServer;
};
declare const serverTypePipe: () => valleyed.Pipe<({
    port: number;
    cors: {
        origin: true | string[] | undefined;
        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | undefined;
        credentials: boolean | undefined;
    } | undefined;
    eventBus: EventBus | undefined;
    publicPath: string | undefined;
    healthPath: string | undefined;
    openapi: {
        docsVersion: string | undefined;
        docsBaseUrl: string[] | undefined;
        docsPath: string | undefined;
    } | undefined;
    requests: {
        log: boolean | undefined;
        rateLimit: {
            enabled: boolean | undefined;
            periodInMs: number | undefined;
            limit: number | undefined;
        } | undefined;
        slowdown: {
            enabled: boolean | undefined;
            periodInMs: number | undefined;
            delayAfter: number | undefined;
            delayInMs: number | undefined;
        } | undefined;
    } | undefined;
    socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[] | undefined;
} & {
    type: "fastify";
}) | ({
    port: number;
    cors: {
        origin: true | string[] | undefined;
        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | undefined;
        credentials: boolean | undefined;
    } | undefined;
    eventBus: EventBus | undefined;
    publicPath: string | undefined;
    healthPath: string | undefined;
    openapi: {
        docsVersion: string | undefined;
        docsBaseUrl: string[] | undefined;
        docsPath: string | undefined;
    } | undefined;
    requests: {
        log: boolean | undefined;
        rateLimit: {
            enabled: boolean | undefined;
            periodInMs: number | undefined;
            limit: number | undefined;
        } | undefined;
        slowdown: {
            enabled: boolean | undefined;
            periodInMs: number | undefined;
            delayAfter: number | undefined;
            delayInMs: number | undefined;
        } | undefined;
    } | undefined;
    socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[] | undefined;
} & {
    type: "express";
}), ExpressServer | FastifyServer>;

declare class Instance {
    #private;
    readonly settings: Readonly<Settings>;
    readonly log: Logger<never>;
    private constructor();
    alias(id: string): undefined;
    get id(): string;
    getScopedName(name: string, key?: string): string;
    createCache<T extends keyof CacheTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof cachePipe>>, {
        type: T;
    }>>): CacheTypes[T];
    createJobs<T extends keyof JobTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof jobsPipe>>, {
        type: T;
    }>>): JobTypes[T];
    createEventBus<T extends keyof EventBusTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof eventBusPipe>>, {
        type: T;
    }>>): EventBusTypes[T];
    createDb<T extends keyof DbTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof dbPipe>>, {
        db: {
            type: T;
        };
    }>>): DbTypes[T];
    createServer<T extends keyof ServerTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof serverTypePipe>>, {
        type: T;
    }>>): ServerTypes[T];
    start(): Promise<void>;
    static envs<E extends object>(envsPipe: Pipe<unknown, E>): E;
    static create(settings: SettingsInput): Instance;
    static get(): Instance;
    static on(event: HookEvent, cb: HookCb, order: number): void;
    static resolveBeforeCrash<T>(cb: () => Promise<T>): Promise<T>;
    static crash(error: EquippedError): never;
    static createId(opts?: {
        prefix?: string;
        time?: Date;
    }): string;
}

export { Instance };