@almadar/core 9.6.0 → 9.7.0

package/dist/types-CBb2iBAY.d.ts

@@ -0,0 +1,454 @@
+import { bA as TraitEventListener, F as EntityField, K as EntityPersistence, bF as TraitReference } from './trait-BjSJtFXv.js';
+
+/**
+ * JSON primitives — the universal "data crossed a boundary" type.
+ *
+ * Every value that arrives over the wire from an LLM (tool-call args),
+ * from disk (workspace files), or from an HTTP body before
+ * domain-specific validation is a `JsonValue`. Narrow with a typed
+ * predicate (`is`-guard) at the boundary; don't widen back to `unknown`.
+ *
+ * `JsonObject` and `ToolArgs` are aliases for the common
+ * `Record<string, JsonValue>` shape. `ToolArgs` is the name the
+ * agent surface uses for LLM-emitted tool-call arguments; `JsonObject`
+ * is the general-purpose alias. They are the same type — the alias
+ * exists so call sites read at the right semantic level.
+ *
+ * Why not `Record<string, unknown>`? Two reasons. (1) `unknown` widens
+ * back to anything, which defeats the purpose of typing the boundary.
+ * (2) The `@almadar/eslint-plugin/no-record-string-unknown` rule blocks
+ * the wider form — `JsonValue`-based records are the typed answer.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Recursive JSON value union — every shape JSON can carry.
+ */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * JSON object — keyed string→JsonValue. The wire form of arbitrary
+ * structured data. Replaces `Record<string, unknown>` at typed
+ * boundaries (LLM emits, file reads, HTTP bodies).
+ */
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+/**
+ * LLM tool-call arguments — same shape as `JsonObject`, named for the
+ * agent-surface call site. Each tool's `execute(args: ToolArgs)`
+ * receives this and narrows via an `is`-guard predicate before any
+ * field access.
+ */
+type ToolArgs = JsonObject;
+/**
+ * Type guard: is the given value a JSON primitive (non-array,
+ * non-object)? Used by walkers that decide whether to recurse.
+ */
+declare function isJsonPrimitive(value: JsonValue): value is string | number | boolean | null;
+/**
+ * Type guard: is the given value a JSON object (non-array, non-null)?
+ */
+declare function isJsonObject(value: JsonValue): value is JsonObject;
+/**
+ * Type guard: is the given value a JSON array?
+ */
+declare function isJsonArray(value: JsonValue): value is JsonValue[];
+
+/**
+ * Cross-cutting presentation knobs that don't live per orbital
+ * because they're factory-layer concerns (nav items live on a layout
+ * trait; theme is a separate `ThemeRef`). The translator reads these
+ * and threads them into the matching factory params.
+ */
+interface PresentationOverlay {
+    /** Nav items to add to the orbital's layout trait. The translator
+     *  looks for a `signature.traits[i]` with `overridableConfigKeys`
+     *  including `navItems` and writes into `traitOverrides[name].config.navItems`. */
+    navAdditions?: ReadonlyArray<PresentationNavItem>;
+    /** Optional theme ref override for the orbital. */
+    themeRef?: string;
+}
+interface PresentationNavItem {
+    label: string;
+    path: string;
+    icon?: string;
+}
+/**
+ * LLM-authored trait-level overrides keyed by trait name (matches
+ * `signature.traits[].name`). Each entry's `config` keys are validated
+ * against `signature.traits[i].overridableConfigKeys`.
+ */
+type TraitOverlay = Readonly<Record<string, TraitOverlayEntry>>;
+interface TraitOverlayEntry {
+    config?: Readonly<Record<string, FactoryParamValue>>;
+    linkedEntity?: string;
+    events?: Readonly<Record<string, string>>;
+    name?: string;
+    emitsScope?: 'internal' | 'external';
+    listens?: ReadonlyArray<TraitEventListener>;
+}
+type TraitOverlayListener = TraitEventListener;
+/**
+ * Rules carry a free-form `capability: string` that the translator
+ * matches against `signature.traits[].capabilities` (source-tagged
+ * in `.lolo`).
+ */
+interface RuleOverlay {
+    rules: ReadonlyArray<RuleOverlayEntry>;
+    /** Entity-level ownership signal. The translator threads it into
+     *  the matched trait's `config.ownerField` (when the matched trait
+     *  advertises that key in `overridableConfigKeys`). */
+    ownership?: ReadonlyArray<OwnershipOverlayEntry>;
+}
+interface RuleOverlayEntry {
+    id: string;
+    /** Free-form capability label, matched against
+     *  `signature.traits[].capabilities` by exact set membership. */
+    capability: string;
+    description: string;
+    /** Entity names this rule binds to. Empty array = cross-cutting. */
+    appliesTo: ReadonlyArray<string>;
+    /** Optional role name (e.g. `"admin"`) when the rule is role-scoped. */
+    role?: string;
+    /** Optional extra config knobs threaded into the matched trait's
+     *  `config`. Validated against the trait's `overridableConfigKeys`. */
+    config?: Readonly<Record<string, FactoryParamValue>>;
+}
+interface OwnershipOverlayEntry {
+    /** Entity name (matches the orbital's bound entity name). */
+    entity: string;
+    /** Field name on the entity that carries the owner identifier. */
+    ownerField: string;
+}
+
+/**
+ * Recursive JSON Schema. Intentionally narrow — only the keywords V2's
+ * signature → schema generator emits. Custom `x-*` extensions carry
+ * descriptive metadata (synonyms, label) that doesn't shape validation
+ * but stays in the schema for prompt rendering / studio UIs.
+ */
+interface JsonSchema {
+    type?: JsonSchemaType | ReadonlyArray<JsonSchemaType>;
+    description?: string;
+    properties?: Readonly<{
+        [key: string]: JsonSchema;
+    }>;
+    required?: ReadonlyArray<string>;
+    additionalProperties?: boolean | JsonSchema;
+    items?: JsonSchema;
+    enum?: ReadonlyArray<string | number | boolean>;
+    oneOf?: ReadonlyArray<JsonSchema>;
+    anyOf?: ReadonlyArray<JsonSchema>;
+    default?: JsonValue;
+    /**
+     * Reference to a shared definition under `$defs` at the schema root.
+     * Lets consumers DRY large repeated subschemas (e.g. a 300-entry enum
+     * of std-behavior paths reused across every orbital branch of a tool
+     * schema). Per JSON Schema 2020-12: absolute reference starting with
+     * `#`. Standard OpenAI / DeepSeek strict-mode tool calling resolves
+     * `$ref` against `$defs` defined on the tool's parameters root.
+     */
+    $ref?: string;
+    /**
+     * Inline subschema definitions referenced from elsewhere via `$ref`.
+     * Lives at the schema root so all `$ref` paths can resolve. Values are
+     * full `JsonSchema` (can be referenced recursively).
+     */
+    $defs?: Readonly<{
+        [key: string]: JsonSchema;
+    }>;
+    /** Knob's `@synonyms` from the source `.lolo`. */
+    'x-synonyms'?: string;
+    /** Knob's `@label` from the source `.lolo`. */
+    'x-label'?: string;
+    /** Knob's `@tier` from the source `.lolo` (`domain`/`presentation`/`internal`). */
+    'x-tier'?: string;
+}
+type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'null';
+/**
+ * OrbitalSchema field type tags. The factory-signature extractor lifts
+ * these directly from the resolved `.orb`; consumers narrow further at
+ * dispatch time.
+ */
+type SchemaFieldType = 'string' | 'number' | 'boolean' | 'date' | 'timestamp' | 'datetime' | 'array' | 'object' | 'enum' | 'relation';
+interface FactorySignatureEntityField {
+    name: string;
+    type: SchemaFieldType;
+    required: boolean;
+    /** Runtime-managed widget state (`@intrinsic`). A composer must NOT remap an
+     *  intrinsic slot onto a domain field — it rides along via `extends`. */
+    intrinsic?: boolean;
+    /** Human/semantic description (`@description "..."`). Slot-side signal for the
+     *  curation field matcher + catalog search. */
+    description?: string;
+    /** User-vocabulary synonyms (`@synonyms "..."`). */
+    synonyms?: string;
+}
+/**
+ * The canonical entity a factory produces. Almost always one entity
+ * per orbital; modeled as an array to keep the door open for orbitals
+ * that compose multiple entities.
+ */
+interface FactoryEntitySignature {
+    /** Canonical entity name the factory's params build (e.g. `"ChatMessage"`). */
+    name: string;
+    /** Fields the factory emits, post-auto-field stripping. */
+    fields: ReadonlyArray<FactorySignatureEntityField>;
+    /** Persistence mode declared on the canonical entity in the `.orb`. */
+    persistence: EntityPersistence;
+}
+/**
+ * One overridable config knob a trait advertises. Lifted directly from
+ * the source `.lolo` `config { }` block (which carries typed
+ * declarations + defaults). Consumers (the questionnaire generator,
+ * the studio) pick a widget from `type` and pre-fill from `default`.
+ *
+ * `label` is reserved for a future `.lolo` grammar extension that
+ * lets atom authors author a human-friendly question prompt; today
+ * it's always undefined and the questionnaire derives a fallback
+ * from the key name.
+ */
+interface FactoryConfigParam {
+    /** Key name as advertised by the trait. Matches the override path
+     *  `traitOverrides.<traitName>.config.<key>`. */
+    key: string;
+    /** Type tag lifted from the `.lolo` config declaration. Drives the
+     *  question widget selection. Free-form to admit array/object
+     *  brackets (`[object]`, `[string]`) and atom-defined custom tags. */
+    type: string;
+    /** Canonical default value the factory uses when no override is
+     *  supplied. Pre-fills the form widget so users see what they're
+     *  about to change. */
+    default?: FactoryParamValue;
+    /** Optional human-friendly question prompt. Lifted from the source
+     *  `.lolo` `@label "..."` annotation. */
+    label?: string;
+    /** Optional help-text. Lifted from `.lolo` `@description "..."`. */
+    description?: string;
+    /** Optional closed-enum value set. Lifted from `.lolo` enum syntax. */
+    enumValues?: ReadonlyArray<string>;
+    /** Array element schema when the slot's type is `[T]`. Mirrors the
+     *  `.orb` `ConfigField.items` carrier (`FieldDefinition`-shaped). Lets
+     *  consumers see the per-element typing — e.g. `metrics : [MetricSpec]`
+     *  exposes `items.properties` with every MetricSpec field + its own
+     *  `values: [...]` enum constraints. */
+    items?: EntityField;
+    /** Object property schemas keyed by property name when the slot's type
+     *  is an inline `{ ... }` or a named struct alias. Mirrors the `.orb`
+     *  `ConfigField.properties` carrier. */
+    properties?: Readonly<Record<string, EntityField>>;
+    /** Comma-separated user-vocabulary synonyms. Authored in `.lolo` as
+     *  `@synonyms "..."` next to the knob declaration. Used by the agent's
+     *  catalog-summary prompt (so the LLM connects user phrases to knob
+     *  names) and by the publish-time knob-embeddings bake (so cosine
+     *  narrowing recalls knobs voiced via synonym).
+     *
+     *  Example for the `height` knob on `std-graphs`:
+     *    `@synonyms "taller, shorter, vertical size, pixel height"`
+     *
+     *  Stays a single free-form string; consumers decide their own
+     *  splitting/formatting policy. */
+    synonyms?: string;
+    /** Decision-kind tier authored in `.lolo` as `@tier "..."` next to the
+     *  knob declaration. Drives the studio Questionnaire's filter +
+     *  disclosure: `internal` knobs are hidden entirely, `presentation`
+     *  knobs collapse under the "Polish wording" panel, `domain` knobs
+     *  render inline. Untagged knobs are treated as `presentation` by the
+     *  studio (safe default — most un-audited knobs are presentation polish). */
+    tier?: FactoryConfigTier;
+}
+/**
+ * Decision-kind tier for a `FactoryConfigParam`. Source-tagged via the
+ * `@tier "..."` annotation in `.lolo` — no heuristic inference on the
+ * consumer side. Missing tag = author did not tag = treat as
+ * `presentation` at render time.
+ *
+ *  - `domain` — changes how the BUSINESS behaves (currency, retention
+ *    days, approver roles, SLA hours, lifecycle rules, recipient map,
+ *    GDPR erasure window). The user MUST own these decisions.
+ *  - `presentation` — changes how the same business meaning is RENDERED
+ *    (labels, placeholders, titles, copy, column lists, action lists,
+ *    layout fidelity like cols/gap/chartType). LLM picks defaults;
+ *    user can edit post-generation.
+ *  - `internal` — framework primitives (trait/slot/pattern types,
+ *    *Event keys, layoutMode); the studio never surfaces these.
+ */
+type FactoryConfigTier = 'domain' | 'presentation' | 'internal';
+/**
+ * One trait the factory composes into the orbital. The projector reads
+ * these to determine which factory's trait stack covers a given
+ * orbital + which override knobs a presentation overlay can target.
+ */
+interface FactoryTraitSignature {
+    /** Canonical trait name post-rename (e.g. `"ChatMessageList"`). */
+    name: string;
+    /** Upstream trait reference path when this trait is a call-site override
+     *  of an imported atom — e.g. `"Stats.traits.StatsItemStats"`. Absent
+     *  when the trait is inline-defined (atom-tier traits). The catalog
+     *  inheritance pass uses this to resolve the upstream atom signature
+     *  so each call-site `overridableConfigKeys` entry gets `type` /
+     *  `items` / `properties` filled in from the canonical declaration. */
+    ref?: string;
+    /** Event keys this trait emits (post-rename). */
+    emittedEvents: ReadonlyArray<string>;
+    /** Event keys this trait listens for. */
+    listenedEvents: ReadonlyArray<string>;
+    /** Structured emit + listen events with their `@description`/`@synonyms`/`@tier`
+     *  annotations. Parallel to `emittedEvents`/`listenedEvents` (kept as bare-key
+     *  back-compat); the curation event matcher reads this. */
+    events?: ReadonlyArray<FactoryEventSignature>;
+    /** Config knobs overridable via `traitOverrides.<name>.config.<key>`.
+     *  Each entry carries the key name plus the typed declaration lifted
+     *  from the source `.lolo` `config { }` block. */
+    overridableConfigKeys: ReadonlyArray<FactoryConfigParam>;
+    /** Capability tags lifted directly from the source `.lolo` trait's
+     *  header annotations. Free-form strings — the translator overlay
+     *  matches rules to traits by exact set membership. */
+    capabilities: ReadonlyArray<string>;
+    /** `true` when the source trait's entity binding was authored
+     *  `-> @rebindable Entity`. Only then may a consumer rebind it via
+     *  `traitOverrides.<name>.linkedEntity`; rabit enum-constrains that
+     *  override to the organism's entities and the validator enforces the
+     *  field contract. Absent/false = fixed binding. */
+    entityRebindable?: boolean;
+    /** Inferred field contract a rebind target must satisfy. `requires` =
+     *  fields the trait reads via `@entity.X`; `provides` = fields it writes.
+     *  Present only alongside `entityRebindable`. */
+    entityContract?: {
+        requires: ReadonlyArray<string>;
+        provides: ReadonlyArray<string>;
+    };
+    /** `@description` / `@synonyms` authored on the `@rebindable` binding —
+     *  fed to catalog prose + knob-embeddings for binding-discovery. */
+    entityBindingDescription?: string;
+    entityBindingSynonyms?: string;
+}
+/** One event a trait emits or listens for, with its authored annotations — the
+ *  per-event analogue of `FactorySignatureEntityField` / `FactoryConfigParam`.
+ *  Feeds the curation event matcher (embedding-wire a composed style atom's
+ *  actions to a domain lifecycle's events). */
+interface FactoryEventSignature {
+    /** Event key (post-rename). */
+    name: string;
+    /** Whether the trait emits the event or listens for it. */
+    direction: 'emit' | 'listen';
+    /** Authored `@description` on the emit/listen. */
+    description?: string;
+    /** Authored `@synonyms` (comma-separated user vocabulary). */
+    synonyms?: string;
+    /** Authoring `@tier` (`essential`/`customization`/`advanced`/`internal`). */
+    tier?: string;
+}
+/** One page the factory emits. The path is the factory default; the
+ *  projector may override via `params.pagePaths`. */
+interface FactoryPageSignature {
+    name: string;
+    defaultPath: string;
+    primaryEntity: string;
+}
+interface FactorySignature {
+    /** Organism the factory belongs to (e.g. `"std-realtime-chat"`). */
+    organism: string;
+    /** Orbital this factory builds within that organism. */
+    orbital: string;
+    /** Tier the factory sits in (informational). */
+    tier: 'atoms' | 'molecules' | 'organisms';
+    /** Path of the generated factory source (relative to the std root). */
+    factoryPath: string;
+    /** Canonical entity surface(s) the factory produces. */
+    entities: ReadonlyArray<FactoryEntitySignature>;
+    /** Trait stack the factory composes. */
+    traits: ReadonlyArray<FactoryTraitSignature>;
+    /** Pages the factory emits. */
+    pages: ReadonlyArray<FactoryPageSignature>;
+    /** Union of all `traits[].emittedEvents`. */
+    emittedEvents: ReadonlyArray<string>;
+    /** Union of all `traits[].listenedEvents`. */
+    listenedEvents: ReadonlyArray<string>;
+    /**
+     * JSON Schema for the orbital's `AnalysisOrbitalParams` shape. Walks
+     * `traitOverrides.<TraitName>.config.<knob>` with the exact type
+     * (string/number/boolean/array/object) lifted from each knob's
+     * declaration, `enum` from `enumValues`, recursive `items` for array
+     * slots, recursive `properties` for struct slots. Every level carries
+     * `additionalProperties: false` so the LLM cannot emit unknown trait
+     * names, invented knob keys, or out-of-set enum values.
+     *
+     * Pre-computed at signature extraction time by
+     * `tools/almadar-pattern-sync/src/std-ts/signatures/`. V2 tool-calling
+     * (`@almadar-io/agent`'s coordinator + per-orbital subagent) feeds this
+     * directly to OpenAI's `tool.parameters` with `strict: true` — the
+     * LLM is physically constrained by the schema instead of relying on
+     * post-hoc validation.
+     *
+     * Optional for backward compatibility: signatures emitted by older
+     * pattern-sync versions don't carry it, in which case V2 tools fall
+     * back to a loose schema + post-hoc validation.
+     */
+    paramsSchema?: JsonSchema;
+}
+/**
+ * Aggregate catalog written to
+ * `packages/almadar-std/behaviors/registry/factory-signatures.json`.
+ * Sorted by organism then orbital.
+ */
+interface FactorySignatureCatalog {
+    /** Generated-by version stamp (the `@almadar/std` minor it shipped in). */
+    generatedFromStdVersion: string;
+    /** Sorted list of factory signatures. */
+    signatures: ReadonlyArray<FactorySignature>;
+}
+/**
+ * A single factory invocation, as the typed result of the translator.
+ * Lower into runtime by calling the factory at `factoryPath` with
+ * these `params`. Stable identity for downstream diffing is
+ * `(organism, orbital)`.
+ */
+interface FactoryCallSite {
+    organism: string;
+    orbital: string;
+    factoryPath: string;
+    params: FactoryCallSiteParams;
+}
+/**
+ * The typed param surface every factory's call site populates. Each
+ * field corresponds to one row in the translator's overlay → factory
+ * mapping table.
+ */
+interface FactoryCallSiteParams {
+    /** Override `signature.entities[0].name` (entity rename). */
+    entityName?: string;
+    /** Additional or overriding entity fields. Caller wins on collision. */
+    entityFields?: ReadonlyArray<EntityField>;
+    /** Override `signature.entities[0].persistence`. */
+    persistence?: EntityPersistence;
+    /** Override the entity's storage collection key. */
+    collection?: string;
+    /** Per-page path overrides keyed by `signature.pages[i].name`. */
+    pagePaths?: Readonly<Record<string, string>>;
+    /** Trait-level overrides keyed by `signature.traits[i].name`. Each value
+     *  is a {@link TraitOverlayEntry} — the canonical override surface that
+     *  admits the full documented set (`config`, `linkedEntity`, `events`,
+     *  `name`, `emitsScope`, `listens`) and mirrors what `TraitOverlay` (the
+     *  LLM-facing input) and {@link MakeTraitRefOpts} (the builder input)
+     *  both accept. The translator threads each field from the overlay
+     *  through to here verbatim; the factory applies them via the same
+     *  `TraitReference` override semantics the inliner uses on hand-authored
+     *  `.orb` traits. Pre-unification this carried only `{ config? }`, which
+     *  silently dropped every other override field even though both the
+     *  overlay layer above and the factory builders below accepted them. */
+    traitOverrides?: Readonly<Record<string, TraitOverlayEntry>>;
+    /** Extra traits to compose into the orbital that aren't part of the
+     *  canonical signature trait stack. */
+    extraTraits?: ReadonlyArray<TraitReference>;
+}
+/**
+ * Allowed leaf values for the typed factory-param surface.
+ */
+type FactoryParamValue = string | number | boolean | ReadonlyArray<FactoryParamValue> | {
+    readonly [key: string]: FactoryParamValue;
+};
+
+export { type FactoryCallSite as F, type JsonObject as J, type OwnershipOverlayEntry as O, type PresentationNavItem as P, type RuleOverlay as R, type SchemaFieldType as S, type ToolArgs as T, type FactoryCallSiteParams as a, type FactoryConfigParam as b, type FactoryConfigTier as c, type FactoryEntitySignature as d, type FactoryEventSignature as e, type FactoryPageSignature as f, type FactoryParamValue as g, type FactorySignature as h, type FactorySignatureCatalog as i, type FactorySignatureEntityField as j, type FactoryTraitSignature as k, type JsonSchema as l, type JsonSchemaType as m, type JsonValue as n, type PresentationOverlay as o, type RuleOverlayEntry as p, type TraitOverlay as q, type TraitOverlayEntry as r, type TraitOverlayListener as s, isJsonArray as t, isJsonObject as u, isJsonPrimitive as v };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@almadar/core",
-  "version": "9.6.0",
+  "version": "9.7.0",
   "description": "Core schema types and definitions for Almadar",
   "type": "module",
   "main": "./dist/index.js",

