vovk 3.0.0-draft.7 → 3.0.0-draft.70

package/src/utils/parseQuery.ts

@@ -0,0 +1,160 @@
+import type { KnownAny } from '../types';
+
+/**
+ * Parse a bracket-based key (e.g. "z[d][0][x]" or "arr[]")
+ * into an array of path segments (strings or special push-markers).
+ *
+ * Example: "z[d][0][x]" => ["z", "d", "0", "x"]
+ * Example: "arr[]"      => ["arr", "" ]  // "" indicates "push" onto array
+ */
+function parseKey(key: string): string[] {
+  // The first segment is everything up to the first '[' (or the entire key if no '[')
+  const segments: string[] = [];
+  const topKeyMatch = key.match(/^([^[\]]+)/);
+  if (topKeyMatch) {
+    segments.push(topKeyMatch[1]);
+  } else {
+    // If it starts with brackets, treat it as empty? (edge case)
+    segments.push('');
+  }
+
+  // Now capture all bracket parts: [something], [0], []
+  const bracketRegex = /\[([^[\]]*)\]/g;
+  let match: RegExpExecArray | null;
+  while ((match = bracketRegex.exec(key)) !== null) {
+    // match[1] is the content inside the brackets
+    segments.push(match[1]);
+  }
+
+  return segments;
+}
+
+/**
+ * Recursively set a value in a nested object/array, given a path of segments.
+ * - If segment is numeric => treat as array index
+ * - If segment is empty "" => push to array
+ * - Else => object property
+ */
+function setValue(obj: Record<string, KnownAny>, path: string[], value: KnownAny): void {
+  let current: KnownAny = obj;
+
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+
+    // If we're at the last segment, set the value
+    if (i === path.length - 1) {
+      if (segment === '') {
+        // Empty bracket => push
+        if (!Array.isArray(current)) {
+          current = [];
+        }
+        current.push(value);
+      } else if (!isNaN(Number(segment))) {
+        // Numeric segment => array index
+        const idx = Number(segment);
+        if (!Array.isArray(current)) {
+          current = [];
+        }
+        current[idx] = value;
+      } else {
+        // Object property
+        current[segment] = value;
+      }
+    } else {
+      // Not the last segment: descend into existing structure or create it
+      const nextSegment = path[i + 1];
+
+      if (segment === '') {
+        // Empty bracket => push
+        if (!Array.isArray(current)) {
+          // Convert the current node into an array, if not one
+          current = [];
+        }
+        // If we are not at the last path, we need a placeholder object or array
+        // for the next segment. We'll push something and move current to that.
+        if (current.length === 0) {
+          // nothing in array yet
+          current.push(typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {});
+        } else if (typeof nextSegment === 'string' && !isNaN(Number(nextSegment))) {
+          // next is numeric => we want an array
+          if (!Array.isArray(current[current.length - 1])) {
+            current[current.length - 1] = [];
+          }
+        } else {
+          // next is not numeric => we want an object
+          if (typeof current[current.length - 1] !== 'object') {
+            current[current.length - 1] = {};
+          }
+        }
+        current = current[current.length - 1];
+      } else if (!isNaN(Number(segment))) {
+        // segment is numeric => array index
+        const idx = Number(segment);
+        if (!Array.isArray(current)) {
+          current = [];
+        }
+        if (current[idx] === undefined) {
+          // Create placeholder for next segment
+          current[idx] = typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {};
+        }
+        current = current[idx];
+      } else {
+        // segment is an object key
+        if (current[segment] === undefined) {
+          // Create placeholder
+          current[segment] = typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {};
+        }
+        current = current[segment];
+      }
+    }
+  }
+}
+
+/**
+ * Deserialize a bracket-based query string into an object.
+ *
+ * Supports:
+ *   - Key/value pairs with nested brackets (e.g. "a[b][0]=value")
+ *   - Arrays with empty bracket (e.g. "arr[]=1&arr[]=2")
+ *   - Mixed arrays of objects, etc.
+ *
+ * @example
+ *   parseQuery("x=xx&y[0]=yy&y[1]=uu&z[f]=x&z[u][0]=uu&z[u][1]=xx&z[d][x]=ee")
+ *   => {
+ *        x: "xx",
+ *        y: ["yy", "uu"],
+ *        z: {
+ *          f: "x",
+ *          u: ["uu", "xx"],
+ *          d: { x: "ee" }
+ *        }
+ *      }
+ *
+ * @param queryString - The raw query string (e.g. location.search.slice(1))
+ * @returns           - A nested object representing the query params
+ */
+export default function parseQuery(queryString: string): Record<string, KnownAny> {
+  const result: Record<string, KnownAny> = {};
+
+  if (!queryString) return result;
+
+  // Split into key=value pairs
+  const pairs = queryString
+    .replace(/^\?/, '') // Remove leading "?" if present
+    .split('&');
+
+  for (const pair of pairs) {
+    const [rawKey, rawVal = ''] = pair.split('=');
+
+    const decodedKey = decodeURIComponent(rawKey || '');
+    const decodedVal = decodeURIComponent(rawVal);
+
+    // Parse bracket notation
+    const pathSegments = parseKey(decodedKey);
+
+    // Insert into the result object
+    setValue(result, pathSegments, decodedVal);
+  }
+
+  return result;
+}

