@intentius/chant-lexicon-otel 0.124.46 → 0.124.49

package/dist/spec/fetch.d.ts

@@ -0,0 +1,120 @@
+/**
+ * The upstream collector schemas, read at the pinned tags (#3361).
+ *
+ * Three repositories, all read at git tags:
+ *
+ * - opentelemetry-collector-releases, for each distribution's builder manifest
+ *   (`distributions/<name>/manifest.yaml`): which component modules a given
+ *   `otelcol` binary is built from, and at which version;
+ * - opentelemetry-collector (`go.opentelemetry.io/collector/...`) and
+ *   opentelemetry-collector-contrib, for each component's `metadata.yaml` (its
+ *   collector type, and the deprecated type it still answers to) and its
+ *   `config.schema.yaml`, plus every schema document those reach through
+ *   `$ref` (the shared `config/*` packages, `exporterhelper`, contrib's
+ *   `internal/*` and `pkg/*`).
+ *
+ * Downloads go through core's `fetchWithCache` under `~/.chant/otel-spec/<tag>`,
+ * with a long TTL, because a tag's content never moves. This module only runs
+ * when the snapshot is refreshed (`just snapshot`); generation reads the
+ * committed snapshot and never touches the network.
+ *
+ * ## `$ref` forms
+ *
+ * `schemagen` writes four:
+ *
+ * - `name`, a definition in the same document's `$defs`;
+ * - `./internal/metadata.name`, a package below the referring document's;
+ * - `/config/configgrpc.client_config`, a package path from the root of the
+ *   referring document's repository;
+ * - `go.opentelemetry.io/collector/config/configopaque.string`, a full Go
+ *   import path.
+ *
+ * Every form ends in `.<definition>`; {@link resolveRef} turns each into a
+ * document key (the Go import path of the package) and a definition name.
+ */
+import type { ComponentKind } from "../model.js";
+export declare const CORE_MODULE = "go.opentelemetry.io/collector";
+export declare const CONTRIB_MODULE = "github.com/open-telemetry/opentelemetry-collector-contrib";
+/** The distributions whose manifests scope the lexicon. */
+export declare const DISTRIBUTIONS: readonly ["otelcol-contrib", "otelcol-k8s"];
+export type DistributionName = (typeof DISTRIBUTIONS)[number];
+/** One component module a distribution is built from. */
+export interface ManifestModule {
+    kind: ComponentKind;
+    /** The Go module path, e.g. `go.opentelemetry.io/collector/receiver/otlpreceiver`. */
+    module: string;
+    /** The module version the manifest names, e.g. `v0.162.0`. */
+    version: string;
+}
+/**
+ * The component modules a builder manifest lists. `providers` (confmap URI
+ * schemes) are not components and are left out.
+ */
+export declare function parseManifest(text: string): ManifestModule[];
+/** The repository and tag a module's files are read from, or undefined for a module outside the two collector repos. */
+export declare function locate(pkg: string, tags: {
+    core: string;
+    contrib: string;
+}): {
+    repo: string;
+    tag: string;
+    path: string;
+    root: string;
+} | undefined;
+/** The repository root module a package belongs to, for resolving `/path` refs. */
+export declare function repoRoot(pkg: string): string | undefined;
+/**
+ * Resolve a `$ref` written in document `from` (a Go package path) to the
+ * document it names and the definition inside it. A local ref returns `from`
+ * itself.
+ */
+export declare function resolveRef(from: string, ref: string): {
+    doc: string;
+    def: string;
+};
+/** Every `$ref` string inside a schema document, in order. */
+export declare function refsIn(node: unknown, out?: string[]): string[];
+/** One component in a distribution's index. */
+export interface IndexedComponent {
+    kind: ComponentKind;
+    /** The collector type its factory registers, from `metadata.yaml`. Absent for a module outside the collector repos. */
+    type?: string;
+    /** The older type the factory still accepts, when it was renamed. */
+    deprecatedType?: string;
+    module: string;
+    version: string;
+    /** The document key of its config schema, when upstream ships one. */
+    schema?: string;
+}
+/** What `fetchUpstreamSpec` returns, and what the committed snapshot holds. */
+export interface OtelSpecSnapshot {
+    versions: {
+        "otelcol-contrib": string;
+        "otelcol-k8s": string;
+        core: string;
+        contrib: string;
+    };
+    distributions: Record<DistributionName, IndexedComponent[]>;
+    /** Schema documents keyed by Go package path. */
+    schemas: Record<string, unknown>;
+    /** `$ref`ed documents that could not be read, and who asked for them. */
+    unresolved: Record<string, string[]>;
+}
+/**
+ * Fetch both manifests at their tags, index every component they list, and
+ * collect the schema documents reachable from the components in `keep` (by
+ * collector type and kind). Other components are indexed (type, schema or
+ * not) but their schemas are not carried, so the snapshot stays the size of
+ * what the lexicon generates from.
+ */
+export declare function fetchUpstreamSpec(options: {
+    contribVersion: string;
+    k8sVersion: string;
+    keep: ReadonlyArray<{
+        kind: ComponentKind;
+        type: string;
+    }>;
+    force?: boolean;
+    log?: (message: string) => void;
+}): Promise<OtelSpecSnapshot>;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/spec/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/spec/fetch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAMH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,eAAO,MAAM,WAAW,kCAAkC,CAAC;AAC3D,eAAO,MAAM,cAAc,8DAA8D,CAAC;AAO1F,2DAA2D;AAC3D,eAAO,MAAM,aAAa,YAAI,iBAAiB,EAAE,aAAa,CAAU,CAAC;AACzE,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAe9D,yDAAyD;AACzD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,aAAa,CAAC;IACpB,sFAAsF;IACtF,MAAM,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;CACjB;AAUD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,CAY5D;AAID,wHAAwH;AACxH,wBAAgB,MAAM,CACpB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAOvE;AAED,mFAAmF;AACnF,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAExD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAYlF;AAED,8DAA8D;AAC9D,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,GAAE,MAAM,EAAO,GAAG,MAAM,EAAE,CAUlE;AAmBD,+CAA+C;AAC/C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,aAAa,CAAC;IACpB,uHAAuH;IACvH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE;QAAE,iBAAiB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9F,aAAa,EAAE,MAAM,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,CAAC,CAAC;IAC5D,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACtC;AAyBD;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE;IAC/C,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,aAAa,CAAC;QAAE,IAAI,EAAE,aAAa,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAsG5B"}

