import { z } from 'zod';

/**
 * Request to be executed by the HTTP executor
 */
interface ExecuteRequest {
    method: string;
    url: string;
    headers: Record<string, string>;
    body?: string;
    timeout?: number;
}
/**
 * Response from the HTTP executor
 */
interface ExecuteResponse<TRawResponse = unknown> {
    status: number;
    statusText: string;
    data: unknown;
    raw: TRawResponse;
}
/**
 * Interface for HTTP executors (fetch, ky, etc.)
 */
interface HttpExecutor<TRawResponse = unknown> {
    execute(request: ExecuteRequest): Promise<ExecuteResponse<TRawResponse>>;
}
type ApiRequestSchema = Record<string, Record<string, unknown>>;
type ApiResponseSchema = Record<string, Record<string, Record<string, z.ZodTypeAny>>>;
type LogLevel = "error" | "warn" | "info" | "debug";
type LogMeta = Record<string, unknown>;
type LogHandler = (message: string, meta?: LogMeta) => void;
/**
 * Optional structured logger for internal client logging.
 */
type Logger = Partial<Record<LogLevel, LogHandler>>;
interface ApiClientLoggingOptions {
    logger?: Logger;
}
/**
 * Extracts path parameters from an endpoint string
 * @example ExtractPathParams<'/users/{id}/posts/{postId}'> → 'id' | 'postId'
 */
type ExtractPathParams<T extends string> = T extends `${string}{${infer Param}}${infer Rest}` ? Param extends `${infer Key}` ? Key | ExtractPathParams<Rest> : ExtractPathParams<Rest> : never;
/**
 * Extracts params type from Request object
 */
type ExtractRequestParams<TRequest extends ApiRequestSchema, TEndpoint extends keyof TRequest, TMethod extends keyof TRequest[TEndpoint]> = TRequest[TEndpoint][TMethod] extends {
    params: infer P;
} ? P extends z.ZodTypeAny ? z.input<P> : never : ExtractPathParams<TEndpoint & string> extends never ? never : Record<ExtractPathParams<TEndpoint & string> & string, string>;
/**
 * Extracts query type from Request object
 */
type ExtractRequestQuery<TRequest extends ApiRequestSchema, TEndpoint extends keyof TRequest, TMethod extends keyof TRequest[TEndpoint]> = TRequest[TEndpoint][TMethod] extends {
    query: infer Q;
} ? Q extends z.ZodTypeAny ? z.input<Q> : never : never;
/**
 * Extracts body type from Request object
 */
type ExtractRequestBody<TRequest extends ApiRequestSchema, TEndpoint extends keyof TRequest, TMethod extends keyof TRequest[TEndpoint]> = TRequest[TEndpoint][TMethod] extends {
    body: infer B;
} ? B extends z.ZodTypeAny ? z.input<B> : never : never;
/**
 * Helper to determine if params are required
 */
type ParamsRequired<TRequest extends ApiRequestSchema, TEndpoint extends keyof TRequest, TMethod extends keyof TRequest[TEndpoint]> = TRequest[TEndpoint][TMethod] extends {
    params: z.ZodTypeAny;
} ? true : ExtractPathParams<TEndpoint & string> extends never ? false : true;
/**
 * Helper to determine if body is required
 */
type BodyRequired<TRequest extends ApiRequestSchema, TEndpoint extends keyof TRequest, TMethod extends keyof TRequest[TEndpoint]> = TRequest[TEndpoint][TMethod] extends {
    body: z.ZodTypeAny;
} ? true : false;
/**
 * Extracts endpoints that have a specific HTTP method
 */
type EndpointsWithMethod<TRequest extends ApiRequestSchema, TMethod extends string> = {
    [K in keyof TRequest]: TMethod extends keyof TRequest[K] ? K : never;
}[keyof TRequest] & string;
/**
 * Extracts all status codes from Response object for an endpoint/method
 */