package/src/utils/reqForm.ts

@@ -0,0 +1,16 @@
+import type { KnownAny, VovkRequest } from '../types';
+
+const formMap = new WeakMap();
+
+export default async function reqForm<T = KnownAny>(req: VovkRequest<KnownAny, KnownAny>): Promise<T> {
+  if (formMap.has(req)) {
+    return formMap.get(req) as T;
+  }
+
+  const body = await req.formData();
+  const formData = Object.fromEntries(body.entries()) as T;
+
+  formMap.set(req, formData);
+
+  return formData;
+}

package/src/utils/reqMeta.ts

@@ -0,0 +1,16 @@
+import type { KnownAny, VovkRequest } from '../types';
+
+const metaMap = new WeakMap();
+
+export default function reqMeta<T = Record<KnownAny, KnownAny>>(
+  req: VovkRequest<KnownAny, KnownAny>,
+  meta?: T | null
+): T {
+  if (meta) {
+    metaMap.set(req, { ...metaMap.get(req), ...meta });
+  } else if (meta === null) {
+    metaMap.delete(req);
+  }
+
+  return (metaMap.get(req) ?? {}) as T;
+}

package/src/utils/reqQuery.ts

@@ -0,0 +1,6 @@
+import type { KnownAny, VovkRequest } from '../types';
+import parseQuery from './parseQuery';
+
+export default function reqQuery<T extends object | undefined>(req: VovkRequest<KnownAny, T>): T {
+  return parseQuery(req.nextUrl.search) as NonNullable<T>;
+}

package/src/utils/serializeQuery.ts

@@ -0,0 +1,69 @@
+import type { KnownAny } from '../types';
+
+/**
+ * Recursively build query parameters from an object.
+ *
+ * @param key      - The query key so far (e.g. 'user', 'user[0]', 'user[0][name]')
+ * @param value    - The current value to serialize
+ * @returns        - An array of `key=value` strings
+ */
+function buildParams(key: string, value: KnownAny): string[] {
+  if (value === null || value === undefined) {
+    return []; // skip null/undefined values entirely
+  }
+
+  // If value is an object or array, we need to recurse
+  if (typeof value === 'object') {
+    // Array case
+    if (Array.isArray(value)) {
+      /**
+       * We use index-based bracket notation here:
+       *   e.g. for value = ['aa', 'bb'] and key = 'foo'
+       *   => "foo[0]=aa&foo[1]=bb"
+       *
+       * If you prefer "foo[]=aa&foo[]=bb" style, replace:
+       *   `${key}[${i}]`
+       * with:
+       *   `${key}[]`
+       */
+      return value.flatMap((v, i) => {
+        const newKey = `${key}[${i}]`;
+        return buildParams(newKey, v);
+      });
+    }
+
+    // Plain object case
+    return Object.keys(value).flatMap((k) => {
+      const newKey = `${key}[${k}]`;
+      return buildParams(newKey, value[k]);
+    });
+  }
+
+  return [`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`];
+}
+
+/**
+ * Serialize a nested object (including arrays, arrays of objects, etc.)
+ * into a bracket-based query string.
+ *
+ * @example
+ *   serializeQuery({ x: 'xx', y: [1, 2], z: { f: 'x' } })
+ *   => "x=xx&y[0]=1&y[1]=2&z[f]=x"
+ *
+ * @param obj - The input object to be serialized
+ * @returns   - A bracket-based query string (without leading "?")
+ */
+export default function serializeQuery(obj: Record<string, KnownAny>): string {
+  if (!obj || typeof obj !== 'object') return '';
+
+  // Collect query segments
+  const segments: string[] = [];
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      const value = obj[key];
+      segments.push(...buildParams(key, value));
+    }
+  }
+
+  return segments.join('&');
+}

