@mionjs/router 0.8.0-alpha.0

package/.dist/cjs/src/types/context.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const __ΩReadonly = ["T", "Readonly", 'l+e#!e"!fRb!Pde"!gN#%w"y'];
+const __ΩOmit = ["T", "K", () => __ΩPick, () => __ΩExclude, "Omit", 'b!b"e!!e!!ge!"o$#o##w%y'];
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+const __ΩIterableIterator = ["T", "TReturn", "TNext", () => __ΩIterator, 0, () => Symbol.iterator, "IterableIterator", `b!"c""c#Pe"!e""e"#o$$Pe#!e#"e##o%$1&Mw'y`];
+const __ΩPick = ["T", "K", "Pick", 'l+e#!e"!fRb!b"Pde""N#!w#y'];
+const __ΩExclude = ["T", "U", "Exclude", 'l6!Re$!RPe#!e$"qk#%QRb!b"Pde"!p)w#y'];
+const __ΩIterator = ["T", "TReturn", "TNext", "param0", () => __ΩIteratorResult, "next", "value", () => __ΩIteratorResult, "return", "e", () => __ΩIteratorResult, "throw", "Iterator", `b!"c""c#PPPPGPe%#GJ@2$e#!e#"o%#1&Pe#"2'8e#!e#"o(#1)8P"2*8e#!e#"o+#1,8Mw-y`];
+const __ΩIteratorResult = ["T", "TReturn", () => __ΩIteratorYieldResult, () => __ΩIteratorReturnResult, "IteratorResult", 'b!"c"Pe"!o#"e""o$"Jw%y'];
+const __ΩIteratorYieldResult = ["TYield", false, "done", "value", "IteratorYieldResult", 'b!P."4#8e"!4$Mw%y'];
+const __ΩIteratorReturnResult = ["TReturn", true, "done", "value", "IteratorReturnResult", 'b!P."4#e"!4$Mw%y'];
+const __ΩCallContext = ["ContextData", "path", () => __ΩMionRequest, "request", () => __ΩMionResponse, "response", "shared", "MethodsExecutionChain", "executionChain", "urlQuery", "routesFlowRouteIds", "CallContext", `"c!P&4"9n#4$9n%4&9e"!4'"w(4)9&4*89&F4+89Mw,y`];
+const __ΩRawRequestBody = ["AnyObject", "RawRequestBody", 'P&_W"w!Jw"y'];
+const __ΩRawResponseBody = ["AnyObject", "RawResponseBody", 'P&_W"w!Jw"y'];
+const __ΩMionRequest = [() => __ΩReadonly, () => __ΩOmit, () => __ΩMionHeaders, "append", "set", "delete", "headers", () => __ΩRawRequestBody, "rawBody", "SerializerCode", "bodyType", () => __ΩReadonly, "AnyObject", "body", () => __ΩReadonly, () => __ΩRecord, "RpcError", "thrownErrors", "MionRequest", `Pn#P.$.%.&Jo"#o!"4'9n(4)9"w*4+9"w-o,"4.9&"w1o0#o/"4289Mw3y`];
+const __ΩMionResponse = ["statusCode", () => __ΩReadonly, () => __ΩMionHeaders, "headers", () => __ΩRawResponseBody, "rawBody", "SerializerCode", "serializer", () => __ΩReadonly, () => __ΩResponseBody, "body", "hasErrors", "DataViewSerializer", "binSerializer", "MionResponse", `P'4!9n#o""4$9n%4&9"w'4(9n*o)"4+9)4,9P"w--J4.89Mw/y`];
+const __ΩMionHeaders = ["name", "value", "append", "delete", "set", "get", "has", () => __ΩIterableIterator, "entries", () => __ΩIterableIterator, "keys", () => __ΩIterableIterator, "values", "MionHeaders", `PP&2!&2"$1#P&2!$1$P&2!&2"$1%P&2!P&-,J1&P&2!)1'PP&&Go("1)P&o*"1+P&o,"1-Mw.y`];
+const __ΩContextDataFactory = ["ContextData", "", "ContextDataFactory", 'b!Pe"!/"w#y'];
+const __ΩResponseBody = [() => __ΩRecord, () => __ΩRecord, "RpcError", "@thrownErrors", "ResponseBody", 'P&"o!#&"w#o"#4$8Mw%y'];
+const __ΩRoutesFlowExecutionResult = ["MethodsExecutionChain", "executionChain", "routesFlowRouteIds", "RoutesFlowMapping", "mappings", "RoutesFlowExecutionResult", 'P"w!4"&F4#8"w$F4%8Mw&y'];
+exports.__ΩCallContext = __ΩCallContext;
+exports.__ΩContextDataFactory = __ΩContextDataFactory;
+exports.__ΩMionHeaders = __ΩMionHeaders;
+exports.__ΩMionRequest = __ΩMionRequest;
+exports.__ΩMionResponse = __ΩMionResponse;
+exports.__ΩRawRequestBody = __ΩRawRequestBody;
+exports.__ΩRawResponseBody = __ΩRawResponseBody;
+exports.__ΩResponseBody = __ΩResponseBody;
+exports.__ΩRoutesFlowExecutionResult = __ΩRoutesFlowExecutionResult;
+//# sourceMappingURL=context.cjs.map

package/.dist/cjs/src/types/context.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/cjs/src/types/context.d.ts