type ExtractStatusCodes<TResponse extends ApiResponseSchema, TEndpoint extends keyof TResponse, TMethod extends keyof TResponse[TEndpoint]> = TResponse[TEndpoint][TMethod] extends Record<string, z.ZodTypeAny> ? keyof TResponse[TEndpoint][TMethod] & string : never;
/**
 * Extracts success status codes (2xx) from Response object
 */
type ExtractSuccessCodes<TResponse extends ApiResponseSchema, TEndpoint extends keyof TResponse, TMethod extends keyof TResponse[TEndpoint]> = ExtractStatusCodes<TResponse, TEndpoint, TMethod> extends infer Codes ? Codes extends string ? Codes extends `2${string}` ? Codes : never : never : never;
/**
 * Extracts error status codes (non-2xx) from Response object
 */
type ExtractErrorCodes<TResponse extends ApiResponseSchema, TEndpoint extends keyof TResponse, TMethod extends keyof TResponse[TEndpoint]> = ExtractStatusCodes<TResponse, TEndpoint, TMethod> extends infer Codes ? Codes extends string ? Codes extends `2${string}` ? never : Codes : never : never;
/**
 * Extracts response schema for a specific status code
 */
type ExtractResponseSchema<TResponse extends ApiResponseSchema, TEndpoint extends keyof TResponse, TMethod extends keyof TResponse[TEndpoint], TCode extends string> = TResponse[TEndpoint][TMethod] extends Record<string, z.ZodTypeAny> ? TCode extends keyof TResponse[TEndpoint][TMethod] ? TResponse[TEndpoint][TMethod][TCode] : never : never;
/**
 * Infers the success response body type (uses first success code, typically 200)
 */
type ExtractSuccessBody<TResponse extends ApiResponseSchema, TEndpoint extends keyof TResponse, TMethod extends keyof TResponse[TEndpoint]> = ExtractSuccessCodes<TResponse, TEndpoint, TMethod> extends infer SuccessCode ? SuccessCode extends string ? ExtractResponseSchema<TResponse, TEndpoint, TMethod, SuccessCode> extends z.ZodTypeAny ? z.infer<ExtractResponseSchema<TResponse, TEndpoint, TMethod, SuccessCode>> : never : never : never;
/**
 * Creates a discriminated union member for a success response
 */
type SuccessResponse<TSuccessBody, TCode extends string, TRawResponse = unknown> = {
    success: true;
    body: TSuccessBody;
    code: TCode;
    raw: TRawResponse;
};
/**
 * Creates a discriminated union member for an error response with specific code
 */
type ErrorResponse<TError, TCode extends string, TRawResponse = unknown> = {
    success: false;
    error: TError;
    code: TCode;
    raw: TRawResponse;
};
/**
 * Unexpected error response (for errors not in the spec)
 */
type UnexpectedErrorResponse<TRawResponse = unknown> = {
    success: false;
    error: unknown;
    code: number;
    raw?: TRawResponse;
};
/**
 * Builds the complete discriminated union response type
 */
type ApiResponse<TResponse extends ApiResponseSchema, TEndpoint extends string, TMethod extends string, TRawResponse = unknown> = TEndpoint extends keyof TResponse ? TMethod extends keyof TResponse[TEndpoint] ? (ExtractSuccessCodes<TResponse, TEndpoint, TMethod> extends infer SuccessCode ? SuccessCode extends string ? ExtractResponseSchema<TResponse, TEndpoint, TMethod, SuccessCode> extends z.ZodTypeAny ? SuccessResponse<z.infer<ExtractResponseSchema<TResponse, TEndpoint, TMethod, SuccessCode>>, SuccessCode, TRawResponse> : never : never : never) | (ExtractErrorCodes<TResponse, TEndpoint, TMethod> extends infer ErrorCodes ? ErrorCodes extends string ? ExtractResponseSchema<TResponse, TEndpoint, TMethod, ErrorCodes> extends z.ZodTypeAny ? ErrorResponse<z.infer<ExtractResponseSchema<TResponse, TEndpoint, TMethod, ErrorCodes>>, ErrorCodes, TRawResponse> : never : never : never) | UnexpectedErrorResponse<TRawResponse> : UnexpectedErrorResponse<TRawResponse> : UnexpectedErrorResponse<TRawResponse>;
/**
 * Context passed to shouldRetry callback
 */
