@n1k1t/mock-server/lib/src/server/index.d.ts

The ultimate toolkit to intercept, transform, and simulate HTTP/WS traffic with type-safe expectations

import { Redis, RedisOptions } from 'ioredis';
import { Server } from 'socket.io';
import { ProvidersStorage, Router, Transport, TransportsStorage } from './models';
import { IIoExchangeSchema, IServerContext, IServerContextDefaults } from './types';
import { OnsiteClient } from '../client';
import * as services from './services';
export * from './transports';
export * from './models';
export * from './types';
export interface IMockServerConfiguration {
    port: number;
    host: string;
    containers?: {
        /** Seconds `default: 1h` */
        expiredCleaningInterval?: number;
    };
    providers?: {
        /** Seconds `default: 5m` */
        expiredCleaningInterval?: number;
    };
    hooks?: {
        shudown?: {
            /** Enables shutdown events listening like `SIGTERM`, `SIGINT`, etc (default `true`) */
            isEnabled?: boolean;
        };
    };
    transports?: Record<string, Transport>;
    databases?: {
        redis?: RedisOptions;
    };
}
export declare class MockServer<TConfiguration extends IMockServerConfiguration = any, TContext extends IServerContext = any> {
    configuration: TConfiguration;
    TContext: TContext;
    timestamp: number;
    authority: string;
    databases: {
        redis: Redis | null;
    };
    exchanges: {
        io: import("./models").ISocketIoExchangeService<IIoExchangeSchema>;
    };
    providers: ProvidersStorage<TContext>;
    transports: TransportsStorage<TContext>;
    router: Router<TContext>;
    wss: import("ws").Server<typeof import("ws"), typeof import("http").IncomingMessage>;
    http: import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
    io: Server<import("socket.io/dist/typed-events").DefaultEventsMap, import("socket.io/dist/typed-events").DefaultEventsMap, import("socket.io/dist/typed-events").DefaultEventsMap, any>;
    services: {
        readonly shutdown: services.ShutdownService;
        readonly metrics: services.MetricsService;
        readonly redis: services.RedisService;
        readonly containers: services.ContainersService;
        readonly history: services.HistoryService;
    };
    private system;
    constructor(configuration: TConfiguration);
    /** Default client to work with main API */
    get client(): OnsiteClient<TContext>;
    private setupJobs;
    /** Starts and setups mock server */
    static start<TConfiguration extends IMockServerConfiguration, TContext extends IServerContext = {
        transport: IServerContextDefaults['transport'] | Extract<keyof TConfiguration['transports'], string>;
        flag: IServerContextDefaults['flag'] | {
            [K in keyof TConfiguration['transports']]: NonNullable<TConfiguration['transports']>[K]['TContext']['flag'];
        }[keyof TConfiguration['transports']];
    }>(configuration: TConfiguration): Promise<MockServer<TConfiguration, TContext>>;
}
//# sourceMappingURL=index.d.ts.map