@wirebench/engine 2.1.1

package/dist/grpc/proto/describe.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Reading a {@link ProtoSet} back as plain, serialisable descriptions: the services and methods an
+ * import turns into folders and requests, and the shape of a message the editor's Form view and
+ * sample generator work from. Nothing here holds a parser object, so the result crosses IPC as it is.
+ */
+import protobuf from 'protobufjs';
+import type { GrpcMethodKind } from '../model.js';
+import type { ProtoSet } from './load.js';
+/** One method of a service, as declared. */
+export interface GrpcMethodDescriptor {
+    readonly name: string;
+    readonly service: string;
+    readonly kind: GrpcMethodKind;
+    /** Fully qualified request and response message types, without a leading dot. */
+    readonly requestType: string;
+    readonly responseType: string;
+    readonly comment?: string;
+    readonly deprecated?: boolean;
+}
+/** One service, with its methods in declaration order. */
+export interface GrpcServiceDescriptor {
+    /** The short name, e.g. `Greeter`. */
+    readonly name: string;
+    /** The fully qualified name, e.g. `helloworld.Greeter`. */
+    readonly fullName: string;
+    /** The enclosing package, empty when the file declares none. */
+    readonly package: string;
+    readonly comment?: string;
+    readonly methods: readonly GrpcMethodDescriptor[];
+}
+/** What kind of value a field holds. */
+export type FieldValueKind = 'scalar' | 'enum' | 'message' | 'map';
+/** One field of a message. */
+export interface MessageFieldDescriptor {
+    readonly name: string;
+    readonly id: number;
+    /** The declared type: a scalar name, or a fully qualified message or enum name. */
+    readonly type: string;
+    readonly valueKind: FieldValueKind;
+    readonly repeated: boolean;
+    /** Declared with the `optional` keyword (proto3 explicit presence, or any proto2 optional field). */
+    readonly optional: boolean;
+    /** The `oneof` this field belongs to, when it does. */
+    readonly oneof?: string;
+    /** For a map field: the key's scalar type. */
+    readonly mapKeyType?: string;
+    /** For an enum field: the value names, in declaration order. */
+    readonly enumValues?: readonly string[];
+    readonly comment?: string;
+}
+/** A message type, flattened for a reader that does not hold the parser's objects. */
+export interface MessageDescriptor {
+    readonly fullName: string;
+    readonly fields: readonly MessageFieldDescriptor[];
+    readonly oneofs: readonly string[];
+}
+/** A reflection object's fully qualified name without the leading dot protobufjs adds. */
+export declare function qualifiedName(object: protobuf.ReflectionObject): string;
+/** Every service in the set, in file and declaration order. */
+export declare function describeServices(set: ProtoSet): GrpcServiceDescriptor[];
+/**
+ * The message type `fullName` names.
+ *
+ * @throws ProtoError `proto-type-unknown` when the set has no such message
+ */
+export declare function lookupMessageType(set: ProtoSet, fullName: string): protobuf.Type;
+/**
+ * The method `service`/`method` names, resolved.
+ *
+ * @throws ProtoError `proto-method-unknown` when the set has no such service or method
+ */
+export declare function lookupMethod(set: ProtoSet, service: string, method: string): protobuf.Method;
+/** The request and response message types of one method, plus its streaming shape. */
+export declare function describeMethod(set: ProtoSet, service: string, method: string): GrpcMethodDescriptor;
+/** The fields of the message type `fullName`, in field-number order. */
+export declare function describeMessage(set: ProtoSet, fullName: string): MessageDescriptor;
+/**
+ * The message whose fields belong at `path` — a chain of JSON object keys — under `rootType`.
+ *
+ * `path` is what {@link jsonCompletionContextAt} reports, so it carries no array indices: a
+ * repeated field is descended through as if it were singular. A map field is followed by the
+ * user's own key, which is consumed here, since only the schema knows that a level of the
+ * document is a map rather than a nested message.
+ *
+ * Returns `undefined` when the path names a field the message does not have, stops on a scalar or
+ * an enum, or ends on a map whose entries the user names — and for a well-known type, whose JSON
+ * is its own mapping (a `Timestamp` is a string, a wrapper is a bare value) rather than its
+ * fields, so offering those fields would be offering a document protobuf will not read back.
+ *
+ * @throws ProtoError `proto-type-unknown` when the set has no `rootType`
+ */
+export declare function describeMessageAt(set: ProtoSet, rootType: string, path: readonly string[]): MessageDescriptor | undefined;

