@duplojs/http 0.1.0

package/dist/core/index.cjs

@@ -0,0 +1,141 @@
+'use strict';
+
+var checker = require('./builders/checker.cjs');
+var builder = require('./builders/route/builder.cjs');
+require('./builders/route/handler.cjs');
+require('./builders/route/cut.cjs');
+require('./builders/route/extract.cjs');
+require('./builders/route/checker.cjs');
+require('./builders/route/process.cjs');
+require('./builders/route/presetChecker.cjs');
+var store = require('./builders/route/store.cjs');
+var builder$1 = require('./builders/process/builder.cjs');
+require('./builders/process/cut.cjs');
+require('./builders/process/extract.cjs');
+require('./builders/process/checker.cjs');
+require('./builders/process/process.cjs');
+require('./builders/process/export.cjs');
+require('./builders/process/presetChecker.cjs');
+var builder$2 = require('./builders/preflight/builder.cjs');
+require('./builders/preflight/process.cjs');
+require('./builders/preflight/route.cjs');
+var index = require('./response/index.cjs');
+var index$1 = require('./route/index.cjs');
+var kind = require('./steps/kind.cjs');
+var identifier = require('./steps/identifier.cjs');
+var checker$1 = require('./steps/checker.cjs');
+var extract = require('./steps/extract.cjs');
+var cut = require('./steps/cut.cjs');
+var handler = require('./steps/handler.cjs');
+var process = require('./steps/process.cjs');
+var presetChecker = require('./steps/presetChecker.cjs');
+var checker$2 = require('./checker.cjs');
+var kind$1 = require('./kind.cjs');
+var index$3 = require('./process/index.cjs');
+var request = require('./request.cjs');
+var presetChecker$1 = require('./presetChecker.cjs');
+var index$4 = require('./hub/index.cjs');
+var build = require('./functionsBuilders/route/build.cjs');
+var create = require('./functionsBuilders/route/create.cjs');
+var _default = require('./functionsBuilders/route/default.cjs');
+var hook = require('./functionsBuilders/route/hook.cjs');
+var create$1 = require('./functionsBuilders/steps/create.cjs');
+var checkerStep = require('./functionsBuilders/steps/defaults/checkerStep.cjs');
+var cutStep = require('./functionsBuilders/steps/defaults/cutStep.cjs');
+var handlerStep = require('./functionsBuilders/steps/defaults/handlerStep.cjs');
+var extractStep = require('./functionsBuilders/steps/defaults/extractStep.cjs');
+var processStep = require('./functionsBuilders/steps/defaults/processStep.cjs');
+var build$1 = require('./functionsBuilders/steps/build.cjs');
+var index$5 = require('./router/index.cjs');
+var stringIdentifier = require('./stringIdentifier.cjs');
+var contract = require('./response/contract.cjs');
+var response = require('./route/hooks/response.cjs');
+var index$2 = require('./route/hooks/index.cjs');
+var hooks = require('./hub/hooks.cjs');
+var defaultNotfoundHandler = require('./hub/defaultNotfoundHandler.cjs');
+var defaultExtractContract = require('./hub/defaultExtractContract.cjs');
+var pathToRegExp = require('./router/pathToRegExp.cjs');
+var buildError = require('./router/buildError.cjs');
+var decodeUrl = require('./router/decodeUrl.cjs');
+
+
+
+exports.checkerBuilder = checker.checkerBuilder;
+exports.useCheckerBuilder = checker.useCheckerBuilder;
+exports.routeBuilderHandler = builder.routeBuilderHandler;
+exports.useRouteBuilder = builder.useRouteBuilder;
+exports.routeStore = store.routeStore;
+exports.processBuilder = builder$1.processBuilder;
+exports.useProcessBuilder = builder$1.useProcessBuilder;
+exports.preflightBuilder = builder$2.preflightBuilder;
+exports.usePreflightBuilder = builder$2.usePreflightBuilder;
+exports.Response = index.Response;
+exports.createRoute = index$1.createRoute;
+exports.routeKind = index$1.routeKind;
+exports.stepKind = kind.stepKind;
+exports.stepIdentifier = identifier.stepIdentifier;
+exports.checkerStepKind = checker$1.checkerStepKind;
+exports.createCheckerStep = checker$1.createCheckerStep;
+exports.createExtractStep = extract.createExtractStep;
+exports.extractStepKind = extract.extractStepKind;
+exports.createCutStep = cut.createCutStep;
+exports.cutStepKind = cut.cutStepKind;
+exports.cutStepOutputKind = cut.cutStepOutputKind;
+exports.createHandlerStep = handler.createHandlerStep;
+exports.handlerStepKind = handler.handlerStepKind;
+exports.createProcessStep = process.createProcessStep;
+exports.processStepKind = process.processStepKind;
+exports.createPresetCheckerStep = presetChecker.createPresetCheckerStep;
+exports.presetCheckerStepKind = presetChecker.presetCheckerStepKind;
+exports.checkerKind = checker$2.checkerKind;
+exports.checkerOutputKind = checker$2.checkerOutputKind;
+exports.createChecker = checker$2.createChecker;
+exports.createCoreLibKind = kind$1.createCoreLibKind;
+exports.createProcess = index$3.createProcess;
+exports.processKind = index$3.processKind;
+exports.Request = request.Request;
+exports.createPresetChecker = presetChecker$1.createPresetChecker;
+exports.presetCheckerKind = presetChecker$1.presetCheckerKind;
+exports.createHub = index$4.createHub;
+exports.hubKind = index$4.hubKind;
+exports.buildRouteFunction = build.buildRouteFunction;
+exports.createRouteFunctionBuilder = create.createRouteFunctionBuilder;
+exports.defaultRouteFunctionBuilder = _default.defaultRouteFunctionBuilder;
+exports.buildHookAfter = hook.buildHookAfter;
+exports.buildHookBefore = hook.buildHookBefore;
+exports.buildHookErrorBefore = hook.buildHookErrorBefore;
+exports.createHookResponse = hook.createHookResponse;
+exports.exitHookFunction = hook.exitHookFunction;
+exports.nextHookFunction = hook.nextHookFunction;
+exports.createStepFunctionBuilder = create$1.createStepFunctionBuilder;
+exports.defaultCheckerStepFunctionBuilder = checkerStep.defaultCheckerStepFunctionBuilder;
+exports.defaultCutStepFunctionBuilder = cutStep.defaultCutStepFunctionBuilder;
+exports.defaultHandlerStepFunctionBuilder = handlerStep.defaultHandlerStepFunctionBuilder;
+exports.defaultExtractStepFunctionBuilder = extractStep.defaultExtractStepFunctionBuilder;
+exports.buildStepsFunction = processStep.buildStepsFunction;
+exports.defaultProcessStepFunctionBuilder = processStep.defaultProcessStepFunctionBuilder;
+exports.buildStepFunction = build$1.buildStepFunction;
+exports.buildRouter = index$5.buildRouter;
+exports.createCoreLibStringIdentifier = stringIdentifier.createCoreLibStringIdentifier;
+Object.defineProperty(exports, "ResponseContract", {
+	enumerable: true,
+	get: function () { return contract.ResponseContract; }
+});
+exports.HookResponse = response.HookResponse;
+exports.createHookRouteLifeCycle = index$2.createHookRouteLifeCycle;
+exports.hookRouteExitKind = index$2.hookRouteExitKind;
+exports.hookRouteNextKind = index$2.hookRouteNextKind;
+exports.hookServerExitKind = hooks.hookServerExitKind;
+exports.hookServerNextKind = hooks.hookServerNextKind;
+exports.launchHookBeforeBuildRoute = hooks.launchHookBeforeBuildRoute;
+exports.launchHookServer = hooks.launchHookServer;
+exports.launchHookServerError = hooks.launchHookServerError;
+exports.serverErrorExitHookFunction = hooks.serverErrorExitHookFunction;
+exports.serverErrorNextHookFunction = hooks.serverErrorNextHookFunction;
+exports.defaultNotfoundHandler = defaultNotfoundHandler.defaultNotfoundHandler;
+exports.defaultExtractContract = defaultExtractContract.defaultExtractContract;
+exports.pathToRegExp = pathToRegExp.pathToRegExp;
+exports.RouterBuildError = buildError.RouterBuildError;
+exports.decodeUrl = decodeUrl.decodeUrl;
+exports.regexQueryAnalyser = decodeUrl.regexQueryAnalyser;
+exports.regexUrlAnalyser = decodeUrl.regexUrlAnalyser;

