import { z, ZodType, ZodSchema, ZodError } from 'zod';
/**
 * Re-export HttpError for backward compatibility
 * @deprecated Use ApiError from '@/lib/api/types' instead
 */
export type { ApiError as HttpError } from '../api/types';
/**
 * Supported HTTP methods
 */
export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
/**
 * Endpoint definition with full type safety
 */
export interface EndpointDefinition<TParams extends ZodType = ZodType, TQuery extends ZodType = ZodType, TBody extends ZodType = ZodType, TResponse extends ZodType = ZodType> {
    /** HTTP method */
    method: HttpMethod;
    /** URL path with optional :param placeholders */
    path: string;
    /** Path parameters schema */
    params?: TParams;
    /** Query parameters schema */
    query?: TQuery;
    /** Request body schema */
    body?: TBody;
    /** Response data schema */
    response: TResponse;
    /** Additional headers */
    headers?: Record<string, string>;
    /** Request timeout (ms) */
    timeout?: number;
    /** Tags for categorization and cache invalidation */
    tags?: string[];
    /** Description for documentation */
    description?: string;
    /** Whether this endpoint requires authentication */
    requiresAuth?: boolean;
}
/**
 * API contract - collection of endpoint definitions
 */
export type ApiContract = Record<string, EndpointDefinition>;
/**
 * Infer request types from endpoint definition
 */
export type InferRequest<E extends EndpointDefinition> = {
    params: E['params'] extends ZodType ? z.infer<E['params']> : never;
    query: E['query'] extends ZodType ? z.infer<E['query']> : never;
    body: E['body'] extends ZodType ? z.infer<E['body']> : never;
};
/**
 * Infer response type from endpoint definition
 */
export type InferResponse<E extends EndpointDefinition> = z.infer<E['response']>;
/**
 * Build request options type based on endpoint requirements
 */
export type RequestOptions<E extends EndpointDefinition> = (E['params'] extends ZodType ? {
    params: z.infer<E['params']>;
} : object) & (E['query'] extends ZodType ? {
    query: z.infer<E['query']>;
} : object) & (E['body'] extends ZodType ? {
    body: z.infer<E['body']>;
} : object) & {
    /** Abort signal for cancellation */
    signal?: AbortSignal;
    /** Skip request/response validation */
    skipValidation?: boolean;
    /** Additional headers for this request */
    headers?: Record<string, string>;
    /** Override timeout for this request */
    timeout?: number;
};
/**
 * Type-safe API client methods generated from contract
 */
export type TypedApiClient<T extends ApiContract> = {
    [K in keyof T]: (options: RequestOptions<T[K]>) => Promise<InferResponse<T[K]>>;
};
/**
 * API client configuration
 */
export interface TypedApiClientConfig {
    /** Base URL for API requests */
    baseUrl: string;
    /** API version prefix (e.g., 'v1') */
    version?: string;
    /** Default headers for all requests */
    defaultHeaders?: Record<string, string>;
    /** Callback for validation errors */
    onValidationError?: (error: ZodError, endpoint: string, direction: 'request' | 'response') => void;
    /** Custom response transformer */
    transformResponse?: <T>(data: unknown, schema: ZodSchema<T>) => T;
    /** Enable strict mode (throw on extra properties) */
    strictMode?: boolean;
    /** Default timeout (ms) */
    timeout?: number;
    /** Auth token getter */
    getAuthToken?: () => string | null | Promise<string | null>;
}
/**
 * API validation error with detailed information
 */
export declare class ApiValidationError extends Error {
    readonly zodError: ZodError;
    readonly isValidationError = true;
    readonly endpoint: string;
    readonly direction: 'request' | 'response';
    readonly issues: z.ZodIssue[];
    constructor(message: string, zodError: ZodError, endpoint: string, direction: 'request' | 'response');
    /**
     * Get formatted error messages
     */
    getFormattedErrors(): string[];
    /**
     * Get field-level errors
     */
    getFieldErrors(): Record<string, string[]>;
}
/**
 * API contract error for invalid endpoint definitions
 */
export declare class ApiContractError extends Error {
    readonly isContractError = true;
    readonly endpoint: string;
    constructor(message: string, endpoint: string);
}
/**
 * Create a type-safe API client from contract definition
 */
