nextjs-django-client/dist/core.d.ts

A comprehensive, type-safe SDK for seamlessly integrating Next.js 15+ applications with Django REST Framework backends

import * as react_jsx_runtime from 'react/jsx-runtime';
import { ReactNode } from 'react';

interface RequestOptions {
    headers?: Record<string, string>;
    timeout?: number;
    signal?: AbortSignal;
    params?: Record<string, string | number | boolean>;
    retries?: number;
    retryDelay?: number;
}
interface UploadOptions extends RequestOptions {
    onProgress?: (progress: ProgressEvent) => void;
}
interface DownloadOptions extends RequestOptions {
    onProgress?: (progress: ProgressEvent) => void;
    responseType?: 'blob' | 'arraybuffer' | 'text';
}
interface StreamOptions extends RequestOptions {
    delimiter?: string;
}
interface BatchRequest {
    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
    endpoint: string;
    data?: unknown;
    options?: RequestOptions;
}
interface BatchResponse<T = unknown> {
    success: boolean;
    data?: T;
    error?: Error;
    status: number;
}
interface ApiResponse<T = unknown> {
    data: T;
    status: number;
    statusText: string;
    headers: Record<string, string>;
}
interface ApiError extends Error {
    status?: number;
    statusText?: string;
    response?: {
        data?: unknown;
        status: number;
        statusText: string;
        headers: Record<string, string>;
    };
}
interface HttpClientConfig {
    baseURL: string;
    timeout?: number;
    defaultHeaders?: Record<string, string>;
    retries?: number;
    retryDelay?: number;
}
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
interface RequestConfig extends RequestOptions {
    method: HttpMethod;
    url: string;
    data?: unknown;
    baseURL?: string;
}

interface Interceptor {
    request?: (config: RequestConfig) => RequestConfig | Promise<RequestConfig>;
    response?: (response: Response) => Response | Promise<Response>;
    error?: (error: Error) => Error | Promise<Error>;
}
interface AuthInterceptorConfig {
    getAccessToken: () => string | null;
    getCsrfToken?: () => string | null;
    refreshToken: () => Promise<string>;
    onAuthError?: (error: Error) => void;
    tokenPrefix?: string;
    csrfHeaderName?: string;
}

declare class ApiClient {
    private baseURL;
    private defaultHeaders;
    private timeout;
    private interceptors;
    constructor(config: HttpClientConfig);
    /**
     * GET request
     */
    get<T>(endpoint: string, options?: RequestOptions): Promise<T>;
    /**
     * POST request
     */
    post<T>(endpoint: string, data?: unknown, options?: RequestOptions): Promise<T>;
    /**
     * PUT request
     */
    put<T>(endpoint: string, data?: unknown, options?: RequestOptions): Promise<T>;
    /**
     * PATCH request
     */
    patch<T>(endpoint: string, data?: unknown, options?: RequestOptions): Promise<T>;
    /**
     * DELETE request
     */
    delete<T>(endpoint: string, options?: RequestOptions): Promise<T>;
    /**
     * File upload with progress tracking
     */
    upload<T>(endpoint: string, file: File | FormData, options?: UploadOptions): Promise<T>;
    /**
     * File download with progress tracking
     */
    download(endpoint: string, options?: DownloadOptions): Promise<Blob>;
    /**
     * Batch requests
     */
    batch(requests: BatchRequest[]): Promise<BatchResponse[]>;
    /**
     * Stream data (placeholder for future implementation)
     */
    stream<T>(endpoint: string, options?: StreamOptions): AsyncGenerator<T>;
    /**
     * Set base URL
     */
    setBaseURL(url: string): void;
    /**
     * Set default headers
     */
    setDefaultHeaders(headers: Record<string, string>): void;
    /**
     * Add an interceptor
     */
    addInterceptor(interceptor: Interceptor): number;
    /**
     * Remove an interceptor by index
     */
    removeInterceptor(index: number): void;
    /**
     * Clear all interceptors
     */
    clearInterceptors(): void;
    /**
     * Core request method
     */
    private request;
    private buildURL;
    private buildHeaders;
    private buildBody;
    private executeRequest;
    private handleResponse;
    private createApiError;
    private handleError;
}