package/dist/core/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./types";
+export * from "./builders";
+export * from "./response";
+export * from "./route";
+export * from "./steps";
+export * from "./checker";
+export * from "./floor";
+export * from "./kind";
+export * from "./process";
+export * from "./request";
+export * from "./presetChecker";
+export * from "./hub";
+export * from "./functionsBuilders";
+export * from "./router";
+export * from "./stringIdentifier";

package/dist/core/index.mjs

@@ -0,0 +1,57 @@
+export { checkerBuilder, useCheckerBuilder } from './builders/checker.mjs';
+export { routeBuilderHandler, useRouteBuilder } from './builders/route/builder.mjs';
+import './builders/route/handler.mjs';
+import './builders/route/cut.mjs';
+import './builders/route/extract.mjs';
+import './builders/route/checker.mjs';
+import './builders/route/process.mjs';
+import './builders/route/presetChecker.mjs';
+export { routeStore } from './builders/route/store.mjs';
+export { processBuilder, useProcessBuilder } from './builders/process/builder.mjs';
+import './builders/process/cut.mjs';
+import './builders/process/extract.mjs';
+import './builders/process/checker.mjs';
+import './builders/process/process.mjs';
+import './builders/process/export.mjs';
+import './builders/process/presetChecker.mjs';
+export { preflightBuilder, usePreflightBuilder } from './builders/preflight/builder.mjs';
+import './builders/preflight/process.mjs';
+import './builders/preflight/route.mjs';
+export { Response } from './response/index.mjs';
+export { createRoute, routeKind } from './route/index.mjs';
+export { stepKind } from './steps/kind.mjs';
+export { stepIdentifier } from './steps/identifier.mjs';
+export { checkerStepKind, createCheckerStep } from './steps/checker.mjs';
+export { createExtractStep, extractStepKind } from './steps/extract.mjs';
+export { createCutStep, cutStepKind, cutStepOutputKind } from './steps/cut.mjs';
+export { createHandlerStep, handlerStepKind } from './steps/handler.mjs';
+export { createProcessStep, processStepKind } from './steps/process.mjs';
+export { createPresetCheckerStep, presetCheckerStepKind } from './steps/presetChecker.mjs';
+export { checkerKind, checkerOutputKind, createChecker } from './checker.mjs';
+export { createCoreLibKind } from './kind.mjs';
+export { createProcess, processKind } from './process/index.mjs';
+export { Request } from './request.mjs';
+export { createPresetChecker, presetCheckerKind } from './presetChecker.mjs';
+export { createHub, hubKind } from './hub/index.mjs';
+export { buildRouteFunction } from './functionsBuilders/route/build.mjs';
+export { createRouteFunctionBuilder } from './functionsBuilders/route/create.mjs';
+export { defaultRouteFunctionBuilder } from './functionsBuilders/route/default.mjs';
+export { buildHookAfter, buildHookBefore, buildHookErrorBefore, createHookResponse, exitHookFunction, nextHookFunction } from './functionsBuilders/route/hook.mjs';
+export { createStepFunctionBuilder } from './functionsBuilders/steps/create.mjs';
+export { defaultCheckerStepFunctionBuilder } from './functionsBuilders/steps/defaults/checkerStep.mjs';
+export { defaultCutStepFunctionBuilder } from './functionsBuilders/steps/defaults/cutStep.mjs';
+export { defaultHandlerStepFunctionBuilder } from './functionsBuilders/steps/defaults/handlerStep.mjs';
+export { defaultExtractStepFunctionBuilder } from './functionsBuilders/steps/defaults/extractStep.mjs';
+export { buildStepsFunction, defaultProcessStepFunctionBuilder } from './functionsBuilders/steps/defaults/processStep.mjs';
+export { buildStepFunction } from './functionsBuilders/steps/build.mjs';
+export { buildRouter } from './router/index.mjs';
+export { createCoreLibStringIdentifier } from './stringIdentifier.mjs';
+export { ResponseContract } from './response/contract.mjs';
+export { HookResponse } from './route/hooks/response.mjs';
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './route/hooks/index.mjs';
+export { hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction } from './hub/hooks.mjs';
+export { defaultNotfoundHandler } from './hub/defaultNotfoundHandler.mjs';
+export { defaultExtractContract } from './hub/defaultExtractContract.mjs';
+export { pathToRegExp } from './router/pathToRegExp.mjs';
+export { RouterBuildError } from './router/buildError.mjs';
+export { decodeUrl, regexQueryAnalyser, regexUrlAnalyser } from './router/decodeUrl.mjs';

