vovk 3.0.0-draft.33 → 3.0.0-draft.331

package/mjs/client/createRPC.d.ts

@@ -0,0 +1,3 @@
+import type { KnownAny, VovkSchema } from '../types';
+import type { VovkClient, VovkClientFetcher, VovkDefaultFetcherOptions } from './types';
+export declare const createRPC: <T, OPTS extends Record<string, KnownAny> = Record<string, never>>(schema: VovkSchema, segmentName: string, rpcModuleName: string, fetcher?: VovkClientFetcher<OPTS>, options?: VovkDefaultFetcherOptions<OPTS>) => VovkClient<T, OPTS>;

package/mjs/client/createRPC.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRPC = void 0;
+const fetcher_1 = require("./fetcher");
+const defaultHandler_1 = require("./defaultHandler");
+const defaultStreamHandler_1 = require("./defaultStreamHandler");
+const serializeQuery_1 = __importDefault(require("../utils/serializeQuery"));
+const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
+const getHandlerPath = (endpoint, params, query) => {
+    let result = endpoint;
+    const queryStr = query ? (0, serializeQuery_1.default)(query) : null;
+    for (const [key, value] of Object.entries(params ?? {})) {
+        result = result.replace(`{${key}}`, value);
+    }
+    return `${result}${queryStr ? '?' : ''}${queryStr}`;
+};
+const createRPC = (schema, segmentName, rpcModuleName, fetcher = fetcher_1.fetcher, options) => {
+    const segmentNamePath = options?.segmentNameOverride ?? segmentName;
+    const segmentSchema = schema.segments[segmentName];
+    if (!segmentSchema)
+        throw new Error(`Unable to create RPC module. Segment schema is missing for segment "${segmentName}".`);
+    const controllerSchema = schema.segments[segmentName]?.controllers[rpcModuleName];
+    const client = {};
+    if (!controllerSchema) {
+        throw new Error(`Unable to create RPC module. Controller schema is missing for module "${rpcModuleName}" from segment "${segmentName}".`);
+    }
+    const controllerPrefix = trimPath(controllerSchema.prefix ?? '');
+    for (const [staticMethodName, handlerSchema] of Object.entries(controllerSchema.handlers ?? {})) {
+        const { path, httpMethod, validation } = handlerSchema;
+        const getEndpoint = ({ apiRoot, params, query, }) => {
+            const forceApiRoot = controllerSchema.forceApiRoot ?? segmentSchema.forceApiRoot;
+            apiRoot = apiRoot ?? forceApiRoot ?? options?.apiRoot ?? '/api';
+            const endpoint = [
+                apiRoot.startsWith('http://') || apiRoot.startsWith('https://') || apiRoot.startsWith('/') ? '' : '/',
+                apiRoot,
+                forceApiRoot ? '' : segmentNamePath,
+                getHandlerPath([controllerPrefix, path].filter(Boolean).join('/'), params, query),
+            ]
+                .filter(Boolean)
+                .join('/')
+                .replace(/([^:])\/+/g, '$1/'); // replace // by / but not for protocols (http://, https://)
+            return endpoint;
+        };
+        const handler = async (input = {}) => {
+            const validate = async ({ body, query, params, endpoint, }) => {
+                const validateOnClient = input.validateOnClient ?? options?.validateOnClient;
+                if (validateOnClient && validation) {
+                    if (typeof validateOnClient !== 'function') {
+                        throw new Error('validateOnClient must be a function');
+                    }
+                    await validateOnClient({ body, query, params, endpoint }, validation, schema);
+                }
+            };
+            const internalOptions = {
+                name: staticMethodName,
+                httpMethod: httpMethod,
+                getEndpoint,
+                validate,
+                defaultHandler: defaultHandler_1.defaultHandler,
+                defaultStreamHandler: defaultStreamHandler_1.defaultStreamHandler,
+                schema: handlerSchema,
+            };
+            const internalInput = {
+                ...options,
+                ...input,
+                body: input.body ?? null,
+                query: input.query ?? {},
+                params: input.params ?? {},
+                meta: input.meta,
+            };
+            if (!fetcher)
+                throw new Error('Fetcher is not provided');
+            const [respData, resp] = await fetcher(internalOptions, internalInput);
+            return input.transform ? input.transform(respData, resp) : respData;
+        };
+        handler.schema = handlerSchema;
+        handler.controllerSchema = controllerSchema;
+        handler.segmentSchema = segmentSchema;
+        handler.fullSchema = schema;
+        handler.isRPC = true;
+        handler.path = [segmentNamePath, controllerPrefix, path].filter(Boolean).join('/');
+        // @ts-expect-error TODO
+        client[staticMethodName] = handler;
+    }
+    return client;
+};
+exports.createRPC = createRPC;