@@ -0,0 +1,57 @@
+import { AnyObject, DataViewSerializer, SerializerCode, RpcError, RoutesFlowMapping } from '@mionjs/core';
+import { MethodsExecutionChain } from './remoteMethods.ts';
+export interface CallContext<ContextData extends Record<string, any> = any> {
+    readonly path: string;
+    readonly request: MionRequest;
+    readonly response: MionResponse;
+    shared: ContextData;
+    readonly executionChain: MethodsExecutionChain;
+    readonly urlQuery?: string;
+    readonly routesFlowRouteIds?: string[];
+}
+export type RawRequestBody = string | ArrayBuffer | Uint8Array | AnyObject;
+export type RawResponseBody = string | ArrayBuffer | Uint8Array | AnyObject;
+export interface MionRequest {
+    readonly headers: Readonly<Omit<MionHeaders, 'append' | 'set' | 'delete'>>;
+    readonly rawBody: RawRequestBody;
+    readonly bodyType: SerializerCode;
+    readonly body: Readonly<AnyObject>;
+    readonly thrownErrors?: Readonly<Record<string, RpcError<string>>>;
+}
+export interface MionResponse {
+    readonly statusCode: number;
+    readonly headers: Readonly<MionHeaders>;
+    readonly rawBody: RawResponseBody;
+    readonly serializer: SerializerCode;
+    readonly body: Readonly<ResponseBody>;
+    readonly hasErrors: boolean;
+    readonly binSerializer?: DataViewSerializer | undefined;
+}
+export interface MionHeaders {
+    append(name: string, value: string): void;
+    delete(name: string): void;
+    set(name: string, value: string): void;
+    get(name: string): string | undefined | null;
+    has(name: string): boolean;
+    entries(): IterableIterator<[string, string]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+}
+export type ContextDataFactory<ContextData extends Record<string, any>> = () => ContextData;
+export interface ResponseBody extends Record<string, any> {
+    '@thrownErrors'?: Record<string, RpcError<string>>;
+}
+export interface RoutesFlowExecutionResult {
+    executionChain: MethodsExecutionChain;
+    routesFlowRouteIds?: string[];
+    mappings?: RoutesFlowMapping[];
+}
+export declare type __ΩCallContext = any[];
+export declare type __ΩRawRequestBody = any[];
+export declare type __ΩRawResponseBody = any[];
+export declare type __ΩMionRequest = any[];
+export declare type __ΩMionResponse = any[];
+export declare type __ΩMionHeaders = any[];
+export declare type __ΩContextDataFactory = any[];
+export declare type __ΩResponseBody = any[];
+export declare type __ΩRoutesFlowExecutionResult = any[];

package/.dist/cjs/src/types/definitions.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_types_remoteMethods = require("./remoteMethods.cjs");
+const __ΩPick = ["T", "K", "Pick", 'l+e#!e"!fRb!b"Pde""N#!w#y'];
+const __ΩRouteDef = ["H", () => __ΩPick, () => src_types_remoteMethods.__ΩRouteMethod, "type", "handler", () => src_types_remoteMethods.__ΩRouteOptions, "options", "RouteDef", `"c!Pe"!o#"P.$.%Jo"#Pn&4'8MKw(y`];
+const __ΩMiddleFnDef = ["H", () => __ΩPick, () => src_types_remoteMethods.__ΩMiddleFnMethod, "type", "handler", () => src_types_remoteMethods.__ΩMiddleFnOptions, "options", "MiddleFnDef", `"c!Pe"!o#"P.$.%Jo"#Pn&4'8MKw(y`];
+const __ΩHeadersMiddleFnDef = ["H", () => __ΩPick, () => src_types_remoteMethods.__ΩHeadersMethod, "type", "handler", () => src_types_remoteMethods.__ΩHeadersMiddleFnOptions, "options", "HeadersMiddleFnDef", `"c!Pe"!o#"P.$.%Jo"#Pn&4'8MKw(y`];
+const __ΩRawMiddleFnDef = ["H", () => __ΩPick, () => src_types_remoteMethods.__ΩRawMethod, "type", "handler", () => src_types_remoteMethods.__ΩRawMiddleFnOptions, "options", "RawMiddleFnDef", `"c!Pe"!o#"P.$.%Jo"#Pn&4'8MKw(y`];
+const __ΩAnyHandlerDef = [() => __ΩRouteDef, () => __ΩMiddleFnDef, () => __ΩHeadersMiddleFnDef, () => __ΩRawMiddleFnDef, "AnyHandlerDef", 'Pn!n"n#n$Jw%y'];
+exports.__ΩAnyHandlerDef = __ΩAnyHandlerDef;
+exports.__ΩHeadersMiddleFnDef = __ΩHeadersMiddleFnDef;
+exports.__ΩMiddleFnDef = __ΩMiddleFnDef;
+exports.__ΩRawMiddleFnDef = __ΩRawMiddleFnDef;
+exports.__ΩRouteDef = __ΩRouteDef;
+//# sourceMappingURL=definitions.cjs.map

package/.dist/cjs/src/types/definitions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

package/.dist/cjs/src/types/definitions.d.ts

@@ -0,0 +1,20 @@
+import { Handler, HeaderHandler, RawMiddleFnHandler } from './handlers.ts';
+import { HeadersMiddleFnOptions, HeadersMethod, MiddleFnOptions, MiddleFnMethod, RawMiddleFnOptions, RawMethod, RouteOptions, RouteMethod } from './remoteMethods.ts';
+export type RouteDef<H extends Handler = any> = Pick<RouteMethod<H>, 'type' | 'handler'> & {
+    options?: RouteOptions;
+};
+export type MiddleFnDef<H extends Handler = any> = Pick<MiddleFnMethod<H>, 'type' | 'handler'> & {
+    options?: MiddleFnOptions;
+};
+export type HeadersMiddleFnDef<H extends HeaderHandler = any> = Pick<HeadersMethod<H>, 'type' | 'handler'> & {
+    options?: HeadersMiddleFnOptions;
+};
+export type RawMiddleFnDef<H extends RawMiddleFnHandler = any> = Pick<RawMethod<H>, 'type' | 'handler'> & {
+    options?: RawMiddleFnOptions;
+};
+export type AnyHandlerDef = RouteDef | MiddleFnDef | HeadersMiddleFnDef | RawMiddleFnDef;
+export declare type __ΩRouteDef = any[];
+export declare type __ΩMiddleFnDef = any[];
+export declare type __ΩHeadersMiddleFnDef = any[];
+export declare type __ΩRawMiddleFnDef = any[];
+export declare type __ΩAnyHandlerDef = any[];

