aspi 1.1.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,1285 @@
+/**
+ * Standard HTTP /**
+ * Common HTTP error status codes with their numeric values.
+ * @readonly
+ * @enum {number}
+ * @property {number} BAD_REQUEST - 400 Bad Request
+ * @property {number} UNAUTHORIZED - 401 Unauthorized
+ * @property {number} FORBIDDEN - 403 Forbidden
+ * @property {number} NOT_FOUND - 404 Not Found
+ * @property {number} METHOD_NOT_ALLOWED - 405 Method Not Allowed
+ * @property {number} CONFLICT - 409 Conflict
+ * @property {number} LARGE - 413 Payload Too Large
+ * @property {number} UNS {number}  * @property
+ - 413Request entity too largeUPPORTED_MEDIA_TYPE - 415 Unsupported Media Type
+ *@property {number} } UNPROCESSABLE_ENTITY - 422 Unprocessable Entity
+ * @property {number} TO_MANY_REQUESTS - 429 Too Many Requests
+ * @property {number}  * @property
+Too many requests made - 429 {number} INTERNAL_SERVER_ERROR - 500 Internal Server Error
+ * @property {number}  *
+ 500Generic server error -@property {number} NOT_IMPLEMENTED - 501 Not Implemented
+ * @property {number}  *
+ 501Functionality not implemented -@property {number} BAD_GATEWAY - 502 Bad Gateway
+ * @property {number} UNAVAILABLE - 503 Service Unavailable
+ * @property {number}  * @property {number
+ temporarily unavailable - 503Server} GATEWAY_TIMEOUT - 504 Gateway Timeout
+ */
+declare const httpErrors: {
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly METHOD_NOT_ALLOWED: 405;
+    readonly CONFLICT: 409;
+    readonly PAYLOAD_TOO_LARGE: 413;
+    readonly UNSUPPORTED_MEDIA_TYPE: 415;
+    readonly UNPROCESSABLE_ENTITY: 422;
+    readonly TOO_MANY_REQUESTS: 429;
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly NOT_IMPLEMENTED: 501;
+    readonly BAD_GATEWAY: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+    readonly GATEWAY_TIMEOUT: 504;
+};
+/**
+ * Type representing the possible numeric HTTP error codes.
+ * Derived from the values in the `httpErrors` const.
+ */
+type HttpErrorCodes = (typeof httpErrors)[keyof typeof httpErrors];
+/**
+ * Type representing the possible HTTP error status keys.
+ * Derived from the keys in the `httpErrors` const.
+ */
+type HttpErrorStatus = keyof typeof httpErrors;
+/**
+ * Gets the string key representation of an HTTP error status code.
+ *
+ * @param {HttpErrorCodes} status - The numeric HTTP error status code
+ * @returns {HttpErrorStatus} The string key representing the status code
+ *
+ * @example
+ * getHttpErrorStatus(404) // returns 'NOT_FOUND'
+ * getHttpErrorStatus(500) // returns 'INTERNAL_SERVER_ERROR'
+ */
+declare const getHttpErrorStatus: (status: HttpErrorCodes) => HttpErrorStatus;
+/**
+ * Valid HTTP methods as defined in the HTTP/1.1 specification.
+ */
+type HttpMethods = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'TRACE' | 'CONNECT';
+
+type AspiConfigBase = {
+    baseUrl: string;
+    retryConfig?: AspiRetryConfig<AspiRequestInit>;
+};
+type AspiRetryConfig<TRequest extends AspiRequestInit> = {
+    retries?: number;
+    retryDelay?: number | ((remainingRetries: number, totalRetries: number, request: AspiRequest<TRequest>, response: AspiResponse) => number | Promise<number>);
+    retryOn?: Array<HttpErrorCodes>;
+    retryWhile?: (request: AspiRequest<TRequest>, response: AspiResponse) => boolean | Promise<boolean>;
+    onRetry?: (request: AspiRequest<TRequest>, response: AspiResponse) => void;
+};
+type AspiConfig = Pick<RequestInit, 'headers' | 'mode'> & AspiConfigBase;
+type CustomErrorCb<T extends AspiRequestInit, A extends {}> = (input: {
+    request: AspiRequest<T>;
+    response: AspiResponse;
+}) => A;
+type Middleware<T extends RequestInit, U extends RequestInit> = (request: T) => U;
+interface AspiRequestInit extends RequestInit, AspiConfigBase {
+}
+type RequestOptions<TRequest extends AspiRequestInit> = {
+    requestConfig: TRequest;
+    retryConfig?: AspiRetryConfig<TRequest>;
+    middlewares?: Middleware<TRequest, TRequest>[];
+    errorCbs?: ErrorCallbacks;
+};
+type ErrorCallbacks = Record<number, {
+    cb: (input: {
+        request: any;
+        response: any;
+    }) => any;
+    tag: unknown;
+}>;
+type AspiResultOk<TRequest extends AspiRequestInit, TData> = {
+    data: TData;
+    request: AspiRequest<TRequest>;
+    response: AspiResponse;
+};
+
+/**
+ * Response interface used in error handling
+ * @interface AspiResponse
+ * @property {HttpErrorCodes} status - The HTTP status code of the response
+ * @property {HttpErrorStatus} statusText - The HTTP status text of the response
+ * @property {Response} [response] - Optional raw Response object
+ * @property {any} [responseData] - Optional response data content
+ */
+interface AspiResponse {
+    status: HttpErrorCodes;
+    statusText: HttpErrorStatus;
+    response?: Response;
+    responseData?: any;
+}
+/**
+ * Interface representing an API request configuration
+ * @interface AspiRequest
+ * @template T - Request initialization options type extending AspiRequestInit
+ * @property {string} baseUrl - Base URL for the API request
+ * @property {string} path - Request path to append to baseUrl
+ * @property {T} requestInit - Request initialization options
+ * @property {URLSearchParams | null} queryParams - URL query parameters, if any
+ * @property {AspiRetryConfig<T>} retryConfig - Retry configuration for failed requests
+ */
+interface AspiRequest<T extends AspiRequestInit> {
+    baseUrl: string;
+    path: string;
+    requestInit: T;
+    queryParams: URLSearchParams | null;
+    retryConfig: AspiRetryConfig<T>;
+}
+/**
+ * Custom error class for API errors
+ * @class AspiError
+ * @extends {Error}
+ * @property {string} tag - Constant identifier for this error type
+ * @property {AspiRe} request - The original request configuration
+ * @property {AspiResponse} response - The error response details
+ */
+declare class AspiError<TReq extends AspiRequestInit> extends Error {
+    tag: "aspiError";
+    request: AspiRequest<TReq>;
+    response: AspiResponse;
+    /**
+     * Creates an instance of AspiError
+     * @param {string} message - The error message
+     * @param {AspiRe} request - The request configuration
+     * @param {AspiResponse} response - The error response
+     */
+    constructor(message: string, request: AspiRequest<TReq>, response: AspiResponse);
+    /**
+     * Conditionally executes callback if status matches
+     * @template T
+     * @param {HttpErrorStatus} status - The status to match against
+     * @param {(args: { request: AspiRequest; response: AspiResponse }) => T} cb - Callback to execute on match
+     * @returns {T | undefined} Result of callback if status matches, undefined otherwise
+     */
+    ifMatch<T>(status: HttpErrorStatus, cb: (args: {
+        request: AspiRequest<TReq>;
+        response: AspiResponse;
+    }) => T): T | undefined;
+}
+/**
+ * Custom error class with generic tag and data fields
+ * @class CustomError
+ * @extends {Error}
+ * @template Tag - String literal type for the error tag
+ * @template A - Type of the error data
+ * @property {Tag} tag - Tag identifying the error type
+ * @property {A} data - Additional error data
+ */
+declare class CustomError<Tag extends string, A> extends Error {
+    tag: Tag;
+    data: A;
+    /**
+     * Creates an instance of CustomError
+     * @param {Tag} tag - Tag identifying the error type
+     * @param {A} data - Additional error data
+     */
+    constructor(tag: Tag, data: A);
+}
+/**
+ * Interface representing a JSON parsing error
+ * @interface JSONParseError
+ * @extends {CustomError<'jsonParseError', { message: string }>}
+ */
+interface JSONParseError extends CustomError<'jsonParseError', {
+    message: string;
+}> {
+}
+
+type Ok<T> = {
+    __tag: 'ok';
+    value: T;
+};
+type Err<E> = {
+    __tag: 'err';
+    error: E;
+};
+/**
+ * Represents either a successful value of type T or an error of type E
+ * @example
+ * const success: Result<number, string> = { __tag: "ok", value: 42 };
+ * const failure: Result<number, string> = { __tag: "err", error: "not found" };
+ */
+type Result<T, E> = Ok<T> | Err<E>;
+/**
+ * Creates a successful Result
+ * @example
+ * const result = ok(42);
+ * // { __tag: "ok", value: 42 }
+ */
+declare const ok: <T>(value: T) => Ok<T>;
+/**
+ * Creates a failed Result
+ * @example
+ * const result = err("not found");
+ * // { __tag: "err", error: "not found" }
+ */
+declare const err: <E>(error: E) => Err<E>;
+/**
+ * Returns true if the result is a success
+ * @example
+ * const result = ok(42);
+ * isOk(result) // true
+ *
+ * const error = err("not found");
+ * isOk(error) // false
+ */
+declare const isOk: <T, E>(result: Result<T, E>) => result is Ok<T>;
+/**
+ * Returns true if the result is a failure
+ * @example
+ * const result = ok(42);
+ * isErr(result) // false
+ *
+ * const error = err("not found");
+ * isErr(error) // true
+ */
+declare const isErr: <T, E>(result: Result<T, E>) => result is Err<E>;
+/**
+ * Maps a function over the value of a successful Result
+ * @param fn - Function to map over the successful value
+ * @param self - The Result to map over
+ * @returns A new Result with the mapped value if successful, or the original error if failed
+ * @example
+ * // Direct style
+ * const result = ok(42);
+ * map(result, (x) => x * 2) // { __tag: "ok", value: 84 }
+ *
+ * const error = err("not found");
+ * map(error, (x) => x * 2) // { __tag: "err", error: "not found" }
+ *
+ * // Curried style
+ * const double = map((x: number) => x * 2);
+ * double(ok(42)) // { __tag: "ok", value: 84 }
+ * double(err("not found")) // { __tag: "err", error: "not found" }
+ */
+declare function map<T, E, U>(fn: (value: T) => U): (self: Result<T, E>) => Result<U, E>;
+declare function map<T, E, U>(self: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+/**
+ * Maps a function over the error of a failed Result
+ * @param fn - Function to map over the error value
+ * @param self - The Result to map over
+ * @returns A new Result with the mapped error if failed, or the original value if successful
+ * @example
+ * // Direct style
+ * const result = ok(42);
+ * mapErr(result, (e) => e.toUpperCase()) // { __tag: "ok", value: 42 }
+ *
+ * const error = err("not found");
+ * mapErr(error, (e) => e.toUpperCase()) // { __tag: "err", error: "NOT FOUND" }
+ *
+ * // Curried style
+ * const toUpper = mapErr((e: string) => e.toUpperCase());
+ * toUpper(ok(42)) // { __tag: "ok", value: 42 }
+ * toUpper(err("not found")) // { __tag: "err", error: "NOT FOUND" }
+ */
+declare function mapErr<T, E, U>(fn: (error: E) => U): (self: Result<T, E>) => Result<T, U>;
+declare function mapErr<T, E, U>(self: Result<T, E>, fn: (error: E) => U): Result<T, U>;
+/**
+ * Pattern matches on a Result, calling onOk if successful or onErr if failed
+ * @example
+ * const result = ok(42);
+ * match(result, {
+ *   onOk: (x) => `Got ${x}`,
+ *   onErr: (e) => `Error: ${e}`
+ * }) // "Got 42"
+ *
+ * const error = err("not found");
+ * match(error, {
+ *   onOk: (x) => `Got ${x}`,
+ *   onErr: (e) => `Error: ${e}`
+ * }) // "Error: not found"
+ */
+declare function match<T, E, U>(handlers: {
+    onOk: (value: T) => U;
+    onErr: (error: E) => U;
+}): (self: Result<T, E>) => U;
+declare function match<T, E, U, V>(self: Result<T, E>, handlers: {
+    onOk: (value: T) => U;
+    onErr: (error: E) => V;
+}): U | V;
+/**
+ * Returns the value of a successful Result, or null if it's a failure
+ * @example
+ * const result = ok(42);
+ * getOrNull(result) // 42
+ *
+ * const error = err("not found");
+ * getOrNull(error) // null
+ */
+declare const getOrNull: <T, E>(result: Result<T, E>) => T | null;
+/**
+ * Returns the error of a failed Result, or null if it's a success
+ * @example
+ * const result = ok(42);
+ * getErrorOrNull(result) // null
+ *
+ * const error = err("not found");
+ * getErrorOrNull(error) // "not found"
+ */
+declare const getErrorOrNull: <T, E>(result: Result<T, E>) => E | null;
+/**
+ * Returns the value of a successful Result, or a fallback value if it's a failure
+ * @example
+ * const result = ok(42);
+ * getOrElse(result, 0) // 42
+ *
+ * const error = err("not found");
+ * getOrElse(error, 0) // 0
+ */
+declare const getOrElse: <T, E>(result: Result<T, E>, fallback: T) => T;
+/**
+ * Returns the value of a successful Result, or throws the error if it's a failure
+ * @example
+ * const result = ok(42);
+ * getOrThrow(result) // 42
+ *
+ * const error = err("not found");
+ * getOrThrow(error) // throws "not found"
+ */
+declare const getOrThrow: <T, E>(result: Result<T, E>) => T;
+/**
+ * Returns the value of a successful Result, or throws a transformed error if it's a failure
+ * @example
+ * const result = ok(42);
+ * getOrThrowWith(result, (e) => new Error(e)) // 42
+ *
+ * const error = err("not found");
+ * getOrThrowWith(error, (e) => new Error(e)) // throws Error("not found")
+ */
+declare function getOrThrowWith<T, E, R>(fn: (error: E) => R): (self: Result<T, E>) => T;
+declare function getOrThrowWith<T, E, R>(self: Result<T, E>, fn: (error: E) => R): T;
+/**
+ * Handles an error with a specific tag by running a callback function
+ * @example
+ * type NetworkError = { tag: "timeout"; duration: number } | { tag: "offline" };
+ *
+ * const error: NetworkError = { tag: "timeout", duration: 5000 };
+ * catchError(error, "timeout", (e) => {
+ *   console.log(`Request timed out after ${e.duration}ms`);
+ * });
+ *
+ * const result = err<number, NetworkError>({ tag: "offline" });
+ * catchError(result, "offline", () => {
+ *   console.log("No internet connection");
+ * }); // { __tag: "ok", value: null }
+ */
+declare function catchError<T, E extends {
+    tag: string;
+}, Tag extends E['tag']>(result: Result<T, E>, tag: Tag, fn: (error: Extract<E, {
+    tag: Tag;
+}>) => void): Result<T, Exclude<E, {
+    tag: Tag;
+}>>;
+declare function catchError<T, E extends {
+    tag: string;
+}, Tag extends E['tag']>(error: E, tag: Tag, fn: (error: Extract<E, {
+    tag: Tag;
+}>) => void): void;
+declare function catchError<T, E extends {
+    tag: string;
+}, Tag extends E['tag']>(tag: Tag, fn: (error: Extract<E, {
+    tag: Tag;
+}>) => void): (result: Result<T, E>) => Result<T, Exclude<E, {
+    tag: Tag;
+}>>;
+declare function catchError<T, E extends {
+    tag: string;
+}, Tag extends E['tag']>(tag: Tag, fn: (error: Extract<E, {
+    tag: Tag;
+}>) => void): (error: E) => void;
+/**
+ * Catches all errors in a Result by running a callback function
+ * @param result - The Result to handle errors for
+ * @param fn - Function to handle any error
+ * @returns The original Result
+ * @example
+ * const result = err<number, string>("not found");
+ *
+ * // Direct style
+ * catchAllErrors(result, (e) => {
+ *   console.log(`Error occurred: ${e}`);
+ * }); // { __tag: "ok", value: null }
+ *
+ * // Curried style
+ * const handleError = catchAllErrors((e: string) => {
+ *   console.log(`Error occurred: ${e}`);
+ * });
+ * handleError(result); // { __tag: "ok", value: null }
+ */
+declare function catchAllErrors<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, never>;
+declare function catchAllErrors<T, E>(fn: (error: E) => void): (result: Result<T, E>) => Result<T, never>;
+/**
+ * Catches specific error tags using handler functions
+ * @param result - The Result to handle errors for
+ * @param handlers - Object mapping error tags to handler functions
+ * @returns Result with handled error tags excluded from error type
+ * @example
+ * type NetworkError = { tag: "timeout"; duration: number } | { tag: "offline" };
+ *
+ * const result = err<number, NetworkError>({ tag: "timeout", duration: 5000 });
+ * catchErrors(result, {
+ *   timeout: (e) => console.log(`Timed out after ${e.duration}ms`),
+ *   offline: () => console.log("No internet connection")
+ * }); // { __tag: "ok", value: null }
+ */
+declare function catchErrors<T, E extends {
+    tag: string;
+}, Key extends E['tag']>(result: Result<T, E>, handlers: {
+    [K in Key]?: (error: Extract<E, {
+        tag: K;
+    }>) => void;
+}): Result<T, Exclude<E, {
+    tag: keyof typeof handlers;
+}>>;
+declare function catchErrors<T, E extends {
+    tag: string;
+}, Key extends E['tag']>(handlers: {
+    [K in Key]?: (error: Extract<E, {
+        tag: K;
+    }>) => void;
+}): (result: Result<T, E>) => Result<T, Exclude<E, {
+    tag: keyof typeof handlers;
+}>>;
+/**
+ * Creates a chainable pipeline to transform a Result through a series of operations.
+ * @param result - The initial Result to transform
+ * @param ab - First transformation function to apply to the Result
+ * @returns A chainable function with pipe() for adding more transformations and execute() to run the pipeline
+ * @example
+ * pipe(
+ *   ok(5),
+ *   (a) => ok(a.value * 2)
+ * )
+ * .pipe(b => ok(b.value + 1))
+ * .execute() // { __tag: "ok", value: 11 }
+ */
+declare const pipe: <AI, AE, BI, BE>(result: Result<AI, AE>, ab: (a: Result<AI, AE>) => Result<BI, BE>) => {
+    (a: Result<AI, AE>): Result<BI, BE>;
+    pipe<CI, CE>(bc: (b: Result<BI, BE>) => Result<CI, CE>): {
+        (a: Result<AI, AE>): Result<CI, CE>;
+        pipe<CI_1, CE_1>(bc: (b: Result<CI, CE>) => Result<CI_1, CE_1>): {
+            (a: Result<AI, AE>): Result<CI_1, CE_1>;
+            pipe<CI_2, CE_2>(bc: (b: Result<CI_1, CE_1>) => Result<CI_2, CE_2>): {
+                (a: Result<AI, AE>): Result<CI_2, CE_2>;
+                pipe<CI_3, CE_3>(bc: (b: Result<CI_2, CE_2>) => Result<CI_3, CE_3>): {
+                    (a: Result<AI, AE>): Result<CI_3, CE_3>;
+                    pipe<CI_4, CE_4>(bc: (b: Result<CI_3, CE_3>) => Result<CI_4, CE_4>): {
+                        (a: Result<AI, AE>): Result<CI_4, CE_4>;
+                        pipe<CI_5, CE_5>(bc: (b: Result<CI_4, CE_4>) => Result<CI_5, CE_5>): {
+                            (a: Result<AI, AE>): Result<CI_5, CE_5>;
+                            pipe<CI_6, CE_6>(bc: (b: Result<CI_5, CE_5>) => Result<CI_6, CE_6>): {
+                                (a: Result<AI, AE>): Result<CI_6, CE_6>;
+                                pipe<CI_7, CE_7>(bc: (b: Result<CI_6, CE_6>) => Result<CI_7, CE_7>): {
+                                    (a: Result<AI, AE>): Result<CI_7, CE_7>;
+                                    pipe<CI_8, CE_8>(bc: (b: Result<CI_7, CE_7>) => Result<CI_8, CE_8>): {
+                                        (a: Result<AI, AE>): Result<CI_8, CE_8>;
+                                        pipe<CI_9, CE_9>(bc: (b: Result<CI_8, CE_8>) => Result<CI_9, CE_9>): {
+                                            (a: Result<AI, AE>): Result<CI_9, CE_9>;
+                                            pipe<CI_10, CE_10>(bc: (b: Result<CI_9, CE_9>) => Result<CI_10, CE_10>): /*elided*/ any;
+                                            execute(): Result<CI_9, CE_9>;
+                                        };
+                                        execute(): Result<CI_8, CE_8>;
+                                    };
+                                    execute(): Result<CI_7, CE_7>;
+                                };
+                                execute(): Result<CI_6, CE_6>;
+                            };
+                            execute(): Result<CI_5, CE_5>;
+                        };
+                        execute(): Result<CI_4, CE_4>;
+                    };
+                    execute(): Result<CI_3, CE_3>;
+                };
+                execute(): Result<CI_2, CE_2>;
+            };
+            execute(): Result<CI_1, CE_1>;
+        };
+        execute(): Result<CI, CE>;
+    };
+    execute(): Result<BI, BE>;
+};
+
+type result_Err<E> = Err<E>;
+type result_Ok<T> = Ok<T>;
+type result_Result<T, E> = Result<T, E>;
+declare const result_catchAllErrors: typeof catchAllErrors;
+declare const result_catchError: typeof catchError;
+declare const result_catchErrors: typeof catchErrors;
+declare const result_err: typeof err;
+declare const result_getErrorOrNull: typeof getErrorOrNull;
+declare const result_getOrElse: typeof getOrElse;
+declare const result_getOrNull: typeof getOrNull;
+declare const result_getOrThrow: typeof getOrThrow;
+declare const result_getOrThrowWith: typeof getOrThrowWith;
+declare const result_isErr: typeof isErr;
+declare const result_isOk: typeof isOk;
+declare const result_map: typeof map;
+declare const result_mapErr: typeof mapErr;
+declare const result_match: typeof match;
+declare const result_ok: typeof ok;
+declare const result_pipe: typeof pipe;
+declare namespace result {
+  export { type result_Err as Err, type result_Ok as Ok, type result_Result as Result, result_catchAllErrors as catchAllErrors, result_catchError as catchError, result_catchErrors as catchErrors, result_err as err, result_getErrorOrNull as getErrorOrNull, result_getOrElse as getOrElse, result_getOrNull as getOrNull, result_getOrThrow as getOrThrow, result_getOrThrowWith as getOrThrowWith, result_isErr as isErr, result_isOk as isOk, result_map as map, result_mapErr as mapErr, result_match as match, result_ok as ok, result_pipe as pipe };
+}
+
+/**
+ * Standard Schema is a common interface designed to be implemented by JavaScript and TypeScript schema libraries.
+ * Will support multiple schema validators including Zod, Valibot, and ArkType
+ * https://standardschema.dev/
+ */
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** The non-existent issues. */
+        readonly issues?: undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+
+/**
+ * A class for building and executing HTTP requests with customizable options and error handling.
+ * @template Method The HTTP method type (GET, POST, etc.)
+ * @template TRequest The request configuration type extending RequestInit
+ * @template Opts Additional options type for custom configurations
+ * @example
+ * // Create a new request instance
+ * const request = new Request('/api/users', {
+ *   baseUrl: 'https://example.com',
+ *   headers: { 'Content-Type': 'application/json' }
+ * });
+ *
+ * // Configure and execute the request
+ * const result = await request
+ *   .setQueryParams({ page: '1' })
+ *   .setBearer('token123')
+ *   .notFound(() => ({ message: 'Not found' }))
+ *   .withResult()
+ *   .json<User>();
+ */
+declare class Request<Method extends HttpMethods, TRequest extends AspiRequestInit = AspiRequestInit, Opts extends Record<any, any> = {
+    error: {};
+}> {
+    #private;
+    constructor(method: HttpMethods, path: string, { requestConfig, retryConfig, middlewares, errorCbs, }: RequestOptions<TRequest>);
+    /**
+     * Sets the base URL for the request.
+     * @param url The base URL to set
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.setBaseUrl('https://api.example.com');
+     */
+    setBaseUrl(url: string): this;
+    /**
+     * Sets the retry configuration for the request.
+     * @param retry The retry configuration object
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.setRetry({
+     *   retries: 3, // Number of retry attempts
+     *   retryDelay: 1000, // Delay between retries in ms
+     *   retryOn: [500, 502, 503], // Status codes to retry on
+     *   retryWhile: (request, response) => response.status >= 500 // Custom retry condition
+     * });
+     */
+    setRetry(retry: AspiRetryConfig<TRequest>): this;
+    /**
+     * Sets multiple headers for the request.
+     * @param headers An object containing header key-value pairs
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.setHeaders({
+     *   'Content-Type': 'application/json',
+     *   'Accept': 'application/json'
+     * });
+     */
+    setHeaders(headers: Record<string, string>): this;
+    /**
+     * Sets a single header for the request.
+     * @param key The header key
+     * @param value The header value
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.setHeader('Content-Type', 'application/json');
+     */
+    setHeader(key: string, value: string): this;
+    /**
+     * Sets the Authorization header with a bearer token.
+     * @param token The bearer token to set
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.setBearer('my-auth-token');
+     */
+    setBearer(token: string): this;
+    /**
+     * Sets a validation schema for the request body using a StandardSchemaV1 schema.
+     * @template TSchema Type parameter extending StandardSchemaV1
+     * @param schema The schema to validate the body against
+     * @returns The request instance for chaining with updated error type
+     * @example
+     * const userSchema = z.object({
+     *   name: z.string(),
+     *   email: z.string().email()
+     * });
+     *
+     * const request = new Request('/users', config);
+     * request
+     *   .bodySchema(userSchema)
+     *   .bodyJson({
+     *     name: 'John',
+     *     email: 'john@example.com'
+     *   });
+     */
+    bodySchema<TSchema extends StandardSchemaV1>(schema: TSchema): Request<Method, TRequest, Omit<Opts, "bodySchema"> & {
+        bodySchema: TSchema;
+        error: Opts["error"] & {
+            parseError: CustomError<"parseError", StandardSchemaV1.FailureResult["issues"]>;
+        };
+    }>;
+    /**
+     * Sets the request body as JSON by automatically stringifying the provided object.
+     * @param body The object to be stringified and sent as the request body
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.bodyJson({
+     *   name: 'John Doe',
+     *   email: 'john@example.com',
+     *   age: 30
+     * });
+     */
+    bodyJson<Body extends StandardSchemaV1.InferInput<Opts['bodySchema']>>(body: Body): Request<Method, TRequest, Omit<Opts, "body"> & {
+        body: Body;
+    }>;
+    /**
+     * Sets the raw request body (unsafe, use with caution).
+     * @param body The body content to send with the request
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.unsafeBody(new FormData());
+     *
+     * // or with raw text
+     * request.unsafeBody('Hello World');
+     *
+     * // or with URLSearchParams
+     * request.unsafeBody(new URLSearchParams({ key: 'value' }));
+     */
+    unsafeBody(body: BodyInit): Request<Method, TRequest, Omit<Opts, "body"> & {
+        body: BodyInit;
+    }>;
+    /**
+     * Handles 404 Not Found errors with a custom callback.
+     * @param cb The callback function to handle the error
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.notFound((error) => {
+     *   console.log('Resource not found:', error);
+     *   return { message: 'Custom not found message' };
+     * });
+     */
+    notFound<A extends {}>(cb: CustomErrorCb<TRequest, A>): Request<Method, TRequest, Omit<Opts, "error"> & {
+        error: { [K in "notFoundError" | keyof Opts["error"]]: K extends "notFoundError" ? CustomError<"notFoundError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Handles 429 Too Many Requests errors with a custom callback.
+     * @param cb The callback function to handle the error
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.tooManyRequests((error) => {
+     *   console.log('Rate limited:', error);
+     *   return { message: 'Please try again later' };
+     * });
+     */
+    tooManyRequests<A extends {}>(cb: CustomErrorCb<TRequest, A>): Request<Method, TRequest, Omit<Opts, "error"> & {
+        error: { [K in keyof Opts["error"] | "tooManyRequestsError"]: K extends "tooManyRequestsError" ? CustomError<"tooManyRequestsError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Handles 400 Bad Request errors with a custom callback.
+     * @param cb The callback function to handle the error
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.badRequest((error) => {
+     *   console.log('Bad request error:', error);
+     *   return { message: 'Invalid request parameters' };
+     * });
+     */
+    badRequest<A extends {}>(cb: CustomErrorCb<TRequest, A>): Request<Method, TRequest, Omit<Opts, "error"> & {
+        error: { [K in keyof Opts["error"] | "badRequestError"]: K extends "badRequestError" ? CustomError<"badRequestError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Handles 409 Conflict errors with a custom callback.
+     * @param cb The callback function to handle the error
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.conflict((error) => {
+     *   console.log('Conflict error:', error);
+     *   return { message: 'Resource conflict detected' };
+     * });
+     */
+    conflict<A extends {}>(cb: CustomErrorCb<TRequest, A>): Request<Method, TRequest, Omit<Opts, "error"> & {
+        error: { [K in keyof Opts["error"] | "conflictError"]: K extends "conflictError" ? CustomError<"conflictError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Handles 401 Unauthorized errors with a custom callback.
+     * @param cb The callback function to handle the error
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.unauthorised((error) => {
+     *   console.log('Unauthorized access:', error);
+     *   return { message: 'Please login first' };
+     * });
+     */
+    unauthorised<A extends {}>(cb: CustomErrorCb<TRequest, A>): Request<Method, TRequest, Omit<Opts, "error"> & {
+        error: { [K in keyof Opts["error"] | "unauthorisedError"]: K extends "unauthorisedError" ? CustomError<"unauthorisedError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Handles 403 Forbidden errors with a custom callback.
+     * @param cb The callback function to handle the error
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.forbidden((error) => {
+     *   console.log('Access forbidden:', error);
+     *   return { message: 'You do not have permission' };
+     * });
+     */
+    forbidden<A extends {}>(cb: CustomErrorCb<TRequest, A>): Request<Method, TRequest, Omit<Opts, "error"> & {
+        error: { [K in keyof Opts["error"] | "forbiddenError"]: K extends "forbiddenError" ? CustomError<"forbiddenError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Handles 501 Not Implemented errors with a custom callback.
+     * @param cb The callback function to handle the error
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.notImplemented((error) => {
+     *   console.log('Not implemented:', error);
+     *   return { message: 'This feature is not implemented yet' };
+     * });
+     */
+    notImplemented<A extends {}>(cb: CustomErrorCb<TRequest, A>): Request<Method, TRequest, Omit<Opts, "error"> & {
+        error: { [K in keyof Opts["error"] | "notImplementedError"]: K extends "notImplementedError" ? CustomError<"notImplementedError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Handles 500 Internal Server Error errors with a custom callback.
+     * @param cb The callback function to handle the error
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.internalServerError((error) => {
+     *   console.log('Server error:', error);
+     *   return { message: 'An unexpected error occurred' };
+     * });
+     */
+    internalServerError<A extends {}>(cb: CustomErrorCb<TRequest, A>): Request<Method, TRequest, Omit<Opts, "error"> & {
+        error: { [K in keyof Opts["error"] | "internalServerError"]: K extends "internalServerError" ? CustomError<"internalServerError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Sets a custom error handler for a specific HTTP status code.
+     * @param tag A string identifier for the error type
+     * @param status The HTTP error status to handle
+     * @param cb The callback function to handle the error
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request
+        .withResult()
+        .error('customError', 'BAD_REQUEST', (error) => {
+     *   console.log('Bad request error:', error);
+     *   return {
+     *     message: 'Invalid input',
+     *     details: error.response.responseData
+     *   };
+     * });
+     *
+     * // Later when making the request:
+     * const result = await request.json();
+     * if (Result.isErr(result)) {
+     *   if(result.tag === 'customError') {
+     *   console.log(result.error.data.message); // 'Invalid input'
+     * }
+     */
+    error<Tag extends string, A extends {}>(tag: Tag, status: HttpErrorStatus, cb: CustomErrorCb<TRequest, A>): Request<Method, TRequest, Omit<Opts, "error"> & {
+        error: { [K in Tag | keyof Opts["error"]]: K extends Tag ? CustomError<Tag, A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Sets query parameters for the request URL.
+     * @param params An object containing query parameter key-value pairs
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.setQueryParams({
+     *   page: '1',
+     *   limit: '10',
+     *   sort: 'desc'
+     * });
+     */
+    setQueryParams<T extends Record<string, string> | string[][] | string | URLSearchParams>(params: T): Request<Method, TRequest, Omit<Opts, "queryParams"> & {
+        qyeryParams: T;
+    }>;
+    /**
+     * Sets the output schema for validating the response data using Zod.
+     * @param schema The Zod schema to validate the response
+     * @returns The request instance for chaining
+     * @example
+     * import { z } from 'zod';
+     *
+     * const userSchema = z.object({
+     *   id: z.number(),
+     *   name: z.string(),
+     *   email: z.string().email()
+     * });
+     *
+     * const request = new Request('/users', config);
+     * const result = await request
+     *   .withResult()
+     *   .output(userSchema)
+     *   .json();
+     *
+     * if (Result.isOk(result)) {
+     *   const user = result.value; // Typed and validated user data
+     * }
+     */
+    schema<TSchema extends StandardSchemaV1>(schema: TSchema): Request<Method, TRequest, Omit<Opts, "schema"> & {
+        schema: TSchema;
+        error: Opts["error"] & {
+            parseError: CustomError<"parseError", StandardSchemaV1.FailureResult["issues"]>;
+        };
+    }>;
+    /**
+     * Executes the request and returns the JSON response.
+     * @returns A Promise containing the Result type with either successful data or error information
+     * @example
+     * const request = new Request('/users', config);
+     * const result = await request
+     *   .setQueryParams({ id: '123' })
+     *   .withResult()
+     *   .notFound((error) => ({ message: 'User not found' }))
+     *   .json<User>();
+     *
+     * if (Result.isOk(result)) {
+     *   const user = result.value; // User data
+     * } else {
+     *   console.error(result.error); // Error handling
+     * }
+     */
+    json<T extends StandardSchemaV1.InferOutput<Opts['schema']>>(): Promise<Opts['withResult'] extends true ? Result<AspiResultOk<TRequest, T>, AspiError<TRequest> | (Opts extends {
+        error: any;
+    } ? Opts['error'][keyof Opts['error']] : never) | JSONParseError> : [
+        AspiResultOk<TRequest, T> | null,
+        ((AspiError<TRequest> | (Opts extends {
+            error: any;
+        } ? Opts['error'][keyof Opts['error']] : never) | JSONParseError) | null)
+    ]>;
+    /**
+     * Executes the request and returns the response as plain text.
+     * @returns A Promise containing the Result type with either successful text data or error information
+     * @example
+     * const request = new Request('/data.txt', config);
+     * const result = await request
+     *   .setQueryParams({ version: '1' })
+     *   .withResult()
+     *   .notFound((error) => ({ message: 'Text file not found' }))
+     *   .text();
+     *
+     * if (Result.isOk(result)) {
+     *   const text = result.value; // Plain text content
+     * } else {
+     *   console.error(result.error); // Error handling
+     * }
+     */
+    text(): Promise<Opts['withResult'] extends true ? Result<AspiResultOk<TRequest, string>, AspiError<TRequest> | (Opts extends {
+        error: any;
+    } ? Opts['error'][keyof Opts['error']] : never)> : [
+        AspiResultOk<TRequest, string> | null,
+        ((AspiError<TRequest> | (Opts extends {
+            error: any;
+        } ? Opts['error'][keyof Opts['error']] : never)) | null)
+    ]>;
+    /**
+     * Executes the request and returns the response as a Blob.
+     * @returns A Promise containing the Result type with either successful Blob data or error information
+     * @example
+     * const request = new Request('/image.jpg', config);
+     * const result = await request
+     *   .setQueryParams({ size: 'large' })
+     *   .withResult()
+     *   .notFound((error) => ({ message: 'Image not found' }))
+     *   .blob();
+     *
+     * if (Result.isOk(result)) {
+     *   const imageBlob = result.value; // Blob data
+     * } else {
+     *   console.error(result.error); // Error handling
+     * }
+     */
+    blob(): Promise<Opts['withResult'] extends true ? Result<AspiResultOk<TRequest, Blob>, AspiError<TRequest> | (Opts extends {
+        error: any;
+    } ? Opts['error'][keyof Opts['error']] : never)> : [
+        AspiResultOk<TRequest, Blob> | null,
+        ((AspiError<TRequest> | (Opts extends {
+            error: any;
+        } ? Opts['error'][keyof Opts['error']] : never)) | null)
+    ]>;
+    /**
+     * Returns the complete URL for the request including base URL, path, and query parameters.
+     * @returns The complete URL string
+     * @example
+     * const request = new Request('/users', config);
+     * request.setBaseUrl('https://api.example.com');
+     * request.setQueryParams({ id: '123' });
+     * console.log(request.url()); // 'https://api.example.com/users?id=123'
+     */
+    url(): string;
+    /**
+     * Configures the request to return a Result type instead of a tuple.
+     * @returns The request instance for chaining with Result type return value
+     * @example
+     * const request = new Request('/users', config);
+     * const result = await request
+     *   .withResult()
+     *   .json<User>();
+     *
+     * // Returns Result type instead of tuple
+     * if (Result.isOk(result)) {
+     *   const user = result.value;
+     * }
+     */
+    withResult(): Request<Method, TRequest, Omit<Opts, "withResult"> & {
+        withResult: true;
+    }>;
+}
+
+/**
+ * A class for making API requests with a base URL and configurable options
+ * @template TRequest - Type extending RequestInit for request configuration
+ * @example
+ * const api = new Aspi({
+ *   baseUrl: 'https://api.example.com',
+ *   headers: {
+ *     'Content-Type': 'application/json'
+ *   }
+ * });
+ *
+ * // Make requests
+ * const users = await api.get('/users').json();
+ * const user = await api.post('/users', { name: 'John' }).json();
+ */
+declare class Aspi<TRequest extends AspiRequestInit = AspiRequestInit, Opts extends Record<any, any> = {}> {
+    #private;
+    constructor(config: AspiConfig);
+    /**
+     * Sets the base URL for all API requests
+     * @param {string} url - The base URL to be set
+     * @returns {Aspi} The Aspi instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * api.setBaseUrl('https://api.newdomain.com');
+     */
+    setBaseUrl(url: string): this;
+    /**
+     * Sets the retry configuration for failed requests
+     * @param {AspiRetryConfig<TRequest>} retry - The retry configuration object
+     * @returns {Aspi} The Aspi instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * api.setRetry({
+     *   retries: 3,
+     *   retryDelay: 1000,
+     *   retryOn: [500, 502],
+     *   retryWhile: (req, res) => res.status === 500
+     * });
+     */
+    setRetry(retry: AspiRetryConfig<TRequest>): this;
+    /**
+     * Makes a GET request to the specified path
+     * @param {string} path - The path to make the request to
+     * @returns {Request} A Request instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * const response = await api.get('/users').json();
+     */
+    get(path: string): Request<"GET", TRequest, Opts>;
+    /**
+     * Makes a POST request to the specified path with an optional body
+     * @param {string} path - The path to make the request to
+     * @param {BodyInit} [body] - The body of the request
+     * @returns {Request} A Request instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * const response = await api.post('/users', { name: 'John' }).json();
+     */
+    post(path: string, body?: BodyInit): Request<"POST", TRequest, Opts>;
+    /**
+     * Makes a PUT request to the specified path with an optional body
+     * @param {string} path - The path to make the request to
+     * @param {BodyInit} [body] - The body of the request
+     * @returns {Request} A Request instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * const response = await api.put('/users/1', { name: 'John' }).json();
+     */
+    put(path: string, body?: BodyInit): Request<"PUT", TRequest, Opts>;
+    /**
+     * Makes a PATCH request to the specified path with an optional body
+     * @param {string} path - The path to make the request to
+     * @param {BodyInit} [body] - The body of the request
+     * @returns {Request} A Request instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * const response = await api.patch('/users/1', { name: 'John' }).json();
+     */
+    patch(path: string, body?: BodyInit): Request<"PATCH", TRequest, Opts>;
+    /**
+     * Makes a DELETE request to the specified path
+     * @param {string} path - The path to make the request to
+     * @returns {Request} A Request instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * const response = await api.delete('/users/1').json();
+     */
+    delete(path: string): Request<"DELETE", TRequest, Opts>;
+    /**
+     * Makes a HEAD request to the specified path
+     * @param {string} path - The path to make the request to
+     * @returns {Request} A Request instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * const response = await api.head('/users').json();
+     */
+    head(path: string): Request<"HEAD", TRequest, Opts>;
+    /**
+     * Makes an OPTIONS request to the specified path
+     * @param {string} path - The path to make the request to
+     * @returns {Request} A Request instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * const response = await api.options('/users').json();
+     */
+    options(path: string): Request<"OPTIONS", TRequest, Opts>;
+    /**
+     * Sets multiple headers for all API requests
+     * @param {Record<string, string>} headers - An object containing header key-value pairs
+     * @returns {Aspi} The Aspi instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * api.setHeaders({
+     *   'Content-Type': 'application/json',
+     *   'Accept': 'application/json'
+     * });
+     */
+    setHeaders(headers: Record<string, string>): this;
+    /**
+     * Sets a single header for all API requests
+     * @param {string} key - The header key
+     * @param {string} value - The header value
+     * @returns {Aspi} The Aspi instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * api.setHeader('Content-Type', 'application/json');
+     */
+    setHeader(key: string, value: string): this;
+    /**
+     * Sets the Authorization header with a Bearer token
+     * @param {string} token - The Bearer token
+     * @returns {Aspi} The Aspi instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * api.setBearer('myAuthToken123');
+     */
+    setBearer(token: string): this;
+    /**
+     * Use a middleware function to transform requests
+     * @param {Middleware<T, U>} fn - The middleware function to apply
+     * @returns {Aspi<U>} A new Aspi instance with the applied middleware
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * api.use((req) => {
+     *   // Add custom headers
+     *   req.headers = {
+     *     ...req.headers,
+     *     'x-custom-header': 'custom-value'
+     *   };
+     *   return req;
+     * });
+     */
+    use<T extends TRequest, U extends TRequest>(fn: Middleware<T, U>): Aspi<U>;
+    /**
+     * Registers a custom error handler for a specific HTTP status
+     * @param {string} tag - The error tag identifier
+     * @param {HttpErrorStatus} status - The HTTP status code to handle
+     * @param {CustomErrorCb<TRequest, A>} cb - The callback function to handle the error
+     * @returns {Aspi} The Aspi instance for chaining
+     * @example
+     * const api = new Aspi({ baseUrl: 'https://api.example.com' });
+     * api.error('customError', 'BAD_REQUEST', (req, res) => {
+     *   console.log('Bad request error occurred');
+     *   return { message: 'Invalid input' };
+     * });
+     */
+    error<Tag extends string, A extends {}>(tag: Tag, status: HttpErrorStatus, cb: CustomErrorCb<TRequest, A>): Aspi<TRequest, Opts & {
+        error: { [K in Tag | keyof Opts["error"]]: K extends Tag ? CustomError<Tag, A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Handles 404 Not Found errors with a custom callback.
+     * @param cb The callback function to handle the error
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.notFound((error) => {
+     *   console.log('Not found:', error);
+     *   return { message: 'Resource not found' };
+     * });
+     */
+    notFound<A extends {}>(cb: CustomErrorCb<TRequest, A>): Aspi<TRequest, Opts & {
+        error: { [K in "notFoundError" | keyof Opts["error"]]: K extends "notFoundError" ? CustomError<"notFoundError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Handles 429 Too Many Requests errors with a custom callback.
+     * @param cb The callback function to handle the error
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.tooManyRequests((error) => {
+     *   console.log('Rate limited:', error);
+     *   return { message: 'Please try again later' };
+     * });
+     */
+    tooManyRequests<A extends {}>(cb: CustomErrorCb<TRequest, A>): Aspi<TRequest, Opts & {
+        error: { [K in "tooManyRequestsError" | keyof Opts["error"]]: K extends "tooManyRequestsError" ? CustomError<"tooManyRequestsError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Handles 409 Conflict errors with a custom callback.
+     * @param cb The callback function to handle the error
+     * @returns The request instance for chaining
+     * @example
+     * const request = new Request('/users', config);
+     * request.conflict((error) => {
+     *   console.log('Conflict error:', error);
+     *   return { message: 'Resource conflict detected' };
+     * });
+     */
+    conflict<A extends {}>(cb: CustomErrorCb<TRequest, A>): Aspi<TRequest, Opts & {
+        error: { [K in "conflictError" | keyof Opts["error"]]: K extends "conflictError" ? CustomError<"conflictError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Registers a handler for 400 Bad Request errors
+     * @param {CustomErrorCb<TRequest, A>} cb - The callback function to handle the error
+     * @returns {Aspi} The Aspi instance for chaining
+     * @example
+     * api.badRequest((req, res) => ({ message: 'Invalid request parameters' }));
+     */
+    badRequest<A extends {}>(cb: CustomErrorCb<TRequest, A>): Aspi<TRequest, Opts & {
+        error: { [K in "badRequestError" | keyof Opts["error"]]: K extends "badRequestError" ? CustomError<"badRequestError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Registers a handler for 401 Unauthorized errors
+     * @param {CustomErrorCb<TRequest, A>} cb - The callback function to handle the error
+     * @returns {Aspi} The Aspi instance for chaining
+     * @example
+     * api.unauthorized((req, res) => ({ message: 'Authentication required' }));
+     */
+    unauthorized<A extends {}>(cb: CustomErrorCb<TRequest, A>): Aspi<TRequest, Opts & {
+        error: { [K in keyof Opts["error"] | "unauthorizedError"]: K extends "unauthorizedError" ? CustomError<"unauthorizedError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Registers a handler for 403 Forbidden errors
+     * @param {CustomErrorCb<TRequest, A>} cb - The callback function to handle the error
+     * @returns {Aspi} The Aspi instance for chaining
+     * @example
+     * api.forbidden((req, res) => ({ message: 'Access denied' }));
+     */
+    forbidden<A extends {}>(cb: CustomErrorCb<TRequest, A>): Aspi<TRequest, Opts & {
+        error: { [K in "forbiddenError" | keyof Opts["error"]]: K extends "forbiddenError" ? CustomError<"forbiddenError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Registers a handler for 501 Not Implemented errors
+     * @param {CustomErrorCb<TRequest, A>} cb - The callback function to handle the error
+     * @returns {Aspi} The Aspi instance for chaining
+     * @example
+     * api.notImplemented((req, res) => ({ message: 'Feature not implemented' }));
+     */
+    notImplemented<A extends {}>(cb: CustomErrorCb<TRequest, A>): Aspi<TRequest, Opts & {
+        error: { [K in "notImplementedError" | keyof Opts["error"]]: K extends "notImplementedError" ? CustomError<"notImplementedError", A> : Opts["error"][K]; };
+    }>;
+    /**
+     * Registers a handler for 500 Internal Server errors
+     * @param {CustomErrorCb<TRequest, A>} cb - The callback function to handle the error
+     * @returns {Aspi} The Aspi instance for chaining
+     * @example
+     * api.internalServerError((req, res) => ({ message: 'Server error occurred' }));
+     */
+    internalServerError<A extends {}>(cb: CustomErrorCb<TRequest, A>): Aspi<TRequest, Opts & {
+        error: { [K in keyof Opts["error"] | "internalServerErrorError"]: K extends "internalServerErrorError" ? CustomError<"internalServerErrorError", A> : Opts["error"][K]; };
+    }>;
+}
+
+export { Aspi, type AspiConfig, type AspiConfigBase, AspiError, type AspiRequest, type AspiRequestInit, type AspiResponse, type AspiResultOk, type AspiRetryConfig, CustomError, type CustomErrorCb, type ErrorCallbacks, type HttpErrorCodes, type HttpErrorStatus, type HttpMethods, type JSONParseError, type Middleware, Request, type RequestOptions, result as Result, getHttpErrorStatus, httpErrors };