export declare function createTypedApiClient<T extends ApiContract>(contract: T, config: TypedApiClientConfig): TypedApiClient<T> & {
    /** Get contract definition */
    getContract: () => T;
    /** Get configuration */
    getConfig: () => TypedApiClientConfig;
    /** Invalidate cache by tags */
    invalidateByTags: (tags: string[]) => void;
};
/**
 * Define an API endpoint with type inference
 */
export declare function defineEndpoint<TParams extends ZodType = never, TQuery extends ZodType = never, TBody extends ZodType = never, TResponse extends ZodType = ZodType>(definition: EndpointDefinition<TParams, TQuery, TBody, TResponse>): EndpointDefinition<TParams, TQuery, TBody, TResponse>;
/**
 * Define a GET endpoint
 */
export declare function defineGet<TResponse extends ZodType, TParams extends ZodType = never, TQuery extends ZodType = never>(path: string, response: TResponse, options?: Omit<EndpointDefinition<TParams, TQuery, never, TResponse>, 'method' | 'path' | 'response' | 'body'>): EndpointDefinition<TParams, TQuery, never, TResponse>;
/**
 * Define a POST endpoint
 */
export declare function definePost<TParams extends ZodType = never, TBody extends ZodType = never, TResponse extends ZodType = ZodType>(path: string, response: TResponse, options?: Omit<EndpointDefinition<TParams, never, TBody, TResponse>, 'method' | 'path' | 'response'>): EndpointDefinition<TParams, never, TBody, TResponse>;
/**
 * Define a PUT endpoint
 */
export declare function definePut<TParams extends ZodType = never, TBody extends ZodType = never, TResponse extends ZodType = ZodType>(path: string, response: TResponse, options?: Omit<EndpointDefinition<TParams, never, TBody, TResponse>, 'method' | 'path' | 'response'>): EndpointDefinition<TParams, never, TBody, TResponse>;
/**
 * Define a PATCH endpoint
 */
export declare function definePatch<TParams extends ZodType = never, TBody extends ZodType = never, TResponse extends ZodType = ZodType>(path: string, response: TResponse, options?: Omit<EndpointDefinition<TParams, never, TBody, TResponse>, 'method' | 'path' | 'response'>): EndpointDefinition<TParams, never, TBody, TResponse>;
/**
 * Define a DELETE endpoint
 */
export declare function defineDelete<TParams extends ZodType = never, TResponse extends ZodType = ZodType>(path: string, response: TResponse, options?: Omit<EndpointDefinition<TParams, never, never, TResponse>, 'method' | 'path' | 'response' | 'body'>): EndpointDefinition<TParams, never, never, TResponse>;
/**
 * Common pagination schema
 */
export declare const paginationSchema: z.ZodObject<{
    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    sortBy: z.ZodOptional<z.ZodString>;
    sortOrder: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
        asc: "asc";
        desc: "desc";
    }>>>;
}, z.core.$strip>;
export type PaginationParams = z.infer<typeof paginationSchema>;
/**
 * Common paginated response schema factory
 */
export declare function createPaginatedResponseSchema<T extends ZodType>(itemSchema: T): z.ZodObject<{
    items: z.ZodArray<T>;
    total: z.ZodNumber;
    page: z.ZodNumber;
    pageSize: z.ZodNumber;
    totalPages: z.ZodNumber;
    hasNextPage: z.ZodOptional<z.ZodBoolean>;
    hasPreviousPage: z.ZodOptional<z.ZodBoolean>;
}>;
/**
 * Common ID parameter schema
 */
export declare const idParamSchema: z.ZodObject<{
    id: z.ZodString;
}, z.core.$strip>;
/**
 * Common error response schema
 */