package/.dist/cjs/src/types/general.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mionjs/core");
+const src_types_context = require("./context.cjs");
+const src_types_definitions = require("./definitions.cjs");
+const __ΩRoute = [() => src_types_definitions.__ΩRouteDef, "Route", 'n!w"y'];
+const __ΩRouterEntry = [() => __ΩRoutes, () => src_types_definitions.__ΩMiddleFnDef, () => src_types_definitions.__ΩRouteDef, () => src_types_definitions.__ΩRawMiddleFnDef, () => src_types_definitions.__ΩHeadersMiddleFnDef, "RouterEntry", 'Pn!n"n#n$n%Jw&y'];
+const __ΩRoutes = [() => __ΩRouterEntry, "Routes", 'P&n!LMw"y'];
+const __ΩRouterOptions = ["Req", "ContextData", () => core.__ΩCoreRouterOptions, "basePath", "suffix", "request", "path", "", "pathTransform", () => src_types_context.__ΩContextDataFactory, "contextDataFactory", () => core.__ΩSerializerMode, "serializer", "RunTypeOptions", "runTypeOptions", "getPublicRoutesData", "autoGenerateErrorId", "skipClientRoutes", "aot", "maxContextPoolSize", "maxRoutesFlowsCacheSize", "RouterOptions", `"c!"c"Pn#&4$&4%Pe#!2&&2'&/(4)8e""o*"4+8n,4-"w.4/)40)41)42)43'44'45Mw6y`];
+exports.__ΩRoute = __ΩRoute;
+exports.__ΩRouterEntry = __ΩRouterEntry;
+exports.__ΩRouterOptions = __ΩRouterOptions;
+exports.__ΩRoutes = __ΩRoutes;
+//# sourceMappingURL=general.cjs.map

package/.dist/cjs/src/types/general.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"general.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/.dist/cjs/src/types/general.d.ts

@@ -0,0 +1,27 @@
+import { CoreRouterOptions, SerializerMode } from '@mionjs/core';
+import { ContextDataFactory } from './context.ts';
+import { HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef } from './definitions.ts';
+import { RunTypeOptions } from '@mionjs/run-types';
+export type Route = RouteDef;
+export type RouterEntry = Routes | MiddleFnDef | RouteDef | RawMiddleFnDef | HeadersMiddleFnDef;
+export interface Routes {
+    [key: string]: RouterEntry;
+}
+export interface RouterOptions<Req = any, ContextData extends Record<string, any> = any> extends CoreRouterOptions {
+    basePath: string;
+    suffix: string;
+    pathTransform?: (request: Req, path: string) => string;
+    contextDataFactory?: ContextDataFactory<ContextData>;
+    serializer: SerializerMode;
+    runTypeOptions: RunTypeOptions;
+    getPublicRoutesData: boolean;
+    autoGenerateErrorId: boolean;
+    skipClientRoutes: boolean;
+    aot: boolean;
+    maxContextPoolSize: number;
+    maxRoutesFlowsCacheSize: number;
+}
+export declare type __ΩRoute = any[];
+export declare type __ΩRouterEntry = any[];
+export declare type __ΩRoutes = any[];
+export declare type __ΩRouterOptions = any[];

package/.dist/cjs/src/types/guards.cjs

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_types_general = require("./general.cjs");
+const src_types_remoteMethods = require("./remoteMethods.cjs");
+const core = require("@mionjs/core");
+function isRouteDef(entry) {
+  return entry.type === core.HandlerType.route;
+}
+isRouteDef.__type = [() => src_types_general.__ΩRouterEntry, "entry", "isRouteDef", 'Pn!2"!/#'];
+function isMiddleFnDef(entry) {
+  return entry.type === core.HandlerType.middleFn;
+}
+isMiddleFnDef.__type = [() => src_types_general.__ΩRouterEntry, "entry", "isMiddleFnDef", 'Pn!2"!/#'];
+function isRawMiddleFnDef(entry) {
+  return entry.type === core.HandlerType.rawMiddleFn;
+}
+isRawMiddleFnDef.__type = [() => src_types_general.__ΩRouterEntry, "entry", "isRawMiddleFnDef", 'Pn!2"!/#'];
+function isHeadersMiddleFnDef(entry) {
+  return entry.type === core.HandlerType.headersMiddleFn;
+}
+isHeadersMiddleFnDef.__type = [() => src_types_general.__ΩRouterEntry, "entry", "isHeadersMiddleFnDef", 'Pn!2"!/#'];
+function isAnyMiddleFnDef(entry) {
+  return isMiddleFnDef(entry) || isRawMiddleFnDef(entry) || isHeadersMiddleFnDef(entry);
+}
+isAnyMiddleFnDef.__type = [() => src_types_general.__ΩRouterEntry, "entry", "isAnyMiddleFnDef", 'Pn!2"!/#'];
+function isRoute(entry) {
+  return entry.type === core.HandlerType.route;
+}
+isRoute.__type = [() => src_types_general.__ΩRouterEntry, "entry", "isRoute", 'Pn!2"!/#'];
+function isRoutes(entry) {
+  return typeof entry === "object";
+}
+isRoutes.__type = [() => src_types_general.__ΩRouterEntry, () => src_types_general.__ΩRoutes, "entry", "isRoutes", 'PPn!n"J2#!/$'];
+function isExecutable(entry) {
+  return typeof entry?.id === "string" && (entry.routes === "undefined" || typeof entry.handler === "function");
+}
+isExecutable.__type = [() => src_types_remoteMethods.__ΩRemoteMethod, "pathPointer", "entry", "isExecutable", 'PPn!P&F4"MJ2#!/$'];
+function isRawExecutable(entry) {
+  return entry.type === core.HandlerType.rawMiddleFn;
+}
+isRawExecutable.__type = [() => src_types_remoteMethods.__ΩRemoteMethod, "entry", "isRawExecutable", 'Pn!2"!/#'];
+function isPublicExecutable(entry) {
+  return entry.hasReturnData || entry.type === core.HandlerType.route || !!entry.paramNames?.length || !!entry.headersParam?.headerNames?.length;
+}
+isPublicExecutable.__type = [() => src_types_remoteMethods.__ΩRemoteMethod, "entry", "isPublicExecutable", 'Pn!2"!/#'];
+function isHeaderExecutable(entry) {
+  return entry.type === core.HandlerType.headersMiddleFn;
+}
+isHeaderExecutable.__type = [() => src_types_remoteMethods.__ΩRemoteMethod, "entry", "isHeaderExecutable", 'Pn!2"!/#'];
+function isRouteExecutable(entry) {
+  return entry.type === core.HandlerType.route;
+}
+isRouteExecutable.__type = [() => src_types_remoteMethods.__ΩRemoteMethod, "entry", "isRouteExecutable", 'Pn!2"!/#'];
+exports.isAnyMiddleFnDef = isAnyMiddleFnDef;
+exports.isExecutable = isExecutable;
+exports.isHeaderExecutable = isHeaderExecutable;
+exports.isHeadersMiddleFnDef = isHeadersMiddleFnDef;
+exports.isMiddleFnDef = isMiddleFnDef;
+exports.isPublicExecutable = isPublicExecutable;
+exports.isRawExecutable = isRawExecutable;
+exports.isRawMiddleFnDef = isRawMiddleFnDef;
+exports.isRoute = isRoute;
+exports.isRouteDef = isRouteDef;
+exports.isRouteExecutable = isRouteExecutable;
+exports.isRoutes = isRoutes;
+//# sourceMappingURL=guards.cjs.map

