import { AnyElysia, MaybeArray, MaybePromise } from 'elysia';
import { E as EdenFetchError } from './errors-DQ0_HKez.cjs';
import { InferRouteOptions, InferRouteBody } from './infer.cjs';
import { N as Nullish, H as HTTPHeaders } from './http-BobyyETH.cjs';
import { D as DataTransformerOptions } from './transformer-BrEsAU6i.cjs';
import { EdenWS } from './ws.cjs';

declare function noop(): void;
type Noop = typeof noop;

type TeardownLogic = Unsubscribable | Noop | void;
type UnaryFunction<TSource = any, TReturn = any> = (source: TSource) => TReturn;
type MonoTypeOperatorFunction<TValue, TError> = OperatorFunction<TValue, TError, TValue, TError>;
type OperatorFunction<TValueBefore = any, TErrorBefore = any, TValueAfter = any, TErrorAfter = any> = UnaryFunction<Subscribable<TValueBefore, TErrorBefore>, Subscribable<TValueAfter, TErrorAfter>>;
type Observer<TValue = any, TError = any> = {
    next: (value: TValue) => void;
    error: (err: TError) => void;
    complete: () => void;
};
type Unsubscribable = {
    unsubscribe(): void;
};
type InferObservableValue<TObservable> = TObservable extends Observable<infer TValue, unknown> ? TValue : never;
declare function isObservable(x: unknown): x is Observable<unknown, unknown>;
declare function pipeReducer(previousValue: any, next: UnaryFunction): any;
declare function promisifyObservable<T>(observable: Observable<T>): {
    promise: Promise<T>;
    abort: typeof noop;
};
declare class ObservableAbortError extends Error {
    constructor(message?: string);
}
declare class Subscribable<TValue = any, TError = any> {
    onSubscribe: (observer: Observer<TValue, TError>) => TeardownLogic;
    constructor(onSubscribe: (observer: Observer<TValue, TError>) => TeardownLogic);
    subscribe(observer?: Partial<Observer<TValue, TError>>): Unsubscribable;
}
declare class Observable<TValue = any, TError = any> extends Subscribable<TValue, TError> {
    constructor(onSubscribe: (observer: Observer<TValue, TError>) => TeardownLogic);
    pipe(): Observable<TValue, TError>;
    pipe<TValue1, TError1>(op1: OperatorFunction<TValue, TError, TValue1, TError1>): Observable<TValue1, TError1>;
    pipe<TValue1, TError1, TValue2, TError2>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>): Observable<TValue2, TError2>;
    pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>): Observable<TValue3, TError3>;
    pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>, op4: OperatorFunction<TValue3, TError3, TValue4, TError4>): Observable<TValue4, TError4>;
    pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4, TValue5, TError5>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>, op4: OperatorFunction<TValue3, TError3, TValue4, TError4>, op5: OperatorFunction<TValue4, TError4, TValue5, TError5>): Observable<TValue5, TError5>;
}

/**
 * Flexible format for defining headers.
 */
type EdenRequestHeaders = MaybeArray<RequestInit['headers'] | ((path: string, options?: RequestInit) => MaybePromise<RequestInit['headers'] | Nullish>)> | MaybePromise<HTTPHeaders>;
/**
 * Callback function to invoke before the request is made. The fetch options can be modified,
 * or new options can be returned.
 */
type EdenOnRequest = (path: string, options: RequestInit) => MaybePromise<RequestInit | Nullish>;
/**
 * Callback function to invoke after a response is received. Output value is ignored.
 */
type EdenOnResponse = (response: Response) => MaybePromise<EdenResponse | Nullish>;
/**
 * General, untyped response.
 */
type EdenResponse<TRaw extends boolean = false> = ({
    data: null;
    error: EdenFetchError<any, any>;
    status: number;
    statusText: string;
} | {
    data: any;
    error: null;
    status: number;
    statusText: string;
}) & (TRaw extends true ? EdenRawResponse : {});
/**
 * Raw response is __not__ JSON serializable, so only available when asked.
 */
type EdenRawResponse = {
    headers: Headers;
    response: Response;
    statusText: string;
};
/**
 * Options to customize the fetch behavior for the request.
 */
type EdenRequestOptions<T extends AnyElysia = AnyElysia, TRaw extends boolean = false> = {
    /**
     */
    domain?: T | string;
    /**
     */
    transformer?: DataTransformerOptions;
    /**
     * Fetch options.
     */
    fetch?: Omit<RequestInit, keyof EdenRequestOptions | 'method'>;
    /**
     * `fetch` implementation.
     */
    fetcher?: typeof fetch;
    /**
     * Custom headers object that's processed and forwarded to the fetch options.
     */
    headers?: EdenRequestHeaders;
    /**
     * Callback to invoke prior to fetching the request.
     */
    onRequest?: MaybeArray<EdenOnRequest>;
    /**
     * Callback to invoke after fetching the request.
     */
    onResponse?: MaybeArray<EdenOnResponse>;
    /**
     */
    keepDomain?: boolean;
    /**
     */
    raw?: TRaw;
    /**
     * Context to pass to the operation links.
     */
    context?: OperationContext;
};