package/dist/grpc/proto/describe.js

@@ -0,0 +1,205 @@
+/**
+ * Reading a {@link ProtoSet} back as plain, serialisable descriptions: the services and methods an
+ * import turns into folders and requests, and the shape of a message the editor's Form view and
+ * sample generator work from. Nothing here holds a parser object, so the result crosses IPC as it is.
+ */
+import protobuf from 'protobufjs';
+import { ProtoError } from '../../errors.js';
+import { WELL_KNOWN_TYPES } from './well-known.js';
+function methodKindOf(method) {
+    if (method.requestStream === true && method.responseStream === true) {
+        return 'bidi-streaming';
+    }
+    if (method.requestStream === true) {
+        return 'client-streaming';
+    }
+    if (method.responseStream === true) {
+        return 'server-streaming';
+    }
+    return 'unary';
+}
+/** A reflection object's fully qualified name without the leading dot protobufjs adds. */
+export function qualifiedName(object) {
+    return object.fullName.replace(/^\./, '');
+}
+function commentOf(object) {
+    const text = object.comment?.trim();
+    return text !== undefined && text.length > 0 ? { comment: text } : {};
+}
+function walkServices(namespace, out) {
+    for (const nested of namespace.nestedArray) {
+        if (nested instanceof protobuf.Service) {
+            out.push(nested);
+        }
+        else if (nested instanceof protobuf.Namespace) {
+            walkServices(nested, out);
+        }
+    }
+}
+/** Every service in the set, in file and declaration order. */
+export function describeServices(set) {
+    const services = [];
+    walkServices(set.root, services);
+    return services.map((service) => {
+        const fullName = qualifiedName(service);
+        const packageName = fullName.slice(0, Math.max(0, fullName.length - service.name.length - 1));
+        return {
+            name: service.name,
+            fullName,
+            package: packageName,
+            ...commentOf(service),
+            methods: service.methodsArray.map((method) => {
+                method.resolve();
+                return {
+                    name: method.name,
+                    service: fullName,
+                    kind: methodKindOf(method),
+                    requestType: method.resolvedRequestType !== null ? qualifiedName(method.resolvedRequestType) : method.requestType,
+                    responseType: method.resolvedResponseType !== null ? qualifiedName(method.resolvedResponseType) : method.responseType,
+                    ...commentOf(method),
+                    ...(method.getOption('deprecated') === true ? { deprecated: true } : {}),
+                };
+            }),
+        };
+    });
+}
+/**
+ * The message type `fullName` names.
+ *
+ * @throws ProtoError `proto-type-unknown` when the set has no such message
+ */
+export function lookupMessageType(set, fullName) {
+    const found = set.root.lookup(fullName.replace(/^\./, ''), protobuf.Type, true);
+    if (found === null || !(found instanceof protobuf.Type)) {
+        throw new ProtoError('proto-type-unknown', `Message type "${fullName}" is not defined by the loaded .proto files`, {
+            details: { type: fullName },
+        });
+    }
+    return found;
+}
+/**
+ * The method `service`/`method` names, resolved.
+ *
+ * @throws ProtoError `proto-method-unknown` when the set has no such service or method
+ */
+export function lookupMethod(set, service, method) {
+    const found = set.root.lookup(service.replace(/^\./, ''), protobuf.Service, true);
+    if (found === null || !(found instanceof protobuf.Service)) {
+        throw new ProtoError('proto-method-unknown', `Service "${service}" is not defined by the loaded .proto files`, {
+            details: { service, method },
+        });
+    }
+    const resolved = found.methods[method];
+    if (resolved === undefined) {
+        throw new ProtoError('proto-method-unknown', `Service "${service}" has no method "${method}"`, {
+            details: { service, method },
+        });
+    }
+    resolved.resolve();
+    return resolved;
+}
+/** The request and response message types of one method, plus its streaming shape. */
+export function describeMethod(set, service, method) {
+    const resolved = lookupMethod(set, service, method);
+    return {
+        name: resolved.name,
+        service: service.replace(/^\./, ''),
+        kind: methodKindOf(resolved),
+        requestType: resolved.resolvedRequestType !== null ? qualifiedName(resolved.resolvedRequestType) : resolved.requestType,
+        responseType: resolved.resolvedResponseType !== null ? qualifiedName(resolved.resolvedResponseType) : resolved.responseType,
+        ...commentOf(resolved),
+    };
+}
+function describeField(field) {
+    field.resolve();
+    const map = field instanceof protobuf.MapField ? field : undefined;
+    const resolvedType = field.resolvedType;
+    const valueKind = map !== undefined
+        ? 'map'
+        : resolvedType instanceof protobuf.Enum
+            ? 'enum'
+            : resolvedType instanceof protobuf.Type
+                ? 'message'
+                : 'scalar';
+    const type = resolvedType !== null ? qualifiedName(resolvedType) : field.type;
+    return {
+        name: field.name,
+        id: field.id,
+        type,
+        valueKind,
+        repeated: field.repeated,
+        optional: (field.partOf?.name.startsWith('_') ?? false) || field.rule === 'optional',
+        ...(field.partOf !== null && !field.partOf.name.startsWith('_') ? { oneof: field.partOf.name } : {}),
+        ...(map !== undefined ? { mapKeyType: map.keyType } : {}),
+        ...(resolvedType instanceof protobuf.Enum ? { enumValues: Object.keys(resolvedType.values) } : {}),
+        ...commentOf(field),
+    };
+}
+/** The fields of the message type `fullName`, in field-number order. */
+export function describeMessage(set, fullName) {
+    const type = lookupMessageType(set, fullName);
+    return {
+        fullName: qualifiedName(type),
+        fields: type.fieldsArray.map(describeField),
+        oneofs: type.oneofsArray.filter((oneof) => !oneof.name.startsWith('_')).map((oneof) => oneof.name),
+    };
+}
+/** The lowerCamelCase JSON name protobuf's JSON mapping accepts alongside a field's declared name. */
+function jsonNameOf(name) {
+    return name.replace(/_([a-z0-9])/g, (_match, char) => char.toUpperCase());
+}
+/** The message type `fullName`, or `undefined` when the set has no such message. */
+function messageOrUndefined(set, fullName) {
+    const found = set.root.lookup(fullName.replace(/^\./, ''), protobuf.Type, true);
+    return found instanceof protobuf.Type ? found : undefined;
+}
+/** The field of `descriptor` a JSON key names, matching either the declared name or its JSON name. */
+function fieldNamed(descriptor, key) {
+    return descriptor.fields.find((field) => field.name === key || jsonNameOf(field.name) === key);
+}
+/**
+ * The message whose fields belong at `path` — a chain of JSON object keys — under `rootType`.
+ *
+ * `path` is what {@link jsonCompletionContextAt} reports, so it carries no array indices: a
+ * repeated field is descended through as if it were singular. A map field is followed by the
+ * user's own key, which is consumed here, since only the schema knows that a level of the
+ * document is a map rather than a nested message.
+ *
+ * Returns `undefined` when the path names a field the message does not have, stops on a scalar or
+ * an enum, or ends on a map whose entries the user names — and for a well-known type, whose JSON
+ * is its own mapping (a `Timestamp` is a string, a wrapper is a bare value) rather than its
+ * fields, so offering those fields would be offering a document protobuf will not read back.
+ *
+ * @throws ProtoError `proto-type-unknown` when the set has no `rootType`
+ */
+export function describeMessageAt(set, rootType, path) {
+    let descriptor = describeMessage(set, rootType);
+    let index = 0;
+    while (index < path.length) {
+        const field = fieldNamed(descriptor, path[index]);
+        if (field === undefined) {
+            return undefined;
+        }
+        if (field.valueKind === 'map') {
+            // The next segment is whatever the user called this entry; the fields under it are the
+            // value type's, so a map costs two segments rather than one.
+            index += 1;
+            if (index >= path.length) {
+                return undefined;
+            }
+        }
+        else if (field.valueKind !== 'message') {
+            return undefined;
+        }
+        if (WELL_KNOWN_TYPES.has(field.type)) {
+            return undefined;
+        }
+        const nested = messageOrUndefined(set, field.type);
+        if (nested === undefined) {
+            return undefined;
+        }
+        descriptor = describeMessage(set, field.type);
+        index += 1;
+    }
+    return descriptor;
+}