interface AuthEndpoints {
    login: string;
    refresh: string;
    logout: string;
    user: string;
    register?: string;
    passwordReset?: string;
    passwordResetConfirm?: string;
    emailVerification?: string;
    changePassword?: string;
}
interface AuthFieldMapping {
    username: string;
    password: string;
    email?: string;
    firstName?: string;
    lastName?: string;
    confirmPassword?: string;
    refreshToken?: string;
}
interface AuthResponseMapping {
    user: string;
    accessToken: string;
    refreshToken: string;
    permissions?: string;
    roles?: string;
}
type AuthProvider$1 = 'django-rest-framework' | 'django-allauth' | 'custom' | 'firebase' | 'auth0' | 'supabase';
interface TokenStorageConfig {
    type?: 'cookie' | 'localStorage' | 'sessionStorage';
    secure?: boolean;
    sameSite?: 'strict' | 'lax' | 'none';
    domain?: string;
    path?: string;
    maxAge?: number;
    prefix?: string;
}
interface AutoRefreshConfig {
    enabled?: boolean;
    threshold?: number;
    maxRetries?: number;
    retryDelay?: number;
}
interface AuthConfig {
    provider?: AuthProvider$1;
    endpoints?: Partial<AuthEndpoints>;
    baseAuthURL?: string;
    fieldMapping?: Partial<AuthFieldMapping>;
    responseMapping?: Partial<AuthResponseMapping>;
    fieldMappings?: Partial<AuthFieldMapping & AuthResponseMapping>;
    useEmailAsUsername?: boolean;
    tokenPrefix?: string;
    accessTokenLifetime?: number;
    refreshTokenLifetime?: number;
    tokenStorage?: TokenStorageConfig;
    autoRefresh?: boolean | AutoRefreshConfig;
    refreshThreshold?: number;
    maxRefreshRetries?: number;
    refreshRetryDelay?: number;
    csrfEnabled?: boolean;
    secureTokens?: boolean;
    validateUser?: (user: unknown) => boolean;
    transformUser?: (user: unknown) => unknown;
    loginEndpoint?: string;
    refreshEndpoint?: string;
    logoutEndpoint?: string;
    userEndpoint?: string;
    usernameField?: string;
    passwordField?: string;
    auth0?: {
        domain: string;
        clientId: string;
        audience?: string;
        scope?: string;
    };
    supabase?: {
        projectUrl: string;
        anonKey: string;
    };
}
interface LoginCredentials {
    username?: string;
    email?: string;
    password: string;
}
interface User$1 {
    id: string | number;
    username: string;
    email: string;
    first_name?: string;
    last_name?: string;
    is_active?: boolean;
    is_staff?: boolean;
    is_superuser?: boolean;
    date_joined?: string;
    last_login?: string;
    [key: string]: unknown;
}
interface AuthTokens$1 {
    access: string;
    refresh: string;
}
interface AuthState {
    user: User$1 | null;
    tokens: AuthTokens$1 | null;
    isAuthenticated: boolean;
    isLoading: boolean;
    error: string | null;
}
interface UseAuthOptions$1 {
    autoRefresh?: boolean;
    refreshThreshold?: number;
    onAuthError?: (error: Error) => void;
    onTokenRefresh?: (newToken: string) => void;
}
interface UseAuthReturn$1<TUser = User$1> {
    user: TUser | null;
    isAuthenticated: boolean;
    isLoading: boolean;
    login: (credentials: LoginCredentials) => Promise<void>;
    logout: () => Promise<void>;
    refresh: () => Promise<void>;
    updateUser: (userData: Partial<TUser>) => Promise<void>;
    serverAccessToken: string | null;
    tokenExpiryTime: number;
    isRefreshing: boolean;
    lastError: Error | null;
    clearError: () => void;
    checkTokenExpiry: () => boolean;
    forceRefresh: () => Promise<void>;
}

interface AuthProviderProps {
    children: ReactNode;
    apiClient: ApiClient;
    config?: Partial<AuthConfig>;
}
/**
 * Authentication Provider Component
 */
declare function AuthProvider({ children, apiClient, config }: AuthProviderProps): react_jsx_runtime.JSX.Element;

interface AuthError {
    type: 'login' | 'refresh' | 'logout' | 'network' | 'unknown';
    message: string;
    code?: string | number;
    timestamp: number;
    retryable: boolean;
}
interface UseAuthErrorOptions {
    autoRetry?: boolean;
    maxRetries?: number;
    retryDelay?: number;
    onError?: (error: AuthError) => void;
    onRetry?: (attempt: number) => void;
}
/**
 * Hook for managing authentication errors with retry logic
 */
declare function useAuthError(options?: UseAuthErrorOptions): {
    errors: AuthError[];
    latestError: AuthError;
    hasErrors: boolean;
    isRetrying: boolean;
    retryCount: number;
    canRetry: boolean;
    addError: (error: Error, type?: AuthError["type"]) => AuthError;
    addLoginError: (error: Error) => AuthError;
    addRefreshError: (error: Error) => AuthError;
    addLogoutError: (error: Error) => AuthError;
    addNetworkError: (error: Error) => AuthError;
    clearErrors: () => void;
    clearError: (timestamp: number) => void;
    retry: (retryFn?: () => Promise<void>) => Promise<boolean>;
};
/**
 * Hook for displaying user-friendly error messages
 */
declare function useAuthErrorMessages(): {
    getErrorMessage: (error: AuthError) => string;
    getErrorTitle: (error: AuthError) => string;
    getErrorSeverity: (error: AuthError) => "error" | "warning" | "info";
};

interface UseAuthOptions {
    autoRefresh?: boolean | AutoRefreshConfig;
    refreshThreshold?: number;
    onAuthError?: (error: AuthError) => void;
    onTokenRefresh?: (newToken: string) => void;
}
interface UseAuthReturn<TUser = User$1> {
    user: TUser | null;
    isAuthenticated: boolean;
    isLoading: boolean;
    login: (credentials: LoginCredentials) => Promise<void>;
    logout: () => Promise<void>;
    refresh: () => Promise<void>;
    updateUser: (userData: Partial<TUser>) => Promise<void>;
    serverAccessToken: string | null;
    tokenExpiryTime: number;
    isRefreshing: boolean;
    error: AuthError | null;
    lastError: AuthError | null;
    clearError: () => void;
    checkTokenExpiry: () => boolean;
    forceRefresh: () => Promise<void>;
}
/**
 * Enhanced useAuth hook with auto-refresh and better error handling
 */
