vovk 3.0.0-draft.46 → 3.0.0-draft.461

package/mjs/VovkApp.js

@@ -0,0 +1,304 @@
+"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_1 = require("./types");
+const HttpException_1 = require("./HttpException");
+const JSONLinesResponse_1 = require("./JSONLinesResponse");
+const reqQuery_1 = __importDefault(require("./utils/reqQuery"));
+const reqMeta_1 = __importDefault(require("./utils/reqMeta"));
+const reqForm_1 = __importDefault(require("./utils/reqForm"));
+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({ httpMethod: types_1.HttpMethod.GET, req, params: await data.params });
+    POST = async (req, data) => this.#callMethod({ httpMethod: types_1.HttpMethod.POST, req, params: await data.params });
+    PUT = async (req, data) => this.#callMethod({ httpMethod: types_1.HttpMethod.PUT, req, params: await data.params });
+    PATCH = async (req, data) => this.#callMethod({ httpMethod: types_1.HttpMethod.PATCH, req, params: await data.params });
+    DELETE = async (req, data) => this.#callMethod({ httpMethod: types_1.HttpMethod.DELETE, req, params: await data.params });
+    HEAD = async (req, data) => this.#callMethod({ httpMethod: types_1.HttpMethod.HEAD, req, params: await data.params });
+    OPTIONS = async (req, data) => this.#callMethod({ httpMethod: types_1.HttpMethod.OPTIONS, req, params: await data.params });
+    respond = async ({ statusCode, responseBody, options, }) => {
+        const response = new Response(JSON.stringify(responseBody), {
+            status: statusCode,
+            headers: {
+                'content-type': 'application/json',
+                ..._a.getHeadersFromOptions(options),
+            },
+        });
+        return response;
+    };
+    #respondWithError = ({ req, statusCode, message, options, cause, }) => {
+        return this.respond({
+            req,
+            statusCode,
+            responseBody: {
+                cause,
+                statusCode,
+                message,
+                isError: true,
+            },
+            options,
+        });
+    };
+    #routeRegexCache = new Map();
+    #routeSegmentsCache = new Map();
+    #routeParamPositionsCache = new Map();
+    #routeMatchCache = new Map();
+    #getHandler = ({ handlers, path, params, }) => {
+        let methodParams = {};
+        if (Object.keys(params).length === 0) {
+            return { handler: handlers[''], methodParams };
+        }
+        const pathStr = path.join('/');
+        // Fast path: Check if this exact path has been matched before
+        const cachedMatch = this.#routeMatchCache.get(pathStr);
+        if (cachedMatch) {
+            return {
+                handler: handlers[cachedMatch.route],
+                methodParams: cachedMatch.params,
+            };
+        }
+        // Check for direct static route match
+        let methodKey = handlers[pathStr] ? pathStr : null;
+        if (!methodKey) {
+            const methodKeys = [];
+            const pathLength = path.length;
+            // First pass: group routes by length for quick filtering
+            const routesByLength = new Map();
+            for (const p of Object.keys(handlers)) {
+                let routeSegments = this.#routeSegmentsCache.get(p);
+                if (!routeSegments) {
+                    routeSegments = p.split('/');
+                    this.#routeSegmentsCache.set(p, routeSegments);
+                    // Pre-compute parameter positions for routes with parameters
+                    if (p.includes('{')) {
+                        const paramPositions = [];
+                        for (let i = 0; i < routeSegments.length; i++) {
+                            const segment = routeSegments[i];
+                            if (segment.includes('{')) {
+                                const paramMatch = segment.match(/\{(\w+)\}/);
+                                if (paramMatch) {
+                                    paramPositions.push({ index: i, paramName: paramMatch[1] });
+                                }
+                            }
+                        }
+                        this.#routeParamPositionsCache.set(p, paramPositions);
+                    }
+                }
+                const segmentLength = routeSegments.length;
+                if (segmentLength !== pathLength)
+                    continue;
+                const lengthRoutes = routesByLength.get(segmentLength) || [];
+                lengthRoutes.push(p);
+                routesByLength.set(segmentLength, lengthRoutes);
+            }
+            // Only process routes with matching segment count
+            const candidateRoutes = routesByLength.get(pathLength) || [];
+            for (const p of candidateRoutes) {
+                const routeSegments = this.#routeSegmentsCache.get(p);
+                const params = {};
+                // Fast path for routes with parameters
+                const paramPositions = this.#routeParamPositionsCache.get(p);
+                if (paramPositions) {
+                    let isMatch = true;
+                    // First check all non-parameter segments for a quick fail
+                    for (let i = 0; i < routeSegments.length; i++) {
+                        const routeSegment = routeSegments[i];
+                        if (!routeSegment.includes('{') && routeSegment !== path[i]) {
+                            isMatch = false;
+                            break;
+                        }
+                    }
+                    if (!isMatch)
+                        continue;
+                    // Now process parameter segments
+                    for (const { index, paramName } of paramPositions) {
+                        const routeSegment = routeSegments[index];
+                        const pathSegment = path[index];
+                        let regex = this.#routeRegexCache.get(routeSegment);
+                        if (!regex) {
+                            const regexPattern = routeSegment
+                                .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+                                .replace(/\\{(\w+)\\}/g, '(?<$1>[^/]+)');
+                            regex = new RegExp(`^${regexPattern}$`);
+                            this.#routeRegexCache.set(routeSegment, regex);
+                        }
+                        const values = pathSegment.match(regex)?.groups;
+                        if (!values) {
+                            isMatch = false;
+                            break;
+                        }
+                        if (paramName in params) {
+                            throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${paramName}" at ${p}`);
+                        }
+                        params[paramName] = values[paramName];
+                    }
+                    if (isMatch) {
+                        methodParams = params;
+                        methodKeys.push(p);
+                    }
+                }
+                else {
+                    // Static route - simple equality comparison for all segments
+                    let isMatch = true;
+                    for (let i = 0; i < routeSegments.length; i++) {
+                        if (routeSegments[i] !== path[i]) {
+                            isMatch = false;
+                            break;
+                        }
+                    }
+                    if (isMatch) {
+                        methodKeys.push(p);
+                    }
+                }
+            }
+            if (methodKeys.length > 1) {
+                throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
+            }
+            [methodKey] = methodKeys;
+            // Cache successful matches
+            if (methodKey) {
+                this.#routeMatchCache.set(pathStr, { route: methodKey, params: methodParams });
+            }
+        }
+        if (methodKey) {
+            return { handler: handlers[methodKey], methodParams };
+        }
+        return { handler: null, methodParams };
+    };
+    #allHandlers = {};
+    #collectHandlers = (httpMethod) => {
+        const controllers = this.routes[httpMethod];
+        const handlers = {};
+        controllers.forEach((staticMethods, controller) => {
+            const prefix = controller._prefix ?? '';
+            Object.entries(staticMethods ?? {}).forEach(([path, staticMethod]) => {
+                const fullPath = [prefix, path].filter(Boolean).join('/');
+                handlers[fullPath] = { staticMethod, controller };
+            });
+        });
+        return handlers;
+    };
+    #callMethod = async ({ httpMethod, req: nextReq, params, }) => {
+        const req = nextReq;
+        const path = params[Object.keys(params)[0]];
+        const handlers = this.#allHandlers[httpMethod] ?? this.#collectHandlers(httpMethod);
+        this.#allHandlers[httpMethod] = handlers;
+        let headerList;
+        try {
+            headerList = nextReq.headers;
+        }
+        catch {
+            // this is static rendering environment, headers are not available
+            headerList = null;
+        }
+        const xMeta = headerList?.get('x-meta');
+        const xMetaHeader = xMeta && JSON.parse(xMeta);
+        if (xMetaHeader)
+            (0, reqMeta_1.default)(req, { xMetaHeader });
+        const { handler, methodParams } = this.#getHandler({ handlers, path, params });
+        if (!handler) {
+            return this.#respondWithError({
+                req,
+                statusCode: types_1.HttpStatus.NOT_FOUND,
+                message: `${Object.keys(handlers)} - Route ${path.join('/')} is not found`,
+            });
+        }
+        const { staticMethod, controller } = handler;
+        const { _onSuccess: onSuccess, _onBefore: onBefore } = controller;
+        req.vovk = {
+            body: () => req.json(),
+            query: () => (0, reqQuery_1.default)(req),
+            meta: (meta) => (0, reqMeta_1.default)(req, meta),
+            form: () => (0, reqForm_1.default)(req),
+            params: () => methodParams,
+        };
+        try {
+            await staticMethod._options?.before?.call(controller, req);
+            await onBefore?.(req);
+            const result = await staticMethod.call(controller, req, methodParams);
+            if (result instanceof Response) {
+                await onSuccess?.(result, req);
+                return result;
+            }
+            const isIterator = typeof result === 'object' &&
+                !!result &&
+                !(result instanceof Array) &&
+                ((Reflect.has(result, Symbol.iterator) &&
+                    typeof result[Symbol.iterator] === 'function') ||
+                    (Reflect.has(result, Symbol.asyncIterator) &&
+                        typeof result[Symbol.asyncIterator] === 'function'));
+            if (isIterator) {
+                const streamResponse = new JSONLinesResponse_1.JSONLinesResponse(req, {
+                    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();
+                })();
+                await onSuccess?.(streamResponse, req);
+                return streamResponse;
+            }
+            const responseBody = result ?? null;
+            await onSuccess?.(responseBody, req);
+            return this.respond({ req, statusCode: 200, responseBody, options: 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_1.HttpStatus.INTERNAL_SERVER_ERROR;
+                return this.#respondWithError({
+                    req,
+                    statusCode,
+                    message: err.message,
+                    options: staticMethod._options,
+                    cause: 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,5 @@
+import type { KnownAny } from '../types';
+import type { VovkRPCModule, VovkFetcher, VovkFetcherOptions } from './types';
+export declare const createRPC: <T, OPTS extends Record<string, KnownAny> = Record<string, never>>(givenSchema: unknown, segmentName: string, rpcModuleName: string, givenFetcher?: VovkFetcher<OPTS> | Promise<{
+    fetcher: VovkFetcher<OPTS>;
+}>, options?: VovkFetcherOptions<OPTS>) => VovkRPCModule<T, OPTS>;

package/mjs/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/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.operationObject && 'x-errorMessageKey' in schema.operationObject
+            ? schema.operationObject['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 = "An unknown error at defaultStreamHandler";
+export declare const defaultStreamHandler: ({ response, abortController, }: {
+    response: Response;
+    abortController: AbortController;
+    schema: VovkHandlerSchema;
+}) => VovkStreamAsyncIterable<unknown>;

package/mjs/client/defaultStreamHandler.js

@@ -0,0 +1,105 @@
+"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 = 'An unknown error at defaultStreamHandler';
+const defaultStreamHandler = ({ response, abortController, }) => {
+    if (!response.ok) {
+        response
+            .json()
+            .then((res) => {
+            throw new HttpException_1.HttpException(response.status, res.message ?? exports.DEFAULT_ERROR_MESSAGE);
+        })
+            .catch((e) => {
+            throw new HttpException_1.HttpException(response.status, e.message ?? exports.DEFAULT_ERROR_MESSAGE, e);
+        });
+        // handle server errors
+    }
+    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();
+    const subscribers = new Set();
+    async function* asyncIterator() {
+        let prepend = '';
+        let i = 0;
+        while (true) {
+            let value;
+            try {
+                let done;
+                if (abortController.signal.aborted)
+                    break;
+                ({ value, done } = await reader.read());
+                if (done)
+                    break;
+            }
+            catch (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;
+            }
+            // 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 = 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;
+                        abortController.abort(data.reason);
+                        if (typeof upcomingError === 'string') {
+                            throw new Error(upcomingError);
+                        }
+                        throw upcomingError;
+                    }
+                    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]: () => {
+            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);
+            };
+        },
+    };
+};
+exports.defaultStreamHandler = defaultStreamHandler;

package/mjs/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;
+}>;