@duplojs/http 0.1.0

package/dist/core/response/contract.d.ts

@@ -0,0 +1,291 @@
+import { DP, type Kind, type NeverCoalescing } from "@duplojs/utils";
+import { type ResponseCode, type Response } from ".";
+export declare namespace ResponseContract {
+    export const contractKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/response-contract", unknown>>;
+    export interface Contract<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericSchema extends DP.DataParser = DP.DataParser> extends Kind<typeof contractKind.definition> {
+        code: GenericCode;
+        information: GenericInformation;
+        schema: GenericSchema;
+    }
+    export type Convert<GenericContract extends Contract> = GenericContract extends Contract ? Response<GenericContract["code"], GenericContract["information"], DP.Input<GenericContract["schema"]>> : never;
+    export const http100Continue: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"100", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const switchingProtocols: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"101", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const processing: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"102", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const earlyHints: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"103", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const ok: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation, schema: GenericSchema) => NoInfer<Contract<"200", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const created: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"201", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const accepted: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"202", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const nonAuthoritativeInformation: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"203", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const noContent: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"204", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const resetContent: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"205", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const partialContent: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"206", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const multiStatus: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"207", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const alreadyReported: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"208", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const imUsed: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"226", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const multipleChoices: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"300", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const movedPermanently: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"301", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const found: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"302", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const seeOther: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"303", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const notModified: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"304", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const useProxy: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"305", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const switchProxy: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"306", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const temporaryRedirect: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"307", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const permanentRedirect: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"308", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const badRequest: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"400", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const unauthorized: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"401", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const paymentRequired: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"402", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const forbidden: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"403", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const notFound: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"404", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const methodNotAllowed: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"405", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const notAcceptable: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"406", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const proxyAuthenticationRequired: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"407", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const requestTimeout: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"408", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const conflict: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"409", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const gone: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"410", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const lengthRequired: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"411", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const preconditionFailed: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"412", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const contentTooLarge: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"413", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const uriTooLong: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"414", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const unsupportedMediaType: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"415", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const rangeNotSatisfiable: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"416", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const expectationFailed: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"417", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const imATeapot: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"418", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const misdirectedRequest: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"421", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const unprocessableContent: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"422", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const locked: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"423", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const failedDependency: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"424", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const tooEarly: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"425", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const upgradeRequired: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"426", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const preconditionRequired: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"428", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const tooManyRequests: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"429", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const requestHeaderFieldsTooLarge: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"431", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const unavailableForLegalReasons: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"451", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const internalServerError: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"500", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const notImplemented: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"501", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const badGateway: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"502", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const serviceUnavailable: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"503", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const gatewayTimeout: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"504", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const httpVersionNotSupported: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"505", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const variantAlsoNegotiates: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"506", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const insufficientStorage: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"507", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const loopDetected: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"508", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const notExtended: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"510", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const networkAuthenticationRequired: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"511", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    const Error_base: new (params: {
+        "@DuplojsHttpCore/contract-error"?: unknown;
+    }, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/contract-error", unknown>, unknown> & Kind<import("@duplojs/utils").KindDefinition<"contract-error", unknown>, unknown> & globalThis.Error;
+    export class Error extends Error_base {
+        information: string;
+        dataParserError?: DP.DataParserError | undefined;
+        constructor(information: string, dataParserError?: DP.DataParserError | undefined);
+    }
+    export {};
+}

package/dist/core/response/contract.mjs