package/dist/grpc/proto/load.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Loading a set of `.proto` sources into one resolved schema.
+ *
+ * The engine never reads a file on its own here: the caller hands over every source it has, keyed
+ * by import path, and this module parses them, follows `import` statements through that map (and
+ * through the well-known `google/protobuf/*` definitions bundled with the parser), and resolves
+ * every type reference. What comes out is a {@link ProtoSet} the describe, sample and codec
+ * modules all read from, so a `.proto` is parsed once per import or send and never re-read.
+ */
+import protobuf from 'protobufjs';
+/** `.proto` sources keyed by the import path other files use to reach them (`/`-separated). */
+export type ProtoSources = ReadonlyMap<string, string>;
+/** A parsed and resolved set of `.proto` files. */
+export interface ProtoSet {
+    /** The resolved namespace tree. Readers use the describe and codec modules rather than this directly. */
+    readonly root: protobuf.Root;
+    /** Every file that took part, roots first, in load order; the bundled well-known files included. */
+    readonly files: readonly string[];
+    /** The import paths the load started from. */
+    readonly roots: readonly string[];
+}
+/** Options for {@link loadProtoSet}. */
+export interface LoadProtoOptions {
+    /** The files to start from; each must be a key of the sources. Defaults to every source. */
+    readonly roots?: readonly string[];
+}
+/**
+ * Parses and resolves `sources`, starting from `roots`.
+ *
+ * @throws ProtoError `proto-parse` when a file does not parse (`details.file`, `details.line` when
+ * the parser reports one); `proto-import-missing` when an `import` names a file that is neither in
+ * the sources nor bundled; `proto-unresolved` when a type reference resolves to nothing;
+ * `proto-no-roots` when there is nothing to load.
+ */
+export declare function loadProtoSet(sources: ProtoSources, options?: LoadProtoOptions): ProtoSet;