package/dist/core/kind.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+const createCoreLibKind = utils.createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsHttpCore");
+
+exports.createCoreLibKind = createCoreLibKind;

package/dist/core/kind.d.ts

@@ -0,0 +1,6 @@
+declare module "@duplojs/utils" {
+    interface ReservedKindNamespace {
+        DuplojsHttpCore: true;
+    }
+}
+export declare const createCoreLibKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("@duplojs/utils/string").ForbiddenString<GenericName, "@" | "/">) => import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<`@DuplojsHttpCore/${GenericName}`, GenericKindValue>>;

package/dist/core/kind.mjs

@@ -0,0 +1,7 @@
+import { createKindNamespace } from '@duplojs/utils';
+
+const createCoreLibKind = createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsHttpCore");
+
+export { createCoreLibKind };

package/dist/core/presetChecker.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('./kind.cjs');
+
+const presetCheckerKind = kind.createCoreLibKind("preset-checker");
+function createPresetChecker(checker, { otherwise, ...definition }) {
+    return utils.pipe({
+        definition: {
+            ...definition,
+            checker,
+            responseContract: otherwise,
+        },
+        indexing(indexing) {
+            return createPresetChecker(checker, {
+                ...definition,
+                indexing,
+                otherwise,
+            });
+        },
+        rewriteInput(rewriteInput) {
+            return createPresetChecker(checker, {
+                ...definition,
+                rewriteInput,
+                otherwise,
+            });
+        },
+        options(options) {
+            return createPresetChecker(checker, {
+                ...definition,
+                options,
+                otherwise,
+            });
+        },
+    }, presetCheckerKind.setTo);
+}
+
+exports.createPresetChecker = createPresetChecker;
+exports.presetCheckerKind = presetCheckerKind;