package/dist/spec/fetch.js

@@ -0,0 +1,282 @@
+/**
+ * The upstream collector schemas, read at the pinned tags (#3361).
+ *
+ * Three repositories, all read at git tags:
+ *
+ * - opentelemetry-collector-releases, for each distribution's builder manifest
+ *   (`distributions/<name>/manifest.yaml`): which component modules a given
+ *   `otelcol` binary is built from, and at which version;
+ * - opentelemetry-collector (`go.opentelemetry.io/collector/...`) and
+ *   opentelemetry-collector-contrib, for each component's `metadata.yaml` (its
+ *   collector type, and the deprecated type it still answers to) and its
+ *   `config.schema.yaml`, plus every schema document those reach through
+ *   `$ref` (the shared `config/*` packages, `exporterhelper`, contrib's
+ *   `internal/*` and `pkg/*`).
+ *
+ * Downloads go through core's `fetchWithCache` under `~/.chant/otel-spec/<tag>`,
+ * with a long TTL, because a tag's content never moves. This module only runs
+ * when the snapshot is refreshed (`just snapshot`); generation reads the
+ * committed snapshot and never touches the network.
+ *
+ * ## `$ref` forms
+ *
+ * `schemagen` writes four:
+ *
+ * - `name`, a definition in the same document's `$defs`;
+ * - `./internal/metadata.name`, a package below the referring document's;
+ * - `/config/configgrpc.client_config`, a package path from the root of the
+ *   referring document's repository;
+ * - `go.opentelemetry.io/collector/config/configopaque.string`, a full Go
+ *   import path.
+ *
+ * Every form ends in `.<definition>`; {@link resolveRef} turns each into a
+ * document key (the Go import path of the package) and a definition name.
+ */
+import { homedir } from "os";
+import { join } from "path";
+import yaml from "js-yaml";
+import { fetchWithCache } from "@intentius/chant/codegen/fetch";
+export const CORE_MODULE = "go.opentelemetry.io/collector";
+export const CONTRIB_MODULE = "github.com/open-telemetry/opentelemetry-collector-contrib";
+const REPOS = [
+    { module: CONTRIB_MODULE, repo: "open-telemetry/opentelemetry-collector-contrib" },
+    { module: CORE_MODULE, repo: "open-telemetry/opentelemetry-collector" },
+];
+/** The distributions whose manifests scope the lexicon. */
+export const DISTRIBUTIONS = ["otelcol-contrib", "otelcol-k8s"];
+/** A tag's content never moves, so a cached copy stays good for a year. */
+const TAG_TTL_MS = 365 * 24 * 60 * 60 * 1000;
+function cacheFile(repo, tag, path) {
+    return join(homedir(), ".chant", "otel-spec", repo.split("/")[1], tag, ...path.split("/"));
+}
+function rawUrl(repo, tag, path) {
+    return `https://raw.githubusercontent.com/${repo}/${tag}/${path}`;
+}
+const SECTION_KIND = {
+    receivers: "receiver",
+    processors: "processor",
+    exporters: "exporter",
+    connectors: "connector",
+    extensions: "extension",
+};
+/**
+ * The component modules a builder manifest lists. `providers` (confmap URI
+ * schemes) are not components and are left out.
+ */
+export function parseManifest(text) {
+    const doc = yaml.load(text);
+    const out = [];
+    for (const [section, kind] of Object.entries(SECTION_KIND)) {
+        const entries = doc[section];
+        if (!Array.isArray(entries))
+            continue;
+        for (const entry of entries) {
+            const [module, version] = (entry.gomod ?? "").trim().split(/\s+/);
+            if (module && version)
+                out.push({ kind, module, version });
+        }
+    }
+    return out;
+}
+// ── Where a Go package lives ────────────────────────────────────────
+/** The repository and tag a module's files are read from, or undefined for a module outside the two collector repos. */
+export function locate(pkg, tags) {
+    for (const { module, repo } of REPOS) {
+        if (pkg === module || pkg.startsWith(`${module}/`)) {
+            return { repo, tag: module === CORE_MODULE ? tags.core : tags.contrib, path: pkg.slice(module.length + 1), root: module };
+        }
+    }
+    return undefined;
+}
+/** The repository root module a package belongs to, for resolving `/path` refs. */
+export function repoRoot(pkg) {
+    return REPOS.find(({ module }) => pkg === module || pkg.startsWith(`${module}/`))?.module;
+}
+/**
+ * Resolve a `$ref` written in document `from` (a Go package path) to the
+ * document it names and the definition inside it. A local ref returns `from`
+ * itself.
+ */
+export function resolveRef(from, ref) {
+    const dot = ref.lastIndexOf(".");
+    const slash = ref.lastIndexOf("/");
+    // `name`: no package part.
+    if (slash < 0 && !ref.startsWith("."))
+        return { doc: from, def: ref };
+    const pkgPart = dot > slash ? ref.slice(0, dot) : ref;
+    const def = dot > slash ? ref.slice(dot + 1) : "";
+    let doc;
+    if (pkgPart.startsWith("./"))
+        doc = `${from}/${pkgPart.slice(2)}`;
+    else if (pkgPart.startsWith("/"))
+        doc = `${repoRoot(from) ?? ""}${pkgPart}`;
+    else
+        doc = pkgPart;
+    return { doc, def };
+}
+/** Every `$ref` string inside a schema document, in order. */
+export function refsIn(node, out = []) {
+    if (Array.isArray(node)) {
+        for (const n of node)
+            refsIn(n, out);
+    }
+    else if (node !== null && typeof node === "object") {
+        for (const [k, v] of Object.entries(node)) {
+            if (k === "$ref" && typeof v === "string")
+                out.push(v);
+            else
+                refsIn(v, out);
+        }
+    }
+    return out;
+}
+// ── Fetching ────────────────────────────────────────────────────────
+async function fetchText(repo, tag, path, force) {
+    try {
+        const buf = await fetchWithCache({ url: rawUrl(repo, tag, path), cacheFile: cacheFile(repo, tag, path), cacheTtlMs: TAG_TTL_MS }, force);
+        return buf.toString("utf-8");
+    }
+    catch (err) {
+        // A missing file is an answer (this component ships no schema); anything
+        // else is not, and must not be read as one.
+        if (err instanceof Error && /returned 404\b/.test(err.message))
+            return undefined;
+        throw err;
+    }
+}
+async function pool(items, size, fn) {
+    const out = new Array(items.length);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(size, items.length) }, async () => {
+        while (next < items.length) {
+            const i = next++;
+            out[i] = await fn(items[i]);
+        }
+    }));
+    return out;
+}
+/** The version a manifest uses for the modules of one repository, the most common one listed. */
+function repoTag(modules, root) {
+    const counts = new Map();
+    for (const m of modules)
+        if (m.module.startsWith(`${root}/`))
+            counts.set(m.version, (counts.get(m.version) ?? 0) + 1);
+    const best = [...counts].sort((a, b) => b[1] - a[1])[0];
+    if (!best)
+        throw new Error(`no ${root} module in the manifest`);
+    return best[0];
+}
+/**
+ * Fetch both manifests at their tags, index every component they list, and
+ * collect the schema documents reachable from the components in `keep` (by
+ * collector type and kind). Other components are indexed (type, schema or
+ * not) but their schemas are not carried, so the snapshot stays the size of
+ * what the lexicon generates from.
+ */
+export async function fetchUpstreamSpec(options) {
+    const log = options.log ?? (() => { });
+    const releases = "open-telemetry/opentelemetry-collector-releases";
+    const manifests = {};
+    const distTags = { "otelcol-contrib": options.contribVersion, "otelcol-k8s": options.k8sVersion };
+    for (const dist of DISTRIBUTIONS) {
+        const text = await fetchText(releases, distTags[dist], `distributions/${dist}/manifest.yaml`, options.force);
+        if (text === undefined)
+            throw new Error(`no manifest for ${dist} at ${distTags[dist]}`);
+        manifests[dist] = parseManifest(text);
+        log(`${dist} ${distTags[dist]}: ${manifests[dist].length} components`);
+    }
+    const contribManifest = manifests["otelcol-contrib"];
+    const tags = { core: repoTag(contribManifest, CORE_MODULE), contrib: repoTag(contribManifest, CONTRIB_MODULE) };
+    // Index each distinct module once: its type, and where its schema is.
+    const modules = new Map();
+    for (const dist of DISTRIBUTIONS)
+        for (const m of manifests[dist])
+            modules.set(m.module, m);
+    const docs = new Map();
+    const info = new Map();
+    await pool([...modules.values()], 16, async (m) => {
+        const where = locate(m.module, tags);
+        if (!where) {
+            info.set(m.module, {});
+            return;
+        }
+        const meta = await fetchText(where.repo, where.tag, `${where.path}/metadata.yaml`, options.force);
+        const parsed = meta ? yaml.load(meta) : {};
+        // Most components keep their config in the module root; a few
+        // (signaltometrics) in a `config` package below it.
+        let schemaDoc;
+        let schema;
+        for (const sub of ["", "/config"]) {
+            const text = await fetchText(where.repo, where.tag, `${where.path}${sub}/config.schema.yaml`, options.force);
+            if (text !== undefined) {
+                schemaDoc = `${m.module}${sub}`;
+                schema = yaml.load(text);
+                break;
+            }
+        }
+        info.set(m.module, { type: parsed.type, deprecatedType: parsed.deprecated_type, schemaDoc, schema });
+    });
+    const distributions = {};
+    for (const dist of DISTRIBUTIONS) {
+        distributions[dist] = manifests[dist]
+            .map((m) => {
+            const i = info.get(m.module);
+            const entry = { kind: m.kind, module: m.module, version: m.version };
+            if (i.type)
+                entry.type = i.type;
+            if (i.deprecatedType)
+                entry.deprecatedType = i.deprecatedType;
+            if (i.schemaDoc)
+                entry.schema = i.schemaDoc;
+            return entry;
+        })
+            .sort((a, b) => a.kind.localeCompare(b.kind) || (a.type ?? a.module).localeCompare(b.type ?? b.module));
+    }
+    // The documents the kept components reach, transitively.
+    const unresolved = {};
+    const queue = [];
+    for (const want of options.keep) {
+        const hit = distributions["otelcol-contrib"].find((c) => c.kind === want.kind && (c.type === want.type || c.deprecatedType === want.type));
+        if (!hit?.schema)
+            continue;
+        docs.set(hit.schema, info.get(hit.module).schema);
+        queue.push(hit.schema);
+    }
+    const seen = new Set();
+    while (queue.length > 0) {
+        const batch = queue.splice(0).filter((d) => !seen.has(d));
+        for (const d of batch)
+            seen.add(d);
+        const wanted = new Map();
+        for (const d of batch) {
+            for (const ref of refsIn(docs.get(d))) {
+                const { doc } = resolveRef(d, ref);
+                if (doc === d || docs.has(doc) || seen.has(doc))
+                    continue;
+                wanted.set(doc, [...(wanted.get(doc) ?? []), d]);
+            }
+        }
+        await pool([...wanted.keys()], 16, async (doc) => {
+            const where = locate(doc, tags);
+            const text = where ? await fetchText(where.repo, where.tag, `${where.path}/config.schema.yaml`, options.force) : undefined;
+            if (text === undefined) {
+                unresolved[doc] = [...new Set(wanted.get(doc))].sort();
+                return;
+            }
+            docs.set(doc, yaml.load(text));
+            queue.push(doc);
+        });
+    }
+    const schemas = {};
+    for (const key of [...docs.keys()].sort())
+        schemas[key] = docs.get(key);
+    const sortedUnresolved = {};
+    for (const key of Object.keys(unresolved).sort())
+        sortedUnresolved[key] = unresolved[key];
+    return {
+        versions: { "otelcol-contrib": options.contribVersion, "otelcol-k8s": options.k8sVersion, ...tags },
+        distributions,
+        schemas,
+        unresolved: sortedUnresolved,
+    };
+}