package/dist/grpc/proto/load.js

@@ -0,0 +1,112 @@
+/**
+ * Loading a set of `.proto` sources into one resolved schema.
+ *
+ * The engine never reads a file on its own here: the caller hands over every source it has, keyed
+ * by import path, and this module parses them, follows `import` statements through that map (and
+ * through the well-known `google/protobuf/*` definitions bundled with the parser), and resolves
+ * every type reference. What comes out is a {@link ProtoSet} the describe, sample and codec
+ * modules all read from, so a `.proto` is parsed once per import or send and never re-read.
+ */
+import protobuf from 'protobufjs';
+import { ProtoError } from '../../errors.js';
+/** The `google/protobuf/*.proto` files the parser bundles, keyed by import path. */
+function bundledCommon(path) {
+    const common = protobuf.common;
+    return Object.hasOwn(common, path) ? common[path] : undefined;
+}
+/**
+ * Finds the source an `import` names. The canonical rule is "relative to a proto root", so the
+ * verbatim path wins; a path relative to the importing file's directory comes second, and a
+ * unique suffix match last — a user who picked files from nested directories should not have to
+ * rearrange them to satisfy the import root convention.
+ */
+function resolveImport(sources, importedBy, target) {
+    if (sources.has(target)) {
+        return target;
+    }
+    const dir = importedBy.includes('/') ? importedBy.slice(0, importedBy.lastIndexOf('/') + 1) : '';
+    const relative = normalisePath(`${dir}${target}`);
+    if (sources.has(relative)) {
+        return relative;
+    }
+    const suffix = `/${target}`;
+    const candidates = [...sources.keys()].filter((key) => key.endsWith(suffix));
+    return candidates.length === 1 ? candidates[0] : undefined;
+}
+/** Collapses `.` and `..` segments of a `/`-separated path. */
+function normalisePath(path) {
+    const out = [];
+    for (const segment of path.split('/')) {
+        if (segment === '' || segment === '.') {
+            continue;
+        }
+        if (segment === '..') {
+            out.pop();
+            continue;
+        }
+        out.push(segment);
+    }
+    return out.join('/');
+}
+/**
+ * Parses and resolves `sources`, starting from `roots`.
+ *
+ * @throws ProtoError `proto-parse` when a file does not parse (`details.file`, `details.line` when
+ * the parser reports one); `proto-import-missing` when an `import` names a file that is neither in
+ * the sources nor bundled; `proto-unresolved` when a type reference resolves to nothing;
+ * `proto-no-roots` when there is nothing to load.
+ */
+export function loadProtoSet(sources, options = {}) {
+    const roots = options.roots ?? [...sources.keys()];
+    if (roots.length === 0) {
+        throw new ProtoError('proto-no-roots', 'No .proto files to load');
+    }
+    const root = new protobuf.Root();
+    const loaded = new Set();
+    const order = [];
+    const load = (path, importedBy) => {
+        if (loaded.has(path)) {
+            return;
+        }
+        loaded.add(path);
+        order.push(path);
+        const source = sources.get(path);
+        if (source === undefined) {
+            const bundled = bundledCommon(path);
+            if (bundled !== undefined) {
+                root.addJSON(bundled.nested ?? {});
+                return;
+            }
+            throw new ProtoError('proto-import-missing', importedBy === undefined
+                ? `${path} is not among the .proto files`
+                : `${importedBy} imports ${path}, which is not among the .proto files`, { details: { file: path, ...(importedBy !== undefined ? { importedBy } : {}) } });
+        }
+        let parsed;
+        try {
+            parsed = protobuf.parse(source, root, { keepCase: true, alternateCommentMode: true });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const line = /\(line (\d+)\)/.exec(message)?.[1];
+            throw new ProtoError('proto-parse', `${path}: ${message}`, {
+                cause: error,
+                details: { file: path, ...(line !== undefined ? { line: Number(line) } : {}) },
+            });
+        }
+        for (const target of [...(parsed.imports ?? []), ...(parsed.weakImports ?? [])]) {
+            const resolved = resolveImport(sources, path, target) ?? target;
+            load(resolved, path);
+        }
+    };
+    for (const path of roots) {
+        load(path, undefined);
+    }
+    try {
+        root.resolveAll();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ProtoError('proto-unresolved', message, { cause: error });
+    }
+    return { root, files: order, roots };
+}