package/dist/core/presetChecker.d.ts

@@ -0,0 +1,38 @@
+import { type O, type Kind, type MaybeArray, type AnyFunction } from "@duplojs/utils";
+import { type GetCheckerInput, type Checker, type GetCheckerOptions, type GetCheckerResult } from "./checker";
+import { type ClientErrorResponseCode, type ResponseContract } from "./response";
+export interface PresetCheckerDefinition {
+    readonly checker: Checker;
+    readonly result: string | readonly string[];
+    readonly indexing?: string;
+    rewriteInput?(input: unknown): unknown;
+    readonly options?: Record<string, unknown>;
+    readonly responseContract: ResponseContract.Contract<ClientErrorResponseCode>;
+}
+export declare const presetCheckerKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/preset-checker", unknown>>;
+export interface PresetChecker<GenericDefinition extends PresetCheckerDefinition = PresetCheckerDefinition> extends Kind<typeof presetCheckerKind.definition> {
+    readonly definition: GenericDefinition;
+    indexing<GenericIndex extends string>(indexing: GenericIndex): PresetChecker<O.AssignObjects<GenericDefinition, {
+        readonly indexing: GenericIndex;
+    }>>;
+    rewriteInput<GenericInput extends unknown>(rewriteInput: (input: GenericInput) => GetCheckerInput<GenericDefinition["checker"]>): PresetChecker<O.AssignObjects<GenericDefinition, {
+        rewriteInput(input: GenericInput): GetCheckerInput<GenericDefinition["checker"]>;
+    }>>;
+    options<const GenericOptions extends GetCheckerOptions<GenericDefinition["checker"]>>(options: GenericOptions): PresetChecker<O.AssignObjects<GenericDefinition, {
+        readonly options: GenericOptions;
+    }>>;
+}
+export declare function createPresetChecker<GenericChecker extends Checker, const GenericDefinition extends {
+    result: MaybeArray<Awaited<GetCheckerResult<GenericChecker>>["information"]>;
+    indexing?: string;
+    rewriteInput?(input: unknown): GetCheckerInput<GenericChecker>;
+    options?: GetCheckerOptions<GenericChecker>;
+    otherwise: ResponseContract.Contract<ClientErrorResponseCode>;
+}>(checker: GenericChecker, { otherwise, ...definition }: GenericDefinition): PresetChecker<O.AssignObjects<Omit<GenericDefinition, "otherwise">, {
+    readonly checker: GenericChecker;
+    readonly responseContract: GenericDefinition["otherwise"];
+}>>;
+export type GetPresetCheckerInput<GenericPresetChecker extends PresetChecker> = GenericPresetChecker["definition"]["rewriteInput"] extends AnyFunction ? Parameters<GenericPresetChecker["definition"]["rewriteInput"]>[0] : Parameters<GenericPresetChecker["definition"]["checker"]["definition"]["theFunction"]>[0];
+export type GetPresetCheckerResult<GenericPresetChecker extends PresetChecker> = ReturnType<GenericPresetChecker["definition"]["checker"]["definition"]["theFunction"]>;
+export type GetPresetCheckerIndex<GenericPresetChecker extends PresetChecker> = GenericPresetChecker["definition"]["indexing"] extends string ? GenericPresetChecker["definition"]["indexing"] : never;
+export type GetPresetCheckerInformation<GenericPresetChecker extends PresetChecker> = GenericPresetChecker["definition"]["result"];

