@duplojs/http 0.1.0 → 0.4.0

package/dist/core/response/index.cjs

@@ -1,45 +1,16 @@
 'use strict';
 
-var utils = require('@duplojs/utils');
-var kind = require('../kind.cjs');
+var base = require('./base.cjs');
 var contract = require('./contract.cjs');
+var hook = require('./hook.cjs');
+var predicted = require('./predicted.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;
-    }
-}
 
+
+exports.Response = base.Response;
 Object.defineProperty(exports, "ResponseContract", {
-    enumerable: true,
-    get: function () { return contract.ResponseContract; }
+	enumerable: true,
+	get: function () { return contract.ResponseContract; }
 });
-exports.Response = Response;
+exports.HookResponse = hook.HookResponse;
+exports.PredictedResponse = predicted.PredictedResponse;

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

@@ -1,21 +1,4 @@
-import { type S } from "@duplojs/utils";
+export * from "./base";
 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;
-}
+export * from "./hook";
+export * from "./predicted";

package/dist/core/response/index.mjs

@@ -1,39 +1,4 @@
-import { kindHeritage, O } from '@duplojs/utils';
-import { createCoreLibKind } from '../kind.mjs';
+export { Response } from './base.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 };
+export { HookResponse } from './hook.mjs';
+export { PredictedResponse } from './predicted.mjs';

package/dist/core/response/predicted.cjs

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

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