package/.dist/cjs/src/types/guards.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.cjs","sources":["../../../../src/types/guards.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef} from './definitions.ts';\nimport {Route, RouterEntry, Routes} from './general.ts';\nimport {RawMethod} from './remoteMethods.ts';\nimport {HeadersMethod} from './remoteMethods.ts';\nimport {RouteMethod} from './remoteMethods.ts';\nimport {RemoteMethod} from './remoteMethods.ts';\nimport {HandlerType} from '@mionjs/core';\n\n// #######  type guards #######\n\nexport function isRouteDef(entry: RouterEntry): entry is RouteDef {\n    return entry.type === HandlerType.route;\n}\n\nexport function isMiddleFnDef(entry: RouterEntry): entry is MiddleFnDef {\n    return entry.type === HandlerType.middleFn;\n}\n\nexport function isRawMiddleFnDef(entry: RouterEntry): entry is RawMiddleFnDef {\n    return entry.type === HandlerType.rawMiddleFn;\n}\n\nexport function isHeadersMiddleFnDef(entry: RouterEntry): entry is HeadersMiddleFnDef {\n    return entry.type === HandlerType.headersMiddleFn;\n}\n\nexport function isAnyMiddleFnDef(entry: RouterEntry): entry is HeadersMiddleFnDef | MiddleFnDef | RawMiddleFnDef {\n    return isMiddleFnDef(entry) || isRawMiddleFnDef(entry) || isHeadersMiddleFnDef(entry);\n}\n\nexport function isRoute(entry: RouterEntry): entry is Route {\n    return entry.type === HandlerType.route;\n}\n\nexport function isRoutes(entry: RouterEntry | Routes): entry is Route {\n    return typeof entry === 'object';\n}\n\nexport function isExecutable(entry: RemoteMethod | {pathPointer: string[]}): entry is RemoteMethod {\n    return (\n        typeof (entry as RemoteMethod)?.id === 'string' &&\n        ((entry as any).routes === 'undefined' || typeof (entry as RemoteMethod).handler === 'function')\n    );\n}\nexport function isRawExecutable(entry: RemoteMethod): entry is RawMethod {\n    return entry.type === HandlerType.rawMiddleFn;\n}\n\nexport function isPublicExecutable(entry: RemoteMethod): entry is RemoteMethod {\n    return (\n        entry.hasReturnData ||\n        entry.type === HandlerType.route ||\n        !!entry.paramNames?.length ||\n        !!(entry as HeadersMethod).headersParam?.headerNames?.length\n    );\n}\n\nexport function isHeaderExecutable(entry: RemoteMethod): entry is HeadersMethod {\n    return entry.type === HandlerType.headersMiddleFn;\n}\n\nexport function isRouteExecutable(entry: RemoteMethod): entry is RouteMethod {\n    return entry.type === HandlerType.route;\n}\n"],"names":["HandlerType"],"mappings":";;;;;AAiBM,SAAU,WAAW,OAAkB;AACzC,SAAO,MAAM,SAASA,KAAAA,YAAY;AACtC;;AAEM,SAAU,cAAc,OAAkB;AAC5C,SAAO,MAAM,SAASA,KAAAA,YAAY;AACtC;;AAEM,SAAU,iBAAiB,OAAkB;AAC/C,SAAO,MAAM,SAASA,KAAAA,YAAY;AACtC;;AAEM,SAAU,qBAAqB,OAAkB;AACnD,SAAO,MAAM,SAASA,KAAAA,YAAY;AACtC;;AAEM,SAAU,iBAAiB,OAAkB;AAC/C,SAAO,cAAc,KAAK,KAAK,iBAAiB,KAAK,KAAK,qBAAqB,KAAK;AACxF;;AAEM,SAAU,QAAQ,OAAkB;AACtC,SAAO,MAAM,SAASA,KAAAA,YAAY;AACtC;;AAEM,SAAU,SAAS,OAA2B;AAChD,SAAO,OAAO,UAAU;AAC5B;;AAEM,SAAU,aAAa,OAA6C;AACtE,SACI,OAAQ,OAAwB,OAAO,aACrC,MAAc,WAAW,eAAe,OAAQ,MAAuB,YAAY;AAE7F;;AACM,SAAU,gBAAgB,OAAmB;AAC/C,SAAO,MAAM,SAASA,KAAAA,YAAY;AACtC;;AAEM,SAAU,mBAAmB,OAAmB;AAClD,SACI,MAAM,iBACN,MAAM,SAASA,KAAAA,YAAY,SAC3B,CAAC,CAAC,MAAM,YAAY,UACpB,CAAC,CAAE,MAAwB,cAAc,aAAa;AAE9D;;AAEM,SAAU,mBAAmB,OAAmB;AAClD,SAAO,MAAM,SAASA,KAAAA,YAAY;AACtC;;AAEM,SAAU,kBAAkB,OAAmB;AACjD,SAAO,MAAM,SAASA,KAAAA,YAAY;AACtC;;;;;;;;;;;;;;"}

package/.dist/cjs/src/types/guards.d.ts

