vovk 3.0.0-draft.21 → 3.0.0-draft.211

package/mjs/VovkApp.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VovkApp = void 0;
+const types_js_1 = require("./types.js");
+const HttpException_js_1 = require("./HttpException.js");
+const JSONLinesResponse_js_1 = require("./JSONLinesResponse.js");
+const reqQuery_js_1 = __importDefault(require("./utils/reqQuery.js"));
+const reqMeta_js_1 = __importDefault(require("./utils/reqMeta.js"));
+const reqForm_js_1 = __importDefault(require("./utils/reqForm.js"));
+const headers_1 = require("next/headers");
+class VovkApp {
+    static getHeadersFromOptions(options) {
+        if (!options)
+            return {};
+        const corsHeaders = {
+            'access-control-allow-origin': '*',
+            'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS, HEAD',
+            'access-control-allow-headers': 'content-type, authorization',
+        };
+        const headers = {
+            ...(options.cors ? corsHeaders : {}),
+            ...(options.headers ?? {}),
+        };
+        return headers;
+    }
+    routes = {
+        GET: new Map(),
+        POST: new Map(),
+        PUT: new Map(),
+        PATCH: new Map(),
+        DELETE: new Map(),
+        HEAD: new Map(),
+        OPTIONS: new Map(),
+    };
+    GET = async (req, data) => this.#callMethod(types_js_1.HttpMethod.GET, req, await data.params);
+    POST = async (req, data) => this.#callMethod(types_js_1.HttpMethod.POST, req, await data.params);
+    PUT = async (req, data) => this.#callMethod(types_js_1.HttpMethod.PUT, req, await data.params);
+    PATCH = async (req, data) => this.#callMethod(types_js_1.HttpMethod.PATCH, req, await data.params);
+    DELETE = async (req, data) => this.#callMethod(types_js_1.HttpMethod.DELETE, req, await data.params);
+    HEAD = async (req, data) => this.#callMethod(types_js_1.HttpMethod.HEAD, req, await data.params);
+    OPTIONS = async (req, data) => this.#callMethod(types_js_1.HttpMethod.OPTIONS, req, await data.params);
+    respond = (status, body, options) => {
+        return new Response(JSON.stringify(body), {
+            status,
+            headers: {
+                'content-type': 'application/json',
+                ..._a.getHeadersFromOptions(options),
+            },
+        });
+    };
+    #respondWithError = (statusCode, message, options, cause) => {
+        return this.respond(statusCode, {
+            cause,
+            statusCode,
+            message,
+            isError: true,
+        }, options);
+    };
+    #getHandler = ({ handlers, path, params, }) => {
+        const methodParams = {};
+        if (Object.keys(params).length === 0) {
+            return { handler: handlers[''], methodParams };
+        }
+        const allMethodKeys = Object.keys(handlers);
+        let methodKeys = [];
+        const pathStr = path.join('/');
+        methodKeys = allMethodKeys
+            // First, try to match literal routes exactly.
+            .filter((p) => {
+            if (p.includes(':'))
+                return false; // Skip parameterized paths
+            return p === pathStr;
+        });
+        if (!methodKeys.length) {
+            methodKeys = allMethodKeys.filter((p) => {
+                const routeSegments = p.split('/');
+                if (routeSegments.length !== path.length)
+                    return false;
+                for (let i = 0; i < routeSegments.length; i++) {
+                    const routeSegment = routeSegments[i];
+                    const pathSegment = path[i];
+                    if (routeSegment.startsWith(':')) {
+                        const parameter = routeSegment.slice(1);
+                        if (parameter in methodParams) {
+                            throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${parameter}" at ${p}`);
+                        }
+                        // If it's a parameterized segment, capture the parameter value.
+                        methodParams[parameter] = pathSegment;
+                    }
+                    else if (routeSegment !== pathSegment) {
+                        // If it's a literal segment and it does not match the corresponding path segment, return false.
+                        return false;
+                    }
+                }
+                return true;
+            });
+        }
+        if (methodKeys.length > 1) {
+            throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
+        }
+        const [methodKey] = methodKeys;
+        if (methodKey) {
+            return { handler: handlers[methodKey], methodParams };
+        }
+        return { handler: null, methodParams };
+    };
+    #callMethod = async (httpMethod, nextReq, params) => {
+        const req = nextReq;
+        const controllers = this.routes[httpMethod];
+        const path = params[Object.keys(params)[0]];
+        const handlers = {};
+        controllers.forEach((staticMethods, controller) => {
+            const prefix = controller._prefix ?? '';
+            if (!controller._activated) {
+                throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, `Controller "${controller.name}" found but not activated`);
+            }
+            Object.entries(staticMethods ?? {}).forEach(([path, staticMethod]) => {
+                const fullPath = [prefix, path].filter(Boolean).join('/');
+                handlers[fullPath] = { staticMethod, controller };
+            });
+        });
+        const { handler, methodParams } = this.#getHandler({ handlers, path, params });
+        if (!handler) {
+            return this.#respondWithError(types_js_1.HttpStatus.NOT_FOUND, `${Object.keys(handlers)} - Route ${path.join('/')} is not found`);
+        }
+        const { staticMethod, controller } = handler;
+        req.vovk = {
+            body: () => req.json(),
+            query: () => (0, reqQuery_js_1.default)(req),
+            meta: (meta) => (0, reqMeta_js_1.default)(req, meta),
+            form: () => (0, reqForm_js_1.default)(req),
+            params: () => methodParams,
+        };
+        try {
+            await staticMethod._options?.before?.call(controller, req);
+            const result = await staticMethod.call(controller, req, methodParams);
+            const isIterator = typeof result === 'object' &&
+                !!result &&
+                ((Reflect.has(result, Symbol.iterator) &&
+                    typeof result[Symbol.iterator] === 'function') ||
+                    (Reflect.has(result, Symbol.asyncIterator) &&
+                        typeof result[Symbol.asyncIterator] === 'function'));
+            if (isIterator && !(result instanceof Array)) {
+                const streamResponse = new JSONLinesResponse_js_1.JSONLinesResponse(await (0, headers_1.headers)(), {
+                    headers: {
+                        ..._a.getHeadersFromOptions(staticMethod._options),
+                    },
+                });
+                void (async () => {
+                    try {
+                        for await (const chunk of result) {
+                            streamResponse.send(chunk);
+                        }
+                    }
+                    catch (e) {
+                        return streamResponse.throw(e);
+                    }
+                    return streamResponse.close();
+                })();
+                return streamResponse;
+            }
+            if (result instanceof Response) {
+                return result;
+            }
+            return this.respond(200, result ?? null, staticMethod._options);
+        }
+        catch (e) {
+            const err = e;
+            try {
+                await controller._onError?.(err, req);
+            }
+            catch (onErrorError) {
+                // eslint-disable-next-line no-console
+                console.error(onErrorError);
+            }
+            if (err.message !== 'NEXT_REDIRECT' && err.message !== 'NEXT_NOT_FOUND') {
+                const statusCode = err.statusCode || types_js_1.HttpStatus.INTERNAL_SERVER_ERROR;
+                return this.#respondWithError(statusCode, err.message, staticMethod._options, err.cause);
+            }
+            throw e; // if NEXT_REDIRECT or NEXT_NOT_FOUND, rethrow it
+        }
+    };
+}
+exports.VovkApp = VovkApp;
+_a = VovkApp;