export declare const errorResponseSchema: z.ZodObject<{
    error: z.ZodObject<{
        code: z.ZodString;
        message: z.ZodString;
        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        traceId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
}, z.core.$strip>;
/**
 * Common success response schema
 */
export declare const successResponseSchema: z.ZodObject<{
    success: z.ZodLiteral<true>;
    message: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
/**
 * User schema
 */
export declare const userSchema: z.ZodObject<{
    id: z.ZodString;
    email: z.ZodString;
    name: z.ZodString;
    role: z.ZodEnum<{
        admin: "admin";
        user: "user";
        viewer: "viewer";
    }>;
    status: z.ZodOptional<z.ZodEnum<{
        pending: "pending";
        active: "active";
        inactive: "inactive";
    }>>;
    profile: z.ZodOptional<z.ZodObject<{
        avatar: z.ZodOptional<z.ZodString>;
        bio: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    createdAt: z.ZodString;
    updatedAt: z.ZodString;
}, z.core.$strip>;
export type User = z.infer<typeof userSchema>;
/**
 * Example user API contract
 */
export declare const userApiContract: {
    readonly getUsers: EndpointDefinition<never, z.ZodObject<{
        page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        sortBy: z.ZodOptional<z.ZodString>;
        sortOrder: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
            asc: "asc";
            desc: "desc";
        }>>>;
        search: z.ZodOptional<z.ZodString>;
        role: z.ZodOptional<z.ZodEnum<{
            admin: "admin";
            user: "user";
            viewer: "viewer";
        }>>;
        status: z.ZodOptional<z.ZodEnum<{
            pending: "pending";
            active: "active";
            inactive: "inactive";
        }>>;
    }, z.core.$strip>, never, z.ZodObject<{
        items: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            email: z.ZodString;
            name: z.ZodString;
            role: z.ZodEnum<{
                admin: "admin";
                user: "user";
                viewer: "viewer";
            }>;
            status: z.ZodOptional<z.ZodEnum<{
                pending: "pending";
                active: "active";
                inactive: "inactive";
            }>>;
            profile: z.ZodOptional<z.ZodObject<{
                avatar: z.ZodOptional<z.ZodString>;
                bio: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
            createdAt: z.ZodString;
            updatedAt: z.ZodString;
        }, z.core.$strip>>;
        total: z.ZodNumber;
        page: z.ZodNumber;
        pageSize: z.ZodNumber;
        totalPages: z.ZodNumber;
        hasNextPage: z.ZodOptional<z.ZodBoolean>;
        hasPreviousPage: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    readonly getUserById: EndpointDefinition<z.ZodObject<{
        id: z.ZodString;
    }, z.core.$strip>, never, never, z.ZodObject<{
        id: z.ZodString;
        email: z.ZodString;
        name: z.ZodString;
        role: z.ZodEnum<{
            admin: "admin";
            user: "user";
            viewer: "viewer";
        }>;
        status: z.ZodOptional<z.ZodEnum<{
            pending: "pending";
            active: "active";
            inactive: "inactive";
        }>>;
        profile: z.ZodOptional<z.ZodObject<{
            avatar: z.ZodOptional<z.ZodString>;
            bio: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
    }, z.core.$strip>>;
    readonly createUser: EndpointDefinition<never, never, z.ZodObject<{
        email: z.ZodString;
        name: z.ZodString;
        role: z.ZodEnum<{
            admin: "admin";
            user: "user";
            viewer: "viewer";
        }>;
        password: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        email: z.ZodString;
        name: z.ZodString;
        role: z.ZodEnum<{
            admin: "admin";
            user: "user";
            viewer: "viewer";
        }>;
        status: z.ZodOptional<z.ZodEnum<{
            pending: "pending";
            active: "active";
            inactive: "inactive";
        }>>;
        profile: z.ZodOptional<z.ZodObject<{
            avatar: z.ZodOptional<z.ZodString>;
            bio: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
    }, z.core.$strip>>;
    readonly updateUser: EndpointDefinition<z.ZodObject<{
        id: z.ZodString;
    }, z.core.$strip>, never, z.ZodObject<{
        name: z.ZodOptional<z.ZodString>;
        role: z.ZodOptional<z.ZodEnum<{
            admin: "admin";
            user: "user";
            viewer: "viewer";
        }>>;
        status: z.ZodOptional<z.ZodEnum<{
            pending: "pending";
            active: "active";
            inactive: "inactive";
        }>>;
        profile: z.ZodOptional<z.ZodObject<{
            avatar: z.ZodOptional<z.ZodString>;
            bio: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        email: z.ZodString;
        name: z.ZodString;
        role: z.ZodEnum<{
            admin: "admin";
            user: "user";
            viewer: "viewer";
        }>;
        status: z.ZodOptional<z.ZodEnum<{
            pending: "pending";
            active: "active";
            inactive: "inactive";
        }>>;
        profile: z.ZodOptional<z.ZodObject<{
            avatar: z.ZodOptional<z.ZodString>;
            bio: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
    }, z.core.$strip>>;
    readonly deleteUser: EndpointDefinition<z.ZodObject<{
        id: z.ZodString;
    }, z.core.$strip>, never, never, z.ZodObject<{
        success: z.ZodLiteral<true>;
        message: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
};
/**
 * Create typed user API client
 */
export declare function createUserApiClient(config?: Partial<TypedApiClientConfig>): TypedApiClient<typeof userApiContract>;