@@ -0,0 +1,17 @@
+import { HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef } from './definitions.ts';
+import { Route, RouterEntry, Routes } from './general.ts';
+import { RawMethod, HeadersMethod, RouteMethod, RemoteMethod } from './remoteMethods.ts';
+export declare function isRouteDef(entry: RouterEntry): entry is RouteDef;
+export declare function isMiddleFnDef(entry: RouterEntry): entry is MiddleFnDef;
+export declare function isRawMiddleFnDef(entry: RouterEntry): entry is RawMiddleFnDef;
+export declare function isHeadersMiddleFnDef(entry: RouterEntry): entry is HeadersMiddleFnDef;
+export declare function isAnyMiddleFnDef(entry: RouterEntry): entry is HeadersMiddleFnDef | MiddleFnDef | RawMiddleFnDef;
+export declare function isRoute(entry: RouterEntry): entry is Route;
+export declare function isRoutes(entry: RouterEntry | Routes): entry is Route;
+export declare function isExecutable(entry: RemoteMethod | {
+    pathPointer: string[];
+}): entry is RemoteMethod;
+export declare function isRawExecutable(entry: RemoteMethod): entry is RawMethod;
+export declare function isPublicExecutable(entry: RemoteMethod): entry is RemoteMethod;
+export declare function isHeaderExecutable(entry: RemoteMethod): entry is HeadersMethod;
+export declare function isRouteExecutable(entry: RemoteMethod): entry is RouteMethod;

package/.dist/cjs/src/types/handlers.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_types_general = require("./general.cjs");
+const src_types_publicMethods = require("./publicMethods.cjs");
+const __ΩHandler = ["Context", "Params", "Ret", "context", "parameters", "", "Handler", '"c!"Fc""c#Pe"!2$e""@2%Pe##e##`J/&w\'y'];
+const __ΩHeaderHandler = ["Context", "ExpectedHeaders", "Params", "Ret", "context", "headers", "parameters", "", "HeaderHandler", '"c!"c""Fc#"c$Pe"!2%e""2&e"#@2\'Pe#$e#$`J/(w)y'];
+const __ΩRawMiddleFnHandler = ["Context", "RawReq", "RawResp", () => src_types_general.__ΩRouterOptions, "Opts", "ctx", "request", "response", "opts", () => src_types_publicMethods.__ΩMayReturnError, "", "RawMiddleFnHandler", `"c!"c""c#e!"o$"c%Pe"!2&e""2'e"#2(e"$2)n*/+w,y`];
+const __ΩAnyHandler = ["Context", "Params", "Ret", () => __ΩHandler, "AnyHandler", '"c!"c""c#e!!e!"e!#o$$w%y'];
+exports.__ΩAnyHandler = __ΩAnyHandler;
+exports.__ΩHandler = __ΩHandler;
+exports.__ΩHeaderHandler = __ΩHeaderHandler;
+exports.__ΩRawMiddleFnHandler = __ΩRawMiddleFnHandler;
+//# sourceMappingURL=handlers.cjs.map

package/.dist/cjs/src/types/handlers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}

package/.dist/cjs/src/types/handlers.d.ts

@@ -0,0 +1,12 @@
+import { HeadersSubset } from '@mionjs/core';
+import { CallContext } from './context.ts';
+import { RouterOptions } from './general.ts';
+import { MayReturnError } from './publicMethods.ts';
+export type Handler<Context extends CallContext = any, Params extends any[] = any[], Ret = any> = (context: Context, ...parameters: Params) => Ret | Promise<Ret>;
+export type HeaderHandler<Context extends CallContext = any, ExpectedHeaders extends HeadersSubset<any> = any, Params extends any[] = any[], Ret = any> = (context: Context, headers: ExpectedHeaders, ...parameters: Params) => Ret | Promise<Ret>;
+export type RawMiddleFnHandler<Context extends CallContext = any, RawReq = any, RawResp = any, Opts extends RouterOptions<RawReq> = RouterOptions<RawReq>> = (ctx: Context, request: RawReq, response: RawResp, opts: Opts) => MayReturnError;
+export type AnyHandler<Context extends CallContext = any, Params extends any[] = any, Ret = any> = Handler<Context, Params, Ret>;
+export declare type __ΩHandler = any[];
+export declare type __ΩHeaderHandler = any[];
+export declare type __ΩRawMiddleFnHandler = any[];
+export declare type __ΩAnyHandler = any[];

package/.dist/cjs/src/types/publicMethods.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const __ΩAwaited = ["T", "onfulfilled", "args", "then", "value", "", 0, "Awaited", `lŒe$!Re"!o'"R!RPde#!Ph"!2%h&"@2#"/&qk'.QRPde#!p0Re$!RPdde#!P%PPh$!2"h$"@2#"1$MKqkJRQRPde%!pVRPe#!P,-Jqk#vQRb!Pde"!p~w(y`];
+const __ΩMayReturnError = ["RpcError", "MayReturnError", 'P$"w!P"w!$J`Jw"y'];
+const __ΩMiddleFnsCollection = ["MiddleFnDef", "HeadersMiddleFnDef", "RawMiddleFnDef", "MiddleFnsCollection", 'P&P"w!"w""w#JLMw$y'];
+const __ΩPrivateMiddleFnDef = ["MiddleFnDef", "ctx", "", "handler", "PrivateMiddleFnDef", 'P"w!P"2"8P$!-J/#4$Mw%y'];
+const __ΩPrivateDef = [() => __ΩPrivateMiddleFnDef, "RawMiddleFnDef", "PrivateDef", 'Pn!"w"Jw#y'];
+const __ΩPublicApi = ["Type", "Prettify", "PublicApi", 'b!"w"w#y'];
+const __ΩRemoteApi = [() => __ΩPublicRoute, () => __ΩPublicMiddleFn, () => __ΩPublicHeadersFn, 0, "RemoteApi", 'P&Pn!n"n#n$JLMw%y'];
+const __ΩPublicRoute = ["H", "MethodMetadata", () => HandlerType.route, "type", "middleFnIds", "headerNames", "handler", "PublicRoute", `"c!P"w"i#4$&F4%-4&e"!4'Mw(y`];
+const __ΩPublicMiddleFn = ["H", "MethodMetadata", () => HandlerType.middleFn, "type", "handler", "PublicMiddleFn", '"c!P"w"i#4$e"!4%Mw&y'];
+const __ΩPublicHeadersFn = ["H", "MethodMetadata", () => HandlerType.headersMiddleFn, "type", "headerNames", "handler", "PublicHeadersFn", `"c!P"w"i#4$&F4%e"!4&Mw'y`];
+const __ΩPublicHandler = ["H", "CallContext", "ctx", "rest", "", () => __ΩAwaited, "PublicHandler", 'lSPe#!@2$e#"o&"`/%R!RPdde#!P"w"2#h"!@2$h""/%qk#4QRb!Pde"!p6w\'y'];
+exports.__ΩMayReturnError = __ΩMayReturnError;
+exports.__ΩMiddleFnsCollection = __ΩMiddleFnsCollection;
+exports.__ΩPrivateDef = __ΩPrivateDef;
+exports.__ΩPrivateMiddleFnDef = __ΩPrivateMiddleFnDef;
+exports.__ΩPublicApi = __ΩPublicApi;
+exports.__ΩPublicHandler = __ΩPublicHandler;
+exports.__ΩPublicHeadersFn = __ΩPublicHeadersFn;
+exports.__ΩPublicMiddleFn = __ΩPublicMiddleFn;
+exports.__ΩPublicRoute = __ΩPublicRoute;
+exports.__ΩRemoteApi = __ΩRemoteApi;
+//# sourceMappingURL=publicMethods.cjs.map