declare function useAuth<TUser = User$1>(options?: UseAuthOptions): UseAuthReturn<TUser>;
/**
 * Simple useAuth hook for basic usage (backward compatibility)
 */
declare function useSimpleAuth<TUser = User$1>(): {
    user: TUser | null;
    isAuthenticated: boolean;
    isLoading: boolean;
    login: (credentials: LoginCredentials) => Promise<void>;
    logout: () => Promise<void>;
    refresh: () => Promise<void>;
    updateUser: (userData: Partial<TUser>) => Promise<void>;
    serverAccessToken: string | null;
    error: AuthError | null;
    clearError: () => void;
};

interface AuthStatus {
    isAuthenticated: boolean;
    isLoading: boolean;
    hasValidToken: boolean;
    tokenExpiresIn: number;
    needsRefresh: boolean;
}
interface UseAuthStatusOptions {
    refreshThreshold?: number;
    pollInterval?: number;
}
/**
 * Hook for monitoring authentication status and token health
 */
declare function useAuthStatus(options?: UseAuthStatusOptions): AuthStatus;
/**
 * Hook for checking if user has specific permissions
 */
declare function useAuthPermissions(requiredPermissions?: string[]): {
    hasPermission: (permission: string) => boolean;
    hasAllPermissions: () => boolean;
    hasAnyPermission: () => boolean;
    isAuthorized: boolean;
};
/**
 * Hook for handling authentication redirects
 */
declare function useAuthRedirect(redirectTo?: string): {
    shouldRedirect: boolean;
    redirect: () => void;
};

/**
 * Create an authentication interceptor that automatically:
 * - Adds auth tokens to requests
 * - Handles 401 responses with token refresh
 * - Adds CSRF tokens when needed
 */
declare function createAuthInterceptor(config: AuthInterceptorConfig): Interceptor;
/**
 * Create a retry interceptor that retries requests after token refresh
 */
declare function createRetryInterceptor(maxRetries?: number, shouldRetry?: (error: Error) => boolean): Interceptor;
/**
 * Create a logging interceptor for debugging authentication issues
 */
declare function createAuthLoggingInterceptor(enabled?: boolean): Interceptor;

/**
 * Basic authentication interceptor - adds auth token to requests
 * @deprecated Use createAuthInterceptor for more advanced functionality
 */
declare const authInterceptor: Interceptor;
/**
 * Retry interceptor - retries failed requests
 */
declare const retryInterceptor: Interceptor;
/**
 * Cache interceptor - caches responses
 */
declare const cacheInterceptor: Interceptor;
/**
 * Logging interceptor - logs requests and responses
 */
declare const loggingInterceptor: Interceptor;

/**
 * Endpoint configuration manager
 */
declare class EndpointManager {
    private provider;
    private baseURL;
    private endpoints;
    private fieldMapping;
    private responseMapping;
    constructor(provider?: AuthProvider$1, baseURL?: string, customEndpoints?: Partial<AuthEndpoints>, customFieldMapping?: Partial<AuthFieldMapping>, customResponseMapping?: Partial<AuthResponseMapping>);
    /**
     * Get full URL for an endpoint
     */
    getEndpointURL(endpoint: keyof AuthEndpoints): string;
    /**
     * Get field name for a logical field
     */
    getFieldName(field: keyof AuthFieldMapping): string;
    /**
     * Get response field path for a logical field
     */
    getResponseField(field: keyof AuthResponseMapping): string;
    /**
     * Extract value from response using configured mapping
     */
    extractFromResponse(response: any, field: keyof AuthResponseMapping): any;
    /**
     * Map request data using field mapping
     */
    mapRequestData(data: Record<string, any>): Record<string, any>;
    /**
     * Get all configured endpoints
     */
    getAllEndpoints(): AuthEndpoints;
    /**
     * Update endpoint configuration
     */
    updateEndpoints(updates: Partial<AuthEndpoints>): void;
    /**
     * Update field mapping
     */
    updateFieldMapping(updates: Partial<AuthFieldMapping>): void;
    /**
     * Update response mapping
     */
    updateResponseMapping(updates: Partial<AuthResponseMapping>): void;
    /**
     * Get provider information
     */
    getProvider(): AuthProvider$1;
    /**
     * Helper to get nested value from object using dot notation
     */
    private getNestedValue;
}