package/dist/json-lCu3FWzv.d.ts

@@ -1,57 +0,0 @@
-/**
- * JSON primitives — the universal "data crossed a boundary" type.
- *
- * Every value that arrives over the wire from an LLM (tool-call args),
- * from disk (workspace files), or from an HTTP body before
- * domain-specific validation is a `JsonValue`. Narrow with a typed
- * predicate (`is`-guard) at the boundary; don't widen back to `unknown`.
- *
- * `JsonObject` and `ToolArgs` are aliases for the common
- * `Record<string, JsonValue>` shape. `ToolArgs` is the name the
- * agent surface uses for LLM-emitted tool-call arguments; `JsonObject`
- * is the general-purpose alias. They are the same type — the alias
- * exists so call sites read at the right semantic level.
- *
- * Why not `Record<string, unknown>`? Two reasons. (1) `unknown` widens
- * back to anything, which defeats the purpose of typing the boundary.
- * (2) The `@almadar/eslint-plugin/no-record-string-unknown` rule blocks
- * the wider form — `JsonValue`-based records are the typed answer.
- *
- * @packageDocumentation
- */
-/**
- * Recursive JSON value union — every shape JSON can carry.
- */
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-/**
- * JSON object — keyed string→JsonValue. The wire form of arbitrary
- * structured data. Replaces `Record<string, unknown>` at typed
- * boundaries (LLM emits, file reads, HTTP bodies).
- */
-type JsonObject = {
-    [key: string]: JsonValue;
-};
-/**
- * LLM tool-call arguments — same shape as `JsonObject`, named for the
- * agent-surface call site. Each tool's `execute(args: ToolArgs)`
- * receives this and narrows via an `is`-guard predicate before any
- * field access.
- */
-type ToolArgs = JsonObject;
-/**
- * Type guard: is the given value a JSON primitive (non-array,
- * non-object)? Used by walkers that decide whether to recurse.
- */
-declare function isJsonPrimitive(value: JsonValue): value is string | number | boolean | null;
-/**
- * Type guard: is the given value a JSON object (non-array, non-null)?
- */
-declare function isJsonObject(value: JsonValue): value is JsonObject;
-/**
- * Type guard: is the given value a JSON array?
- */
-declare function isJsonArray(value: JsonValue): value is JsonValue[];
-
-export { type JsonObject as J, type ToolArgs as T, type JsonValue as a, isJsonObject as b, isJsonPrimitive as c, isJsonArray as i };