@apisr/response 0.0.1 → 0.0.2

package/dist/error/default.d.mts

@@ -0,0 +1,8 @@
+import { ErrorOptions } from "../options/error.mjs";
+import { Options } from "../options/base.mjs";
+import { ErrorRegistry } from "./index.mjs";
+
+//#region src/error/default.d.ts
+declare function generateDefaultErrors<TOptions extends Options>(_mapDefaultError: ErrorOptions.Base["mapDefaultError"]): ErrorRegistry<TOptions>;
+//#endregion
+export { generateDefaultErrors };

package/dist/error/default.mjs

@@ -0,0 +1,103 @@
+import { zod } from "../zod/dist/index.mjs";
+
+//#region src/error/default.ts
+function generateDefaultErrors(_mapDefaultError) {
+	const mapDefaultError = _mapDefaultError ?? ((err) => err);
+	const inputSchema = zod.object({ cause: zod.any().optional() }).optional();
+	return {
+		unauthorized: {
+			handler: ({ input }) => mapDefaultError({
+				message: "Unauthorized",
+				code: "UNAUTHORIZED",
+				name: "UnauthorizedError",
+				cause: input.cause
+			}),
+			options: {
+				input: inputSchema,
+				status: 401,
+				statusText: "Unauthorized"
+			}
+		},
+		forbidden: {
+			handler: ({ input }) => mapDefaultError({
+				message: "Forbidden",
+				code: "FORBIDDEN",
+				name: "ForbiddenError",
+				cause: input.cause
+			}),
+			options: {
+				input: inputSchema,
+				status: 403,
+				statusText: "Forbidden"
+			}
+		},
+		notFound: {
+			handler: ({ input }) => mapDefaultError({
+				message: "Not Found",
+				code: "NOT_FOUND",
+				name: "NotFoundError",
+				cause: input.cause
+			}),
+			options: {
+				input: inputSchema,
+				status: 404,
+				statusText: "Not Found"
+			}
+		},
+		badRequest: {
+			handler: ({ input }) => mapDefaultError({
+				message: "Bad Request",
+				code: "BAD_REQUEST",
+				name: "BadRequestError",
+				cause: input.cause
+			}),
+			options: {
+				input: inputSchema,
+				status: 400,
+				statusText: "Bad Request"
+			}
+		},
+		conflict: {
+			handler: ({ input }) => mapDefaultError({
+				message: "Conflict",
+				code: "CONFLICT",
+				name: "ConflictError",
+				cause: input.cause
+			}),
+			options: {
+				input: inputSchema,
+				status: 409,
+				statusText: "Conflict"
+			}
+		},
+		tooMany: {
+			handler: ({ input }) => mapDefaultError({
+				message: "Too Many Requests",
+				code: "TOO_MANY_REQUESTS",
+				name: "TooManyRequestsError",
+				cause: input.cause
+			}),
+			options: {
+				input: inputSchema,
+				status: 429,
+				statusText: "Too Many Requests"
+			}
+		},
+		internal: {
+			handler: ({ input }) => mapDefaultError({
+				message: "Internal Server Error",
+				code: "INTERNAL_SERVER_ERROR",
+				name: "InternalServerError",
+				cause: input.cause
+			}),
+			options: {
+				input: inputSchema,
+				status: 500,
+				statusText: "Internal Server Error"
+			}
+		}
+	};
+}
+
+//#endregion
+export { generateDefaultErrors };

package/dist/error/index.d.mts