package/dist/grpc/proto/sample.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A sample request message for a type, as the JSON the editor starts from — the counterpart of the
+ * `?`-filled envelope a WSDL import generates. Every field is present once with a zero-ish value of
+ * the right JSON shape, so the user replaces values rather than remembering names; a `oneof` shows
+ * its first member only, and recursion stops at a fixed depth so a self-referencing tree does not
+ * unroll for ever.
+ */
+import type { ProtoSet } from './load.js';
+/** Options for {@link sampleMessage}. */
+export interface SampleMessageOptions {
+    /** Message nesting depth at which a message becomes `{}`. Defaults to 3. */
+    readonly maxDepth?: number;
+}
+/**
+ * A sample value for the message type `fullName`, as a plain JSON-ready value.
+ *
+ * @throws ProtoError `proto-type-unknown` when the set has no such message
+ */
+export declare function sampleMessage(set: ProtoSet, fullName: string, options?: SampleMessageOptions): unknown;
+/** {@link sampleMessage} as pretty-printed JSON text, which is what a new request's body file holds. */
+export declare function sampleMessageText(set: ProtoSet, fullName: string, options?: SampleMessageOptions): string;

package/dist/grpc/proto/sample.js

@@ -0,0 +1,79 @@
+/**
+ * A sample request message for a type, as the JSON the editor starts from — the counterpart of the
+ * `?`-filled envelope a WSDL import generates. Every field is present once with a zero-ish value of
+ * the right JSON shape, so the user replaces values rather than remembering names; a `oneof` shows
+ * its first member only, and recursion stops at a fixed depth so a self-referencing tree does not
+ * unroll for ever.
+ */
+import protobuf from 'protobufjs';
+import { lookupMessageType } from './describe.js';
+import { wellKnownSample } from './well-known.js';
+const DEFAULT_MAX_DEPTH = 3;
+function scalarSample(type) {
+    switch (type) {
+        case 'string':
+            return '';
+        case 'bool':
+            return false;
+        case 'bytes':
+            return '';
+        case 'int64':
+        case 'uint64':
+        case 'sint64':
+        case 'fixed64':
+        case 'sfixed64':
+            return '0';
+        default:
+            return 0;
+    }
+}
+function fieldSample(field, depth, options) {
+    field.resolve();
+    const resolved = field.resolvedType;
+    if (resolved instanceof protobuf.Enum) {
+        const names = Object.keys(resolved.values);
+        return names[0] ?? 0;
+    }
+    if (resolved instanceof protobuf.Type) {
+        return typeSample(resolved, depth + 1, options);
+    }
+    return scalarSample(field.type);
+}
+function typeSample(type, depth, options) {
+    const wellKnown = wellKnownSample(type.fullName.replace(/^\./, ''));
+    if (wellKnown !== undefined) {
+        return wellKnown;
+    }
+    if (depth > options.maxDepth) {
+        return {};
+    }
+    const out = {};
+    const seenOneofs = new Set();
+    for (const field of type.fieldsArray) {
+        if (field.partOf !== null && !field.partOf.name.startsWith('_')) {
+            if (seenOneofs.has(field.partOf.name)) {
+                continue;
+            }
+            seenOneofs.add(field.partOf.name);
+        }
+        if (field instanceof protobuf.MapField) {
+            out[field.name] = { key: fieldSample(field, depth, options) };
+            continue;
+        }
+        const value = fieldSample(field, depth, options);
+        out[field.name] = field.repeated ? [value] : value;
+    }
+    return out;
+}
+/**
+ * A sample value for the message type `fullName`, as a plain JSON-ready value.
+ *
+ * @throws ProtoError `proto-type-unknown` when the set has no such message
+ */
+export function sampleMessage(set, fullName, options = {}) {
+    return typeSample(lookupMessageType(set, fullName), 0, { maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH });
+}
+/** {@link sampleMessage} as pretty-printed JSON text, which is what a new request's body file holds. */
+export function sampleMessageText(set, fullName, options = {}) {
+    return `${JSON.stringify(sampleMessage(set, fullName, options), null, 2)}\n`;
+}