package/mjs/client/defaultHandler.d.ts

@@ -0,0 +1,6 @@
+import { VovkHandlerSchema } from '../types';
+export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultHandler";
+export declare const defaultHandler: ({ response, schema }: {
+    response: Response;
+    schema: VovkHandlerSchema;
+}) => Promise<unknown>;

package/mjs/client/defaultHandler.js

@@ -0,0 +1,29 @@
+"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';
+// Helper function to get a value from an object using dot notation path
+const getNestedValue = (obj, path) => {
+    return path.split('.').reduce((o, key) => (o && typeof o === 'object' ? o[key] : undefined), obj);
+};
+const defaultHandler = async ({ response, schema }) => {
+    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) {
+        const errorKey = schema.openapi && 'x-errorMessageKey' in schema.openapi
+            ? schema.openapi['x-errorMessageKey']
+            : 'message';
+        // handle server errors
+        const errorResponse = result;
+        throw new HttpException_1.HttpException(response.status, getNestedValue(errorResponse, errorKey) ?? exports.DEFAULT_ERROR_MESSAGE, errorResponse?.cause ?? JSON.stringify(result));
+    }
+    return result;
+};
+exports.defaultHandler = defaultHandler;

package/mjs/client/defaultStreamHandler.d.ts

@@ -0,0 +1,9 @@
+import { VovkHandlerSchema } from '../types';
+import type { VovkStreamAsyncIterable } from './types';
+import '../utils/shim';
+export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultStreamHandler";
+export declare const defaultStreamHandler: ({ response, controller, }: {
+    response: Response;
+    controller: AbortController;
+    schema: VovkHandlerSchema;
+}) => Promise<VovkStreamAsyncIterable<unknown>>;