declare class AuthService {
    private apiClient;
    private config;
    private tokenStorage;
    private tokenManager;
    private endpointManager;
    constructor(apiClient: ApiClient, config?: Partial<AuthConfig>);
    /**
     * Normalize configuration to handle both current and documented formats
     */
    private normalizeConfig;
    private getDefaultConfig;
    /**
     * Login with credentials
     */
    login(credentials: LoginCredentials): Promise<{
        user: User$1;
        tokens: AuthTokens$1;
    }>;
    /**
     * Logout user
     */
    logout(): Promise<void>;
    /**
     * Refresh access token
     */
    refreshToken(): Promise<string>;
    /**
     * Get current user data
     */
    getCurrentUser(): Promise<User$1>;
    /**
     * Update user data
     */
    updateUser(userData: Partial<User$1>): Promise<User$1>;
    /**
     * Check if user is authenticated
     */
    isAuthenticated(): boolean;
    /**
     * Get stored tokens
     */
    getTokens(): AuthTokens$1 | null;
    /**
     * Get access token for server-side usage
     */
    getServerAccessToken(): string | null;
    /**
     * Set CSRF token
     */
    setCsrfToken(token: string): void;
    /**
     * Get CSRF token
     */
    getCsrfToken(): string | null;
    /**
     * Initialize authentication state (check for existing tokens)
     */
    initialize(): Promise<{
        user: User$1 | null;
        tokens: AuthTokens$1 | null;
    }>;
    /**
     * Start automatic token refresh
     */
    private startAutoRefresh;
    /**
     * Stop automatic token refresh
     */
    private stopAutoRefresh;
    /**
     * Check if current token needs refresh
     */
    checkAndRefreshToken(): Promise<boolean>;
    /**
     * Get time until current token expires
     */
    getTokenExpiryTime(): number;
    /**
     * Get endpoint manager for external use
     */
    getEndpointManager(): EndpointManager;
    /**
     * Update endpoint configuration
     */
    updateEndpoints(updates: Partial<AuthConfig>): void;
    /**
     * Cleanup resources
     */
    destroy(): void;
}

interface AuthInterceptorSetupOptions {
    enableRetry?: boolean;
    maxRetries?: number;
    enableLogging?: boolean;
    tokenPrefix?: string;
    csrfHeaderName?: string;
    onAuthError?: (error: Error) => void;
}
/**
 * Setup authentication interceptors for an API client using an AuthService
 */
declare function setupAuthInterceptors(apiClient: ApiClient, authService: AuthService, options?: AuthInterceptorSetupOptions): void;
/**
 * Setup auth interceptors with development-friendly defaults
 */
declare function setupDevelopmentAuthInterceptors(apiClient: ApiClient, authService: AuthService, options?: Partial<AuthInterceptorSetupOptions>): void;
/**
 * Setup auth interceptors with production-optimized defaults
 */
declare function setupProductionAuthInterceptors(apiClient: ApiClient, authService: AuthService, options?: Partial<AuthInterceptorSetupOptions>): void;
/**
 * Create a pre-configured API client with auth interceptors
 */
declare function createAuthenticatedApiClient(baseURL: string, authService: AuthService, options?: AuthInterceptorSetupOptions): Promise<ApiClient>;

/**
 * Creates a configured API client instance
 */
declare function createApiClient(config: HttpClientConfig): ApiClient;
/**
 * Creates an API client with default Django REST Framework configuration
 */
declare function createDjangoApiClient(baseURL: string, options?: Partial<HttpClientConfig>): ApiClient;

/**
 * Configure authentication with sensible defaults for Django REST Framework
 */
declare function configureAuth(config?: Partial<AuthConfig>): AuthConfig;
/**
 * Configure authentication for email-based login
 */
declare function configureEmailAuth(config?: Partial<AuthConfig>): AuthConfig;
/**
 * Configure authentication for development environment
 */
declare function configureDevelopmentAuth(config?: Partial<AuthConfig>): AuthConfig;

/**
 * OpenAPI 3.0+ specification types
 */
