vovk 3.5.0 → 3.7.0

package/dist/client/create-rpc.d.ts

@@ -0,0 +1,13 @@
+import type { VovkHandlerSchema } from '../internal.js';
+import type { VovkRequest } from '../types/request.js';
+import type { VovkRPCModule, VovkFetcher, VovkFetcherOptions } from '../types/client.js';
+import type { CombinedSpec } from '../types/validation.js';
+import type { KnownAny } from '../types/utils.js';
+export type { VovkHandlerSchema, VovkRequest, CombinedSpec };
+/**
+ * Creates a client-side RPC module for interacting with server-side controllers.
+ * @see https://vovk.dev/typescript
+ */
+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/dist/client/create-rpc.js

@@ -0,0 +1,147 @@
+import { fetcher as defaultFetcher } from './fetcher.js';
+import { defaultHandler } from './default-handler.js';
+import { defaultStreamHandler } from './default-stream-handler.js';
+import { serializeQuery } from './serialize-query.js';
+import { deepExtend } from '../utils/deep-extend.js';
+const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
+const getHandlerPath = (endpoint, params, query) => {
+    let result = endpoint;
+    const queryStr = query ? serializeQuery(query) : null;
+    for (const [key, value] of Object.entries(params ?? {})) {
+        result = result.replace(`{${key}}`, value);
+    }
+    return `${result}${queryStr ? `?${queryStr}` : ''}`;
+};
+/**
+ * Creates a client-side RPC module for interacting with server-side controllers.
+ * @see https://vovk.dev/typescript
+ */
+export 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 = segmentSchema.forceApiRoot;
+    const configRootEntry = schema.meta?.config?.rootEntry;
+    const originalApiRoot = forceApiRoot ?? options?.apiRoot ?? (configRootEntry ? `/${configRootEntry}` : '/api');
+    for (const [staticMethodName, handlerSchema] of Object.entries(controllerSchema.handlers ?? {})) {
+        const { path, httpMethod, validation } = handlerSchema;
+        const getURL = ({ 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 optionsResolvedValidateOnClient = options?.validateOnClient instanceof Promise
+                ? (await options?.validateOnClient)?.validateOnClient
+                : options?.validateOnClient;
+            const fetcher = givenFetcher instanceof Promise
+                ? (await givenFetcher).fetcher
+                : (givenFetcher ?? defaultFetcher);
+            const validate = async (validationInput, { endpoint, }) => {
+                const validateOnClient = input.validateOnClient ?? optionsResolvedValidateOnClient;
+                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,
+                getURL,
+                validate,
+                defaultHandler,
+                defaultStreamHandler,
+                schema: handlerSchema,
+            };
+            let processedBody = input.body;
+            if ((validation?.body?.['x-contentType']?.includes('multipart/form-data') ||
+                validation?.body?.['x-contentType']?.includes('application/x-www-form-urlencoded')) &&
+                input.body &&
+                !(input.body instanceof FormData || input.body instanceof URLSearchParams || input.body instanceof Blob)) {
+                processedBody = new FormData();
+                for (const [key, value] of Object.entries(input.body)) {
+                    if (Array.isArray(value)) {
+                        value.forEach((item) => {
+                            processedBody.append(key, item);
+                        });
+                    }
+                    else {
+                        processedBody.append(key, value);
+                    }
+                }
+            }
+            else {
+                processedBody = input.body;
+            }
+            const internalInput = {
+                ...deepExtend({}, options, {
+                    validateOnClient: optionsResolvedValidateOnClient,
+                }, input),
+                body: processedBody ?? 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.getURL = getURL;
+        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;
+    }
+    Object.defineProperty(client, 'withDefaults', {
+        value: (newOptions) => {
+            return createRPC(schema, segmentName, rpcModuleName, givenFetcher, {
+                ...options,
+                ...newOptions,
+            });
+        },
+        enumerable: false,
+        writable: false,
+        configurable: false,
+    });
+    return client;
+};

package/dist/client/default-handler.d.ts

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

package/dist/client/default-handler.js

@@ -0,0 +1,25 @@
+import { HttpException } from '../core/http-exception.js';
+export const 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);
+};
+export const defaultHandler = async ({ response, schema }) => {
+    let result;
+    try {
+        result = await response.json();
+    }
+    catch (e) {
+        // handle parsing errors
+        throw new HttpException(response.status, e?.message ?? 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(response.status, getNestedValue(errorResponse, errorKey) ?? DEFAULT_ERROR_MESSAGE, errorResponse?.cause ?? JSON.stringify(result));
+    }
+    return result;
+};

package/dist/client/default-stream-handler.d.ts

@@ -0,0 +1,16 @@
+import type { VovkStreamAsyncIterable } from '../types/client.js';
+import '../utils/shim.js';
+export declare const DEFAULT_ERROR_MESSAGE = "An unknown error at the default stream handler";
+/**
+ * Converts a ReadableStream of JSON Lines into a VovkStreamAsyncIterable.
+ * This is the core streaming logic extracted for reuse outside of HTTP contexts.
+ * @see https://vovk.dev/jsonlines
+ */
+export declare const readableStreamToAsyncIterable: <T = unknown>({ readableStream, abortController, }: {
+    readableStream: ReadableStream<Uint8Array | string>;
+    abortController?: AbortController;
+}) => Omit<VovkStreamAsyncIterable<T>, "abortController" | "status">;
+export declare const defaultStreamHandler: ({ response, abortController, }: {
+    response: Response;
+    abortController: AbortController;
+}) => VovkStreamAsyncIterable<unknown>;

package/dist/client/default-stream-handler.js

@@ -0,0 +1,282 @@
+import { HttpStatus } from '../types/enums.js';
+import { HttpException } from '../core/http-exception.js';
+import '../utils/shim.js';
+export const DEFAULT_ERROR_MESSAGE = 'An unknown error at the default stream handler';
+/**
+ * Converts a ReadableStream of JSON Lines into a VovkStreamAsyncIterable.
+ * This is the core streaming logic extracted for reuse outside of HTTP contexts.
+ * @see https://vovk.dev/jsonlines
+ */
+export const readableStreamToAsyncIterable = ({ readableStream, abortController, }) => {
+    const reader = readableStream.getReader();
+    const subscribers = new Set();
+    // State
+    let isAbortedWithoutError = false;
+    let streamExhausted = false;
+    let streamError = null;
+    let errorIndex = -1;
+    let primaryStarted = false;
+    const cachedItems = [];
+    const waiters = [];
+    // --- Helper functions ---
+    const notifyWaiters = () => {
+        for (let i = waiters.length - 1; i >= 0; i--) {
+            const waiter = waiters[i];
+            let handled = false;
+            if (streamError && waiter.index >= errorIndex) {
+                waiter.reject(streamError);
+                handled = true;
+            }
+            else if (waiter.index < cachedItems.length) {
+                waiter.resolve({ value: cachedItems[waiter.index], done: false });
+                handled = true;
+            }
+            else if (streamExhausted || (abortController?.signal.aborted && isAbortedWithoutError)) {
+                waiter.resolve({ value: undefined, done: true });
+                handled = true;
+            }
+            if (handled) {
+                waiters.splice(i, 1);
+            }
+        }
+    };
+    const setStreamError = (error) => {
+        errorIndex = cachedItems.length;
+        streamError = error;
+        notifyWaiters();
+    };
+    const disposeStream = (reason) => {
+        isAbortedWithoutError = true;
+        streamExhausted = true;
+        notifyWaiters();
+        abortController?.abort(reason);
+        reader.cancel().catch(() => { });
+    };
+    // --- Primary reader ---
+    const runPrimaryReader = async () => {
+        let buffer = '';
+        let iterationIndex = 0;
+        // Returns true if the stream should stop (error encountered)
+        const processLine = (line) => {
+            let data;
+            try {
+                data = JSON.parse(line);
+            }
+            catch {
+                return false;
+            }
+            if (data) {
+                subscribers.forEach((cb) => {
+                    if (!abortController?.signal.aborted)
+                        cb(data, iterationIndex);
+                });
+                iterationIndex++;
+                if (typeof data === 'object' && data !== null && 'isError' in data && 'reason' in data) {
+                    const upcomingError = data.reason;
+                    abortController?.abort(upcomingError);
+                    const error = typeof upcomingError === 'string' ? new Error(upcomingError) : upcomingError;
+                    setStreamError(error);
+                    return true;
+                }
+                else if (!abortController?.signal.aborted) {
+                    cachedItems.push(data);
+                    notifyWaiters();
+                }
+            }
+            return false;
+        };
+        try {
+            while (true) {
+                if (abortController?.signal.aborted && isAbortedWithoutError) {
+                    break;
+                }
+                let value;
+                let done;
+                try {
+                    ({ value, done } = await reader.read());
+                    if (done)
+                        break;
+                }
+                catch (error) {
+                    if (error?.name === 'AbortError' && isAbortedWithoutError) {
+                        break;
+                    }
+                    const err = new Error(`JSONLines stream error. ${String(error)}`);
+                    err.cause = error;
+                    setStreamError(err);
+                    return;
+                }
+                const chunk = typeof value === 'string'
+                    ? value
+                    : typeof value === 'number'
+                        ? String.fromCharCode(value)
+                        : new TextDecoder().decode(value);
+                buffer += chunk;
+                let newlineIdx;
+                while (true) {
+                    newlineIdx = buffer.indexOf('\n');
+                    if (newlineIdx === -1)
+                        break;
+                    if (abortController?.signal.aborted && isAbortedWithoutError) {
+                        break;
+                    }
+                    const line = buffer.slice(0, newlineIdx);
+                    buffer = buffer.slice(newlineIdx + 1);
+                    if (!line)
+                        continue;
+                    if (processLine(line))
+                        return;
+                }
+                if (abortController?.signal.aborted && isAbortedWithoutError) {
+                    break;
+                }
+            }
+            // Process any remaining data in the buffer (last line without trailing newline)
+            const remaining = buffer.trim();
+            if (remaining) {
+                processLine(remaining);
+            }
+        }
+        finally {
+            streamExhausted = true;
+            notifyWaiters();
+        }
+    };
+    // --- Async iterator ---
+    async function* asyncIterator() {
+        if (!primaryStarted) {
+            primaryStarted = true;
+            void runPrimaryReader();
+        }
+        let index = 0;
+        while (true) {
+            // Check error first
+            if (streamError && index >= errorIndex) {
+                throw streamError;
+            }
+            // Clean exit on abort without error
+            if (abortController?.signal.aborted && isAbortedWithoutError) {
+                return;
+            }
+            // Yield from cache if available
+            if (index < cachedItems.length) {
+                yield cachedItems[index++];
+                continue;
+            }
+            // Stream finished
+            if (streamExhausted) {
+                return;
+            }
+            // Wait for next item or completion
+            const result = await new Promise((resolve, reject) => {
+                // Re-check state inside promise to handle race conditions
+                if (streamError && index >= errorIndex) {
+                    reject(streamError);
+                    return;
+                }
+                if (abortController?.signal.aborted && isAbortedWithoutError) {
+                    resolve({ value: undefined, done: true });
+                    return;
+                }
+                if (index < cachedItems.length) {
+                    resolve({ value: cachedItems[index], done: false });
+                    return;
+                }
+                if (streamExhausted) {
+                    resolve({ value: undefined, done: true });
+                    return;
+                }
+                waiters.push({ index, resolve, reject });
+            });
+            if (result.done) {
+                return;
+            }
+            index++;
+            yield result.value;
+        }
+    }
+    // --- Public API ---
+    const asPromise = async () => {
+        const items = [];
+        for await (const item of asyncIterator()) {
+            items.push(item);
+        }
+        return items;
+    };
+    const abortSilently = (reason) => {
+        isAbortedWithoutError = true;
+        streamExhausted = true;
+        notifyWaiters();
+        abortController?.abort(reason);
+        reader.cancel().catch(() => { });
+    };
+    return {
+        asPromise,
+        // abortController,
+        [Symbol.asyncIterator]: asyncIterator,
+        [Symbol.dispose]: () => disposeStream('Stream disposed'),
+        [Symbol.asyncDispose]: async () => disposeStream('Stream async disposed'),
+        abortSilently,
+        onIterate: (cb) => {
+            if (abortController?.signal.aborted)
+                return () => { };
+            subscribers.add(cb);
+            return () => subscribers.delete(cb);
+        },
+    };
+};
+export const defaultStreamHandler = ({ response, abortController, }) => {
+    // Handle error responses by creating a stream that fails on first iteration
+    if (!response.ok) {
+        let cachedError = null;
+        let errorParsed = false;
+        // Parse error asynchronously and cache it
+        void response
+            .json()
+            .then((res) => {
+            cachedError = new HttpException(response.status, res.message ?? DEFAULT_ERROR_MESSAGE);
+        })
+            .catch((e) => {
+            cachedError = new HttpException(response.status, e.message ?? DEFAULT_ERROR_MESSAGE, e);
+        })
+            .finally(() => {
+            errorParsed = true;
+        });
+        const getError = async () => {
+            // Wait for error to be parsed
+            while (!errorParsed) {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            }
+            return cachedError ?? new HttpException(response.status, DEFAULT_ERROR_MESSAGE);
+        };
+        const errorIterator = () => ({
+            async next() {
+                throw await getError();
+            },
+        });
+        const noop = () => { };
+        return {
+            status: response.status,
+            asPromise: async () => {
+                throw await getError();
+            },
+            abortController,
+            [Symbol.asyncIterator]: errorIterator,
+            [Symbol.dispose]: noop,
+            [Symbol.asyncDispose]: async () => { },
+            abortSilently: noop,
+            onIterate: () => noop,
+        };
+    }
+    if (!response.body) {
+        throw new HttpException(HttpStatus.NULL, 'Stream body is falsy');
+    }
+    return {
+        status: response.status,
+        abortController,
+        ...readableStreamToAsyncIterable({
+            readableStream: response.body,
+            abortController,
+        }),
+    };
+};

package/dist/client/fetcher.d.ts

@@ -1,4 +1,4 @@
-import { HttpException } from '../core/HttpException.js';
+import { HttpException } from '../core/http-exception.js';
 import type { VovkFetcherOptions, VovkFetcher } from '../types/client.js';
 import type { VovkHandlerSchema } from '../types/core.js';
 export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at default fetcher";

package/dist/client/fetcher.js

@@ -1,6 +1,6 @@
 import { HttpStatus } from '../types/enums.js';
-import { HttpException } from '../core/HttpException.js';
-import { fileNameToDisposition } from '../utils/fileNameToDisposition.js';
+import { HttpException } from '../core/http-exception.js';
+import { fileNameToDisposition } from '../utils/file-name-to-disposition.js';
 export const DEFAULT_ERROR_MESSAGE = 'Unknown error at default fetcher';
 /**
  * Creates a customizable fetcher function for client requests.

package/dist/client/serialize-query.d.ts

@@ -0,0 +1,13 @@
+import type { KnownAny } from '../types/utils.js';
+/**
+ * Serialize a nested object (including arrays, arrays of objects, etc.)
+ * into a bracket-based query string.
+ *
+ * @example
+ *   serializeQuery({ x: 'xx', y: [1, 2], z: { f: 'x' } })
+ *   => "x=xx&y[0]=1&y[1]=2&z[f]=x"
+ *
+ * @param obj - The input object to be serialized
+ * @returns   - A bracket-based query string (without leading "?")
+ */
+export declare function serializeQuery(obj: Record<string, KnownAny>): string;

package/dist/client/serialize-query.js

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

package/dist/core/apply-decorator-adapter.d.ts

@@ -0,0 +1,7 @@
+import type { VovkController } from '../types/core.js';
+import type { KnownAny } from '../types/utils.js';
+/**
+ * Adapts a decorator callback to work with experimental, 2018-09, and TC39 Stage 3 decorator formats.
+ * The callback receives (controller, propertyKey) when the class and field/method value are available.
+ */
+export declare function applyDecoratorAdapter(arg1: unknown, arg2: unknown, callback: (controller: VovkController, propertyKey: string) => void): KnownAny;

package/dist/core/apply-decorator-adapter.js

@@ -0,0 +1,50 @@
+/**
+ * Adapts a decorator callback to work with experimental, 2018-09, and TC39 Stage 3 decorator formats.
+ * The callback receives (controller, propertyKey) when the class and field/method value are available.
+ */
+export function applyDecoratorAdapter(arg1, arg2, callback) {
+    // Experimental decorators: (target, propertyKey: string)
+    if (typeof arg2 === 'string') {
+        callback(arg1, arg2);
+        return;
+    }
+    // TC39 Stage 3: (value, context: { kind, name, addInitializer })
+    if (typeof arg2 === 'object' && arg2 !== null && 'name' in arg2) {
+        const ctx = arg2;
+        const propertyKey = String(ctx.name);
+        if (ctx.kind === 'field') {
+            return function (initialValue) {
+                this[propertyKey] = initialValue;
+                callback(this, propertyKey);
+                return this[propertyKey];
+            };
+        }
+        ctx.addInitializer(function () {
+            callback(this, propertyKey);
+        });
+        return;
+    }
+    // 2018-09 proposal: (descriptor: { kind, key, placement, initializer? })
+    if (typeof arg1 === 'object' && arg1 !== null && 'kind' in arg1 && 'key' in arg1) {
+        const desc = arg1;
+        const propertyKey = String(desc.key);
+        if (desc.kind === 'field') {
+            const origInit = desc.initializer;
+            return {
+                ...desc,
+                initializer() {
+                    const value = origInit?.call(this);
+                    this[propertyKey] = value;
+                    callback(this, propertyKey);
+                    return this[propertyKey];
+                },
+            };
+        }
+        return {
+            ...desc,
+            finisher(klass) {
+                callback(klass, propertyKey);
+            },
+        };
+    }
+}

package/dist/core/controllers-to-static-params.d.ts

@@ -0,0 +1,13 @@
+import type { StaticClass } from '../types/utils.js';
+/**
+ * Generates static API of the given controllers for a static segment.
+ * @see https://vovk.dev/segment
+ * @example
+ * ```ts
+ * export function generateStaticParams() {
+ *  return controllersToStaticParams(controllers);
+ * }
+ */
+export declare function controllersToStaticParams(c: Record<string, StaticClass>, slug?: string): {
+    [slug]: string[];
+}[];