package/mjs/client/defaultStreamHandler.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultStreamHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
+const types_1 = require("../types");
+const HttpException_1 = require("../HttpException");
+require("../utils/shim");
+exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at defaultStreamHandler';
+const defaultStreamHandler = async ({ response, controller, }) => {
+    if (!response.ok) {
+        let result;
+        try {
+            result = await response.json();
+        }
+        catch {
+            // ignore parsing errors
+        }
+        // handle server errors
+        throw new HttpException_1.HttpException(response.status, result.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    if (!response.body)
+        throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, 'Stream body is falsy. Check your controller code.');
+    const reader = response.body.getReader();
+    // if streaming is too rapid, we need to make sure that the loop is stopped
+    let canceled = false;
+    const subscribers = new Set();
+    async function* asyncIterator() {
+        let prepend = '';
+        while (true) {
+            let value;
+            try {
+                let done;
+                ({ value, done } = await reader.read());
+                if (done)
+                    break;
+            }
+            catch (error) {
+                await reader.cancel();
+                const err = new Error('Stream error. ' + String(error));
+                err.cause = error;
+                throw err;
+            }
+            // typeof value === 'number' is a workaround for React Native
+            const string = typeof value === 'number' ? String.fromCharCode(value) : new TextDecoder().decode(value);
+            prepend += string;
+            const lines = prepend.split('\n').filter(Boolean);
+            for (const line of lines) {
+                let data;
+                try {
+                    data = JSON.parse(line);
+                    prepend = '';
+                }
+                catch {
+                    break;
+                }
+                if (data) {
+                    subscribers.forEach((cb) => {
+                        if (!canceled)
+                            cb(data);
+                    });
+                    if ('isError' in data && 'reason' in data) {
+                        const upcomingError = data.reason;
+                        await reader.cancel();
+                        if (typeof upcomingError === 'string') {
+                            throw new Error(upcomingError);
+                        }
+                        throw upcomingError;
+                    }
+                    else if (!canceled) {
+                        yield data;
+                    }
+                }
+            }
+        }
+    }
+    return {
+        status: response.status,
+        [Symbol.asyncIterator]: asyncIterator,
+        [Symbol.dispose]: () => controller.abort(),
+        [Symbol.asyncDispose]: () => controller.abort(),
+        onIterate: (cb) => {
+            if (canceled)
+                return () => { };
+            subscribers.add(cb);
+            return () => {
+                subscribers.delete(cb);
+            };
+        },
+        abort: () => {
+            canceled = true;
+            return controller.abort();
+        },
+    };
+};
+exports.defaultStreamHandler = defaultStreamHandler;

package/mjs/client/fetcher.d.ts

@@ -0,0 +1,14 @@
+import type { VovkDefaultFetcherOptions, VovkClientFetcher } from './types';
+import { KnownAny } from '../types';
+export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at default fetcher";
+export declare function createFetcher<T>({ prepareRequestInit, transformResponse, }?: {
+    prepareRequestInit?: (init: RequestInit, options: VovkDefaultFetcherOptions<T>) => RequestInit | Promise<RequestInit> | void | Promise<void>;
+    transformResponse?: (respData: KnownAny, response: Response, options: VovkDefaultFetcherOptions<T>, init: RequestInit) => unknown;
+}): VovkClientFetcher<VovkDefaultFetcherOptions<T>>;
+export declare const fetcher: VovkClientFetcher<{
+    apiRoot?: string;
+    disableClientValidation?: boolean;
+    validateOnClient?: import("./types").VovkValidateOnClient;
+    interpretAs?: string;
+    init?: RequestInit;
+}>;

package/mjs/client/fetcher.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetcher = exports.DEFAULT_ERROR_MESSAGE = void 0;
+exports.createFetcher = createFetcher;
+const types_1 = require("../types");
+const HttpException_1 = require("../HttpException");
+exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at default fetcher';
+function createFetcher({ prepareRequestInit, transformResponse, } = {}) {
+    // fetcher uses HttpException class to throw errors of fake HTTP status 0 if client-side error occurs
+    // For normal HTTP errors, it uses message and status code from the response of VovkErrorResponse type
+    const newFetcher = async ({ httpMethod, getEndpoint, validate, defaultHandler, defaultStreamHandler, schema }, options) => {
+        const { params, query, body, meta, apiRoot, disableClientValidation, init, interpretAs } = options;
+        const endpoint = getEndpoint({ apiRoot, params, query });
+        const unusedParams = Array.from(new URL(endpoint.startsWith('/') ? `http://localhost${endpoint}` : endpoint).pathname.matchAll(/\{([^}]+)\}/g)).map((m) => m[1]);
+        if (unusedParams.length) {
+            throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, `Unused params: ${unusedParams.join(', ')} in ${endpoint}`, {
+                body,
+                query,
+                params,
+                endpoint,
+            });
+        }
+        if (!disableClientValidation) {
+            try {
+                await validate({ body, query, params, endpoint });
+            }
+            catch (e) {
+                // if HttpException is thrown, rethrow it
+                if (e instanceof HttpException_1.HttpException)
+                    throw e;
+                // otherwise, throw HttpException with status 0
+                throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE, {
+                    body,
+                    query,
+                    params,
+                    endpoint,
+                });
+            }
+        }
+        let requestInit = {
+            method: httpMethod,
+            ...init,
+            headers: {
+                accept: 'application/jsonl, application/json',
+                ...(body instanceof FormData ? {} : { 'content-type': 'application/json' }),
+                ...(meta ? { 'x-meta': JSON.stringify(meta) } : {}),
+                ...init?.headers,
+            },
+        };
+        if (body instanceof FormData) {
+            requestInit.body = body;
+        }
+        else if (body) {
+            requestInit.body = JSON.stringify(body);
+        }
+        requestInit = prepareRequestInit
+            ? ((await prepareRequestInit(requestInit, options)) ?? requestInit)
+            : requestInit;
+        let response;
+        const controller = new AbortController();
+        requestInit.signal = controller.signal;
+        try {
+            response = await fetch(endpoint, requestInit);
+        }
+        catch (e) {
+            // handle network errors
+            throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, (e?.message ?? exports.DEFAULT_ERROR_MESSAGE) + ' ' + endpoint, {
+                body,
+                query,
+                params,
+                endpoint,
+            });
+        }
+        const contentType = interpretAs ?? response.headers.get('content-type');
+        let resp;
+        if (contentType?.startsWith('application/jsonl')) {
+            resp = defaultStreamHandler({ response, controller, schema });
+        }
+        else if (contentType?.startsWith('application/json')) {
+            resp = defaultHandler({ response, schema });
+        }
+        else {
+            resp = response;
+        }
+        resp = await resp;
+        resp = transformResponse
+            ? await transformResponse(resp, response, options, requestInit)
+            : resp;
+        return [resp, response];
+    };
+    return newFetcher;
+}
+exports.fetcher = createFetcher();