interface OpenAPISpec {
    openapi: string;
    info: OpenAPIInfo;
    servers?: OpenAPIServer[];
    paths: OpenAPIPaths;
    components?: OpenAPIComponents;
    security?: OpenAPISecurityRequirement[];
    tags?: OpenAPITag[];
    externalDocs?: OpenAPIExternalDocumentation;
}
interface OpenAPIInfo {
    title: string;
    description?: string;
    termsOfService?: string;
    contact?: OpenAPIContact;
    license?: OpenAPILicense;
    version: string;
}
interface OpenAPIContact {
    name?: string;
    url?: string;
    email?: string;
}
interface OpenAPILicense {
    name: string;
    url?: string;
}
interface OpenAPIServer {
    url: string;
    description?: string;
    variables?: Record<string, OpenAPIServerVariable>;
}
interface OpenAPIServerVariable {
    enum?: string[];
    default: string;
    description?: string;
}
interface OpenAPIPaths {
    [path: string]: OpenAPIPathItem;
}
interface OpenAPIPathItem {
    $ref?: string;
    summary?: string;
    description?: string;
    get?: OpenAPIOperation;
    put?: OpenAPIOperation;
    post?: OpenAPIOperation;
    delete?: OpenAPIOperation;
    options?: OpenAPIOperation;
    head?: OpenAPIOperation;
    patch?: OpenAPIOperation;
    trace?: OpenAPIOperation;
    servers?: OpenAPIServer[];
    parameters?: (OpenAPIParameter | OpenAPIReference)[];
}
interface OpenAPIOperation {
    tags?: string[];
    summary?: string;
    description?: string;
    externalDocs?: OpenAPIExternalDocumentation;
    operationId?: string;
    parameters?: (OpenAPIParameter | OpenAPIReference)[];
    requestBody?: OpenAPIRequestBody | OpenAPIReference;
    responses: OpenAPIResponses;
    callbacks?: Record<string, OpenAPICallback | OpenAPIReference>;
    deprecated?: boolean;
    security?: OpenAPISecurityRequirement[];
    servers?: OpenAPIServer[];
}
interface OpenAPIParameter {
    name: string;
    in: 'query' | 'header' | 'path' | 'cookie';
    description?: string;
    required?: boolean;
    deprecated?: boolean;
    allowEmptyValue?: boolean;
    style?: string;
    explode?: boolean;
    allowReserved?: boolean;
    schema?: OpenAPISchema | OpenAPIReference;
    example?: any;
    examples?: Record<string, OpenAPIExample | OpenAPIReference>;
    content?: Record<string, OpenAPIMediaType>;
}
interface OpenAPIRequestBody {
    description?: string;
    content: Record<string, OpenAPIMediaType>;
    required?: boolean;
}
interface OpenAPIResponses {
    [statusCode: string]: OpenAPIResponse | OpenAPIReference;
}
interface OpenAPIResponse {
    description: string;
    headers?: Record<string, OpenAPIHeader | OpenAPIReference>;
    content?: Record<string, OpenAPIMediaType>;
    links?: Record<string, OpenAPILink | OpenAPIReference>;
}
interface OpenAPIMediaType {
    schema?: OpenAPISchema | OpenAPIReference;
    example?: any;
    examples?: Record<string, OpenAPIExample | OpenAPIReference>;
    encoding?: Record<string, OpenAPIEncoding>;
}
interface OpenAPIEncoding {
    contentType?: string;
    headers?: Record<string, OpenAPIHeader | OpenAPIReference>;
    style?: string;
    explode?: boolean;
    allowReserved?: boolean;
}
interface OpenAPISchema {
    type?: 'null' | 'boolean' | 'object' | 'array' | 'number' | 'string' | 'integer';
    format?: string;
    title?: string;
    description?: string;
    default?: any;
    example?: any;
    examples?: any[];
    multipleOf?: number;
    maximum?: number;
    exclusiveMaximum?: boolean;
    minimum?: number;
    exclusiveMinimum?: boolean;
    maxLength?: number;
    minLength?: number;
    pattern?: string;
    maxItems?: number;
    minItems?: number;
    uniqueItems?: boolean;
    maxProperties?: number;
    minProperties?: number;
    required?: string[];
    enum?: any[];
    properties?: Record<string, OpenAPISchema | OpenAPIReference>;
    additionalProperties?: boolean | OpenAPISchema | OpenAPIReference;
    items?: OpenAPISchema | OpenAPIReference;
    allOf?: (OpenAPISchema | OpenAPIReference)[];
    oneOf?: (OpenAPISchema | OpenAPIReference)[];
    anyOf?: (OpenAPISchema | OpenAPIReference)[];
    not?: OpenAPISchema | OpenAPIReference;
    if?: OpenAPISchema | OpenAPIReference;
    then?: OpenAPISchema | OpenAPIReference;
    else?: OpenAPISchema | OpenAPIReference;
    nullable?: boolean;
    discriminator?: OpenAPIDiscriminator;
    readOnly?: boolean;
    writeOnly?: boolean;
    xml?: OpenAPIXML;
    externalDocs?: OpenAPIExternalDocumentation;
    deprecated?: boolean;
}
interface OpenAPIDiscriminator {
    propertyName: string;
    mapping?: Record<string, string>;
}
interface OpenAPIXML {
    name?: string;
    namespace?: string;
    prefix?: string;
    attribute?: boolean;
    wrapped?: boolean;
}
interface OpenAPIComponents {
    schemas?: Record<string, OpenAPISchema | OpenAPIReference>;
    responses?: Record<string, OpenAPIResponse | OpenAPIReference>;
    parameters?: Record<string, OpenAPIParameter | OpenAPIReference>;
    examples?: Record<string, OpenAPIExample | OpenAPIReference>;
    requestBodies?: Record<string, OpenAPIRequestBody | OpenAPIReference>;
    headers?: Record<string, OpenAPIHeader | OpenAPIReference>;
    securitySchemes?: Record<string, OpenAPISecurityScheme | OpenAPIReference>;
    links?: Record<string, OpenAPILink | OpenAPIReference>;
    callbacks?: Record<string, OpenAPICallback | OpenAPIReference>;
}
interface OpenAPIReference {
    $ref: string;
}
interface OpenAPIExample {
    summary?: string;
    description?: string;
    value?: any;
    externalValue?: string;
}
interface OpenAPIHeader {
    description?: string;
    required?: boolean;
    deprecated?: boolean;
    allowEmptyValue?: boolean;
    style?: string;
    explode?: boolean;
    allowReserved?: boolean;
    schema?: OpenAPISchema | OpenAPIReference;
    example?: any;
    examples?: Record<string, OpenAPIExample | OpenAPIReference>;
    content?: Record<string, OpenAPIMediaType>;
}
interface OpenAPISecurityScheme {
    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
    description?: string;
    name?: string;
    in?: 'query' | 'header' | 'cookie';
    scheme?: string;
    bearerFormat?: string;
    flows?: OpenAPIOAuthFlows;
    openIdConnectUrl?: string;
}
interface OpenAPIOAuthFlows {
    implicit?: OpenAPIOAuthFlow;
    password?: OpenAPIOAuthFlow;
    clientCredentials?: OpenAPIOAuthFlow;
    authorizationCode?: OpenAPIOAuthFlow;
}
interface OpenAPIOAuthFlow {
    authorizationUrl?: string;
    tokenUrl?: string;
    refreshUrl?: string;
    scopes: Record<string, string>;
}
interface OpenAPISecurityRequirement {
    [name: string]: string[];
}
interface OpenAPITag {
    name: string;
    description?: string;
    externalDocs?: OpenAPIExternalDocumentation;
}
interface OpenAPIExternalDocumentation {
    description?: string;
    url: string;
}
interface OpenAPILink {
    operationRef?: string;
    operationId?: string;
    parameters?: Record<string, any>;
    requestBody?: any;
    description?: string;
    server?: OpenAPIServer;
}
interface OpenAPICallback {
    [expression: string]: OpenAPIPathItem;
}
/**
 * Code generation specific types
 */