package/dist/core/presetChecker.mjs

@@ -0,0 +1,36 @@
+import { pipe } from '@duplojs/utils';
+import { createCoreLibKind } from './kind.mjs';
+
+const presetCheckerKind = createCoreLibKind("preset-checker");
+function createPresetChecker(checker, { otherwise, ...definition }) {
+    return pipe({
+        definition: {
+            ...definition,
+            checker,
+            responseContract: otherwise,
+        },
+        indexing(indexing) {
+            return createPresetChecker(checker, {
+                ...definition,
+                indexing,
+                otherwise,
+            });
+        },
+        rewriteInput(rewriteInput) {
+            return createPresetChecker(checker, {
+                ...definition,
+                rewriteInput,
+                otherwise,
+            });
+        },
+        options(options) {
+            return createPresetChecker(checker, {
+                ...definition,
+                options,
+                otherwise,
+            });
+        },
+    }, presetCheckerKind.setTo);
+}
+
+export { createPresetChecker, presetCheckerKind };

package/dist/core/process/index.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('../kind.cjs');
+
+const processKind = kind.createCoreLibKind("process");
+function createProcess(definition) {
+    return utils.pipe({ definition }, processKind.setTo);
+}
+
+exports.createProcess = createProcess;
+exports.processKind = processKind;

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

@@ -0,0 +1,31 @@
+import { type IsEqual, type Kind, type O } from "@duplojs/utils";
+import { type ProcessStep, type CheckerStep, type CutStep, type ExtractStep, type stepKind, type PresetCheckerStep } from "../steps";
+import { type Floor } from "../floor";
+import { type HookRouteLifeCycle } from "../route";
+import { type Request } from "../request";
+export * from "./types";
+export interface ProcessStepsCustom {
+}
+export type ProcessSteps = (ProcessStepsCustom[O.GetPropsWithValueExtends<ProcessStepsCustom, Kind<typeof stepKind.definition>>] | CheckerStep | ExtractStep | PresetCheckerStep | CutStep | ProcessStep);
+declare const SymbolProcessExportValue: unique symbol;
+declare const SymbolProcessRequest: unique symbol;
+export interface ProcessDefinition {
+    steps: readonly ProcessSteps[];
+    options?: Record<string, unknown>;
+    readonly hooks: readonly HookRouteLifeCycle[];
+    [SymbolProcessExportValue]?: Floor;
+    [SymbolProcessRequest]?: Request;
+}
+export interface ProcessExportValue<GenericExportValue extends Floor> {
+    [SymbolProcessExportValue]: GenericExportValue;
+}
+export type GetProcessExportValue<GenericProcess extends Process> = IsEqual<GenericProcess["definition"][typeof SymbolProcessExportValue], unknown> extends true ? never : GenericProcess["definition"][typeof SymbolProcessExportValue];
+export interface ProcessRequest<GenericRequest extends Request> {
+    [SymbolProcessRequest]: GenericRequest;
+}
+export type GetProcessRequest<GenericProcess extends Process> = IsEqual<GenericProcess["definition"][typeof SymbolProcessRequest], unknown> extends true ? never : GenericProcess["definition"][typeof SymbolProcessRequest];
+export declare const processKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process", unknown>>;
+export interface Process<GenericDefinition extends ProcessDefinition = ProcessDefinition> extends Kind<typeof processKind.definition> {
+    definition: GenericDefinition;
+}
+export declare function createProcess<GenericDefinition extends Pick<ProcessDefinition, "steps" | "options" | "hooks">>(definition: GenericDefinition): Process<GenericDefinition>;