@@ -0,0 +1,30 @@
+import { ErrorOptions } from "../options/error.mjs";
+import { Options } from "../options/base.mjs";
+import { generateDefaultErrors } from "./default.mjs";
+
+//#region src/error/index.d.ts
+type DefaultErrorTypes = "unauthorized" | "forbidden" | "notFound" | "badRequest" | "conflict" | "tooMany" | "internal";
+type DefaultError = {
+  message: string;
+  code: string;
+  name: string;
+  cause?: unknown;
+  stack?: string[];
+};
+type ErrorHandler<TOptions extends Options, THandlerOptions extends ErrorHandlerOptions | undefined> = (data: {
+  meta: TOptions["meta"] extends undefined ? never : Infer<ExtractSchema<TOptions["meta"]>>;
+  input: THandlerOptions extends undefined ? never : Infer<Exclude<THandlerOptions, undefined>["input"]>;
+}) => ErrorOptions.InferedSchema<TOptions>;
+interface ErrorHandlerOptions<TSchema extends Schema = Schema> {
+  input?: TSchema;
+  status?: number;
+  statusText?: string;
+  validationType?: ValidationType;
+}
+type ErrorDefinition<TOptions extends Options, THandlerOptions extends ErrorHandlerOptions | undefined> = {
+  handler: ErrorHandler<TOptions, THandlerOptions> | ErrorOptions.InferedSchema<TOptions>;
+  options: THandlerOptions;
+};
+type ErrorRegistry<TOptions extends Options> = Record<string, ErrorDefinition<TOptions, any>>;
+//#endregion
+export { DefaultError, DefaultErrorTypes, ErrorDefinition, ErrorHandler, ErrorHandlerOptions, ErrorRegistry };

package/dist/error/index.mjs

@@ -0,0 +1,3 @@
+import { generateDefaultErrors } from "./default.mjs";
+
+export {  };

package/dist/handler.d.mts