@@ -0,0 +1,91 @@
+import { DP, kindHeritage, pipe } from '@duplojs/utils';
+import { createCoreLibKind } from '../kind.mjs';
+
+const errorClass = Error;
+var ResponseContract;
+(function (ResponseContract) {
+    ResponseContract.contractKind = createCoreLibKind("response-contract");
+    function createContractBuilder(code, options) {
+        return (information, ...[schema]) => pipe({
+            code,
+            information,
+            schema: (schema ?? options?.defaultSchema ?? DP.empty()),
+        }, ResponseContract.contractKind.setTo);
+    }
+    const defaultSchema = DP.empty();
+    ResponseContract.http100Continue = createContractBuilder("100", { defaultSchema });
+    ResponseContract.switchingProtocols = createContractBuilder("101", { defaultSchema });
+    ResponseContract.processing = createContractBuilder("102", { defaultSchema });
+    ResponseContract.earlyHints = createContractBuilder("103", { defaultSchema });
+    ResponseContract.ok = createContractBuilder("200");
+    ResponseContract.created = createContractBuilder("201", { defaultSchema });
+    ResponseContract.accepted = createContractBuilder("202", { defaultSchema });
+    ResponseContract.nonAuthoritativeInformation = createContractBuilder("203", { defaultSchema });
+    ResponseContract.noContent = createContractBuilder("204", { });
+    ResponseContract.resetContent = createContractBuilder("205", { defaultSchema });
+    ResponseContract.partialContent = createContractBuilder("206", { defaultSchema });
+    ResponseContract.multiStatus = createContractBuilder("207", { defaultSchema });
+    ResponseContract.alreadyReported = createContractBuilder("208", { defaultSchema });
+    ResponseContract.imUsed = createContractBuilder("226", { defaultSchema });
+    ResponseContract.multipleChoices = createContractBuilder("300", { });
+    ResponseContract.movedPermanently = createContractBuilder("301", { });
+    ResponseContract.found = createContractBuilder("302", { });
+    ResponseContract.seeOther = createContractBuilder("303", { });
+    ResponseContract.notModified = createContractBuilder("304", { });
+    ResponseContract.useProxy = createContractBuilder("305", { });
+    ResponseContract.switchProxy = createContractBuilder("306", { });
+    ResponseContract.temporaryRedirect = createContractBuilder("307", { });
+    ResponseContract.permanentRedirect = createContractBuilder("308", { });
+    ResponseContract.badRequest = createContractBuilder("400", { defaultSchema });
+    ResponseContract.unauthorized = createContractBuilder("401", { defaultSchema });
+    ResponseContract.paymentRequired = createContractBuilder("402", { defaultSchema });
+    ResponseContract.forbidden = createContractBuilder("403", { defaultSchema });
+    ResponseContract.notFound = createContractBuilder("404", { defaultSchema });
+    ResponseContract.methodNotAllowed = createContractBuilder("405", { defaultSchema });
+    ResponseContract.notAcceptable = createContractBuilder("406", { defaultSchema });
+    ResponseContract.proxyAuthenticationRequired = createContractBuilder("407", { defaultSchema });
+    ResponseContract.requestTimeout = createContractBuilder("408", { defaultSchema });
+    ResponseContract.conflict = createContractBuilder("409", { defaultSchema });
+    ResponseContract.gone = createContractBuilder("410", { defaultSchema });
+    ResponseContract.lengthRequired = createContractBuilder("411", { defaultSchema });
+    ResponseContract.preconditionFailed = createContractBuilder("412", { defaultSchema });
+    ResponseContract.contentTooLarge = createContractBuilder("413", { defaultSchema });
+    ResponseContract.uriTooLong = createContractBuilder("414", { defaultSchema });
+    ResponseContract.unsupportedMediaType = createContractBuilder("415", { defaultSchema });
+    ResponseContract.rangeNotSatisfiable = createContractBuilder("416", { defaultSchema });
+    ResponseContract.expectationFailed = createContractBuilder("417", { defaultSchema });
+    ResponseContract.imATeapot = createContractBuilder("418", { defaultSchema });
+    ResponseContract.misdirectedRequest = createContractBuilder("421", { defaultSchema });
+    ResponseContract.unprocessableContent = createContractBuilder("422", { defaultSchema });
+    ResponseContract.locked = createContractBuilder("423", { defaultSchema });
+    ResponseContract.failedDependency = createContractBuilder("424", { defaultSchema });
+    ResponseContract.tooEarly = createContractBuilder("425", { defaultSchema });
+    ResponseContract.upgradeRequired = createContractBuilder("426", { defaultSchema });
+    ResponseContract.preconditionRequired = createContractBuilder("428", { defaultSchema });
+    ResponseContract.tooManyRequests = createContractBuilder("429", { defaultSchema });
+    ResponseContract.requestHeaderFieldsTooLarge = createContractBuilder("431", { defaultSchema });
+    ResponseContract.unavailableForLegalReasons = createContractBuilder("451", { defaultSchema });
+    ResponseContract.internalServerError = createContractBuilder("500", { defaultSchema });
+    ResponseContract.notImplemented = createContractBuilder("501", { defaultSchema });
+    ResponseContract.badGateway = createContractBuilder("502", { defaultSchema });
+    ResponseContract.serviceUnavailable = createContractBuilder("503", { defaultSchema });
+    ResponseContract.gatewayTimeout = createContractBuilder("504", { defaultSchema });
+    ResponseContract.httpVersionNotSupported = createContractBuilder("505", { defaultSchema });
+    ResponseContract.variantAlsoNegotiates = createContractBuilder("506", { defaultSchema });
+    ResponseContract.insufficientStorage = createContractBuilder("507", { defaultSchema });
+    ResponseContract.loopDetected = createContractBuilder("508", { defaultSchema });
+    ResponseContract.notExtended = createContractBuilder("510", { defaultSchema });
+    ResponseContract.networkAuthenticationRequired = createContractBuilder("511", { defaultSchema });
+    class Error extends kindHeritage("contract-error", createCoreLibKind("contract-error"), errorClass) {
+        information;
+        dataParserError;
+        constructor(information, dataParserError) {
+            super({}, [`Error executing the response contract with the information: "${information}".`]);
+            this.information = information;
+            this.dataParserError = dataParserError;
+        }
+    }
+    ResponseContract.Error = Error;
+})(ResponseContract || (ResponseContract = {}));
+
+export { ResponseContract };

