vovk 3.0.0-draft.46 → 3.0.0-draft.460

package/cjs/client/createRPC.js

@@ -0,0 +1,116 @@
+"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 = (givenSchema, segmentName, rpcModuleName, givenFetcher, options) => {
+    const schema = givenSchema; // fixes incompatibilities with JSON module
+    // fetcher ??= defaultFetcher as NonNullable<typeof fetcher>;
+    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}".`);
+    let controllerSchema = schema.segments[segmentName]?.controllers[rpcModuleName];
+    const client = {};
+    if (!controllerSchema) {
+        // eslint-disable-next-line no-console
+        console.warn(`🐺 Unable to create RPC module. Controller schema is missing for module "${rpcModuleName}" from segment "${segmentName}". Assuming that schema is not ready yet and a segment is importing an uncompiled RPC module.`);
+        controllerSchema = {
+            rpcModuleName,
+            prefix: '',
+            handlers: {},
+        };
+    }
+    const controllerPrefix = trimPath(controllerSchema.prefix ?? '');
+    const forceApiRoot = controllerSchema.forceApiRoot ?? segmentSchema.forceApiRoot;
+    const originalApiRoot = forceApiRoot ?? options?.apiRoot ?? '/api';
+    for (const [staticMethodName, handlerSchema] of Object.entries(controllerSchema.handlers ?? {})) {
+        const { path, httpMethod, validation } = handlerSchema;
+        const getEndpoint = ({ apiRoot, params, query }) => {
+            apiRoot = apiRoot ?? originalApiRoot;
+            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 fetcher = givenFetcher instanceof Promise
+                ? (await givenFetcher).fetcher
+                : (givenFetcher ?? fetcher_1.fetcher);
+            const validate = async (validationInput, { endpoint, }) => {
+                const validateOnClient = input.validateOnClient ??
+                    (options?.validateOnClient instanceof Promise
+                        ? (await options?.validateOnClient)?.validateOnClient
+                        : options?.validateOnClient);
+                if (validateOnClient && validation) {
+                    if (typeof validateOnClient !== 'function') {
+                        throw new Error('validateOnClient must be a function');
+                    }
+                    return ((await validateOnClient({ ...validationInput }, validation, { fullSchema: schema, endpoint })) ??
+                        validationInput);
+                }
+                return validationInput;
+            };
+            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 ?? {},
+            };
+            if (!fetcher)
+                throw new Error('Fetcher is not provided');
+            const [respData, resp] = await fetcher(internalOptions, internalInput);
+            return input.transform ? input.transform(respData, resp) : respData;
+        });
+        // TODO use Object.freeze, Object.seal or Object.defineProperty to avoid mutation
+        handler.schema = handlerSchema;
+        handler.controllerSchema = controllerSchema;
+        handler.segmentSchema = segmentSchema;
+        handler.fullSchema = schema;
+        handler.isRPC = true;
+        handler.apiRoot = originalApiRoot;
+        handler.path = [segmentNamePath, controllerPrefix, path].filter(Boolean).join('/');
+        handler.queryKey = (key) => [
+            handler.segmentSchema.segmentName,
+            handler.controllerSchema.prefix ?? '',
+            handler.controllerSchema.rpcModuleName,
+            handler.schema.path,
+            handler.schema.httpMethod,
+            ...(key ?? []),
+        ];
+        // @ts-expect-error TODO
+        client[staticMethodName] = handler;
+    }
+    return client;
+};
+exports.createRPC = createRPC;

package/cjs/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/{client → cjs/client}/defaultHandler.js

