guardz-axios/dist/utils/request-utils.d.ts

Type-safe HTTP client built on top of Axios with runtime validation using guardz. Part of the guardz ecosystem for comprehensive TypeScript type safety.

/**
 * Request Utilities - Pure functions for request handling
 * Following Functional Programming (FP) principles
 */
import { RequestConfig, HttpMethod, RequestResult, RequestStatus, ErrorType } from "../domain/types";
/**
 * Creates a request configuration object with validation
 * Pure function - no side effects, deterministic output
 *
 * @param url - Request URL
 * @param method - HTTP method
 * @param data - Request data (optional)
 * @param headers - Request headers (optional)
 * @param timeout - Request timeout in milliseconds (optional)
 * @param baseURL - Base URL (optional)
 * @returns Request configuration object
 */
export declare function createRequestConfig(url: string, method: HttpMethod, data?: unknown, headers?: Record<string, string>, timeout?: number, baseURL?: string): RequestConfig;
/**
 * Merges multiple request configurations with deep merging for headers
 * Pure function - no side effects, deterministic output
 *
 * @param base - Base request configuration
 * @param override - Override configuration
 * @returns Merged request configuration
 */
export declare function mergeRequestConfigs(base: RequestConfig, override: Partial<RequestConfig>): RequestConfig;
/**
 * Validates request configuration with comprehensive checks
 * Pure function - no side effects, deterministic output
 *
 * @param config - Request configuration to validate
 * @returns Error message if invalid, null if valid
 */
export declare function validateRequestConfig(config: RequestConfig): string | null;
/**
 * Creates a success result with type safety
 * Pure function - no side effects, deterministic output
 *
 * @param data - Success data
 * @returns Success result object
 */
export declare function createSuccessResult<T>(data: T): RequestResult<T>;
/**
 * Creates an error result with comprehensive error information
 * Pure function - no side effects, deterministic output
 *
 * @param code - Error code (HTTP status code or custom code)
 * @param message - Error message
 * @param type - Error type
 * @returns Error result object
 */
export declare function createErrorResult<T>(code: number, message: string, type?: ErrorType): RequestResult<T>;
/**
 * Type guard to check if a result is successful
 * Pure function - no side effects, deterministic output
 *
 * @param result - Request result to check
 * @returns True if the result is successful
 */
export declare function isSuccessResult<T>(result: RequestResult<T>): result is {
    status: RequestStatus.SUCCESS;
    data: T;
};
/**
 * Type guard to check if a result is an error
 * Pure function - no side effects, deterministic output
 *
 * @param result - Request result to check
 * @returns True if the result is an error
 */
export declare function isErrorResult<T>(result: RequestResult<T>): result is {
    status: RequestStatus.ERROR;
    code: number;
    message: string;
    type: ErrorType;
};
/**
 * Extracts data from a success result with null safety
 * Pure function - no side effects, deterministic output
 *
 * @param result - Request result
 * @returns Data if successful, null if error
 */
export declare function extractData<T>(result: RequestResult<T>): T | null;
/**
 * Extracts error information from an error result with null safety
 * Pure function - no side effects, deterministic output
 *
 * @param result - Request result
 * @returns Error information if error, null if successful
 */
export declare function extractError<T>(result: RequestResult<T>): {
    code: number;
    message: string;
    type: ErrorType;
} | null;
/**
 * Safely extracts data with a default value
 * Pure function - no side effects, deterministic output
 *
 * @param result - Request result
 * @param defaultValue - Default value to return if error
 * @returns Data if successful, default value if error
 */
export declare function extractDataWithDefault<T>(result: RequestResult<T>, defaultValue: T): T;
/**
 * Maps a successful result to a new type
 * Pure function - no side effects, deterministic output
 *
 * @param result - Request result
 * @param mapper - Function to transform successful data
 * @returns New result with transformed data or original error
 */
export declare function mapSuccessResult<T, U>(result: RequestResult<T>, mapper: (data: T) => U): RequestResult<U>;
//# sourceMappingURL=request-utils.d.ts.map