interface ParsedOpenAPISpec {
    spec: OpenAPISpec;
    operations: ParsedOperation[];
    schemas: ParsedSchema[];
    components: ParsedComponents;
}
interface ParsedOperation {
    id: string;
    method: string;
    path: string;
    summary?: string;
    description?: string;
    tags: string[];
    parameters: ParsedParameter[];
    requestBody?: ParsedRequestBody;
    responses: ParsedResponse[];
    security: ParsedSecurity[];
    deprecated: boolean;
}
interface ParsedParameter {
    name: string;
    in: 'query' | 'header' | 'path' | 'cookie';
    required: boolean;
    schema: ParsedSchema;
    description?: string;
}
interface ParsedRequestBody {
    required: boolean;
    content: Record<string, ParsedMediaType>;
    description?: string;
}
interface ParsedResponse {
    statusCode: string;
    description: string;
    content?: Record<string, ParsedMediaType>;
    headers?: Record<string, ParsedHeader>;
}
interface ParsedMediaType {
    schema: ParsedSchema;
    examples?: Record<string, any>;
}
interface ParsedHeader {
    required: boolean;
    schema: ParsedSchema;
    description?: string;
}
interface ParsedSchema {
    type: string;
    name?: string;
    description?: string;
    required: boolean;
    nullable: boolean;
    properties?: Record<string, ParsedSchema>;
    items?: ParsedSchema;
    enum?: any[];
    format?: string;
    pattern?: string;
    minimum?: number;
    maximum?: number;
    minLength?: number;
    maxLength?: number;
    minItems?: number;
    maxItems?: number;
    default?: any;
    example?: any;
    ref?: string;
    originalSchema: OpenAPISchema | OpenAPIReference;
}
interface ParsedSecurity {
    type: string;
    name: string;
    in?: string;
    scheme?: string;
    scopes?: string[];
}
interface ParsedComponents {
    schemas: Record<string, ParsedSchema>;
    securitySchemes: Record<string, ParsedSecurity>;
}
/**
 * Code generation configuration
 */
interface CodeGenConfig {
    input: string;
    output: string;
    generateTypes: boolean;
    generateClient: boolean;
    generateHooks: boolean;
    typePrefix?: string;
    typeSuffix?: string;
    clientName?: string;
    hookPrefix?: string;
    enableAuth: boolean;
    enableCaching: boolean;
    enableOptimisticUpdates: boolean;
    enableErrorHandling: boolean;
    framework: 'react' | 'vue' | 'angular' | 'vanilla';
    stateManagement?: 'react-query' | 'swr' | 'zustand' | 'redux' | 'none';
    customTemplates?: string;
    additionalImports?: string[];
    skipOperations?: string[];
    includeOperations?: string[];
    strictMode: boolean;
    validateResponses: boolean;
    prettier: boolean;
    eslint: boolean;
}

/**
 * OpenAPI specification parser and validator
 */
declare class OpenAPIParser {
    private spec;
    private resolvedRefs;
    constructor(spec: OpenAPISpec);
    /**
     * Parse the OpenAPI specification
     */
    parse(): Promise<ParsedOpenAPISpec>;
    /**
     * Validate the OpenAPI specification
     */
    private validateSpec;
    /**
     * Resolve all $ref references in the specification
     */
    private resolveReferences;
    /**
     * Parse all operations from paths
     */
    private parseOperations;
    /**
     * Parse a single operation
     */
    private parseOperation;
    /**
     * Generate operation ID from method and path
     */
    private generateOperationId;
    /**
     * Parse operation parameters
     */
    private parseParameters;
    /**
     * Parse request body
     */
    private parseRequestBody;
    /**
     * Parse operation responses
     */
    private parseResponses;
    /**
     * Parse headers
     */
    private parseHeaders;
    /**
     * Parse security requirements
     */
    private parseSecurity;
    /**
     * Parse all schemas from components
     */
    private parseSchemas;
    /**
     * Parse a single schema
     */
    private parseSchema;
    /**
     * Parse object properties
     */
    private parseProperties;
    /**
     * Parse components
     */
    private parseComponents;
    /**
     * Check if object is a reference
     */
    private isReference;
    /**
     * Resolve a reference or return the object as-is
     */
    private resolveReference;
}
/**
 * Parse OpenAPI specification from URL or object (browser-safe)
 */
declare function parseOpenAPISpecFromUrl(input: string | OpenAPISpec): Promise<ParsedOpenAPISpec>;
/**
 * Parse OpenAPI specification from object
 */
