export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
export type Primitive = string | number | boolean | null;
export type JsonValue = Primitive | JsonObject | JsonValue[];
export interface JsonObject {
    [key: string]: JsonValue;
}
/** Header values may be multi-valued (e.g. Set-Cookie). */
export type Headers = Record<string, string | string[]>;
export type Query = Record<string, string | string[]>;
export interface SimulatorRequest<TBody = unknown> {
    method: HttpMethod;
    /** Pathname used for matching. Optional when `url` or `baseUrl` is provided. */
    path?: string;
    /**
     * Absolute or relative URL. Absolute `http(s)://` URLs contribute pathname,
     * query, and Host. Relative values without `baseUrl` are treated as a path.
     */
    url?: string;
    /** Resolve `path` (or relative `url`) against this origin, same as `new URL(path, baseUrl)`. */
    baseUrl?: string;
    headers?: Headers;
    query?: Query;
    body?: TBody;
}
export interface MatchedSimulatorRequest<TBody = unknown> extends SimulatorRequest<TBody> {
    path: string;
    headers: Headers;
    query: Query;
    params: Record<string, string>;
}
export interface SimulatorResponse<TBody = unknown> {
    status?: number;
    headers?: Headers;
    body?: TBody;
}
export interface FixedBehavior<TBody = unknown> {
    type: 'fixed';
    response: SimulatorResponse<TBody>;
}
export interface RelativeBehavior<TTemplate = unknown> {
    type: 'relative';
    response: SimulatorResponse<TTemplate>;
    /** Throw when a token cannot be resolved. Defaults to true. */
    strict?: boolean;
}
/**
 * Mutable bag shared across endpoints of one `ApiDefinition`.
 * Single-process only — no locks, not durable across restarts.
 */
export interface SimulationState {
    get<T = unknown>(key: string): T | undefined;
    set(key: string, value: unknown): void;
    delete(key: string): boolean;
    snapshot(): Record<string, unknown>;
    reset(): void;
}
export interface SimulationContext<TData extends Record<string, unknown> = Record<string, unknown>> {
    apiId: string;
    endpointId: string;
    request: MatchedSimulatorRequest;
    data: Readonly<TData>;
    state: SimulationState;
}
export type SimulationFunction<TData extends Record<string, unknown> = Record<string, unknown>, TBody = unknown> = (context: SimulationContext<TData>) => SimulatorResponse<TBody> | Promise<SimulatorResponse<TBody>>;
export interface SimulationBehavior<TData extends Record<string, unknown> = Record<string, unknown>, TBody = unknown> {
    type: 'simulation';
    handler: SimulationFunction<TData, TBody>;
}
/**
 * A discriminated union guarantees that every endpoint has exactly one behavior.
 */
export type EndpointBehavior<TData extends Record<string, unknown> = Record<string, unknown>> = FixedBehavior | RelativeBehavior | SimulationBehavior<TData>;
export type EndpointValidateResult = void | SimulatorResponse | Promise<void | SimulatorResponse>;
export interface EndpointDefinition<TData extends Record<string, unknown> = Record<string, unknown>> {
    id: string;
    method: HttpMethod;
    /** Express-style path, for example /parents/:parentId/children. Supports `:id(\\d+)` and `:id?`. */
    path: string;
    behavior: EndpointBehavior<TData>;
    enabled?: boolean;
    /** Optional artificial latency for this endpoint. */
    delayMs?: number;
    /**
     * Optional request/response gate. Runs after route match, before behavior.
     * Returning a SimulatorResponse short-circuits the behavior handler.
     */
    validate?: (context: SimulationContext<TData>) => EndpointValidateResult;
}
export interface CorsOptions {
    origins: string[] | '*';
    methods?: HttpMethod[];
    headers?: string[];
    maxAge?: number;
}
export interface ApiDefinition<TData extends Record<string, unknown> = Record<string, unknown>> {
    id: string;
    /** Optional prefix, for example /crm/v1. */
    basePath?: string;
    /**
     * Optional host matcher for multi-tenant routing.
     * Compared against the request `Host` header (hostname only, port stripped).
     */
    host?: string | RegExp;
    data?: TData;
    endpoints: EndpointDefinition<TData>[];
    /** When set, expands OPTIONS preflight routes and adds CORS headers on matches. */
    cors?: CorsOptions;
}
export interface SimulatorDefinition {
    apis: ApiDefinition[];
}
export interface SimulatorOptions {
    recordHistory?: boolean | {
        limit?: number;
    };
    /** At construction, validate `{{data.*}}` tokens in relative templates. */
    validateTemplates?: boolean;
}
export interface DispatchMatch {
    apiId: string;
    endpointId: string;
    request: MatchedSimulatorRequest;
    response: SimulatorResponse;
}
export interface ApiSimulator {
    dispatch(request: SimulatorRequest): Promise<DispatchMatch>;
    tryDispatch(request: SimulatorRequest): Promise<DispatchMatch | undefined>;
    listEndpoints(): Array<{
        apiId: string;
        endpointId: string;
        method: HttpMethod;
        path: string;
        behaviorType: EndpointBehavior['type'];
    }>;
    getHistory(): readonly DispatchMatch[];
    clearHistory(): void;
    /** Mutable state for one API. Throws if `apiId` is unknown. */
    getState(apiId: string): SimulationState;
    /** Reset one API's state, or every API when `apiId` is omitted. */
    resetState(apiId?: string): void;
}
//# sourceMappingURL=types.d.ts.map