@@ -0,0 +1,127 @@
+import { PromiseOr } from "./types.mjs";
+import { MetaOptions } from "./options/meta.mjs";
+import { ErrorOptions } from "./options/error.mjs";
+import { BaseResponse } from "./response/base.mjs";
+import { JsonResponse } from "./response/json/index.mjs";
+import { JsonOptions } from "./options/json.mjs";
+import { Binary, BinaryResponse } from "./response/binary/index.mjs";
+import { BinaryOptions } from "./options/binary.mjs";
+import { ErrorResponse } from "./response/error/index.mjs";
+import { DefaultResponse } from "./response/default.mjs";
+import { Options } from "./options/base.mjs";
+import { options as options$1 } from "./options/index.mjs";
+import { DefaultErrorTypes, ErrorDefinition, ErrorHandler, ErrorHandlerOptions, ErrorRegistry } from "./error/index.mjs";
+import { TextResponse } from "./response/text/index.mjs";
+
+//#region src/handler.d.ts
+declare function createResponseHandler<TMeta extends MetaOptions.Base, TError extends ErrorOptions.Base, TJson extends JsonOptions.Base, TBinary extends BinaryOptions.Base, TOptions extends Options<TMeta, TError, TJson, TBinary> = Options<TMeta, TError, TJson, TBinary>>(opts: TOptions | ((options: typeof options$1) => TOptions)): ResponseHandler<TMeta, TError, TJson, TBinary, TOptions, {}>;
+type ResolveOptionsMeta<TOptions extends Options> = TOptions["meta"] extends undefined ? never : Exclude<TOptions["meta"], undefined>;
+type AnyResponseHandler = ResponseHandler<any, any, any, any, any>;
+declare class ResponseHandler<TMeta extends MetaOptions.Base, TError extends ErrorOptions.Base, TJson extends JsonOptions.Base, TBinary extends BinaryOptions.Base, TOptions extends Options<TMeta, TError, TJson, TBinary>, TErrors extends ErrorRegistry<TOptions> = {}> {
+  options: TOptions;
+  private errors;
+  private preasignedMeta;
+  /**
+   * Create a `ResponseHandler` instance.
+   *
+   * Prefer using {@link createResponseHandler} instead of calling this directly.
+   *
+   * @param params - Constructor params.
+   * @param params.options - Handler options.
+   * @param params.errors - Optional pre-defined error registry.
+   * @param params.preasignedMeta - Optional meta merged into each response.
+   */
+  constructor({
+    options,
+    errors,
+    preasignedMeta
+  }: {
+    options: TOptions;
+    errors?: TErrors;
+    preasignedMeta?: Partial<MetaOptions.InferedSchema<TOptions>>;
+  });
+  fail<TKey extends keyof TErrors & string, TInput extends Infer<TErrors[TKey]["options"]["input"]>>(name: TKey, input?: TInput): ErrorResponse.Base<TKey, MetaOptions.InferedSchema<TOptions>, TInput>;
+  fail(name: DefaultErrorTypes, input?: Record<string, any>): ErrorResponse.Base<DefaultErrorTypes, MetaOptions.InferedSchema<TOptions>, Record<string, any>>;
+  /**
+   * Create a JSON `Response`.
+   *
+   * Validates input/output using configured schemas (if present), applies `onData` transformation,
+   * and resolves/merges headers.
+   *
+   * @typeParam IInput - Inferred input type for configured JSON input schema.
+   * @param _input - JSON input value.
+   * @param options - Optional response init options.
+   * @returns JSON response instance.
+   */
+  json<IInput extends JsonOptions.InferedSchema<TOptions>>(_input: IInput, options?: JsonResponse.Options): JsonResponse.Base<IInput>;
+  /**
+   * Create a plain text `Response`.
+   *
+   * @param text - Raw text response body.
+   * @param options - Optional response init options.
+   * @returns Text response instance.
+   */
+  text(text: string, options?: TextResponse.Options): TextResponse.Base;
+  /**
+   * Create a binary `Response`.
+   *
+   * Applies optional `binary.onData` transformation and resolves/merges headers.
+   *
+   * @param binary - Binary payload (Blob/ArrayBuffer/Uint8Array/ReadableStream).
+   * @param options - Optional response init options.
+   * @returns Binary response instance.
+   */
+  binary(binary: Binary, options?: BinaryResponse.Options): BinaryResponse.Base;
+  /**
+   * Create a new `ResponseHandler` with preassigned meta.
+   *
+   * The provided meta is validated against the configured meta schema (if present).
+   *
+   * @param _meta - Partial meta that will be merged into each next response.
+   * @returns New `ResponseHandler` instance.
+   */
+  withMeta(_meta: Partial<MetaOptions.InferedSchema<TOptions>>): ResponseHandler<TMeta, TError, TJson, TBinary, TOptions, TErrors>;
+  /**
+   * Define a named error handler.
+   *
+   * Returns a new `ResponseHandler` instance with the extended error registry.
+   *
+   * @typeParam TName - Error name.
+   * @typeParam THandlerOptions - Handler options type.
+   * @param name - Error name to register.
+   * @param handler - Error handler function or static error output.
+   * @param options - Error handler options (e.g. input schema).
+   * @returns New `ResponseHandler` instance with the new error registered.
+   */
+  defineError<TName extends string, THandlerOptions extends ErrorHandlerOptions | undefined>(name: TName, handler: ErrorHandler<TOptions, THandlerOptions> | ErrorOptions.InferedSchema<TOptions>, options?: THandlerOptions): ResponseHandler<TMeta, TError, TJson, TBinary, TOptions, TErrors & Record<TName, ErrorDefinition<TOptions, THandlerOptions>>>;
+  mapResponse(raw: {
+    data: JsonOptions.InferedSchemaFromBase<TJson> | Binary | string | undefined;
+    error: ErrorOptions.InferedSchemaFromBase<TError> | undefined;
+  }): PromiseOr<Response>;
+  /**
+   * Returns response that mapped into `DefaultResponse`:
+   * ```
+   * export interface DefaultResponse<TData = unknown> {
+   *   success: boolean;
+   *   error: ErrorResponse.Base<any, any, any> | null;
+   *   data: TData | null;
+   *   metadata: Record<string, unknown>;
+   * }
+   * ```
+   * @param raw
+   * @returns Response
+   */
+  defaultMapResponse(raw: {
+    data: JsonOptions.InferedSchemaFromBase<TJson> | Binary | string | undefined;
+    error: ErrorOptions.InferedSchemaFromBase<TError> | undefined;
+  }): BaseResponse.Base<DefaultResponse> | BaseResponse.Base<Binary>;
+  /**
+   * Prepare `meta` by merging preassigned meta (from `withMeta`) with default meta (if any).
+   *
+   * @returns Resolved meta object.
+   */
+  private prepareMeta;
+  private isBinaryData;
+}
+//#endregion
+export { AnyResponseHandler, ResolveOptionsMeta, ResponseHandler, createResponseHandler };