package/src/utils/setClientValidatorsForHandler.ts

@@ -0,0 +1,45 @@
+import type { KnownAny, VovkController } from '../types';
+
+export function setClientValidatorsForHandler(
+  h: (...args: KnownAny[]) => KnownAny,
+  validation: {
+    body: unknown;
+    query: unknown;
+  }
+) {
+  return new Promise<void>((resolve) => {
+    // the setTimeout is necessary to ensure that the _controller is already defined
+    setTimeout(() => {
+      const controller = (h as unknown as { _controller: VovkController })._controller;
+
+      if (!controller) {
+        throw new Error(
+          'Error setting client validators. Controller not found. Did you forget to use an HTTP decorator?'
+        );
+      }
+
+      const handlerName = Object.getOwnPropertyNames(controller).find(
+        (key) =>
+          (
+            controller[key] as {
+              _sourceMethod?: unknown;
+            }
+          )._sourceMethod === h
+      );
+
+      if (!handlerName) {
+        throw new Error('Error setting client validators. Handler not found.');
+      }
+
+      controller._handlers = {
+        ...controller._handlers,
+        [handlerName]: {
+          ...controller._handlers[handlerName],
+          validation,
+        },
+      };
+
+      resolve();
+    }, 0);
+  });
+}

package/src/utils/shim.ts

@@ -0,0 +1,17 @@
+if (typeof Symbol.dispose !== 'symbol') {
+  Object.defineProperty(Symbol, 'dispose', {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: Symbol.for('dispose'),
+  });
+}
+
+if (typeof Symbol.asyncDispose !== 'symbol') {
+  Object.defineProperty(Symbol, 'asyncDispose', {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: Symbol.for('asyncDispose'),
+  });
+}

package/.npmignore

@@ -1,2 +0,0 @@
-!*
-tsconfig.*

package/client/clientizeController.d.ts

@@ -1,4 +0,0 @@
-import { type _VovkControllerSchema as VovkControllerSchema, type _KnownAny as KnownAny } from '../types';
-import { type _VovkClientOptions as VovkClientOptions, type _VovkClient as VovkClient, type _VovkDefaultFetcherOptions as VovkDefaultFetcherOptions } from './types';
-export declare const ARRAY_QUERY_KEY = "_vovkarr";
-export declare const _clientizeController: <T, OPTS extends Record<string, KnownAny> = VovkDefaultFetcherOptions>(givenController: VovkControllerSchema, segmentName?: string, options?: VovkClientOptions<OPTS>) => VovkClient<T, OPTS>;

package/client/defaultFetcher.d.ts

@@ -1,4 +0,0 @@
-import type { _VovkDefaultFetcherOptions as VovkDefaultFetcherOptions, _VovkClientFetcher as VovkClientFetcher } from './types';
-export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultFetcher";
-declare const defaultFetcher: VovkClientFetcher<VovkDefaultFetcherOptions>;
-export default defaultFetcher;

package/client/defaultHandler.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._defaultHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
-const HttpException_1 = require("../HttpException");
-exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at defaultHandler';
-const _defaultHandler = async (response) => {
-    let result;
-    try {
-        result = await response.json();
-    }
-    catch (e) {
-        // handle parsing errors
-        throw new HttpException_1._HttpException(response.status, e?.message ?? exports.DEFAULT_ERROR_MESSAGE);
-    }
-    if (!response.ok) {
-        // handle server errors
-        throw new HttpException_1._HttpException(response.status, result?.message ?? exports.DEFAULT_ERROR_MESSAGE);
-    }
-    return result;
-};
-exports._defaultHandler = _defaultHandler;