package/dist/core/response/index.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('../kind.cjs');
+var contract = require('./contract.cjs');
+
+class Response extends utils.kindHeritage("response", kind.createCoreLibKind("response")) {
+    code;
+    information;
+    body;
+    headers = undefined;
+    constructor(code, information, body) {
+        super();
+        this.code = code;
+        this.information = information;
+        this.body = body;
+    }
+    setHeaders(headers) {
+        this.headers = utils.O.override(this.headers ?? {}, headers);
+        return this;
+    }
+    setHeader(key, header) {
+        if (!this.headers) {
+            this.headers = {};
+        }
+        if (typeof header !== "undefined") {
+            this.headers[key] = header;
+        }
+        return this;
+    }
+    deleteHeader(key) {
+        if (!this.headers) {
+            return this;
+        }
+        const { [key]: deleteHeader, ...rest } = this.headers;
+        this.headers = rest;
+        return this;
+    }
+}
+
+Object.defineProperty(exports, "ResponseContract", {
+    enumerable: true,
+    get: function () { return contract.ResponseContract; }
+});
+exports.Response = Response;

package/dist/core/response/index.d.ts

@@ -0,0 +1,21 @@
+import { type S } from "@duplojs/utils";
+export * from "./contract";
+export type InformationResponseCode = `1${S.Digit}${S.Digit}`;
+export type SuccessResponseCode = `2${S.Digit}${S.Digit}`;
+export type RedirectionResponseCode = `3${S.Digit}${S.Digit}`;
+export type ClientErrorResponseCode = `4${S.Digit}${S.Digit}`;
+export type ServerErrorResponseCode = `5${S.Digit}${S.Digit}`;
+export type ResponseCode = (InformationResponseCode | SuccessResponseCode | RedirectionResponseCode | ClientErrorResponseCode | ServerErrorResponseCode);
+declare const Response_base: new (params?: {
+    "@DuplojsHttpCore/response"?: unknown;
+} | undefined) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"response", unknown>, unknown>;
+export declare class Response<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends Response_base {
+    code: GenericCode;
+    information: GenericInformation;
+    body: GenericBody;
+    headers: Record<string, string | string[]> | undefined;
+    constructor(code: GenericCode, information: GenericInformation, body: GenericBody);
+    setHeaders(headers: Partial<Record<string, string | string[]>>): this;
+    setHeader(key: string, header?: string | string[]): this;
+    deleteHeader(key: string): this;
+}

package/dist/core/response/index.mjs