declare function streamResponse(response: Response): AsyncGenerator<any, void, unknown>;
declare function parseResponse<T extends AnyElysia = AnyElysia, TRaw extends boolean = false>(response: Response, params?: EdenRequestParams<T, TRaw>): Promise<{
    data: {
        data: null;
        error: EdenFetchError<any, any>;
        status: number;
        statusText: string;
    } | {
        data: any;
        error: null;
        status: number;
        statusText: string;
    };
    error: null;
    status: number;
    statusText?: undefined;
} | {
    data: null;
    error: EdenFetchError<any, any>;
    status: number;
    statusText?: undefined;
} | {
    data: null;
    error: EdenFetchError<number, any>;
    status: number;
    statusText: string;
} | {
    data: any;
    error: null;
    status: number;
    statusText: string;
}>;
/**
 * Parameters that control how an Eden request is resolved.
 */
type EdenRequestParams<T extends AnyElysia = AnyElysia, TRaw extends boolean = false> = EdenRequestOptions<T, TRaw> & {
    /**
     */
    domain?: T | string;
    /**
     * Fetch options for a "query" method, i.e. "GET", "HEAD", "OPTIONS".
     */
    options?: InferRouteOptions;
    /**
     * The request body for "POST", "PATCH", etc. requests.
     */
    body?: InferRouteBody;
    /**
     */
    path?: string;
    /**
     */
    method?: string;
};
declare function resolveEdenRequest<T extends AnyElysia = AnyElysia, TRaw extends boolean = false>(params: EdenRequestParams<T, TRaw>): Promise<EdenResponse<TRaw> | EdenWS>;

type OperationType = 'query' | 'mutation' | 'subscription';
interface OperationContext extends Record<string, unknown> {
}
type Operation<T extends AnyElysia = any> = {
    id: number;
    type: OperationType;
    params: EdenRequestParams<T>;
    context: OperationContext;
};
type OperationLink<TElysia extends AnyElysia = AnyElysia, TInput = unknown, TOutput = unknown> = (options: OperationLinkOptions<TElysia, TInput, TOutput>) => OperationResultObservable<TElysia, TOutput>;
type OperationLinkOptions<TElysia extends AnyElysia = AnyElysia, _TInput = unknown, TOutput = unknown> = {
    operation: Operation<TElysia>;
    next: (operation: Operation<TElysia>) => OperationResultObservable<TElysia, TOutput>;
};
type OperationResultObservable<TElysia extends AnyElysia, TOutput> = Observable<OperationResultEnvelope<TOutput>, EdenClientError<TElysia>>;
type OperationResultObserver<TRoute extends AnyElysia, TOutput> = Observer<OperationResultEnvelope<TOutput>, EdenClientError<TRoute>>;
type OperationResultEnvelope<T = any> = (EdenResultMessage<T> | EdenSuccessResponse<T>) & {
    context?: OperationContext;
};
type EdenResultMessage<T> = {
    type: 'started';
    data?: never;
} | {
    type: 'stopped';
    data?: never;
} | {
    data: T;
    type: 'data';
};
type EdenSuccessResponse<T> = {
    data: T;
    type?: 'data';
};
type EdenLink<T extends AnyElysia = any, TMeta = {}> = ((opts: EdenClientRuntime) => OperationLink<T>) & TMeta;
type EdenClientRuntime = {};
type EdenClientOptions<T extends AnyElysia> = {
    links: EdenLink<T>[];
};
/**
 * Type representing errors that can occur during Eden client operations.
 * This is the union of all possible error types from the Elysia route schema.
 *
 * @template _T - The Elysia app type (reserved for future use with route-specific error types)
 */
type EdenClientError<_T extends AnyElysia = AnyElysia> = EdenFetchError<number, unknown> | Error;
declare class OperationError extends Error {
    constructor(message?: string);
}

export { type EdenRawResponse as A, streamResponse as B, parseResponse as C, type EdenRequestParams as D, type EdenRequestOptions as E, resolveEdenRequest as F, type InferObservableValue as I, type MonoTypeOperatorFunction as M, type Noop as N, type Operation as O, Subscribable as S, type TeardownLogic as T, type UnaryFunction as U, type EdenLink as a, type OperationResultEnvelope as b, type OperatorFunction as c, type Observer as d, type Unsubscribable as e, promisifyObservable as f, ObservableAbortError as g, Observable as h, isObservable as i, type OperationType as j, type OperationContext as k, type OperationLink as l, type OperationLinkOptions as m, type OperationResultObservable as n, type OperationResultObserver as o, pipeReducer as p, type EdenResultMessage as q, type EdenSuccessResponse as r, type EdenClientRuntime as s, type EdenClientOptions as t, type EdenClientError as u, OperationError as v, type EdenRequestHeaders as w, type EdenOnRequest as x, type EdenOnResponse as y, type EdenResponse as z };