declare function parseOpenAPISpecFromObject(spec: OpenAPISpec): Promise<ParsedOpenAPISpec>;

/**
 * TypeScript type generator for OpenAPI specifications
 */
declare class TypeScriptTypeGenerator {
    private config;
    private generatedTypes;
    constructor(config: CodeGenConfig);
    /**
     * Generate TypeScript types from parsed OpenAPI spec
     */
    generateTypes(spec: ParsedOpenAPISpec): string;
    /**
     * Generate file header with metadata
     */
    private generateHeader;
    /**
     * Generate necessary imports
     */
    private generateImports;
    /**
     * Generate base utility types
     */
    private generateBaseTypes;
    /**
     * Generate types for all schemas
     */
    private generateSchemaTypes;
    /**
     * Generate a single schema type
     */
    private generateSchemaType;
    /**
     * Generate type definition for a schema
     */
    private generateTypeDefinition;
    /**
     * Generate object type definition
     */
    private generateObjectType;
    /**
     * Generate array type definition
     */
    private generateArrayType;
    /**
     * Generate primitive type definition
     */
    private generatePrimitiveType;
    /**
     * Get TypeScript type for a property
     */
    private getPropertyType;
    /**
     * Generate types for all operations
     */
    private generateOperationTypes;
    /**
     * Generate types for a single operation
     */
    private generateOperationType;
    /**
     * Generate parameter types for an operation
     */
    private generateParameterTypes;
    /**
     * Generate parameter interface
     */
    private generateParameterInterface;
    /**
     * Generate request type for an operation
     */
    private generateRequestType;
    /**
     * Generate response type for an operation
     */
    private generateResponseType;
    /**
     * Generate utility types
     */
    private generateUtilityTypes;
    /**
     * Get formatted type name
     */
    private getTypeName;
    /**
     * Get formatted operation type name
     */
    private getOperationTypeName;
    /**
     * Convert string to PascalCase
     */
    private toPascalCase;
}

/**
 * API client generator for OpenAPI specifications
 */
declare class ApiClientGenerator {
    private config;
    constructor(config: CodeGenConfig);
    /**
     * Generate API client from parsed OpenAPI spec
     */
    generateClient(spec: ParsedOpenAPISpec): string;
    /**
     * Generate file header
     */
    private generateHeader;
    /**
     * Generate necessary imports
     */
    private generateImports;
    /**
     * Generate main class definition
     */
    private generateClassDefinition;
    /**
     * Generate constructor
     */
    private generateConstructor;
    /**
     * Generate all API methods
     */
    private generateMethods;
    /**
     * Generate a single API method
     */
    private generateMethod;
    /**
     * Generate method parameters
     */
    private generateMethodParameters;
    /**
     * Generate path construction code
     */
    private generatePathConstruction;
    /**
     * Generate request configuration
     */
    private generateRequestConfig;
    /**
     * Get parameter TypeScript type
     */
    private getParameterType;
    /**
     * Get schema TypeScript type
     */
    private getSchemaType;
    /**
     * Generate return type for method
     */
    private generateReturnType;
    /**
     * Get response data type
     */
    private getResponseDataType;
    /**
     * Get request body type
     */
    private getRequestBodyType;
    /**
     * Generate the correct method call based on HTTP method
     */
    private generateMethodCall;
    /**
     * Generate utility methods
     */
    private generateUtilities;
    /**
     * Generate error handler
     */
    private generateErrorHandler;
    /**
     * Get client class name from API title
     */
    private getClientName;
    /**
     * Get method name from operation ID
     */
    private getMethodName;
    /**
     * Convert string to PascalCase
     */
    private toPascalCase;
    /**
     * Convert string to camelCase
     */
    private toCamelCase;
}

/**
 * React hooks generator for OpenAPI specifications
 */
declare class ReactHooksGenerator {
    private config;
    constructor(config: CodeGenConfig);
    /**
     * Generate React hooks from parsed OpenAPI spec
     */
    generateHooks(spec: ParsedOpenAPISpec): string;
    /**
     * Generate file header
     */
    private generateHeader;
    /**
     * Generate necessary imports
     */
    private generateImports;
    /**
     * Generate query hooks (GET operations)
     */
    private generateQueryHooks;
    /**
     * Generate a single query hook
     */
    private generateQueryHook;
    /**
     * Generate React Query hook
     */
    private generateReactQueryHook;
    /**
     * Generate SWR hook
     */
    private generateSWRHook;
    /**
     * Generate custom query hook
     */
    private generateCustomQueryHook;
    /**
     * Generate mutation hooks (POST, PUT, PATCH, DELETE operations)
     */
    private generateMutationHooks;
    /**
     * Generate a single mutation hook
     */
    private generateMutationHook;
    /**
     * Generate React Query mutation hook
     */
    private generateReactQueryMutation;
    /**
     * Generate custom mutation hook
     */
    private generateCustomMutationHook;
    /**
     * Generate utility hooks
     */
    private generateUtilityHooks;
    private getQueryHookName;
    private getMutationHookName;
    private generateHookParameters;
    private generateMutationParameters;
    /**
     * Generate mutation variables type
     */
    private generateMutationVariablesType;
    private generateQueryKey;
    private generateFetcher;
    private generateFetcherArgs;
    private generateEnabledCondition;
    private generateDependencyArray;
    private generateMutationFunction;
    private generateMutationDependencies;
    private generateInvalidationLogic;
    private getQueryReturnType;
    private getRequestBodyType;
    private getParameterType;
    private getMutationReturnType;
    private getMutationVariablesType;
    private toPascalCase;
    private toCamelCase;
}