package/.dist/cjs/src/types/publicMethods.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"publicMethods.cjs","sources":["../../../../src/types/publicMethods.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {Prettify, RpcError, MethodMetadata} from '@mionjs/core';\nimport type {CallContext} from './context.ts';\nimport type {Routes} from './general.ts';\nimport type {Handler} from './handlers.ts';\nimport type {HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef} from './definitions.ts';\nimport {HandlerType} from '@mionjs/core'; // do not import type only\n\n// ####### Raw MiddleFns #######\n\nexport type MayReturnError = void | RpcError<string> | Promise<RpcError<string> | void>;\n\nexport type MiddleFnsCollection = {\n    [key: string]: MiddleFnDef | HeadersMiddleFnDef | RawMiddleFnDef;\n};\n\n// ####### Private MiddleFns #######\n\nexport interface PrivateMiddleFnDef extends MiddleFnDef {\n    handler: (ctx?: any) => void | never | undefined;\n}\n\nexport type PrivateDef = PrivateMiddleFnDef | RawMiddleFnDef;\n\n// ####### Remote Methods Metadata #######\n\n/** Data structure containing all public routes & middleFns.\n * is a Ts Mapped type the remove private middleFns and rawMiddleFns\n */\n// prettier-ignore\nexport type PublicApi<Type extends Routes> = Prettify<{\n    [Property in keyof Type as Type[Property] extends PrivateDef ? never : Property]\n    : Type[Property] extends MiddleFnDef\n    ? PublicMiddleFn<PublicHandler<Type[Property]['handler']>>\n    : Type[Property] extends HeadersMiddleFnDef\n    ? PublicHeadersFn<PublicHandler<Type[Property]['handler']>>\n    : Type[Property] extends RouteDef // Routes\n    ? PublicRoute<PublicHandler<Type[Property]['handler']>>\n        : Type[Property] extends Routes // Routes & PureRoutes (recursion)\n        ? PublicApi<Type[Property]>\n        : never;\n}>;\n\n// type-remote-api-start\n/** Same as Public Api but no type mapping, should be easier to use than PublicApi when non strong types are required. */\nexport type RemoteApi = {\n    [key: string]: PublicRoute | PublicMiddleFn | PublicHeadersFn | RemoteApi;\n};\n// type-remote-api-end\n\n/** Public Routes, handler type is the same as RemoteRoute but does not include the context  */\nexport interface PublicRoute<H extends Handler = any> extends MethodMetadata {\n    type: typeof HandlerType.route;\n    middleFnIds: string[];\n    headerNames: undefined;\n    handler: H;\n}\n\n/** Public MiddleFns, handler type is the same as RemoteMiddleFns but does not include the context  */\nexport interface PublicMiddleFn<H extends Handler = any> extends MethodMetadata {\n    type: typeof HandlerType.middleFn;\n    handler: H;\n}\n\n/** Public HeadersFns, handler type is the same as HeadersFns but does not include the context */\nexport interface PublicHeadersFn<H extends Handler = any> extends MethodMetadata {\n    type: typeof HandlerType.headersMiddleFn;\n    headerNames: string[];\n    handler: H;\n}\n\n/** Removes the context from handlers */\n// prettier-ignore\nexport type PublicHandler<H extends Handler> =\n    H extends (ctx: CallContext, ...rest: infer Req) => infer Resp\n    ? (...rest: Req) => Promise<Awaited<Resp>>\n    : never;\n"],"names":[],"mappings":";;;;;;;;;iEA0D6B,OAAK,QAAA,eAAA,eAAA,WAAA,eAAA,6BAAA;oEAQL,UAAQ,QAAA,WAAA,kBAAA,sBAAA;qEAMR,iBAAe,QAAA,eAAA,WAAA,mBAAA,0BAAA;;;;;;;;;;;;"}

package/.dist/cjs/src/types/publicMethods.d.ts