package/dist/spec/parse.d.ts

@@ -0,0 +1,77 @@
+/**
+ * `config.schema.yaml` to TypeScript (#3361).
+ *
+ * `schemagen` writes a small JSON Schema dialect: `type`, `properties`,
+ * `items`, `additionalProperties`, `enum`, `allOf` (an embedded struct,
+ * `mapstructure:",squash"`), `$ref` and `$defs`, `format: duration`, and three
+ * extensions:
+ *
+ * - `x-customType`, the Go type when the JSON type alone loses it (`int64`,
+ *   `component.ID`, `time.Duration`, or a type from outside the collector);
+ * - `x-optional`, a `configoptional.Optional`: the key may be written with no
+ *   value (`grpc:`) to turn the section on with its defaults, so it also takes
+ *   `null`;
+ * - `x-pointer`, a Go pointer, which changes nothing in YAML.
+ *
+ * It writes no `required`, so every generated property is optional; what a
+ * component cannot start without is its definition's `validate` overlay.
+ *
+ * Every definition reached from a built-in becomes one named type alias,
+ * `<document><Definition>`, so recursive definitions (tail_sampling's `and`
+ * and `not` policies) are expressible. A `$ref` to a document upstream does
+ * not publish, or to a definition it lacks, becomes `unknown` and is listed in
+ * {@link GeneratedTypes.unresolved}.
+ */
+/** One node of a schema document. */
+export interface SchemaNode {
+    type?: string | string[];
+    description?: string;
+    format?: string;
+    enum?: unknown[];
+    pattern?: string;
+    default?: unknown;
+    properties?: Record<string, SchemaNode>;
+    additionalProperties?: SchemaNode | boolean;
+    items?: SchemaNode;
+    allOf?: SchemaNode[];
+    $ref?: string;
+    $defs?: Record<string, SchemaNode>;
+    "x-customType"?: string;
+    "x-optional"?: boolean;
+    "x-pointer"?: boolean;
+}
+/** The TypeScript for one `x-customType`, or undefined when the JSON type should decide. */
+export declare function customType(name: string): string | undefined;
+/** The type-name prefix for a document: its package path below the repository, PascalCased, with `Collector` for core packages. */
+export declare function documentAlias(doc: string): string;
+/** A description that says the field is deprecated, as Go comments do. */
+export declare function isDeprecated(description: string | undefined): boolean;
+export interface GeneratedTypes {
+    /** The `type X = …` declarations, in name order. */
+    declarations: string;
+    /** The type name of each requested root document. */
+    roots: Map<string, string>;
+    /** `$ref`s that could not be followed, as `doc.def` → the documents that wrote them. */
+    unresolved: Map<string, Set<string>>;
+}
+/**
+ * Generate TypeScript for the root documents in `roots` and every definition
+ * they reach. `docs` holds every available document, keyed by Go package path.
+ */
+export declare function generateTypes(docs: Readonly<Record<string, unknown>>, roots: readonly string[]): GeneratedTypes;
+/** One property as completion and hover show it. */
+export interface PropertyDoc {
+    description?: string;
+    /** A short type label, e.g. `string`, `duration`, `object`, `boolean[]`. */
+    type: string;
+    deprecated?: boolean;
+    /** For object-valued properties, their own properties. */
+    properties?: Record<string, PropertyDoc>;
+}
+/**
+ * The property tree of a root document, for completion and hover: each
+ * property's description and a short type label, nested objects expanded to
+ * `depth` levels, embedded structs (`allOf`) flattened in.
+ */
+export declare function propertyDocs(docs: Readonly<Record<string, unknown>>, root: string, depth?: number): Record<string, PropertyDoc>;
+//# sourceMappingURL=parse.d.ts.map

package/dist/spec/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/spec/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,qCAAqC;AACrC,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACxC,oBAAoB,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC;IAC5C,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AA8CD,4FAA4F;AAC5F,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE3D;AAUD,mIAAmI;AACnI,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIjD;AAiBD,0EAA0E;AAC1E,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAGrE;AAaD,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3B,wFAAwF;IACxF,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CACtC;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,cAAc,CA8H/G;AAID,oDAAoD;AACpD,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CAC1C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CA+D1H"}