package/dist/handler.mjs

@@ -0,0 +1,272 @@
+import { checkSchema } from "./schema/dist/index.mjs";
+import { generateDefaultErrors } from "./error/default.mjs";
+import { resolveHeaders } from "./headers.mjs";
+import { options } from "./options/index.mjs";
+import { BaseResponse } from "./response/base.mjs";
+import { BinaryResponse } from "./response/binary/index.mjs";
+import { ErrorResponse } from "./response/error/index.mjs";
+import { JsonResponse } from "./response/json/index.mjs";
+import { TextResponse } from "./response/text/index.mjs";
+
+//#region src/handler.ts
+function createResponseHandler(opts) {
+	return new ResponseHandler({ options: typeof opts === "function" ? opts(options) : opts });
+}
+var ResponseHandler = class ResponseHandler {
+	options;
+	errors;
+	preasignedMeta;
+	/**
+	* Create a `ResponseHandler` instance.
+	*
+	* Prefer using {@link createResponseHandler} instead of calling this directly.
+	*
+	* @param params - Constructor params.
+	* @param params.options - Handler options.
+	* @param params.errors - Optional pre-defined error registry.
+	* @param params.preasignedMeta - Optional meta merged into each response.
+	*/
+	constructor({ options: options$1, errors, preasignedMeta }) {
+		this.options = options$1;
+		this.errors = errors ?? generateDefaultErrors(options$1?.error?.mapDefaultError) ?? {};
+		this.preasignedMeta = preasignedMeta ?? {};
+	}
+	/**
+	* Create an `ErrorResponse` by name.
+	*
+	* If the error has an `input` schema, the `input` is validated according to `validationType`.
+	* The resulting error response also includes prepared `meta`.
+	*
+	* @param name - Error name (registered via `defineError` or built-in default types).
+	* @param _input - Optional error payload to validate (if a schema exists).
+	* @returns Error response instance.
+	*/
+	fail(name, _input) {
+		const error = this.errors[name];
+		const errorOptions = error?.options;
+		const input = errorOptions?.input ? checkSchema(errorOptions?.input, _input, { validationType: errorOptions?.validationType ?? "parse" }) : _input;
+		const meta = this.prepareMeta();
+		const handler = error?.handler;
+		const output = typeof handler === "function" ? handler({
+			meta,
+			input
+		}) : handler;
+		const status = errorOptions?.status ?? 500;
+		const statusText = errorOptions?.statusText ?? "Unknown";
+		return new ErrorResponse.Base({
+			meta,
+			name,
+			output,
+			status,
+			statusText
+		});
+	}
+	/**
+	* Create a JSON `Response`.
+	*
+	* Validates input/output using configured schemas (if present), applies `onData` transformation,
+	* and resolves/merges headers.
+	*
+	* @typeParam IInput - Inferred input type for configured JSON input schema.
+	* @param _input - JSON input value.
+	* @param options - Optional response init options.
+	* @returns JSON response instance.
+	*/
+	json(_input, options$1) {
+		const jsonOptions = this.options?.json;
+		const _output = jsonOptions?.mapData ? jsonOptions.mapData(_input) : JsonResponse.defaultOnDataOutput(_input);
+		const str = JSON.stringify(_output, null, 2);
+		const headers = {
+			"Content-Type": "application/json",
+			...options$1?.headers ?? {},
+			...resolveHeaders(jsonOptions?.headers, { output: _output }) ?? {}
+		};
+		return new JsonResponse.Base(str, {
+			headers,
+			status: options$1?.status ?? 200,
+			statusText: options$1?.statusText,
+			output: _output
+		});
+	}
+	/**
+	* Create a plain text `Response`.
+	*
+	* @param text - Raw text response body.
+	* @param options - Optional response init options.
+	* @returns Text response instance.
+	*/
+	text(text, options$1) {
+		return new TextResponse.Base(text, { ...options$1 ?? {} });
+	}
+	/**
+	* Create a binary `Response`.
+	*
+	* Applies optional `binary.onData` transformation and resolves/merges headers.
+	*
+	* @param binary - Binary payload (Blob/ArrayBuffer/Uint8Array/ReadableStream).
+	* @param options - Optional response init options.
+	* @returns Binary response instance.
+	*/
+	binary(binary, options$1) {
+		const binaryOptions = this.options?.binary;
+		const data = binaryOptions?.mapData ? binaryOptions.mapData(binary) : binary;
+		const headers = {
+			...options$1?.headers ?? {},
+			...resolveHeaders(binaryOptions?.headers, data) ?? {}
+		};
+		return new BinaryResponse.Base(data, {
+			headers,
+			status: options$1?.status ?? 200,
+			statusText: options$1?.statusText
+		});
+	}
+	/**
+	* Create a new `ResponseHandler` with preassigned meta.
+	*
+	* The provided meta is validated against the configured meta schema (if present).
+	*
+	* @param _meta - Partial meta that will be merged into each next response.
+	* @returns New `ResponseHandler` instance.
+	*/
+	withMeta(_meta) {
+		const metaOptions = this.options.meta;
+		const meta = metaOptions?.schema ? checkSchema(metaOptions.schema.partial(), _meta, { validationType: metaOptions.validationType ?? "parse" }) : _meta;
+		return new ResponseHandler({
+			options: this.options,
+			errors: this.errors,
+			preasignedMeta: meta
+		});
+	}
+	/**
+	* Define a named error handler.
+	*
+	* Returns a new `ResponseHandler` instance with the extended error registry.
+	*
+	* @typeParam TName - Error name.
+	* @typeParam THandlerOptions - Handler options type.
+	* @param name - Error name to register.
+	* @param handler - Error handler function or static error output.
+	* @param options - Error handler options (e.g. input schema).
+	* @returns New `ResponseHandler` instance with the new error registered.
+	*/
+	defineError(name, handler, options$1) {
+		const nextErrors = {
+			...this.errors,
+			[name]: {
+				handler,
+				options: options$1
+			}
+		};
+		return new ResponseHandler({
+			options: this.options,
+			errors: nextErrors
+		});
+	}
+	mapResponse(raw) {
+		const mapResponse = this.options.mapResponse;
+		if (this.isBinaryData(raw.data)) return this.defaultMapResponse(raw);
+		const response = this.defaultMapResponse(raw);
+		return mapResponse ? mapResponse({
+			data: raw.data,
+			error: raw.error,
+			response
+		}) : response;
+	}
+	/**
+	* Returns response that mapped into `DefaultResponse`:
+	* ```
+	* export interface DefaultResponse<TData = unknown> {
+	*   success: boolean;
+	*   error: ErrorResponse.Base<any, any, any> | null;
+	*   data: TData | null;
+	*   metadata: Record<string, unknown>;
+	* }
+	* ```
+	* @param raw
+	* @returns Response
+	*/
+	defaultMapResponse(raw) {
+		const options$1 = this.options;
+		const meta = this.prepareMeta();
+		const error = options$1.error?.mapError ? options$1.error?.mapError?.({
+			error: raw.error && raw.error instanceof Error ? raw.error : null,
+			meta,
+			parsedError: raw.error instanceof ErrorResponse.Base ? raw.error : null
+		}) : raw.error;
+		if (error) {
+			const status = error?.status ?? 500;
+			const statusText = error?.statusText ?? "Internal Server Error";
+			const payload$1 = {
+				error,
+				data: null,
+				success: false,
+				metadata: meta
+			};
+			const headers$1 = {
+				"Content-Type": "application/json",
+				...resolveHeaders(options$1.headers, {
+					type: "error",
+					data: error
+				}) ?? {},
+				...resolveHeaders(options$1.error?.headers, error) ?? {}
+			};
+			return new BaseResponse.Base(JSON.stringify(payload$1), {
+				status,
+				statusText,
+				headers: headers$1,
+				payload: payload$1
+			});
+		}
+		if (this.isBinaryData(raw.data)) {
+			const headers$1 = {
+				...resolveHeaders(options$1.headers, {
+					type: "binary",
+					data: raw.data
+				}) ?? {},
+				...resolveHeaders(options$1.binary?.headers, raw.data) ?? {}
+			};
+			return new BaseResponse.Base(raw.data, {
+				status: 200,
+				headers: headers$1,
+				payload: raw.data
+			});
+		}
+		const payload = {
+			error: null,
+			data: raw.data ?? null,
+			success: true,
+			metadata: meta
+		};
+		const headers = {
+			"Content-Type": "application/json",
+			...resolveHeaders(options$1.headers, {
+				type: "json",
+				data: raw.data
+			}) ?? {},
+			...resolveHeaders(options$1.json?.headers, { output: raw.data }) ?? {}
+		};
+		return new BaseResponse.Base(JSON.stringify(payload), {
+			status: 200,
+			headers,
+			payload
+		});
+	}
+	/**
+	* Prepare `meta` by merging preassigned meta (from `withMeta`) with default meta (if any).
+	*
+	* @returns Resolved meta object.
+	*/
+	prepareMeta() {
+		const objOrFn = this.options.meta?.default;
+		return {
+			...typeof objOrFn === "function" ? objOrFn() : objOrFn,
+			...this.preasignedMeta ?? {}
+		};
+	}
+	isBinaryData(data) {
+		return data instanceof Blob || data instanceof ArrayBuffer || data instanceof Uint8Array || typeof ReadableStream !== "undefined" && data instanceof ReadableStream;
+	}
+};
+
+//#endregion
+export { ResponseHandler, createResponseHandler };