@@ -0,0 +1,39 @@
+import { kindHeritage, O } from '@duplojs/utils';
+import { createCoreLibKind } from '../kind.mjs';
+export { ResponseContract } from './contract.mjs';
+
+class Response extends kindHeritage("response", createCoreLibKind("response")) {
+    code;
+    information;
+    body;
+    headers = undefined;
+    constructor(code, information, body) {
+        super();
+        this.code = code;
+        this.information = information;
+        this.body = body;
+    }
+    setHeaders(headers) {
+        this.headers = O.override(this.headers ?? {}, headers);
+        return this;
+    }
+    setHeader(key, header) {
+        if (!this.headers) {
+            this.headers = {};
+        }
+        if (typeof header !== "undefined") {
+            this.headers[key] = header;
+        }
+        return this;
+    }
+    deleteHeader(key) {
+        if (!this.headers) {
+            return this;
+        }
+        const { [key]: deleteHeader, ...rest } = this.headers;
+        this.headers = rest;
+        return this;
+    }
+}
+
+export { Response };

package/dist/core/route/hooks/index.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var kind = require('../../kind.cjs');
+var response = require('./response.cjs');
+
+const hookRouteExitKind = kind.createCoreLibKind("route-hook-exit");
+const hookRouteNextKind = kind.createCoreLibKind("route-hook-next");
+function createHookRouteLifeCycle(...args) {
+    if (args.length === 1) {
+        return args[0];
+    }
+    return {
+        ...args[1],
+        onConstructRequest: args[0],
+    };
+}
+
+exports.HookResponse = response.HookResponse;
+exports.createHookRouteLifeCycle = createHookRouteLifeCycle;
+exports.hookRouteExitKind = hookRouteExitKind;
+exports.hookRouteNextKind = hookRouteNextKind;

package/dist/core/route/hooks/index.d.ts