package/client/defaultStreamHandler.d.ts

@@ -1,4 +0,0 @@
-import type { _StreamAsyncIterator as StreamAsyncIterator } from './types';
-import '../utils/shim';
-export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultStreamHandler";
-export declare const _defaultStreamHandler: (response: Response) => Promise<StreamAsyncIterator<unknown>>;

package/client/index.d.ts

@@ -1,4 +0,0 @@
-import { _clientizeController as clientizeController } from './clientizeController';
-import type { _VovkClientFetcher as VovkClientFetcher, _VovkClientOptions as VovkClientOptions, _VovkDefaultFetcherOptions as VovkDefaultFetcherOptions } from './types';
-export { clientizeController };
-export type { VovkClientFetcher, VovkClientOptions, VovkDefaultFetcherOptions };

package/client/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clientizeController = void 0;
-const clientizeController_1 = require("./clientizeController");
-Object.defineProperty(exports, "clientizeController", { enumerable: true, get: function () { return clientizeController_1._clientizeController; } });

package/client/types.d.ts

@@ -1,102 +0,0 @@
-import type { _KnownAny as KnownAny, _HttpMethod as HttpMethod, _ControllerStaticMethod, _VovkControllerBody, _VovkControllerQuery, _VovkControllerParams } from '../types';
-import { _StreamResponse as StreamResponse } from '../StreamResponse';
-import type { NextResponse } from 'next/server';
-export type _StaticMethodInput<T extends _ControllerStaticMethod> = (_VovkControllerBody<T> extends undefined | void ? {
-    body?: undefined;
-} : _VovkControllerBody<T> extends null ? {
-    body?: null;
-} : {
-    body: _VovkControllerBody<T>;
-}) & (_VovkControllerQuery<T> extends undefined | void ? {
-    query?: undefined;
-} : {
-    query: _VovkControllerQuery<T>;
-}) & (_VovkControllerParams<T> extends undefined | void ? {
-    params?: undefined;
-} : {
-    params: _VovkControllerParams<T>;
-});
-type ToPromise<T> = T extends PromiseLike<unknown> ? T : Promise<T>;
-export type _StreamAsyncIterator<T> = {
-    status: number;
-    [Symbol.dispose](): Promise<void> | void;
-    [Symbol.asyncDispose](): Promise<void> | void;
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-    cancel: () => Promise<void> | void;
-};
-type StaticMethodReturn<T extends _ControllerStaticMethod> = ReturnType<T> extends NextResponse<infer U> | Promise<NextResponse<infer U>> ? U : ReturnType<T> extends Response | Promise<Response> ? unknown : ReturnType<T>;
-type StaticMethodReturnPromise<T extends _ControllerStaticMethod> = ToPromise<StaticMethodReturn<T>>;
-type ClientMethod<T extends (...args: KnownAny[]) => void | object | StreamResponse<STREAM> | Promise<StreamResponse<STREAM>>, OPTS extends Record<string, KnownAny>, STREAM extends KnownAny = unknown> = <R>(options: (_StaticMethodInput<T> extends {
-    body?: undefined | null;
-    query?: undefined;
-    params?: undefined;
-} ? unknown : Parameters<T>[0] extends void ? _StaticMethodInput<T>['params'] extends object ? {
-    params: _StaticMethodInput<T>['params'];
-} : unknown : _StaticMethodInput<T>) & (Partial<OPTS & {
-    transform: (staticMethodReturn: Awaited<StaticMethodReturn<T>>) => R;
-}> | void)) => ReturnType<T> extends Promise<StreamResponse<infer U>> | StreamResponse<infer U> | Iterator<infer U> | AsyncIterator<infer U> ? Promise<_StreamAsyncIterator<U>> : R extends object ? Promise<R> : StaticMethodReturnPromise<T>;
-type OmitNever<T> = {
-    [K in keyof T as T[K] extends never ? never : K]: T[K];
-};
-type _VovkClientWithNever<T, OPTS extends {
-    [key: string]: KnownAny;
-}> = {
-    [K in keyof T]: T[K] extends (...args: KnownAny) => KnownAny ? ClientMethod<T[K], OPTS> & {
-        __isClientMethod: boolean;
-    } : never;
-};
-export type _VovkClient<T, OPTS extends {
-    [key: string]: KnownAny;
-}> = OmitNever<_VovkClientWithNever<T, OPTS>>;
-export type _VovkClientFetcher<OPTS extends Record<string, KnownAny> = Record<string, never>, T = KnownAny> = (options: {
-    name: keyof T;
-    httpMethod: HttpMethod;
-    getEndpoint: (data: {
-        prefix: string;
-        params: {
-            [key: string]: string;
-        };
-        query: {
-            [key: string]: string;
-        };
-    }) => string;
-    validate: (input: {
-        body?: unknown;
-        query?: unknown;
-        endpoint: string;
-    }) => void | Promise<void>;
-    defaultStreamHandler: (response: Response) => Promise<_StreamAsyncIterator<unknown>>;
-    defaultHandler: (response: Response) => Promise<unknown>;
-}, input: {
-    body: unknown;
-    query: {
-        [key: string]: string;
-    };
-    params: {
-        [key: string]: string;
-    };
-} & OPTS) => KnownAny;
-export interface _VovkDefaultFetcherOptions extends Omit<RequestInit, 'body' | 'method'> {
-    reactNative?: {
-        textStreaming: boolean;
-    };
-    prefix?: string;
-    segmentName?: string;
-    disableClientValidation?: boolean;
-    validateOnClient?: _VovkValidateOnClient;
-    fetcher?: _VovkClientFetcher;
-}
-export type _VovkValidateOnClient = (input: {
-    body?: unknown;
-    query?: unknown;
-    endpoint: string;
-}, validators: {
-    body?: unknown;
-    query?: unknown;
-}) => void | Promise<void>;
-export type _VovkClientOptions<OPTS extends Record<string, KnownAny> = Record<string, never>> = {
-    fetcher?: _VovkClientFetcher<OPTS>;
-    validateOnClient?: _VovkValidateOnClient;
-    defaultOptions?: Partial<OPTS>;
-};
-export {};