package/dist/headers.d.mts

@@ -0,0 +1,8 @@
+import { FunctionObject } from "./types.mjs";
+
+//#region src/headers.d.ts
+type RawHeaders = Record<string, string>;
+type Headers<T> = FunctionObject<RawHeaders, T>;
+declare function resolveHeaders(headers: Headers<any> | undefined, input: unknown): RawHeaders | null;
+//#endregion
+export { Headers, RawHeaders, resolveHeaders };

package/dist/headers.mjs

@@ -0,0 +1,9 @@
+//#region src/headers.ts
+function resolveHeaders(headers, input) {
+	const result = typeof headers === "function" ? headers(input) : headers;
+	if (!headers) return null;
+	return result;
+}
+
+//#endregion
+export { resolveHeaders };

package/dist/index.d.mts

@@ -0,0 +1,20 @@
+import { DefaultMeta } from "./response/meta/index.mjs";
+import { AnyObject, FunctionObject, PromiseOr } from "./types.mjs";
+import { MetaOptions, meta } from "./options/meta.mjs";
+import { Headers, RawHeaders, resolveHeaders } from "./headers.mjs";
+import { ErrorOptions, error } from "./options/error.mjs";
+import { BaseResponse, ResponseTypes } from "./response/base.mjs";
+import { JsonResponse } from "./response/json/index.mjs";
+import { JsonOptions, json } from "./options/json.mjs";
+import { Binary, BinaryResponse } from "./response/binary/index.mjs";
+import { BinaryOptions, binary } from "./options/binary.mjs";
+import { ErrorResponse } from "./response/error/index.mjs";
+import { DefaultResponse } from "./response/default.mjs";
+import { Options } from "./options/base.mjs";
+import { options } from "./options/index.mjs";
+import { generateDefaultErrors } from "./error/default.mjs";
+import { DefaultError, DefaultErrorTypes, ErrorDefinition, ErrorHandler, ErrorHandlerOptions, ErrorRegistry } from "./error/index.mjs";
+import { TextResponse } from "./response/text/index.mjs";
+import { AnyResponseHandler, ResolveOptionsMeta, ResponseHandler, createResponseHandler } from "./handler.mjs";
+import { responseSymbol } from "./symbol.mjs";
+export { AnyObject, AnyResponseHandler, BaseResponse, Binary, BinaryOptions, BinaryResponse, DefaultError, DefaultErrorTypes, DefaultMeta, DefaultResponse, ErrorDefinition, ErrorHandler, ErrorHandlerOptions, ErrorOptions, ErrorRegistry, ErrorResponse, FunctionObject, Headers, JsonOptions, JsonResponse, MetaOptions, Options, PromiseOr, RawHeaders, ResolveOptionsMeta, ResponseHandler, ResponseTypes, TextResponse, binary, createResponseHandler, error, generateDefaultErrors, json, meta, options, resolveHeaders, responseSymbol };