@@ -0,0 +1,45 @@
+import { Prettify, RpcError, MethodMetadata, HandlerType } from '@mionjs/core';
+import { CallContext } from './context.ts';
+import { Routes } from './general.ts';
+import { Handler } from './handlers.ts';
+import { HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef } from './definitions.ts';
+export type MayReturnError = void | RpcError<string> | Promise<RpcError<string> | void>;
+export type MiddleFnsCollection = {
+    [key: string]: MiddleFnDef | HeadersMiddleFnDef | RawMiddleFnDef;
+};
+export interface PrivateMiddleFnDef extends MiddleFnDef {
+    handler: (ctx?: any) => void | never | undefined;
+}
+export type PrivateDef = PrivateMiddleFnDef | RawMiddleFnDef;
+export type PublicApi<Type extends Routes> = Prettify<{
+    [Property in keyof Type as Type[Property] extends PrivateDef ? never : Property]: Type[Property] extends MiddleFnDef ? PublicMiddleFn<PublicHandler<Type[Property]['handler']>> : Type[Property] extends HeadersMiddleFnDef ? PublicHeadersFn<PublicHandler<Type[Property]['handler']>> : Type[Property] extends RouteDef ? PublicRoute<PublicHandler<Type[Property]['handler']>> : Type[Property] extends Routes ? PublicApi<Type[Property]> : never;
+}>;
+export type RemoteApi = {
+    [key: string]: PublicRoute | PublicMiddleFn | PublicHeadersFn | RemoteApi;
+};
+export interface PublicRoute<H extends Handler = any> extends MethodMetadata {
+    type: typeof HandlerType.route;
+    middleFnIds: string[];
+    headerNames: undefined;
+    handler: H;
+}
+export interface PublicMiddleFn<H extends Handler = any> extends MethodMetadata {
+    type: typeof HandlerType.middleFn;
+    handler: H;
+}
+export interface PublicHeadersFn<H extends Handler = any> extends MethodMetadata {
+    type: typeof HandlerType.headersMiddleFn;
+    headerNames: string[];
+    handler: H;
+}
+export type PublicHandler<H extends Handler> = H extends (ctx: CallContext, ...rest: infer Req) => infer Resp ? (...rest: Req) => Promise<Awaited<Resp>> : never;
+export declare type __ΩMayReturnError = any[];
+export declare type __ΩMiddleFnsCollection = any[];
+export declare type __ΩPrivateMiddleFnDef = any[];
+export declare type __ΩPrivateDef = any[];
+export declare type __ΩPublicApi = any[];
+export declare type __ΩRemoteApi = any[];
+export declare type __ΩPublicRoute = any[];
+export declare type __ΩPublicMiddleFn = any[];
+export declare type __ΩPublicHeadersFn = any[];
+export declare type __ΩPublicHandler = any[];

package/.dist/cjs/src/types/remoteMethods.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const __ΩPartial = ["T", "Partial", 'l+e#!e"!fRb!Pde"!gN#"w"y'];
+const __ΩPick = ["T", "K", "Pick", 'l+e#!e"!fRb!b"Pde""N#!w#y'];
+const __ΩRemoteMethod = ["AnyHandler", "H", "MethodWithJitFns", "RemoteMethodOpts", "options", "handler", "args", "", "methodCaller", "RemoteMethod", `"w!c"P"w#"w$4%e"!4&P"@2'"/(4)8Mw*y`];
+const __ΩRouteMethod = ["H", () => __ΩRemoteMethod, () => HandlerType.route, "type", "RouteOnlyOptions", "options", "RouteMethod", `"c!Pe"!o""i#4$"w%4&Mw'y`];
+const __ΩMiddleFnMethod = ["H", () => __ΩRemoteMethod, () => HandlerType.middleFn, "type", "MiddleFnMethod", '"c!Pe"!o""i#4$Mw%y'];
+const __ΩHeadersMethod = ["H", () => __ΩRemoteMethod, () => HandlerType.headersMiddleFn, "type", "HeadersMethodWithJitFns", "headersParam", "HeadersMethod", `"c!Pe"!o""i#4$"w%4&Mw'y`];
+const __ΩRawMethod = ["H", () => __ΩRemoteMethod, () => HandlerType.rawMiddleFn, "type", "RemoteMethodOpts", false, "validateParams", false, "validateReturn", "options", "RawMethod", `"c!Pe"!o""i#4$P"w%P.&4'.(4)8MK4*Mw+y`];
+const __ΩRouteOptions = [() => __ΩPartial, () => __ΩPick, () => __ΩRouteMethod, "options", "description", "validateParams", "validateReturn", "serializer", "isMutation", "RouteOptions", `n#.$fP.%.&.'.(.)Jo"#o!"w*y`];
+const __ΩMiddleFnOptions = [() => __ΩPartial, () => __ΩPick, () => __ΩMiddleFnMethod, "options", "description", "validateParams", "validateReturn", "runOnError", "MiddleFnOptions", `n#.$fP.%.&.'.(Jo"#o!"w)y`];
+const __ΩHeadersMiddleFnOptions = [() => __ΩPartial, () => __ΩPick, () => __ΩHeadersMethod, "options", "description", "validateParams", "validateReturn", "runOnError", "HeadersMiddleFnOptions", `n#.$fP.%.&.'.(Jo"#o!"w)y`];
+const __ΩRawMiddleFnOptions = [() => __ΩPartial, () => __ΩPick, () => __ΩRawMethod, "options", "description", "runOnError", "RawMiddleFnOptions", `n#.$fP.%.&Jo"#o!"w'y`];
+const __ΩMethodsExecutionChain = ["routeIndex", () => __ΩRemoteMethod, "methods", "SerializerCode", "serializer", "MethodsExecutionChain", `P'4!n"F4#"w$4%Mw&y`];
+exports.__ΩHeadersMethod = __ΩHeadersMethod;
+exports.__ΩHeadersMiddleFnOptions = __ΩHeadersMiddleFnOptions;
+exports.__ΩMethodsExecutionChain = __ΩMethodsExecutionChain;
+exports.__ΩMiddleFnMethod = __ΩMiddleFnMethod;
+exports.__ΩMiddleFnOptions = __ΩMiddleFnOptions;
+exports.__ΩRawMethod = __ΩRawMethod;
+exports.__ΩRawMiddleFnOptions = __ΩRawMiddleFnOptions;
+exports.__ΩRemoteMethod = __ΩRemoteMethod;
+exports.__ΩRouteMethod = __ΩRouteMethod;
+exports.__ΩRouteOptions = __ΩRouteOptions;
+//# sourceMappingURL=remoteMethods.cjs.map