type RetryContext = {
    /** Current attempt number (0-indexed) */
    attempt: number;
    /** Error thrown during request (network errors, timeouts, etc.) */
    error?: unknown;
    /** HTTP response received (for retrying based on status codes) */
    response?: {
        status: number;
        statusText: string;
        data: unknown;
    };
};
/**
 * Request options with conditional required fields
 */
type RequestOptions<TRequest extends ApiRequestSchema, TEndpoint extends keyof TRequest, TMethod extends keyof TRequest[TEndpoint]> = {
    timeout?: number;
    retries?: number;
    headers?: Record<string, unknown>;
    /** Custom retry logic - return true to retry, false to stop */
    shouldRetry?: (context: RetryContext) => boolean;
} & (ExtractRequestQuery<TRequest, TEndpoint, TMethod> extends never ? {
    query?: never;
} : {
    query?: ExtractRequestQuery<TRequest, TEndpoint, TMethod>;
}) & (ParamsRequired<TRequest, TEndpoint, TMethod> extends true ? {
    params: ExtractRequestParams<TRequest, TEndpoint, TMethod>;
} : ExtractRequestParams<TRequest, TEndpoint, TMethod> extends never ? {
    params?: never;
} : {
    params?: ExtractRequestParams<TRequest, TEndpoint, TMethod>;
}) & (BodyRequired<TRequest, TEndpoint, TMethod> extends true ? {
    body: ExtractRequestBody<TRequest, TEndpoint, TMethod>;
} : {
    body?: ExtractRequestBody<TRequest, TEndpoint, TMethod>;
});

interface ApiClientOptions<TRequest extends ApiRequestSchema, TResponse extends ApiResponseSchema, TRawResponse = unknown> extends ApiClientLoggingOptions {
    baseUrl: string;
    headers?: Record<string, unknown>;
    Request: TRequest;
    Response: TResponse;
    /**
     * Called when Zod validation fails for request or response data.
     * This is only invoked for schema parse failures (i.e. when Zod would throw),
     * not for other validation errors like missing path params.
     */
    onValidationError?: ApiClientValidationErrorHandler<TRawResponse>;
    executor: HttpExecutor<TRawResponse>;
}
type ApiClientValidationErrorLocation = "params" | "query" | "body" | "response";
type ApiClientValidationErrorContext<TRawResponse = unknown> = {
    kind: "request" | "response";
    location: ApiClientValidationErrorLocation;
    endpoint: string;
    method: string;
    /** Human-readable context string (also used as the thrown ValidationError message). */
    message: string;
    /** The data that failed validation. */
    data: unknown;
    /** Zod issues produced by the schema. */
    issues: z.ZodIssue[];
    /** The underlying ZodError object. */
    zodError: z.ZodError;
    /** Response-only context. */
    status?: number;
    statusCode?: string;
    statusText?: string;
    raw?: TRawResponse;
};
type ApiClientValidationErrorHandler<TRawResponse = unknown> = (context: ApiClientValidationErrorContext<TRawResponse>) => void;
declare class ApiClient<TRequest extends ApiRequestSchema, TResponse extends ApiResponseSchema, TRawResponse = unknown> {
    readonly options: ApiClientOptions<TRequest, TResponse, TRawResponse>;
    private readonly internalLog;
    constructor(options: ApiClientOptions<TRequest, TResponse, TRawResponse>);
    private log;
    private safeInvokeOnValidationError;
    private validateSchema;
    private throwValidationError;
    private validateAndEncodeSchema;
    /**
     * Makes a GET request
     */
    get<TEndpoint extends EndpointsWithMethod<TRequest, "GET">>(endpoint: TEndpoint, options: RequestOptions<TRequest, TEndpoint, "GET">): Promise<ApiResponse<TResponse, TEndpoint, "GET", TRawResponse>>;
    /**
     * Makes a POST request
     */
    post<TEndpoint extends EndpointsWithMethod<TRequest, "POST">>(endpoint: TEndpoint, options: RequestOptions<TRequest, TEndpoint, "POST"> & {
        body: ExtractRequestBody<TRequest, TEndpoint, "POST">;
    }): Promise<ApiResponse<TResponse, TEndpoint, "POST", TRawResponse>>;
    /**
     * Makes a PUT request
     */
    put<TEndpoint extends EndpointsWithMethod<TRequest, "PUT">>(endpoint: TEndpoint, options: RequestOptions<TRequest, TEndpoint, "PUT"> & {
        body: ExtractRequestBody<TRequest, TEndpoint, "PUT">;
    }): Promise<ApiResponse<TResponse, TEndpoint, "PUT", TRawResponse>>;
    /**
     * Makes a PATCH request
     */
    patch<TEndpoint extends EndpointsWithMethod<TRequest, "PATCH">>(endpoint: TEndpoint, options: RequestOptions<TRequest, TEndpoint, "PATCH"> & {
        body: ExtractRequestBody<TRequest, TEndpoint, "PATCH">;
    }): Promise<ApiResponse<TResponse, TEndpoint, "PATCH", TRawResponse>>;
    /**
     * Makes a DELETE request
     */
    delete<TEndpoint extends EndpointsWithMethod<TRequest, "DELETE">>(endpoint: TEndpoint, options: RequestOptions<TRequest, TEndpoint, "DELETE">): Promise<ApiResponse<TResponse, TEndpoint, "DELETE", TRawResponse>>;
    /**
     * Internal request method
     */
    private request;
    /**
     * Validates path parameters against Request schema
     */
    private validatePathParams;
    /**
     * Validates query parameters against Request schema
     */
    private validateQuery;
    /**
     * Validates body against Request schema
     */
    private validateBody;
    /**
     * Gets path parameter names from endpoint string
     */
    private getPathParamNames;
    /**
     * Handles the response and returns discriminated union
     */
    private handleResponse;
}