package/dist/index.mjs

@@ -0,0 +1,18 @@
+import { generateDefaultErrors } from "./error/default.mjs";
+import { resolveHeaders } from "./headers.mjs";
+import { json } from "./options/json.mjs";
+import { meta } from "./options/meta.mjs";
+import { error } from "./options/error.mjs";
+import { binary } from "./options/binary.mjs";
+import { options } from "./options/index.mjs";
+import { BaseResponse } from "./response/base.mjs";
+import { BinaryResponse } from "./response/binary/index.mjs";
+import { ErrorResponse } from "./response/error/index.mjs";
+import { JsonResponse } from "./response/json/index.mjs";
+import { TextResponse } from "./response/text/index.mjs";
+import { ResponseHandler, createResponseHandler } from "./handler.mjs";
+import { responseSymbol } from "./symbol.mjs";
+import "./response/index.mjs";
+import "./error/index.mjs";
+
+export { BaseResponse, BinaryResponse, ErrorResponse, JsonResponse, ResponseHandler, TextResponse, binary, createResponseHandler, error, generateDefaultErrors, json, meta, options, resolveHeaders, responseSymbol };

package/dist/options/base.d.mts

@@ -0,0 +1,28 @@
+import { PromiseOr } from "../types.mjs";
+import { MetaOptions } from "./meta.mjs";
+import { Headers } from "../headers.mjs";
+import { ErrorOptions } from "./error.mjs";
+import { BaseResponse, ResponseTypes } from "../response/base.mjs";
+import { JsonOptions } from "./json.mjs";
+import { Binary } from "../response/binary/index.mjs";
+import { BinaryOptions } from "./binary.mjs";
+import { DefaultResponse } from "../response/default.mjs";
+
+//#region src/options/base.d.ts
+interface Options<TMeta extends MetaOptions.Base = MetaOptions.Base, TError extends ErrorOptions.Base = ErrorOptions.Base, TJson extends JsonOptions.Base = JsonOptions.Base, TBinary extends BinaryOptions.Base = BinaryOptions.Base> {
+  headers?: Headers<{
+    type: ResponseTypes;
+    data: any;
+  }>;
+  meta?: TMeta;
+  error?: TError;
+  json?: TJson;
+  binary?: TBinary;
+  mapResponse?(data: {
+    data: JsonOptions.InferedSchemaFromBase<TJson> | Binary | string;
+    error: ErrorOptions.InferedSchemaFromBase<TError>;
+    response: BaseResponse.Base<DefaultResponse>;
+  }): PromiseOr<Response>;
+}
+//#endregion
+export { Options };

package/dist/options/binary.d.mts

@@ -0,0 +1,13 @@
+import { Headers } from "../headers.mjs";
+import { Binary } from "../response/binary/index.mjs";
+
+//#region src/options/binary.d.ts
+declare namespace BinaryOptions {
+  interface Base {
+    headers?: Headers<Binary>;
+    mapData?: (data: Binary) => Binary;
+  }
+}
+declare function binary<T extends BinaryOptions.Base>(opts: T): T;
+//#endregion
+export { BinaryOptions, binary };

package/dist/options/binary.mjs

@@ -0,0 +1,7 @@
+//#region src/options/binary.ts
+function binary(opts) {
+	return opts;
+}
+
+//#endregion
+export { binary };