package/.dist/cjs/src/types/remoteMethods.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteMethods.cjs","sources":["../../../../src/types/remoteMethods.ts"],"sourcesContent":["// ####### Executables #######\n\nimport type {HeadersMethodWithJitFns, MethodWithJitFns, RemoteMethodOpts, RouteOnlyOptions, SerializerCode} from '@mionjs/core'; // do not import type only\nimport type {AnyHandler, Handler, HeaderHandler, RawMiddleFnHandler} from './handlers.ts'; // do not import type only\nimport {HandlerType} from '@mionjs/core'; // do not import type only\n\n/** Contains the handlers for middleFns and routes */\nexport interface RemoteMethod<H extends AnyHandler = AnyHandler> extends MethodWithJitFns {\n    /** router options */\n    options: RemoteMethodOpts;\n    handler: H;\n    methodCaller?: (...args: any[]) => any;\n}\n\nexport interface RouteMethod<H extends Handler = any> extends RemoteMethod<H> {\n    type: typeof HandlerType.route;\n    options: RouteOnlyOptions;\n}\nexport interface MiddleFnMethod<H extends Handler = any> extends RemoteMethod<H> {\n    type: typeof HandlerType.middleFn;\n}\nexport interface HeadersMethod<H extends HeaderHandler = any> extends RemoteMethod<H> {\n    type: typeof HandlerType.headersMiddleFn;\n    headersParam: HeadersMethodWithJitFns;\n}\nexport interface RawMethod<H extends RawMiddleFnHandler = any> extends RemoteMethod<H> {\n    type: typeof HandlerType.rawMiddleFn;\n    options: RemoteMethodOpts & {\n        validateParams: false;\n        validateReturn?: false;\n    };\n}\n\nexport type RouteOptions = Partial<\n    Pick<RouteMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'serializer' | 'isMutation'>\n>;\nexport type MiddleFnOptions = Partial<\n    Pick<MiddleFnMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'runOnError'>\n>;\nexport type HeadersMiddleFnOptions = Partial<\n    Pick<HeadersMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'runOnError'>\n>;\n// RawMiddleFnOptions doesn't need encoding - raw middleFns handle their own serialization\nexport type RawMiddleFnOptions = Partial<Pick<RawMethod['options'], 'description' | 'runOnError'>>;\n\nexport interface MethodsExecutionChain {\n    routeIndex: number;\n    methods: RemoteMethod[];\n    /** Precalculated serializer code for the route's response body type */\n    serializer: SerializerCode;\n}\n"],"names":[],"mappings":";;;;;sEAe6B,OAAK,QAAA,oBAAA,WAAA,eAAA,yBAAA;yEAIL,UAAQ,QAAA,kBAAA,oBAAA;wEAGR,iBAAe,QAAA,2BAAA,gBAAA,iBAAA,yBAAA;oEAIf,aAAW,QAAA,oBAAA,OAAA,kBAAA,OAAA,kBAAA,WAAA,aAAA,sCAAA;;;;;;;;;;;;;;;;"}

package/.dist/cjs/src/types/remoteMethods.d.ts

@@ -0,0 +1,44 @@
+import { HeadersMethodWithJitFns, MethodWithJitFns, RemoteMethodOpts, RouteOnlyOptions, SerializerCode, HandlerType } from '@mionjs/core';
+import { AnyHandler, Handler, HeaderHandler, RawMiddleFnHandler } from './handlers.ts';
+export interface RemoteMethod<H extends AnyHandler = AnyHandler> extends MethodWithJitFns {
+    options: RemoteMethodOpts;
+    handler: H;
+    methodCaller?: (...args: any[]) => any;
+}
+export interface RouteMethod<H extends Handler = any> extends RemoteMethod<H> {
+    type: typeof HandlerType.route;
+    options: RouteOnlyOptions;
+}
+export interface MiddleFnMethod<H extends Handler = any> extends RemoteMethod<H> {
+    type: typeof HandlerType.middleFn;
+}
+export interface HeadersMethod<H extends HeaderHandler = any> extends RemoteMethod<H> {
+    type: typeof HandlerType.headersMiddleFn;
+    headersParam: HeadersMethodWithJitFns;
+}
+export interface RawMethod<H extends RawMiddleFnHandler = any> extends RemoteMethod<H> {
+    type: typeof HandlerType.rawMiddleFn;
+    options: RemoteMethodOpts & {
+        validateParams: false;
+        validateReturn?: false;
+    };
+}
+export type RouteOptions = Partial<Pick<RouteMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'serializer' | 'isMutation'>>;
+export type MiddleFnOptions = Partial<Pick<MiddleFnMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'runOnError'>>;
+export type HeadersMiddleFnOptions = Partial<Pick<HeadersMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'runOnError'>>;
+export type RawMiddleFnOptions = Partial<Pick<RawMethod['options'], 'description' | 'runOnError'>>;
+export interface MethodsExecutionChain {
+    routeIndex: number;
+    methods: RemoteMethod[];
+    serializer: SerializerCode;
+}
+export declare type __ΩRemoteMethod = any[];
+export declare type __ΩRouteMethod = any[];
+export declare type __ΩMiddleFnMethod = any[];
+export declare type __ΩHeadersMethod = any[];
+export declare type __ΩRawMethod = any[];
+export declare type __ΩRouteOptions = any[];
+export declare type __ΩMiddleFnOptions = any[];
+export declare type __ΩHeadersMiddleFnOptions = any[];
+export declare type __ΩRawMiddleFnOptions = any[];
+export declare type __ΩMethodsExecutionChain = any[];

package/.dist/esm/index.d.ts

@@ -0,0 +1,19 @@
+export * from './src/types/context.ts';
+export * from './src/types/definitions.ts';
+export * from './src/types/remoteMethods.ts';
+export * from './src/types/general.ts';
+export * from './src/types/guards.ts';
+export * from './src/types/handlers.ts';
+export * from './src/types/publicMethods.ts';
+export * from './src/constants.ts';
+export * from './src/router.ts';
+export * from './src/dispatch.ts';
+export * from './src/callContext.ts';
+export * from './src/lib/dispatchError.ts';
+export * from './src/lib/headers.ts';
+export * from './src/lib/remoteMethods.ts';
+export * from './src/lib/handlers.ts';
+export * from './src/lib/queryBody.ts';
+export * from './src/lib/methodsCache.ts';
+export * from './src/routes/errors.routes.ts';
+export * from './src/routes/mion.routes.ts';