@@ -3,7 +3,11 @@ 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) => {
+// 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();
@@ -13,9 +17,12 @@ const defaultHandler = async (response) => {
         throw new HttpException_1.HttpException(response.status, e?.message ?? exports.DEFAULT_ERROR_MESSAGE);
     }
     if (!response.ok) {
+        const errorKey = schema.operationObject && 'x-errorMessageKey' in schema.operationObject
+            ? schema.operationObject['x-errorMessageKey']
+            : 'message';
         // handle server errors
         const errorResponse = result;
-        throw new HttpException_1.HttpException(response.status, errorResponse?.message ?? exports.DEFAULT_ERROR_MESSAGE, errorResponse?.cause);
+        throw new HttpException_1.HttpException(response.status, getNestedValue(errorResponse, errorKey) ?? exports.DEFAULT_ERROR_MESSAGE, errorResponse?.cause ?? JSON.stringify(result));
     }
     return result;
 };

package/cjs/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 = "An unknown error at defaultStreamHandler";
+export declare const defaultStreamHandler: ({ response, abortController, }: {
+    response: Response;
+    abortController: AbortController;
+    schema: VovkHandlerSchema;
+}) => VovkStreamAsyncIterable<unknown>;

package/{client → cjs/client}/defaultStreamHandler.js

@@ -4,41 +4,42 @@ 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) => {
+exports.DEFAULT_ERROR_MESSAGE = 'An unknown error at defaultStreamHandler';
+const defaultStreamHandler = ({ response, abortController, }) => {
     if (!response.ok) {
-        let result;
-        try {
-            result = await response.json();
-        }
-        catch {
-            // ignore parsing errors
-        }
+        response
+            .json()
+            .then((res) => {
+            throw new HttpException_1.HttpException(response.status, res.message ?? exports.DEFAULT_ERROR_MESSAGE);
+        })
+            .catch(() => {
+            throw new HttpException_1.HttpException(response.status, exports.DEFAULT_ERROR_MESSAGE);
+        });
         // 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 = '';
+        let i = 0;
         while (true) {
             let value;
-            let done = false;
             try {
+                let done;
+                if (abortController.signal.aborted)
+                    break;
                 ({ value, done } = await reader.read());
+                if (done)
+                    break;
             }
             catch (error) {
-                await reader.cancel();
-                const err = new Error('Stream error. ' + String(error));
+                // await reader.cancel(); // TODO in which cases it needs to be canceled?
+                const err = new Error('JSONLines stream error. ' + String(error));
                 err.cause = error;
                 throw err;
             }
-            if (done) {
-                return;
-            }
             // typeof value === 'number' is a workaround for React Native
             const string = typeof value === 'number' ? String.fromCharCode(value) : new TextDecoder().decode(value);
             prepend += string;
@@ -47,35 +48,57 @@ const defaultStreamHandler = async (response) => {
                 let data;
                 try {
                     data = JSON.parse(line);
-                    prepend = '';
+                    prepend = prepend.slice(line.length + 1);
                 }
                 catch {
                     break;
                 }
                 if (data) {
+                    subscribers.forEach((cb) => {
+                        if (!abortController.signal.aborted)
+                            cb(data, i);
+                    });
+                    i++;
                     if ('isError' in data && 'reason' in data) {
                         const upcomingError = data.reason;
-                        await reader.cancel();
+                        abortController.abort(data.reason);
                         if (typeof upcomingError === 'string') {
                             throw new Error(upcomingError);
                         }
                         throw upcomingError;
                     }
-                    else if (!canceled) {
+                    else if (!abortController.signal.aborted) {
                         yield data;
                     }
                 }
             }
         }
     }
+    const asPromise = async () => {
+        const items = [];
+        for await (const item of asyncIterator()) {
+            items.push(item);
+        }
+        return items;
+    };
     return {
         status: response.status,
+        asPromise,
+        abortController,
         [Symbol.asyncIterator]: asyncIterator,
-        [Symbol.dispose]: () => reader.cancel(),
-        [Symbol.asyncDispose]: () => reader.cancel(),
-        cancel: () => {
-            canceled = true;
-            return reader.cancel();
+        [Symbol.dispose]: () => {
+            abortController.abort('Stream disposed');
+        },
+        [Symbol.asyncDispose]: () => {
+            abortController.abort('Stream async disposed');
+        },
+        onIterate: (cb) => {
+            if (abortController.signal.aborted)
+                return () => { };
+            subscribers.add(cb);
+            return () => {
+                subscribers.delete(cb);
+            };
         },
     };
 };

package/cjs/client/fetcher.d.ts

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

package/cjs/client/fetcher.js

@@ -0,0 +1,97 @@
+"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, onSuccess, onError, } = {}) {
+    // 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 }, inputOptions) => {
+        let response = null;
+        let respData = null;
+        let requestInit = null;
+        try {
+            const { meta, apiRoot, disableClientValidation, init, interpretAs } = inputOptions;
+            let { body, query, params } = inputOptions;
+            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 {
+                    ({ body, query, params } = (await validate(inputOptions, { endpoint })) ?? { body, query, params });
+                }
+                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,
+                    });
+                }
+            }
+            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);
+            }
+            const abortController = new AbortController();
+            requestInit.signal = abortController.signal;
+            requestInit = prepareRequestInit ? await prepareRequestInit(requestInit, inputOptions) : requestInit;
+            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');
+            if (contentType?.startsWith('application/jsonl')) {
+                respData = defaultStreamHandler({ response, abortController, schema });
+            }
+            else if (contentType?.startsWith('application/json')) {
+                respData = await defaultHandler({ response, schema });
+            }
+            else {
+                respData = response;
+            }
+            respData = transformResponse ? await transformResponse(respData, inputOptions, response, requestInit) : respData;
+            await onSuccess?.(respData, inputOptions, response, requestInit);
+            return [respData, response];
+        }
+        catch (error) {
+            await onError?.(error, inputOptions, response, requestInit, respData);
+            throw error;
+        }
+    };
+    return newFetcher;
+}
+exports.fetcher = createFetcher();