declare const HTTP_CLIENT_DEBUG_NAMESPACE = "alt-stack:http-client";

/**
 * Base error class for API client errors
 */
declare class ApiClientError extends Error {
    readonly endpoint?: string | undefined;
    readonly method?: string | undefined;
    readonly cause?: unknown | undefined;
    constructor(message: string, endpoint?: string | undefined, method?: string | undefined, cause?: unknown | undefined);
}
/**
 * Unexpected error that doesn't match any defined error schema
 * Used in the discriminated union for errors not in the OpenAPI spec
 */
declare class UnexpectedApiClientError extends ApiClientError {
    readonly code?: number | undefined;
    constructor(message: string, code?: number | undefined, endpoint?: string, method?: string, cause?: unknown);
}
/**
 * Validation error for request/response schema validation failures
 */
declare class ValidationError extends ApiClientError {
    readonly validationErrors: unknown;
    constructor(message: string, validationErrors: unknown, endpoint?: string, method?: string);
}
/**
 * Timeout error when request exceeds configured timeout
 */
declare class TimeoutError extends ApiClientError {
    readonly timeout: number;
    constructor(timeout: number, endpoint?: string, method?: string, cause?: unknown);
}

export { ApiClient, ApiClientError, type ApiClientLoggingOptions, type ApiClientOptions, type ApiClientValidationErrorContext, type ApiClientValidationErrorHandler, type ApiClientValidationErrorLocation, type ApiRequestSchema, type ApiResponse, type ApiResponseSchema, type BodyRequired, type EndpointsWithMethod, type ErrorResponse, type ExecuteRequest, type ExecuteResponse, type ExtractErrorCodes, type ExtractPathParams, type ExtractRequestBody, type ExtractRequestParams, type ExtractRequestQuery, type ExtractResponseSchema, type ExtractStatusCodes, type ExtractSuccessBody, type ExtractSuccessCodes, HTTP_CLIENT_DEBUG_NAMESPACE, type HttpExecutor, type LogHandler, type LogLevel, type LogMeta, type Logger, type ParamsRequired, type RequestOptions, type RetryContext, type SuccessResponse, TimeoutError, UnexpectedApiClientError, type UnexpectedErrorResponse, ValidationError };