package/createDecorator.d.ts

@@ -1,4 +0,0 @@
-import type { _HandlerSchema as HandlerSchema, _KnownAny as KnownAny, _VovkController as VovkController, _VovkRequest as VovkRequest } from './types';
-type Next = () => Promise<unknown>;
-export declare function _createDecorator<ARGS extends unknown[], REQUEST = VovkRequest>(handler: null | ((this: VovkController, req: REQUEST, next: Next, ...args: ARGS) => unknown), initHandler?: (this: VovkController, ...args: ARGS) => Omit<HandlerSchema, 'path' | 'httpMethod'> | ((handlerSchema: HandlerSchema | null) => Omit<HandlerSchema, 'path' | 'httpMethod'>) | null | undefined): (...args: ARGS) => (target: KnownAny, propertyKey: string) => void;
-export {};

package/generateStaticAPI.d.ts

@@ -1,4 +0,0 @@
-import { _StaticClass as StaticClass } from './types';
-export declare function _generateStaticAPI(c: Record<string, StaticClass>, slug?: string): {
-    [x: string]: string[];
-}[];

package/index.d.ts

@@ -1,60 +0,0 @@
-import { _createSegment as createSegment } from './createSegment';
-import { type _VovkErrorResponse as VovkErrorResponse, type _VovkRequest as VovkRequest, type _VovkBody as VovkBody, type _VovkQuery as VovkQuery, type _VovkParams as VovkParams, type _VovkReturnType as VovkReturnType, type _VovkYieldType as VovkYieldType, type _VovkSchema as VovkSchema, _HttpStatus as HttpStatus, _HttpMethod as HttpMethod } from './types';
-import type { _VovkClientOptions as VovkClientOptions, _VovkClientFetcher as VovkClientFetcher, _VovkDefaultFetcherOptions as VovkDefaultFetcherOptions, _VovkValidateOnClient as VovkValidateOnClient } from './client/types';
-import { _HttpException as HttpException } from './HttpException';
-import { _createDecorator as createDecorator } from './createDecorator';
-import { _StreamResponse as StreamResponse } from './StreamResponse';
-import { worker } from './worker';
-import { _generateStaticAPI as generateStaticAPI } from './generateStaticAPI';
-export { type VovkClientFetcher, type VovkDefaultFetcherOptions, type VovkValidateOnClient, type VovkSchema, type VovkErrorResponse, type VovkRequest, type VovkBody, type VovkQuery, type VovkParams, type VovkReturnType, type VovkYieldType, type VovkClientOptions, StreamResponse, HttpException, HttpStatus, HttpMethod, createSegment, createDecorator, worker, generateStaticAPI, };
-export declare const get: {
-    (givenPath?: string | undefined, options?: import("./types")._DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void;
-}, post: {
-    (givenPath?: string | undefined, options?: import("./types")._DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void;
-}, put: {
-    (givenPath?: string | undefined, options?: import("./types")._DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void;
-}, patch: {
-    (givenPath?: string | undefined, options?: import("./types")._DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void;
-}, del: {
-    (givenPath?: string | undefined, options?: import("./types")._DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void;
-}, head: {
-    (givenPath?: string | undefined, options?: import("./types")._DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void;
-}, options: {
-    (givenPath?: string | undefined, options?: import("./types")._DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types")._DecoratorOptions) => (givenTarget: import("./types")._KnownAny, propertyKey: string) => void;
-}, prefix: (givenPath?: string) => (givenTarget: import("./types")._KnownAny) => any, initVovk: (options: {
-    segmentName?: string;
-    controllers: Record<string, import("./types")._StaticClass>;
-    workers?: Record<string, import("./types")._StaticClass>;
-    exposeValidation?: boolean;
-    emitSchema?: boolean;
-    onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
-}) => {
-    GET: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    POST: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    PUT: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    PATCH: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    DELETE: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    HEAD: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    OPTIONS: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-};

package/index.js

@@ -1,20 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initVovk = exports.prefix = exports.options = exports.head = exports.del = exports.patch = exports.put = exports.post = exports.get = exports.generateStaticAPI = exports.worker = exports.createDecorator = exports.createSegment = exports.HttpMethod = exports.HttpStatus = exports.HttpException = exports.StreamResponse = void 0;
-const createSegment_1 = require("./createSegment");
-Object.defineProperty(exports, "createSegment", { enumerable: true, get: function () { return createSegment_1._createSegment; } });
-const types_1 = require("./types");
-Object.defineProperty(exports, "HttpStatus", { enumerable: true, get: function () { return types_1._HttpStatus; } });
-Object.defineProperty(exports, "HttpMethod", { enumerable: true, get: function () { return types_1._HttpMethod; } });
-const HttpException_1 = require("./HttpException");
-Object.defineProperty(exports, "HttpException", { enumerable: true, get: function () { return HttpException_1._HttpException; } });
-const createDecorator_1 = require("./createDecorator");
-Object.defineProperty(exports, "createDecorator", { enumerable: true, get: function () { return createDecorator_1._createDecorator; } });
-const StreamResponse_1 = require("./StreamResponse");
-Object.defineProperty(exports, "StreamResponse", { enumerable: true, get: function () { return StreamResponse_1._StreamResponse; } });
-const worker_1 = require("./worker");
-Object.defineProperty(exports, "worker", { enumerable: true, get: function () { return worker_1.worker; } });
-const generateStaticAPI_1 = require("./generateStaticAPI");
-Object.defineProperty(exports, "generateStaticAPI", { enumerable: true, get: function () { return generateStaticAPI_1._generateStaticAPI; } });
-_a = (0, createSegment_1._createSegment)(), exports.get = _a.get, exports.post = _a.post, exports.put = _a.put, exports.patch = _a.patch, exports.del = _a.del, exports.head = _a.head, exports.options = _a.options, exports.prefix = _a.prefix, exports.initVovk = _a.initVovk;