@@ -0,0 +1,61 @@
+import { type Request } from "../../request";
+import { type UnionToIntersection, type AnyFunction, type Kind, type MaybePromise, type SimplifyTopLevel, type IsEqual } from "@duplojs/utils";
+import { type HookResponse } from "./response";
+import { type ResponseCode, type Response } from "../../response";
+export * from "./response";
+export interface HookParamsOnConstructRequest {
+    request: Request;
+    addRequestProperties<GenericNewProperties extends Record<string, unknown>>(newProperties: GenericNewProperties): Request & GenericNewProperties;
+}
+export type HookOnConstructRequest<GenericRequest extends Request = Request> = (params: HookParamsOnConstructRequest) => MaybePromise<GenericRequest>;
+export declare const hookRouteExitKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-exit", unknown>>;
+export interface RouteHookExit extends Kind<typeof hookRouteExitKind.definition> {
+}
+export declare const hookRouteNextKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>>;
+export interface RouteHookNext extends Kind<typeof hookRouteNextKind.definition> {
+}
+export interface RouteHookParams<GenericRequest extends Request = Request> {
+    readonly request: GenericRequest;
+    next(): RouteHookNext;
+    exit(): RouteHookExit;
+    response<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown>(code: GenericCode, information: GenericInformation, body?: GenericBody): HookResponse<GenericCode, GenericInformation, GenericBody | undefined>;
+}
+export type HookBeforeRouteExecution<GenericRequest extends Request = Request> = (params: RouteHookParams<GenericRequest>) => MaybePromise<HookResponse | RouteHookExit | RouteHookNext>;
+export type HookParseBody<GenericRequest extends Request = Request> = (params: RouteHookParams<GenericRequest>) => MaybePromise<HookResponse | RouteHookExit | RouteHookNext>;
+export interface RouteHookErrorParams<GenericRequest extends Request = Request> {
+    readonly request: GenericRequest;
+    readonly error: unknown;
+    next(): RouteHookNext;
+    exit(): RouteHookExit;
+    response<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown>(code: GenericCode, information: GenericInformation, body?: GenericBody): HookResponse<GenericCode, GenericInformation, GenericBody | undefined>;
+}
+export type HookError = (params: RouteHookErrorParams<Request>) => MaybePromise<HookResponse | RouteHookExit | RouteHookNext>;
+export interface RouteHookParamsAfter<GenericRequest extends Request = Request> {
+    readonly request: GenericRequest;
+    readonly currentResponse: Response;
+    next(): RouteHookNext;
+    exit(): RouteHookExit;
+}
+export type HookBeforeSendResponse<GenericRequest extends Request = Request> = (params: RouteHookParamsAfter<GenericRequest>) => MaybePromise<RouteHookExit | RouteHookNext>;
+export type HookSendResponse<GenericRequest extends Request = Request> = (params: RouteHookParamsAfter<GenericRequest>) => MaybePromise<RouteHookExit | RouteHookNext>;
+export type HookAfterSendResponse<GenericRequest extends Request = Request> = (params: RouteHookParamsAfter<GenericRequest>) => MaybePromise<RouteHookExit | RouteHookNext>;
+export interface HookRouteLifeCycle<GenericRequest extends Request = Request> {
+    onConstructRequest?: HookOnConstructRequest<GenericRequest>;
+    beforeRouteExecution?: HookBeforeRouteExecution<GenericRequest>;
+    parseBody?: HookParseBody<GenericRequest>;
+    error?: HookError;
+    beforeSendResponse?: HookBeforeSendResponse<GenericRequest>;
+    sendResponse?: HookSendResponse<GenericRequest>;
+    afterSendResponse?: HookAfterSendResponse<GenericRequest>;
+}
+export declare function createHookRouteLifeCycle<GenericHookLiveCycle extends Omit<HookRouteLifeCycle, "onConstructRequest">>(hookRouteLifeCycle: GenericHookLiveCycle): GenericHookLiveCycle;
+export declare function createHookRouteLifeCycle<GenericOnConstructRequest extends HookOnConstructRequest, GenericHookLiveCycle extends Omit<HookRouteLifeCycle<Awaited<ReturnType<GenericOnConstructRequest>>>, "onConstructRequest">>(onConstructRequest: GenericOnConstructRequest, hookRouteLifeCycle: GenericHookLiveCycle): SimplifyTopLevel<{
+    onConstructRequest: GenericOnConstructRequest;
+} & GenericHookLiveCycle>;
+export type ExtractRequestFromHooks<GenericHooks extends readonly HookRouteLifeCycle[]> = GenericHooks extends readonly [
+    infer InferredFirst,
+    ...infer InferredRest extends HookRouteLifeCycle[]
+] ? (InferredFirst extends {
+    onConstructRequest: AnyFunction;
+} ? Awaited<ReturnType<InferredFirst["onConstructRequest"]>> : never) extends infer InferredResultFirst ? InferredRest extends readonly [] ? InferredResultFirst : ExtractRequestFromHooks<InferredRest> extends infer InferredResultRest ? InferredResultFirst | InferredResultRest : never : never : never;
+export type MakeRequestFromHooks<GenericHooks extends readonly HookRouteLifeCycle[]> = ExtractRequestFromHooks<GenericHooks> extends infer InferredResult extends Request ? IsEqual<InferredResult, never> extends true ? never : UnionToIntersection<InferredResult> : never;

package/dist/core/route/hooks/index.mjs

@@ -0,0 +1,16 @@
+import { createCoreLibKind } from '../../kind.mjs';
+export { HookResponse } from './response.mjs';
+
+const hookRouteExitKind = createCoreLibKind("route-hook-exit");
+const hookRouteNextKind = createCoreLibKind("route-hook-next");
+function createHookRouteLifeCycle(...args) {
+    if (args.length === 1) {
+        return args[0];
+    }
+    return {
+        ...args[1],
+        onConstructRequest: args[0],
+    };
+}
+
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind };

package/dist/core/route/hooks/response.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var kind = require('../../kind.cjs');
+var index = require('../../response/index.cjs');
+var utils = require('@duplojs/utils');
+
+const defaultParamsParent = [undefined, undefined, undefined];
+const defaultParams = {};
+class HookResponse extends utils.kindHeritage("hook-response", kind.createCoreLibKind("hook-response"), index.Response) {
+    code;
+    information;
+    body;
+    fromHook;
+    constructor(from, code, information, body) {
+        super(defaultParams, defaultParamsParent);
+        this.code = code;
+        this.information = `from-hook-${information}`;
+        this.body = body;
+        this.fromHook = from;
+    }
+}
+
+exports.HookResponse = HookResponse;