/**
 * Generate all code from OpenAPI specification (browser-safe)
 */
declare function generateFromSpecUrl(spec: string | OpenAPISpec, config: CodeGenConfig): Promise<{
    types?: string;
    client?: string;
    hooks?: string;
}>;
/**
 * Generate all code from OpenAPI specification object
 */
declare function generateFromSpecObject(spec: OpenAPISpec, config: CodeGenConfig): Promise<{
    types?: string;
    client?: string;
    hooks?: string;
}>;
/**
 * Generate TypeScript types only
 */
declare function generateTypes(spec: ParsedOpenAPISpec, config: CodeGenConfig): string;
/**
 * Generate API client only
 */
declare function generateClient(spec: ParsedOpenAPISpec, config: CodeGenConfig): string;
/**
 * Generate React hooks only
 */
declare function generateHooks(spec: ParsedOpenAPISpec, config: CodeGenConfig): string;
/**
 * Create default configuration
 */
declare function createDefaultConfig(overrides?: Partial<CodeGenConfig>): CodeGenConfig;
/**
 * Validate configuration
 */
declare function validateConfig(config: Partial<CodeGenConfig>): {
    isValid: boolean;
    errors: string[];
    warnings: string[];
};
/**
 * Generate index file content for exports
 */
declare function generateIndexFileContent(generated: {
    types?: string;
    client?: string;
    hooks?: string;
}): string;
/**
 * Merge configurations
 */
declare function mergeConfigs(...configs: Partial<CodeGenConfig>[]): CodeGenConfig;

interface PaginatedResponse<T> {
    count: number;
    next: string | null;
    previous: string | null;
    results: T[];
}
interface ApiErrorResponse {
    detail?: string;
    message?: string;
    errors?: Record<string, string[]>;
    non_field_errors?: string[];
}
interface ListParams {
    page?: number;
    page_size?: number;
    ordering?: string;
    search?: string;
}
interface CreateResponse<T> {
    data: T;
    message?: string;
}
interface UpdateResponse<T> {
    data: T;
    message?: string;
}
interface DeleteResponse {
    message?: string;
}

interface User {
    id: string | number;
    username: string;
    email: string;
    first_name?: string;
    last_name?: string;
    is_active?: boolean;
    is_staff?: boolean;
    is_superuser?: boolean;
    date_joined?: string;
    last_login?: string;
}
interface AuthTokens {
    access: string;
    refresh: string;
}
interface AuthResponse {
    user: User;
    tokens: AuthTokens;
}
interface RefreshTokenResponse {
    access: string;
}

interface StateConfig {
    defaultCacheTTL?: number;
    maxCacheSize?: number;
    persistState?: boolean;
    enableRealtime?: boolean;
    websocketUrl?: string;
    syncInterval?: number;
    enableOffline?: boolean;
    offlineQueueSize?: number;
    enableOptimisticUpdates?: boolean;
    rollbackTimeout?: number;
}
interface ApiStateOptions {
    cacheTTL?: number;
    tags?: string[];
    optimistic?: boolean;
    realtime?: boolean;
}
interface CacheEntry<T> {
    data: T;
    timestamp: number;
    ttl: number;
    tags: string[];
}
interface ApiState<T> {
    data: T | null;
    loading: boolean;
    error: Error | null;
    lastFetch: number | null;
    tags: string[];
}
interface GlobalState {
    [key: string]: unknown;
}

export { ApiClient, ApiClientGenerator, AuthProvider, OpenAPIParser, ReactHooksGenerator, TypeScriptTypeGenerator, authInterceptor, cacheInterceptor, configureAuth, configureDevelopmentAuth, configureEmailAuth, createApiClient, createAuthInterceptor, createAuthLoggingInterceptor, createAuthenticatedApiClient, createDefaultConfig, createDjangoApiClient, createRetryInterceptor, generateClient, generateFromSpecObject, generateFromSpecUrl, generateHooks, generateIndexFileContent, generateTypes, loggingInterceptor, mergeConfigs, parseOpenAPISpecFromObject, parseOpenAPISpecFromUrl, retryInterceptor, setupAuthInterceptors, setupDevelopmentAuthInterceptors, setupProductionAuthInterceptors, useAuth, useAuthError, useAuthErrorMessages, useAuthPermissions, useAuthRedirect, useAuthStatus, useSimpleAuth, validateConfig };
export type { ApiError, ApiErrorResponse, ApiResponse, ApiState, ApiStateOptions, AuthConfig, AuthInterceptorConfig, AuthResponse, AuthState, AuthTokens, BatchRequest, BatchResponse, CacheEntry, CreateResponse, DeleteResponse, DownloadOptions, GlobalState, HttpClientConfig, Interceptor, ListParams, LoginCredentials, PaginatedResponse, RefreshTokenResponse, RequestConfig, RequestOptions, StateConfig, StreamOptions, UpdateResponse, UploadOptions, UseAuthOptions$1 as UseAuthOptions, UseAuthReturn$1 as UseAuthReturn, User$1 as User };