package/mjs/client/index.d.ts

@@ -0,0 +1,4 @@
+export { createRPC } from './createRPC';
+export { fetcher, createFetcher } from './fetcher';
+export { progressive } from './progressive';
+export type { VovkClient, VovkClientFetcher, VovkDefaultFetcherOptions, VovkValidateOnClient, VovkStreamAsyncIterable, } from './types';

package/mjs/client/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progressive = exports.createFetcher = exports.fetcher = exports.createRPC = void 0;
+var createRPC_1 = require("./createRPC");
+Object.defineProperty(exports, "createRPC", { enumerable: true, get: function () { return createRPC_1.createRPC; } });
+var fetcher_1 = require("./fetcher");
+Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return fetcher_1.fetcher; } });
+Object.defineProperty(exports, "createFetcher", { enumerable: true, get: function () { return fetcher_1.createFetcher; } });
+var progressive_1 = require("./progressive");
+Object.defineProperty(exports, "progressive", { enumerable: true, get: function () { return progressive_1.progressive; } });

package/mjs/client/progressive.d.ts

@@ -0,0 +1,9 @@
+import type { VovkStreamAsyncIterable } from './types';
+import type { KnownAny, VovkYieldType } from '../types';
+type UnionToIntersection<U> = (U extends KnownAny ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type PromisifyProperties<T> = {
+    [K in keyof T]: Promise<T[K]>;
+};
+type TransformUnionToPromises<T> = PromisifyProperties<UnionToIntersection<T>>;
+export declare function progressive<T extends (...args: KnownAny[]) => Promise<VovkStreamAsyncIterable<KnownAny>>>(fn: T, ...args: undefined extends Parameters<T>[0] ? [arg?: Parameters<T>[0]] : [arg: Parameters<T>[0]]): TransformUnionToPromises<VovkYieldType<T>>;
+export {};

package/mjs/client/progressive.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progressive = progressive;
+function progressive(fn, ...args) {
+    const [arg] = args;
+    const reg = {};
+    void fn(arg)
+        .then(async (result) => {
+        for await (const item of result) {
+            for (const [key, value] of Object.entries(item)) {
+                if (key in reg) {
+                    if (!reg[key].isSettled) {
+                        reg[key].isSettled = true;
+                        reg[key].resolve(value);
+                    }
+                }
+                else {
+                    const { promise, resolve, reject } = Promise.withResolvers();
+                    reg[key] = { resolve, reject, promise, isSettled: true };
+                    reg[key].resolve(value);
+                }
+            }
+        }
+        return result;
+    })
+        .catch((error) => {
+        Object.keys(reg).forEach((key) => {
+            if (reg[key].isSettled)
+                return;
+            reg[key].isSettled = true;
+            reg[key].reject(error);
+        });
+        return error;
+    });
+    return new Proxy({}, {
+        get(_target, prop) {
+            if (prop in reg) {
+                return reg[prop].promise;
+            }
+            const { promise, resolve, reject } = Promise.withResolvers();
+            reg[prop] = { resolve, reject, promise, isSettled: false };
+            return promise;
+        },
+    });
+}

package/mjs/client/types.d.ts

@@ -0,0 +1,123 @@
+import type { KnownAny, HttpMethod, ControllerStaticMethod, VovkHandlerSchema, VovkControllerSchema, VovkSegmentSchema, VovkSchema, VovkRequest } from '../types';
+import type { JSONLinesResponse } from '../JSONLinesResponse';
+import type { NextResponse } from 'next/server';
+import type { defaultStreamHandler } from './defaultStreamHandler';
+import type { defaultHandler } from './defaultHandler';
+type OmitNullable<T> = {
+    [K in keyof T as T[K] extends null | undefined ? never : K]: T[K];
+};
+type Empty = {};
+export type StaticMethodInput<T extends ((req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => KnownAny) & {
+    __types?: {
+        isForm: boolean;
+    };
+}> = OmitNullable<(Parameters<T>[0] extends VovkRequest<infer BODY, infer QUERY, infer PARAMS> ? (BODY extends Record<KnownAny, KnownAny> ? {
+    body: T['__types'] extends {
+        isForm: true;
+    } ? FormData : BODY;
+} : Empty) & (QUERY extends Record<KnownAny, KnownAny> ? {
+    query: QUERY;
+} : Empty) & (PARAMS extends Record<KnownAny, KnownAny> ? {
+    params: PARAMS;
+} : Empty) & {
+    meta?: {
+        [key: string]: KnownAny;
+    };
+} : Empty) & (Parameters<T>[1] extends Record<KnownAny, KnownAny> ? {
+    params: Parameters<T>[1];
+} : Empty)>;
+type ToPromise<T> = T extends PromiseLike<unknown> ? T : Promise<T>;
+export type VovkStreamAsyncIterable<T> = {
+    status: number;
+    [Symbol.dispose](): Promise<void> | void;
+    [Symbol.asyncDispose](): Promise<void> | void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    onIterate: (cb: (data: T) => void) => () => void;
+    abort: () => 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> ? Awaited<ReturnType<T>> : ReturnType<T>;
+type StaticMethodReturnPromise<T extends ControllerStaticMethod> = ToPromise<StaticMethodReturn<T>>;
+type StaticMethodOptions<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<STREAM> | Promise<JSONLinesResponse<STREAM>>, OPTS extends Record<string, KnownAny>, STREAM, R, F extends VovkDefaultFetcherOptions<KnownAny>> = Partial<OPTS & {
+    transform: (staticMethodReturn: Awaited<StaticMethodReturn<T>>, resp: Response) => R;
+    fetcher: VovkClientFetcher<F>;
+}>;
+type ClientMethodReturn<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<STREAM> | Promise<JSONLinesResponse<STREAM>>, STREAM, R> = ReturnType<T> extends Promise<JSONLinesResponse<infer U>> | JSONLinesResponse<infer U> | Iterator<infer U> | AsyncIterator<infer U> ? Promise<VovkStreamAsyncIterable<U>> : R extends object ? Promise<Awaited<R>> : StaticMethodReturnPromise<T>;
+type ClientMethod<T extends ((req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<STREAM> | Promise<JSONLinesResponse<STREAM>>) & {
+    __types?: {
+        body: KnownAny;
+        query: KnownAny;
+        params: KnownAny;
+        output: KnownAny;
+        iteration: KnownAny;
+        isForm: boolean;
+    };
+}, OPTS extends Record<string, KnownAny>, STREAM extends KnownAny = unknown> = (IsEmptyObject<StaticMethodInput<T>> extends true ? <R, F extends VovkDefaultFetcherOptions<KnownAny> = VovkDefaultFetcherOptions<OPTS>>(options?: Prettify<StaticMethodOptions<T, OPTS, STREAM, R, F>>) => ClientMethodReturn<T, STREAM, R> : <R, F extends VovkDefaultFetcherOptions<KnownAny> = VovkDefaultFetcherOptions<OPTS>>(options: Prettify<StaticMethodInput<T> & StaticMethodOptions<T, OPTS, STREAM, R, F>>) => ClientMethodReturn<T, STREAM, R>) & {
+    isRPC: true;
+    schema: VovkHandlerSchema;
+    controllerSchema: VovkControllerSchema;
+    segmentSchema: VovkSegmentSchema;
+    fullSchema: VovkSchema;
+    __types: T['__types'];
+};
+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> : never;
+};
+export type VovkClient<T, OPTS extends {
+    [key: string]: KnownAny;
+}> = OmitNever<VovkClientWithNever<T, OPTS>>;
+export type VovkClientFetcher<OPTS> = (options: {
+    name: string;
+    httpMethod: HttpMethod;
+    getEndpoint: (data: {
+        apiRoot: string | undefined;
+        params: {
+            [key: string]: string;
+        };
+        query: {
+            [key: string]: string;
+        };
+    }) => string;
+    validate: (input: {
+        body?: unknown;
+        query?: unknown;
+        params?: unknown;
+        endpoint: string;
+    }) => void | Promise<void>;
+    defaultStreamHandler: typeof defaultStreamHandler;
+    defaultHandler: typeof defaultHandler;
+    schema: VovkHandlerSchema;
+}, input: {
+    body: unknown;
+    query: {
+        [key: string]: string;
+    };
+    params: {
+        [key: string]: string;
+    };
+    meta?: {
+        [key: string]: KnownAny;
+    };
+} & OPTS) => Promise<[KnownAny, Response]>;
+export type VovkDefaultFetcherOptions<T> = T & {
+    apiRoot?: string;
+    disableClientValidation?: boolean;
+    validateOnClient?: VovkValidateOnClient;
+    interpretAs?: string;
+    init?: RequestInit;
+};
+export type VovkValidateOnClient = (input: {
+    body?: unknown;
+    query?: unknown;
+    params?: unknown;
+    endpoint: string;
+}, validation: Omit<Exclude<VovkHandlerSchema['validation'], undefined>, 'output' | 'iteration'>, fullSchema: VovkSchema) => void | Promise<void>;
+type IsEmptyObject<T> = T extends object ? keyof T extends never ? true : T extends Partial<T> ? Partial<T> extends T ? true : false : false : false;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export {};

package/mjs/createVovkApp.d.ts

@@ -0,0 +1,63 @@
+import type { NextRequest } from 'next/server';
+import { type KnownAny, type DecoratorOptions, type VovkRequest, type StaticClass } from './types';
+export declare function createVovkApp(): {
+    get: {
+        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    post: {
+        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    put: {
+        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    patch: {
+        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    del: {
+        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    head: {
+        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    options: {
+        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    prefix: (givenPath?: string) => (givenTarget: KnownAny) => any;
+    initSegment: (options: {
+        segmentName?: string;
+        controllers: Record<string, StaticClass>;
+        exposeValidation?: boolean;
+        emitSchema?: boolean;
+        forceApiRoot?: string;
+        onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
+    }) => {
+        GET: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+        POST: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+        PUT: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+        PATCH: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+        DELETE: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+        HEAD: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+        OPTIONS: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+    };
+};