package/dist/core/process/index.mjs

@@ -0,0 +1,9 @@
+import { pipe } from '@duplojs/utils';
+import { createCoreLibKind } from '../kind.mjs';
+
+const processKind = createCoreLibKind("process");
+function createProcess(definition) {
+    return pipe({ definition }, processKind.setTo);
+}
+
+export { createProcess, processKind };

package/dist/core/process/types/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/request.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('./kind.cjs');
+
+class Request extends utils.kindHeritage("request", kind.createCoreLibKind("request")) {
+    method;
+    headers;
+    url;
+    host;
+    origin;
+    path;
+    params;
+    query;
+    matchedPath;
+    body = undefined;
+    constructor({ method, headers, url, host, origin, path, params, query, matchedPath, ...rest }) {
+        super();
+        this.method = method;
+        this.headers = headers;
+        this.url = url;
+        this.host = host;
+        this.origin = origin;
+        this.path = path;
+        this.params = params;
+        this.query = query;
+        this.matchedPath = matchedPath;
+        for (const key in rest) {
+            this[key] = rest[key];
+        }
+    }
+}
+
+exports.Request = Request;

package/dist/core/request.d.ts

@@ -0,0 +1,40 @@
+import { type GetPropsWithValue } from "@duplojs/utils/object";
+export interface RequestMethodsWrapper {
+    GET: true;
+    POST: true;
+    PUT: true;
+    DELETE: true;
+    HEAD: true;
+    OPTIONS: true;
+    TRACE: true;
+    CONNECT: true;
+}
+export type RequestMethods = GetPropsWithValue<RequestMethodsWrapper, true>;
+export interface RequestInitializationData {
+    readonly headers: Partial<Record<string, string | string[]>>;
+    readonly host: string;
+    readonly matchedPath: string | null;
+    readonly method: string;
+    readonly origin: string;
+    readonly params: Record<string, string>;
+    readonly path: string;
+    readonly query: Record<string, string | string[]>;
+    readonly url: string;
+}
+declare const Request_base: new (params?: {
+    "@DuplojsHttpCore/request"?: unknown;
+} | undefined) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/request", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"request", unknown>, unknown>;
+export declare class Request extends Request_base implements RequestInitializationData {
+    method: string;
+    headers: Partial<Record<string, string | string[]>>;
+    url: string;
+    host: string;
+    origin: string;
+    path: string;
+    params: Record<string, string>;
+    query: Record<string, string | string[]>;
+    matchedPath: string | null;
+    body: unknown;
+    constructor({ method, headers, url, host, origin, path, params, query, matchedPath, ...rest }: RequestInitializationData);
+}
+export {};

package/dist/core/request.mjs

@@ -0,0 +1,32 @@
+import { kindHeritage } from '@duplojs/utils';
+import { createCoreLibKind } from './kind.mjs';
+
+class Request extends kindHeritage("request", createCoreLibKind("request")) {
+    method;
+    headers;
+    url;
+    host;
+    origin;
+    path;
+    params;
+    query;
+    matchedPath;
+    body = undefined;
+    constructor({ method, headers, url, host, origin, path, params, query, matchedPath, ...rest }) {
+        super();
+        this.method = method;
+        this.headers = headers;
+        this.url = url;
+        this.host = host;
+        this.origin = origin;
+        this.path = path;
+        this.params = params;
+        this.query = query;
+        this.matchedPath = matchedPath;
+        for (const key in rest) {
+            this[key] = rest[key];
+        }
+    }
+}
+
+export { Request };

package/dist/core/response/contract.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('../kind.cjs');
+
+const errorClass = Error;
+exports.ResponseContract = void 0;
+(function (ResponseContract) {
+    ResponseContract.contractKind = kind.createCoreLibKind("response-contract");
+    function createContractBuilder(code, options) {
+        return (information, ...[schema]) => utils.pipe({
+            code,
+            information,
+            schema: (schema ?? options?.defaultSchema ?? utils.DP.empty()),
+        }, ResponseContract.contractKind.setTo);
+    }
+    const defaultSchema = utils.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 utils.kindHeritage("contract-error", kind.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;
+})(exports.ResponseContract || (exports.ResponseContract = {}));