package/mjs/client/createRPC.d.ts

@@ -0,0 +1,3 @@
+import type { KnownAny, VovkSchema } from '../types.js';
+import type { VovkClient, VovkClientFetcher, VovkDefaultFetcherOptions } from './types.js';
+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,87 @@
+"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_js_1 = require("./fetcher.js");
+const defaultHandler_js_1 = require("./defaultHandler.js");
+const defaultStreamHandler_js_1 = require("./defaultStreamHandler.js");
+const serializeQuery_js_1 = __importDefault(require("../utils/serializeQuery.js"));
+const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
+const getHandlerPath = (endpoint, params, query) => {
+    let result = endpoint;
+    const queryStr = query ? (0, serializeQuery_js_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_js_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. Check client template.`);
+    const controllerSchema = schema.segments[segmentName]?.controllers[rpcModuleName];
+    const client = {};
+    if (!controllerSchema)
+        throw new Error(`Unable to create RPC module. Controller schema is missing. Check client template.`);
+    const controllerPrefix = trimPath(controllerSchema.prefix ?? '');
+    for (const [staticMethodName, handlerSchema] of Object.entries(controllerSchema.handlers ?? {})) {
+        const { path, httpMethod, validation } = handlerSchema;
+        const getEndpoint = ({ apiRoot, params, query, }) => {
+            apiRoot ??= options?.apiRoot ?? '/api';
+            const endpoint = [
+                apiRoot.startsWith('http://') || apiRoot.startsWith('https://') || apiRoot.startsWith('/') ? '' : '/',
+                apiRoot,
+                segmentNamePath,
+                getHandlerPath([controllerPrefix, path].filter(Boolean).join('/'), params, query),
+            ]
+                .filter(Boolean)
+                .join('/');
+            return endpoint;
+        };
+        const handler = (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_js_1.defaultHandler,
+                defaultStreamHandler: defaultStreamHandler_js_1.defaultStreamHandler,
+            };
+            const internalInput = {
+                ...options,
+                ...input,
+                body: input.body ?? null,
+                query: input.query ?? {},
+                params: input.params ?? {},
+            };
+            if (!fetcher)
+                throw new Error('Fetcher is not provided');
+            const fetcherPromise = fetcher(internalOptions, internalInput);
+            if (!(fetcherPromise instanceof Promise))
+                return Promise.resolve(fetcherPromise);
+            return input.transform ? fetcherPromise.then(input.transform) : fetcherPromise;
+        };
+        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,2 @@
+export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultHandler";
+export declare const defaultHandler: (response: Response) => Promise<unknown>;

package/mjs/client/defaultHandler.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
+const HttpException_js_1 = require("../HttpException.js");
+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_js_1.HttpException(response.status, e?.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    if (!response.ok) {
+        // handle server errors
+        const errorResponse = result;
+        throw new HttpException_js_1.HttpException(response.status, errorResponse?.message ?? exports.DEFAULT_ERROR_MESSAGE, errorResponse?.cause);
+    }
+    return result;
+};
+exports.defaultHandler = defaultHandler;

package/mjs/client/defaultStreamHandler.d.ts

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

package/mjs/client/defaultStreamHandler.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultStreamHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
+const types_js_1 = require("../types.js");
+const HttpException_js_1 = require("../HttpException.js");
+require("../utils/shim.js");
+exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at defaultStreamHandler';
+const defaultStreamHandler = async (response) => {
+    if (!response.ok) {
+        let result;
+        try {
+            result = await response.json();
+        }
+        catch {
+            // ignore parsing errors
+        }
+        // handle server errors
+        throw new HttpException_js_1.HttpException(response.status, result.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    if (!response.body)
+        throw new HttpException_js_1.HttpException(types_js_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;
+    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) {
+                    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]: () => reader.cancel(),
+        [Symbol.asyncDispose]: () => reader.cancel(),
+        cancel: () => {
+            canceled = true;
+            return reader.cancel();
+        },
+    };
+};
+exports.defaultStreamHandler = defaultStreamHandler;

package/mjs/client/fetcher.d.ts

@@ -0,0 +1,13 @@
+import type { VovkDefaultFetcherOptions, VovkClientFetcher } from './types.js';
+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?: (resp: unknown, options: VovkDefaultFetcherOptions<T>, init: RequestInit) => unknown;
+}): VovkClientFetcher<VovkDefaultFetcherOptions<T>>;
+export declare const fetcher: VovkClientFetcher<{
+    apiRoot?: string;
+    disableClientValidation?: boolean;
+    validateOnClient?: import("./types.js").VovkValidateOnClient;
+    interpretAs?: string;
+    init?: RequestInit;
+}>;

package/mjs/client/fetcher.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetcher = exports.DEFAULT_ERROR_MESSAGE = void 0;
+exports.createFetcher = createFetcher;
+const types_js_1 = require("../types.js");
+const HttpException_js_1 = require("../HttpException.js");
+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 }, options) => {
+        const { params, query, body, apiRoot, disableClientValidation, init, interpretAs } = options;
+        const endpoint = getEndpoint({ apiRoot, params, query });
+        const unusedParams = new URL(endpoint.startsWith('/') ? `http://localhost${endpoint}` : endpoint).pathname
+            .split('/')
+            .filter((segment) => segment.startsWith(':'));
+        if (unusedParams.length) {
+            throw new HttpException_js_1.HttpException(types_js_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_js_1.HttpException)
+                    throw e;
+                // otherwise, throw HttpException with status 0
+                throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE, {
+                    body,
+                    query,
+                    params,
+                    endpoint,
+                });
+            }
+        }
+        let requestInit = {
+            method: httpMethod,
+            ...init,
+            headers: {
+                accept: 'application/jsonl, application/json',
+                ...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;
+        try {
+            response = await fetch(endpoint, requestInit);
+        }
+        catch (e) {
+            // handle network errors
+            throw new HttpException_js_1.HttpException(types_js_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);
+        }
+        else if (contentType?.startsWith('application/json')) {
+            resp = defaultHandler(response);
+        }
+        else {
+            resp = response;
+        }
+        resp = await resp;
+        return transformResponse
+            ? ((await transformResponse(resp, options, requestInit)) ?? resp)
+            : resp;
+    };
+    return newFetcher;
+}
+exports.fetcher = createFetcher();