@@ -0,0 +1,11 @@
+import { type ResponseCode, Response } from "../response";
+declare const PredictedResponse_base: new (params: {
+    "@DuplojsHttpCore/predicted-response"?: unknown;
+}, parentParams: [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/predicted-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"predicted-response", unknown>, unknown>;
+export declare class PredictedResponse<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends PredictedResponse_base {
+    code: GenericCode;
+    information: GenericInformation;
+    body: GenericBody;
+    constructor(code: GenericCode, information: GenericInformation, body: GenericBody);
+}
+export {};

package/dist/core/response/predicted.mjs

@@ -0,0 +1,20 @@
+import { createCoreLibKind } from '../kind.mjs';
+import './index.mjs';
+import { kindHeritage } from '@duplojs/utils';
+import { Response } from './base.mjs';
+
+const defaultParamsParent = [undefined, undefined, undefined];
+const defaultParams = {};
+class PredictedResponse extends kindHeritage("predicted-response", createCoreLibKind("predicted-response"), Response) {
+    code;
+    information;
+    body;
+    constructor(code, information, body) {
+        super(defaultParams, defaultParamsParent);
+        this.code = code;
+        this.information = information;
+        this.body = body;
+    }
+}
+
+export { PredictedResponse };

package/dist/core/route/{hooks/index.cjs → hooks.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var kind = require('../../kind.cjs');
-var response = require('./response.cjs');
+var kind = require('../kind.cjs');
+require('../response/index.cjs');
 
 const hookRouteExitKind = kind.createCoreLibKind("route-hook-exit");
 const hookRouteNextKind = kind.createCoreLibKind("route-hook-next");
@@ -15,7 +15,6 @@ function createHookRouteLifeCycle(...args) {
     };
 }
 
-exports.HookResponse = response.HookResponse;
 exports.createHookRouteLifeCycle = createHookRouteLifeCycle;
 exports.hookRouteExitKind = hookRouteExitKind;
 exports.hookRouteNextKind = hookRouteNextKind;

package/dist/core/route/{hooks/index.d.ts → hooks.d.ts}

@@ -1,8 +1,8 @@
-import { type Request } from "../../request";
+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";
+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;

package/dist/core/route/{hooks/index.mjs → hooks.mjs}

@@ -1,5 +1,5 @@
-import { createCoreLibKind } from '../../kind.mjs';
-export { HookResponse } from './response.mjs';
+import { createCoreLibKind } from '../kind.mjs';
+import '../response/index.mjs';
 
 const hookRouteExitKind = createCoreLibKind("route-hook-exit");
 const hookRouteNextKind = createCoreLibKind("route-hook-next");

package/dist/core/route/index.cjs

@@ -2,15 +2,16 @@
 
 var utils = require('@duplojs/utils');
 var kind = require('../kind.cjs');
-var index = require('./hooks/index.cjs');
+require('./types/index.cjs');
+var hooks = require('./hooks.cjs');
 
 const routeKind = kind.createCoreLibKind("route");
 function createRoute(definition) {
     return utils.pipe({ definition }, routeKind.setTo);
 }
 
-exports.createHookRouteLifeCycle = index.createHookRouteLifeCycle;
-exports.hookRouteExitKind = index.hookRouteExitKind;
-exports.hookRouteNextKind = index.hookRouteNextKind;
+exports.createHookRouteLifeCycle = hooks.createHookRouteLifeCycle;
+exports.hookRouteExitKind = hooks.hookRouteExitKind;
+exports.hookRouteNextKind = hooks.hookRouteNextKind;
 exports.createRoute = createRoute;
 exports.routeKind = routeKind;

package/dist/core/route/index.mjs

@@ -1,6 +1,7 @@
 import { pipe } from '@duplojs/utils';
 import { createCoreLibKind } from '../kind.mjs';
-export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './hooks/index.mjs';
+import './types/index.mjs';
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './hooks.mjs';
 
 const routeKind = createCoreLibKind("route");
 function createRoute(definition) {

package/dist/core/route/types/buildedRoute.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/route/types/buildedRoute.mjs

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,4 @@
+'use strict';
+
+require('./buildedRoute.cjs');
+

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

@@ -0,0 +1 @@
+import './buildedRoute.mjs';

package/dist/core/router/buildError.cjs

@@ -4,9 +4,11 @@ var kind = require('../kind.cjs');
 var utils = require('@duplojs/utils');
 
 class RouterBuildError extends utils.kindHeritage("router-build-error", kind.createCoreLibKind("router-build-error"), Error) {
+    route;
     element;
-    constructor(element) {
+    constructor(route, element) {
         super({}, ["Error during build route."]);
+        this.route = route;
         this.element = element;
     }
 }

package/dist/core/router/buildError.d.ts

@@ -1,9 +1,11 @@
 import { type Route } from "../route";
+import { type Steps } from "../steps";
 declare const RouterBuildError_base: new (params: {
     "@DuplojsHttpCore/router-build-error"?: unknown;
 }, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/router-build-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"router-build-error", unknown>, unknown>;
 export declare class RouterBuildError extends RouterBuildError_base {
-    element: Route;
-    constructor(element: Route);
+    route: Route;
+    element: Route | Steps;
+    constructor(route: Route, element: Route | Steps);
 }
 export {};

package/dist/core/router/buildError.mjs

@@ -2,9 +2,11 @@ import { createCoreLibKind } from '../kind.mjs';
 import { kindHeritage } from '@duplojs/utils';
 
 class RouterBuildError extends kindHeritage("router-build-error", createCoreLibKind("router-build-error"), Error) {
+    route;
     element;
-    constructor(element) {
+    constructor(route, element) {
         super({}, ["Error during build route."]);
+        this.route = route;
         this.element = element;
     }
 }

package/dist/core/router/index.cjs

@@ -5,16 +5,18 @@ var utils = require('@duplojs/utils');
 var pathToRegExp = require('./pathToRegExp.cjs');
 var index = require('../route/index.cjs');
 var buildError = require('./buildError.cjs');
-var build = require('../functionsBuilders/route/build.cjs');
+require('../functionsBuilders/route/index.cjs');
+require('../functionsBuilders/steps/index.cjs');
+var decodeUrl = require('./decodeUrl.cjs');
+require('./types/index.cjs');
 var _default = require('../functionsBuilders/route/default.cjs');
-require('../functionsBuilders/route/hook.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 decodeUrl = require('./decodeUrl.cjs');
 var hooks = require('../hub/hooks.cjs');
+var build = require('../functionsBuilders/route/build.cjs');
 
 async function buildRouter(inputHub) {
     const hub = inputHub
@@ -34,12 +36,13 @@ async function buildRouter(inputHub) {
         globalHooksRouteLifeCycle: hooksRouteLifeCycle,
         stepFunctionBuilders,
         routeFunctionBuilders,
+        defaultExtractContract: hub.defaultExtractContract,
     };
     const groupedRoute = await utils.G.asyncReduce(routes, utils.G.reduceFrom({}), async ({ lastValue, element: route, nextWithObject, }) => {
         const routeAfterHook = await hooks.launchHookBeforeBuildRoute(hooksBeforeBuildRoute, route);
         const buildedRoute = await build.buildRouteFunction(routeAfterHook, buildParams);
         if (utils.E.isLeft(buildedRoute)) {
-            throw new buildError.RouterBuildError(utils.unwrap(buildedRoute));
+            throw new buildError.RouterBuildError(route, utils.unwrap(buildedRoute));
         }
         return nextWithObject(lastValue, {
             [route.definition.method]: utils.A.concat(lastValue[route.definition.method] ?? [], utils.A.map(route.definition.paths, utils.O.to({
@@ -55,9 +58,12 @@ async function buildRouter(inputHub) {
         hooks: [],
         preflightSteps: [],
         steps: [hub.notfoundHandler],
-    }), (route) => build.buildRouteFunction(route, buildParams), utils.E.whenIsLeft((element) => {
-        throw new buildError.RouterBuildError(element);
-    }), utils.unwrap);
+    }), async (route) => {
+        const result = await build.buildRouteFunction(route, buildParams);
+        return utils.E.whenIsLeft(result, (element) => {
+            throw new buildError.RouterBuildError(route, element);
+        });
+    }, utils.unwrap);
     const Request = hub.classRequest;
     return {
         exec: (initializationData) => {

package/dist/core/router/index.mjs

@@ -3,17 +3,19 @@ import { pipe, A, isType, G, E, unwrap, O, forward, justReturn, asyncPipe } from
 import { pathToRegExp } from './pathToRegExp.mjs';
 import { createRoute } from '../route/index.mjs';
 import { RouterBuildError } from './buildError.mjs';
-import { buildRouteFunction } from '../functionsBuilders/route/build.mjs';
+import '../functionsBuilders/route/index.mjs';
+import '../functionsBuilders/steps/index.mjs';
+import { decodeUrl } from './decodeUrl.mjs';
+export { regexQueryAnalyser, regexUrlAnalyser } from './decodeUrl.mjs';
+import './types/index.mjs';
 import { defaultRouteFunctionBuilder } from '../functionsBuilders/route/default.mjs';
-import '../functionsBuilders/route/hook.mjs';
 import { defaultCheckerStepFunctionBuilder } from '../functionsBuilders/steps/defaults/checkerStep.mjs';
 import { defaultCutStepFunctionBuilder } from '../functionsBuilders/steps/defaults/cutStep.mjs';
 import { defaultHandlerStepFunctionBuilder } from '../functionsBuilders/steps/defaults/handlerStep.mjs';
 import { defaultExtractStepFunctionBuilder } from '../functionsBuilders/steps/defaults/extractStep.mjs';
 import { defaultProcessStepFunctionBuilder } from '../functionsBuilders/steps/defaults/processStep.mjs';
-import { decodeUrl } from './decodeUrl.mjs';
-export { regexQueryAnalyser, regexUrlAnalyser } from './decodeUrl.mjs';
 import { launchHookBeforeBuildRoute } from '../hub/hooks.mjs';
+import { buildRouteFunction } from '../functionsBuilders/route/build.mjs';
 
 async function buildRouter(inputHub) {
     const hub = inputHub
@@ -33,12 +35,13 @@ async function buildRouter(inputHub) {
         globalHooksRouteLifeCycle: hooksRouteLifeCycle,
         stepFunctionBuilders,
         routeFunctionBuilders,
+        defaultExtractContract: hub.defaultExtractContract,
     };
     const groupedRoute = await G.asyncReduce(routes, G.reduceFrom({}), async ({ lastValue, element: route, nextWithObject, }) => {
         const routeAfterHook = await launchHookBeforeBuildRoute(hooksBeforeBuildRoute, route);
         const buildedRoute = await buildRouteFunction(routeAfterHook, buildParams);
         if (E.isLeft(buildedRoute)) {
-            throw new RouterBuildError(unwrap(buildedRoute));
+            throw new RouterBuildError(route, unwrap(buildedRoute));
         }
         return nextWithObject(lastValue, {
             [route.definition.method]: A.concat(lastValue[route.definition.method] ?? [], A.map(route.definition.paths, O.to({
@@ -54,9 +57,12 @@ async function buildRouter(inputHub) {
         hooks: [],
         preflightSteps: [],
         steps: [hub.notfoundHandler],
-    }), (route) => buildRouteFunction(route, buildParams), E.whenIsLeft((element) => {
-        throw new RouterBuildError(element);
-    }), unwrap);
+    }), async (route) => {
+        const result = await buildRouteFunction(route, buildParams);
+        return E.whenIsLeft(result, (element) => {
+            throw new RouterBuildError(route, element);
+        });
+    }, unwrap);
     const Request = hub.classRequest;
     return {
         exec: (initializationData) => {

package/dist/core/router/types/buildedRouter.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/router/types/buildedRouter.mjs

@@ -0,0 +1 @@
+

package/dist/core/router/types/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+require('./buildedRouter.cjs');
+

package/dist/core/router/types/index.mjs

@@ -0,0 +1 @@
+import './buildedRouter.mjs';

package/dist/core/steps/cut.d.ts

@@ -2,16 +2,16 @@ import { type WrappedValue, type Kind, type MaybePromise, type NeverCoalescing }
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
 import { type StepFunctionParams } from "./types";
-import { type Response, type ResponseContract } from "../response";
+import { type PredictedResponse, type ResponseContract } from "../response";
 import { type Request } from "../request";
 export declare const cutStepOutputKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-output", unknown>>;
 export interface CutStepFunctionOutput<GenericData extends Record<string, unknown> = Record<string, unknown>> extends Kind<typeof cutStepOutputKind.definition>, WrappedValue<GenericData> {
 }
-export interface CutStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends Response = Response> extends StepFunctionParams<GenericRequest, GenericResponse> {
+export interface CutStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> extends StepFunctionParams<GenericRequest, GenericResponse> {
     output<GenericData extends Record<string, unknown> = never>(data?: GenericData): CutStepFunctionOutput<NeverCoalescing<GenericData, {}>>;
 }
 export interface CutStepDefinition {
-    theFunction(floor: Floor, params: CutStepFunctionParams): MaybePromise<CutStepFunctionOutput | Response>;
+    theFunction(floor: Floor, params: CutStepFunctionParams): MaybePromise<CutStepFunctionOutput | PredictedResponse>;
     readonly responseContract: ResponseContract.Contract | readonly ResponseContract.Contract[];
 }
 export declare const cutStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>>;

package/dist/core/steps/handler.d.ts

@@ -1,13 +1,13 @@
 import { type MaybePromise, type Kind } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
-import { type Response, type ResponseContract } from "../response";
+import { type PredictedResponse, type ResponseContract } from "../response";
 import { type Request } from "../request";
 import { type StepFunctionParams } from "./types";
-export interface HandlerStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends Response = Response> extends StepFunctionParams<GenericRequest, GenericResponse> {
+export interface HandlerStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> extends StepFunctionParams<GenericRequest, GenericResponse> {
 }
 export interface HandlerStepDefinition {
-    theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<Response>;
+    theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<PredictedResponse>;
     readonly responseContract: ResponseContract.Contract | readonly ResponseContract.Contract[];
 }
 export declare const handlerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>>;

package/dist/core/steps/identifier.d.ts

@@ -1,5 +1,5 @@
 import { type Kind } from "@duplojs/utils";
 export declare const stepIdentifier: {
-    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>, GenericResult extends Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericKindHandler extends any ? import("@duplojs/utils").IsEqual<false | (import("@duplojs/utils").GetKindHandler<GenericInput> extends infer T ? T extends import("@duplojs/utils").GetKindHandler<GenericInput> ? T extends any ? import("@duplojs/utils").IsEqual<T, GenericKindHandler> : never : never : never), boolean> : never, true> extends true ? import("@duplojs/utils/either").EitherSuccess<GenericInput> : import("@duplojs/utils/either").EitherError<GenericInput> : never) | import("@duplojs/utils/either").EitherSuccess<GenericResult>;
-    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>, GenericResult extends Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericKindHandler extends any ? import("@duplojs/utils").IsEqual<false | (import("@duplojs/utils").GetKindHandler<GenericInput> extends infer T ? T extends import("@duplojs/utils").GetKindHandler<GenericInput> ? T extends any ? import("@duplojs/utils").IsEqual<T, GenericKindHandler> : never : never : never), boolean> : never, true> extends true ? import("@duplojs/utils/either").EitherSuccess<GenericInput> : import("@duplojs/utils/either").EitherError<GenericInput> : never) | import("@duplojs/utils/either").EitherSuccess<GenericResult>;
+    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends unknown, GenericGroupedKind extends import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import("@duplojs/utils").IsEqual<import("@duplojs/utils").IsEqual<false | (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericInput, Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>> : never), boolean>, true> extends true ? Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, GenericGroupedKind> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, GenericGroupedKind> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, GenericGroupedKind> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, GenericGroupedKind> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, GenericGroupedKind> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends unknown, GenericGroupedKind extends import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import("@duplojs/utils").IsEqual<import("@duplojs/utils").IsEqual<false | (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericInput, Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>> : never), boolean>, true> extends true ? Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, GenericGroupedKind> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, GenericGroupedKind> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, GenericGroupedKind> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, GenericGroupedKind> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, GenericGroupedKind> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
 };

package/dist/core/steps/index.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+require('./types/index.cjs');
+var kind = require('./kind.cjs');
+var identifier = require('./identifier.cjs');
+var checker = require('./checker.cjs');
+var extract = require('./extract.cjs');
+var cut = require('./cut.cjs');
+var handler = require('./handler.cjs');
+var process = require('./process.cjs');
+var presetChecker = require('./presetChecker.cjs');
+
+
+
+exports.stepKind = kind.stepKind;
+exports.stepIdentifier = identifier.stepIdentifier;
+exports.checkerStepKind = checker.checkerStepKind;
+exports.createCheckerStep = checker.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;

package/dist/core/steps/index.mjs

@@ -0,0 +1,9 @@
+import './types/index.mjs';
+export { stepKind } from './kind.mjs';
+export { stepIdentifier } from './identifier.mjs';
+export { checkerStepKind, createCheckerStep } from './checker.mjs';
+export { createExtractStep, extractStepKind } from './extract.mjs';
+export { createCutStep, cutStepKind, cutStepOutputKind } from './cut.mjs';
+export { createHandlerStep, handlerStepKind } from './handler.mjs';
+export { createProcessStep, processStepKind } from './process.mjs';
+export { createPresetCheckerStep, presetCheckerStepKind } from './presetChecker.mjs';

package/dist/core/steps/types/buildedStep.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/steps/types/buildedStep.mjs

@@ -0,0 +1 @@
+

package/dist/core/steps/types/index.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+require('./stepFunctionParams.cjs');
+require('./steps.cjs');
+require('./buildedStep.cjs');
+

package/dist/core/steps/types/index.mjs

@@ -0,0 +1,3 @@
+import './stepFunctionParams.mjs';
+import './steps.mjs';
+import './buildedStep.mjs';

package/dist/core/steps/types/stepFunctionParams.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/steps/types/stepFunctionParams.d.ts

@@ -1,7 +1,7 @@
 import { type Request } from "../../request";
-import { type Response } from "../../response";
+import { type PredictedResponse } from "../../response";
 import { type IsEqual, type Or } from "@duplojs/utils";
-export interface StepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends Response = Response> {
+export interface StepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> {
     request: GenericRequest;
     response<GenericInformation extends GenericResponse["information"], GenericFilteredResponse extends Extract<GenericResponse, {
         information: GenericInformation;

package/dist/core/steps/types/stepFunctionParams.mjs

@@ -0,0 +1 @@
+

package/dist/core/steps/types/steps.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/steps/types/steps.mjs

@@ -0,0 +1 @@
+

package/dist/core/types/environment.cjs

@@ -0,0 +1,2 @@
+'use strict';
+