package/dist/grpc/proto/well-known.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The JSON mapping the protobuf specification gives the well-known types: a `Timestamp` is an
+ * RFC 3339 string, a `Duration` is `"1.5s"`, a `Struct` is the JSON object it represents, a wrapper
+ * is its bare value, an `Any` carries an `@type` beside the message's own fields. The parser
+ * itself knows only the field-by-field form (`{seconds, nanos}`), so the codec converts between
+ * the two here, on the way in and on the way out, field numbers rather than names because the
+ * bundled definitions do not spell the names the way a `.proto` on disk does.
+ */
+/** The fully qualified names this module handles. */
+export declare const WELL_KNOWN_TYPES: ReadonlySet<string>;
+/** Whether `fullName` is a wrapper type (`google.protobuf.StringValue` and its siblings). */
+export declare function isWrapperType(fullName: string): boolean;
+/** The sample the editor shows for a well-known type, or `undefined` for an ordinary message. */
+export declare function wellKnownSample(fullName: string): unknown;
+/** `{seconds, nanos}` from a JSON `Timestamp` string. */
+export declare function timestampFromJson(value: unknown): {
+    seconds: string;
+    nanos: number;
+};
+/** A JSON `Timestamp` string from `{seconds, nanos}`. */
+export declare function timestampToJson(value: {
+    seconds?: unknown;
+    nanos?: unknown;
+}): string;
+/** `{seconds, nanos}` from a JSON `Duration` string such as `"1.5s"`. */
+export declare function durationFromJson(value: unknown): {
+    seconds: string;
+    nanos: number;
+};
+/** A JSON `Duration` string from `{seconds, nanos}`. */
+export declare function durationToJson(value: {
+    seconds?: unknown;
+    nanos?: unknown;
+}): string;
+/** A JSON `FieldMask` string (`"a.b,c"`) as `{paths}`. */
+export declare function fieldMaskFromJson(value: unknown): {
+    paths: string[];
+};
+/** `{paths}` as the JSON `FieldMask` string. */
+export declare function fieldMaskToJson(value: {
+    paths?: unknown;
+}): string;