package/mjs/client/index.d.ts

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

package/mjs/client/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFetcher = exports.fetcher = exports.createRPC = void 0;
+var createRPC_js_1 = require("./createRPC.js");
+Object.defineProperty(exports, "createRPC", { enumerable: true, get: function () { return createRPC_js_1.createRPC; } });
+var fetcher_js_1 = require("./fetcher.js");
+Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return fetcher_js_1.fetcher; } });
+Object.defineProperty(exports, "createFetcher", { enumerable: true, get: function () { return fetcher_js_1.createFetcher; } });

package/mjs/client/types.d.ts

@@ -0,0 +1,111 @@
+import type { KnownAny, HttpMethod, ControllerStaticMethod, VovkHandlerSchema, VovkControllerSchema, VovkSegmentSchema, VovkSchema, VovkRequest } from '../types.js';
+import type { JSONLinesResponse } from '../JSONLinesResponse.js';
+import type { NextResponse } from 'next/server';
+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: NonNullable<T['__types']>['isForm'] extends true ? FormData : BODY;
+} : Empty) & (QUERY extends Record<KnownAny, KnownAny> ? {
+    query: QUERY;
+} : Empty) & (PARAMS extends Record<KnownAny, KnownAny> ? {
+    params: PARAMS;
+} : Empty) : 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>;
+    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> ? 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>>) => 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;
+    path: string;
+    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: (response: Response) => Promise<VovkStreamAsyncIterable<unknown>>;
+    defaultHandler: (response: Response) => Promise<unknown>;
+}, input: {
+    body: unknown;
+    query: {
+        [key: string]: string;
+    };
+    params: {
+        [key: string]: string;
+    };
+} & OPTS) => KnownAny;
+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 : false : false;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export {};