package/cjs/client/index.d.ts

@@ -0,0 +1,4 @@
+export { createRPC } from './createRPC';
+export { fetcher, createFetcher } from './fetcher';
+export { progressive } from './progressive';
+export type { VovkRPCModule, VovkFetcher, VovkFetcherOptions, VovkValidateOnClient, VovkStreamAsyncIterable, } from './types';

package/cjs/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/cjs/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/cjs/client/progressive.js

@@ -0,0 +1,54 @@
+"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);
+                }
+            }
+        }
+        Object.keys(reg).forEach((key) => {
+            if (reg[key].isSettled)
+                return;
+            reg[key].isSettled = true;
+            reg[key].reject(new Error(`The connection was closed without sending a value for "${key}"`));
+        });
+        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;
+        },
+        ownKeys: () => {
+            throw new Error('Getting own keys is not possible as they are dynamically created');
+        },
+    });
+}

package/cjs/client/types.d.ts

@@ -0,0 +1,120 @@
+import type { NextResponse } from 'next/server';
+import type { KnownAny, HttpMethod, ControllerStaticMethod, VovkHandlerSchema, VovkControllerSchema, VovkSegmentSchema, VovkSchema, VovkRequest, Prettify, IsEmptyObject } from '../types';
+import type { JSONLinesResponse } from '../JSONLinesResponse';
+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 TBody, infer TQuery, infer TParams> ? (TBody extends Record<KnownAny, KnownAny> ? {
+    body: T['__types'] extends {
+        isForm: true;
+    } ? FormData : TBody;
+} : Empty) & (TQuery extends Record<KnownAny, KnownAny> ? {
+    query: TQuery;
+} : Empty) & (TParams extends Record<KnownAny, KnownAny> ? {
+    params: TParams;
+} : 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;
+    asPromise: () => Promise<T[]>;
+    [Symbol.dispose](): Promise<void> | void;
+    [Symbol.asyncDispose](): Promise<void> | void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    onIterate: (cb: (data: T, i: number) => void) => () => void;
+    abortController: AbortController;
+};
+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<TStreamIteration> | Promise<JSONLinesResponse<TStreamIteration>>, TFetcherOptions extends Record<string, KnownAny>, TStreamIteration, R, F extends VovkFetcherOptions<KnownAny>> = Partial<TFetcherOptions & {
+    transform: (staticMethodReturn: Awaited<StaticMethodReturn<T>>, resp: Response) => R;
+    fetcher: VovkFetcher<F>;
+}>;
+export type ClientMethodReturn<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<TStreamIteration> | Promise<JSONLinesResponse<TStreamIteration>>, TStreamIteration, 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>;
+export type ClientMethod<T extends ((req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<TStreamIteration> | Promise<JSONLinesResponse<TStreamIteration>>) & {
+    __types?: {
+        body: KnownAny;
+        query: KnownAny;
+        params: KnownAny;
+        output: KnownAny;
+        iteration: KnownAny;
+        isForm: boolean;
+    };
+}, TFetcherOptions extends Record<string, KnownAny>, TStreamIteration extends KnownAny = unknown> = (IsEmptyObject<StaticMethodInput<T>> extends true ? <R, F extends VovkFetcherOptions<KnownAny> = VovkFetcherOptions<TFetcherOptions>>(options?: Prettify<StaticMethodOptions<T, TFetcherOptions, TStreamIteration, R, F>>) => ClientMethodReturn<T, TStreamIteration, R> : <R, F extends VovkFetcherOptions<KnownAny> = VovkFetcherOptions<TFetcherOptions>>(options: Prettify<StaticMethodInput<T> & StaticMethodOptions<T, TFetcherOptions, TStreamIteration, R, F>>) => ClientMethodReturn<T, TStreamIteration, R>) & {
+    isRPC: true;
+    schema: VovkHandlerSchema;
+    controllerSchema: VovkControllerSchema;
+    segmentSchema: VovkSegmentSchema;
+    fullSchema: VovkSchema;
+    path: string;
+    apiRoot: string;
+    queryKey: (key?: unknown[]) => unknown[];
+    __types: T['__types'];
+};
+type OmitNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+type VovkClientWithNever<T, TFetcherOptions extends {
+    [key: string]: KnownAny;
+}> = {
+    [K in keyof T]: T[K] extends (...args: KnownAny) => KnownAny ? ClientMethod<T[K], TFetcherOptions> : never;
+};
+export type VovkRPCModule<T, TFetcherOptions extends {
+    [key: string]: KnownAny;
+}> = OmitNever<VovkClientWithNever<T, TFetcherOptions>>;
+export type VovkFetcher<TFetcherOptions> = (options: {
+    name: string;
+    httpMethod: HttpMethod;
+    getEndpoint: (data: {
+        apiRoot: string | undefined;
+        params: unknown;
+        query: unknown;
+    }) => string;
+    validate: (inputOptions: {
+        body?: unknown;
+        query?: unknown;
+        params?: unknown;
+        meta?: unknown;
+    } & TFetcherOptions, meta: {
+        endpoint: string;
+    }) => KnownAny | Promise<KnownAny>;
+    defaultStreamHandler: typeof defaultStreamHandler;
+    defaultHandler: typeof defaultHandler;
+    schema: VovkHandlerSchema;
+}, input: {
+    body?: unknown;
+    query?: unknown;
+    params?: unknown;
+    meta?: unknown;
+} & TFetcherOptions) => Promise<[KnownAny, Response]>;
+export type VovkFetcherOptions<T> = T & {
+    apiRoot?: string;
+    disableClientValidation?: boolean;
+    validateOnClient?: VovkValidateOnClient<T> | Promise<{
+        validateOnClient: VovkValidateOnClient<T>;
+    }>;
+    interpretAs?: string;
+    init?: RequestInit;
+};
+export type VovkValidateOnClient<TFetcherOptions> = (input: {
+    body?: unknown;
+    query?: unknown;
+    params?: unknown;
+    meta?: unknown;
+} & TFetcherOptions, validation: Omit<Exclude<VovkHandlerSchema['validation'], undefined>, 'output' | 'iteration'>, meta: {
+    fullSchema: VovkSchema;
+    endpoint: string;
+}) => KnownAny | Promise<KnownAny>;
+export {};