@jarenjs/linq 0.67.0 → 0.72.2

package/types/charts.d.ts

@@ -0,0 +1,481 @@
+// Derived from chart-definition.schema.json by scripts/generate-chart-pen.js.
+/**
+ * createStreamAdapter mapping: how reader events accumulate into this chart's data
+ */
+export interface StreamSpec {
+  recordPath?: Array<string | number>;
+  recordBoundary?: "path" | "document";
+  xField?: string;
+  yField?: string;
+  seriesField?: string;
+  /**
+   * Schema constraints this type cannot express: type="integer", minimum=1
+   */
+  maxPoints?: number;
+  [key: string]: unknown;
+}
+
+
+export interface Slice {
+  label: string;
+  /**
+   * Schema constraints this type cannot express: minimum=0
+   */
+  value: number;
+  [key: string]: unknown;
+}
+
+
+export type Tone = "win" | "loss" | null;
+
+export interface BarSeries {
+  name: string;
+  values: Array<number | null>;
+  tone?: Tone;
+  tones?: Array<Tone>;
+  [key: string]: unknown;
+}
+
+
+export interface Point {
+  x: number;
+  y: number;
+  tone?: Tone;
+  [key: string]: unknown;
+}
+
+
+export interface LineSeries {
+  name: string;
+  points: Array<Point>;
+  [key: string]: unknown;
+}
+
+
+export interface Candle {
+  t: number;
+  open: number;
+  high: number;
+  low: number;
+  close: number;
+  [key: string]: unknown;
+}
+
+
+/**
+ * a named series of index-aligned values (radar axes / streamgraph samples)
+ */
+export interface ValueSeries {
+  name: string;
+  values: Array<number | null>;
+  [key: string]: unknown;
+}
+
+
+/**
+ * one boxplot category: raw samples in `values`, or a precomputed five-number summary
+ */
+export type Box = ({ values: unknown; [key: string]: unknown; } | Array<unknown> | string | number | boolean | null | { min: unknown; q1: unknown; med: unknown; q3: unknown; max: unknown; [key: string]: unknown; }) & { label: string; values?: Array<number | null>; min?: number; q1?: number; med?: number; q3?: number; max?: number; outliers?: Array<number>; [key: string]: unknown; };
+
+export interface TreemapItem {
+  label: string;
+  /**
+   * Schema constraints this type cannot express: exclusiveMinimum=0
+   */
+  value: number;
+  [key: string]: unknown;
+}
+
+
+/**
+ * one hierarchy level: the group's value is its children's sum
+ */
+export interface TreemapGroup {
+  label: string;
+  /**
+   * Schema constraints this type cannot express: minItems=1
+   */
+  children: Array<TreemapItem>;
+  [key: string]: unknown;
+}
+
+
+/**
+ * a flow from source to target; endpoints are node names or node indexes
+ */
+export interface SankeyLink {
+  /**
+   * Schema constraints this type cannot express: type="integer"
+   */
+  source: string | number;
+  /**
+   * Schema constraints this type cannot express: type="integer"
+   */
+  target: string | number;
+  /**
+   * Schema constraints this type cannot express: exclusiveMinimum=0
+   */
+  value: number;
+  [key: string]: unknown;
+}
+
+
+/**
+ * Schema constraints this type cannot express: minimum=-180, maximum=180
+ */
+export type MapPointAtItem1 = number;
+
+/**
+ * Schema constraints this type cannot express: minimum=-90, maximum=90
+ */
+export type MapPointAtItem2 = number;
+
+/**
+ * a place marker: the convenience path for a caller holding positions rather than GeoJSON
+ */
+export interface MapPoint {
+  /**
+   * a GeoJSON position: [longitude, latitude]
+   * Schema constraints this type cannot express: minItems=2, maxItems=3
+   */
+  at: [MapPointAtItem1, MapPointAtItem2, ...Array<number>];
+  label?: string;
+  value?: number;
+  [key: string]: unknown;
+}
+
+
+export interface SamplingPolicyAnyOf3 {
+  method?: "lttb" | "minmax";
+  /**
+   * the most points one series may draw; an explicit target makes the rendered line independent of any layout
+   * Schema constraints this type cannot express: type="integer", minimum=2
+   */
+  target?: number;
+  /**
+   * the width the derived target assumes, in CSS pixels (default 560)
+   * Schema constraints this type cannot express: exclusiveMinimum=0
+   */
+  width?: number;
+  /**
+   * Schema constraints this type cannot express: exclusiveMinimum=0
+   */
+  pixelRatio?: number;
+  [key: string]: unknown;
+}
+
+
+/**
+ * how many of a line's points are drawn: false never samples, a method name or object samples whatever the count, and an omitted member samples a TIME line above 2000 points through @jarenjs/core/series. Distinct from stream.maxPoints, which decides what exists rather than what is drawn.
+ */
+export type SamplingPolicy = false | "lttb" | "minmax" | SamplingPolicyAnyOf3;
+
+/**
+ * the month, weekday and meridiem names a time-axis pattern with a name token reads (compileDateLocale(pack).names from @jarenjs/locales); a name token with no record is a compile error, never an English fallback
+ */
+export interface DateNames {
+  /**
+   * Schema constraints this type cannot express: minItems=12, maxItems=12
+   */
+  months?: Array<string>;
+  /**
+   * Schema constraints this type cannot express: minItems=12, maxItems=12
+   */
+  monthsShort?: Array<string>;
+  /**
+   * Schema constraints this type cannot express: minItems=7, maxItems=7
+   */
+  weekdays?: Array<string>;
+  /**
+   * Schema constraints this type cannot express: minItems=7, maxItems=7
+   */
+  weekdaysShort?: Array<string>;
+  /**
+   * Schema constraints this type cannot express: minItems=2, maxItems=2
+   */
+  meridiem?: Array<string>;
+  [key: string]: unknown;
+}
+
+
+/**
+ * LDML label patterns for a time axis, keyed by the granularity of the tick step; an omitted member keeps its numeric default (HH:mm:ss, HH:mm, yyyy-MM-dd, yyyy-MM, yyyy)
+ */
+export interface TimeFormats {
+  second?: string;
+  minute?: string;
+  day?: string;
+  month?: string;
+  year?: string;
+  [key: string]: unknown;
+}
+
+
+export interface DomainPolicyX {
+  /**
+   * Schema constraints this type cannot express: exclusiveMinimum=0
+   */
+  window: number;
+  /**
+   * Schema constraints this type cannot express: exclusiveMinimum=0
+   */
+  slide?: number;
+  [key: string]: unknown;
+}
+
+
+/**
+ * domain-stability policy: a quantized sliding x window and/or pinned or step-quantized y bounds, so most streaming ticks keep the scales still
+ */
+export interface DomainPolicy {
+  x?: DomainPolicyX;
+  y?: "step" | { min?: number; max?: number; [key: string]: unknown; };
+  [key: string]: unknown;
+}
+
+
+export interface PieChart {
+  type: "pie";
+  title?: string | null;
+  stream?: StreamSpec;
+  /**
+   * true for the default hole fraction, or the hole radius as a fraction of the outer radius
+   * Schema constraints this type cannot express: exclusiveMinimum=0, exclusiveMaximum=1
+   */
+  donut?: boolean | number;
+  slices?: Array<Slice>;
+}
+
+
+export interface BarChart {
+  type: "bar";
+  title?: string | null;
+  stream?: StreamSpec;
+  stacked?: boolean;
+  log?: boolean;
+  orient?: "v" | "h";
+  catLabel?: string | null;
+  valLabel?: string | null;
+  categories?: Array<string>;
+  series?: Array<BarSeries>;
+}
+
+
+export interface LineChart {
+  type: "line";
+  title?: string | null;
+  stream?: StreamSpec;
+  x?: "linear" | "time";
+  log?: boolean;
+  markers?: boolean;
+  xLabel?: string | null;
+  yLabel?: string | null;
+  domain?: DomainPolicy;
+  sampling?: SamplingPolicy;
+  dateNames?: DateNames;
+  timeFormats?: TimeFormats;
+  series?: Array<LineSeries>;
+}
+
+
+export interface ScatterChart {
+  type: "scatter";
+  title?: string | null;
+  stream?: StreamSpec;
+  xLog?: boolean;
+  yLog?: boolean;
+  refY?: number;
+  refLabel?: string | null;
+  xLabel?: string | null;
+  yLabel?: string | null;
+  points?: Array<Point>;
+}
+
+
+export interface CandlestickChart {
+  type: "candlestick";
+  title?: string | null;
+  stream?: StreamSpec;
+  xLabel?: string | null;
+  yLabel?: string | null;
+  domain?: DomainPolicy;
+  dateNames?: DateNames;
+  timeFormats?: TimeFormats;
+  candles?: Array<Candle>;
+}
+
+
+export interface RadarChart {
+  type: "radar";
+  title?: string | null;
+  stream?: StreamSpec;
+  /**
+   * Schema constraints this type cannot express: exclusiveMinimum=0
+   */
+  max?: number;
+  axes?: Array<string>;
+  series?: Array<ValueSeries>;
+}
+
+
+export interface GaugeChart {
+  type: "gauge";
+  title?: string | null;
+  stream?: StreamSpec;
+  value?: number;
+  min?: number;
+  max?: number;
+  unit?: string | null;
+  tone?: Tone;
+}
+
+
+export interface BoxplotChart {
+  type: "boxplot";
+  title?: string | null;
+  stream?: StreamSpec;
+  catLabel?: string | null;
+  valLabel?: string | null;
+  boxes?: Array<Box>;
+}
+
+
+export interface HeatmapChart {
+  type: "heatmap";
+  title?: string | null;
+  stream?: StreamSpec;
+  log?: boolean;
+  xLabel?: string | null;
+  yLabel?: string | null;
+  xLabels?: Array<string>;
+  yLabels?: Array<string>;
+  /**
+   * values[yi][xi], row-major from the top row; null marks a missing cell
+   */
+  values?: Array<Array<number | null>>;
+}
+
+
+export interface TreemapChart {
+  type: "treemap";
+  title?: string | null;
+  stream?: StreamSpec;
+  /**
+   * Schema constraints this type cannot express: exclusiveMinimum=0
+   */
+  aspect?: number;
+  /**
+   * leaves, or one level of groups; a chart with any group treats a bare leaf as a group of one
+   */
+  items?: Array<TreemapItem | TreemapGroup>;
+}
+
+
+export interface StreamgraphChart {
+  type: "streamgraph";
+  title?: string | null;
+  stream?: StreamSpec;
+  xLabel?: string | null;
+  xs?: Array<number>;
+  series?: Array<ValueSeries>;
+}
+
+
+export interface SankeyChart {
+  type: "sankey";
+  title?: string | null;
+  stream?: StreamSpec;
+  nodes?: Array<string | { name: string; [key: string]: unknown; }>;
+  links?: Array<SankeyLink>;
+}
+
+
+export interface MapChart {
+  type: "map";
+  title?: string | null;
+  stream?: StreamSpec;
+  /**
+   * feature property to shade by; absent leaves the map unshaded
+   */
+  value?: string;
+  /**
+   * feature property to name features by (default 'name')
+   */
+  label?: string;
+  log?: boolean;
+  /**
+   * Schema constraints this type cannot express: exclusiveMinimum=0
+   */
+  aspect?: number;
+  /**
+   * Douglas-Peucker tolerance as a fraction of the frame's width, or false to keep every vertex
+   * Schema constraints this type cannot express: minimum=0
+   */
+  simplify?: number | boolean;
+  /**
+   * GeoJSON: a FeatureCollection, or an array of Features or geometries
+   */
+  features?: { [key: string]: unknown; } | Array<unknown>;
+  points?: Array<MapPoint>;
+}
+
+
+export type ChartDefinition = PieChart | BarChart | LineChart | ScatterChart | CandlestickChart | RadarChart | GaugeChart | BoxplotChart | HeatmapChart | TreemapChart | StreamgraphChart | SankeyChart | MapChart;
+
+
+export interface ChartDefinitions {
+  pie: PieChart;
+  bar: BarChart;
+  line: LineChart;
+  scatter: ScatterChart;
+  candlestick: CandlestickChart;
+  radar: RadarChart;
+  gauge: GaugeChart;
+  boxplot: BoxplotChart;
+  heatmap: HeatmapChart;
+  treemap: TreemapChart;
+  streamgraph: StreamgraphChart;
+  sankey: SankeyChart;
+  map: MapChart;
+}
+export type ChartKind = keyof ChartDefinitions;
+type Immutable<T> = T extends object ? { readonly [K in keyof T]: Immutable<T[K]> } : T;
+export type ChartOptions<K extends ChartKind> = Omit<Immutable<ChartDefinitions[K]>, 'type'>;
+export type ChartPen<K extends ChartKind> = ChartBuilder<K> & {
+  readonly [P in keyof ChartOptions<K>]-?: (value: Exclude<ChartOptions<K>[P], undefined>) => ChartPen<K>;
+};
+/** The kind controls the available fluent members and their value types. */
+export class ChartBuilder<K extends ChartKind = ChartKind> {
+  protected constructor();
+  readonly schema: Immutable<ChartDefinitions[K]>;
+  toJSON(): Immutable<ChartDefinitions[K]>;
+  options(value: ChartOptions<K>): ChartPen<K>;
+}
+/** A raw public chart definition; extensions remain JSON and engine-validated. */
+export function from<K extends ChartKind>(document: ChartDefinitions[K]): ChartPen<K>;
+/** A pie chart definition. */
+export function pie(options?: ChartOptions<'pie'>): ChartPen<'pie'>;
+/** A bar chart definition. */
+export function bar(options?: ChartOptions<'bar'>): ChartPen<'bar'>;
+/** A line chart definition. */
+export function line(options?: ChartOptions<'line'>): ChartPen<'line'>;
+/** A scatter chart definition. */
+export function scatter(options?: ChartOptions<'scatter'>): ChartPen<'scatter'>;
+/** A candlestick chart definition. */
+export function candlestick(options?: ChartOptions<'candlestick'>): ChartPen<'candlestick'>;
+/** A radar chart definition. */
+export function radar(options?: ChartOptions<'radar'>): ChartPen<'radar'>;
+/** A gauge chart definition. */
+export function gauge(options?: ChartOptions<'gauge'>): ChartPen<'gauge'>;
+/** A boxplot chart definition. */
+export function boxplot(options?: ChartOptions<'boxplot'>): ChartPen<'boxplot'>;
+/** A heatmap chart definition. */
+export function heatmap(options?: ChartOptions<'heatmap'>): ChartPen<'heatmap'>;
+/** A treemap chart definition. */
+export function treemap(options?: ChartOptions<'treemap'>): ChartPen<'treemap'>;
+/** A streamgraph chart definition. */
+export function streamgraph(options?: ChartOptions<'streamgraph'>): ChartPen<'streamgraph'>;
+/** A sankey chart definition. */
+export function sankey(options?: ChartOptions<'sankey'>): ChartPen<'sankey'>;
+/** A map chart definition. */
+export function map(options?: ChartOptions<'map'>): ChartPen<'map'>;

package/types/jtlt.d.ts

@@ -0,0 +1,45 @@
+import type { ExprBase, UnknownExpr } from './index.js';
+import type { Json, JsonSchema } from './schema.js';
+
+export type Match = string | { readonly path?: string; readonly schema?: JsonSchema };
+export type Output = 'text' | 'xml';
+export type Segment = string | Readonly<Record<string, Json>> | readonly Segment[];
+export interface RuleDocument {
+  readonly match?: Match;
+  readonly mode?: string;
+  readonly priority?: number;
+  readonly body: readonly Segment[];
+}
+export type TemplateDocument = readonly RuleDocument[] | {
+  readonly $jtlt: '0.1';
+  readonly output?: Output;
+  readonly rules: readonly RuleDocument[];
+};
+export type QueryInput<N extends string = never> = Json | ((value: UnknownExpr, externals: Readonly<Record<N | 'root' | 'path', UnknownExpr>>) => ExprBase<unknown> | Json);
+export interface QueryOptions<N extends string> { readonly externals?: readonly N[] }
+export function text(value: string): string;
+export function query<N extends string = never>(value: QueryInput<N>, options?: QueryOptions<N>): string | Readonly<Record<string, Json>>;
+export function raw<N extends string = never>(value: QueryInput<N>, options?: QueryOptions<N>): { readonly $raw: Json };
+export function json<N extends string = never>(value: QueryInput<N>, options?: QueryOptions<N>): { readonly $json: Json };
+export function apply<N extends string = never>(value: QueryInput<N>, mode?: string, options?: QueryOptions<N>): { readonly $apply: Json };
+export class RuleBuilder {
+  protected constructor();
+  readonly schema: RuleDocument;
+  toJSON(): RuleDocument;
+  body(value: readonly Segment[]): RuleBuilder;
+  match(value: Match): RuleBuilder;
+  mode(value: string): RuleBuilder;
+  priority(value: number): RuleBuilder;
+}
+export function rule(body?: readonly Segment[], options?: Omit<RuleDocument, 'body'>): RuleBuilder;
+export class TemplateBuilder {
+  protected constructor();
+  readonly schema: TemplateDocument;
+  toJSON(): TemplateDocument;
+  rules(values: readonly (RuleBuilder | RuleDocument)[]): TemplateBuilder;
+  rule(value: RuleBuilder | RuleDocument): TemplateBuilder;
+  output(value: Output): TemplateBuilder;
+}
+export function stylesheet(rules?: readonly (RuleBuilder | RuleDocument)[], options?: { readonly output?: Output }): TemplateBuilder;
+export function bare(rules?: readonly (RuleBuilder | RuleDocument)[]): TemplateBuilder;
+export function from(document: TemplateDocument): TemplateBuilder;

package/types/message-vocabulary.d.ts

@@ -0,0 +1,96 @@
+// Derived from the English catalogs by scripts/generate-message-pen.js.
+export interface CatalogIds {
+  validate: "type" | "required" | "minimum" | "maximum" | "exclusiveMinimum" | "exclusiveMaximum" | "multipleOf" | "minLength" | "maxLength" | "pattern" | "additionalProperties" | "minProperties" | "maxProperties" | "minItems" | "maxItems" | "uniqueItems" | "contains" | "items" | "allOf" | "anyOf" | "oneOf" | "not" | "format" | "if" | "then" | "else" | "false schema" | "$query" | "JQ2001" | "JQ2003";
+  forms: "form/required" | "form/type" | "form/const" | "form/enum" | "form/minLength" | "form/maxLength" | "form/pattern" | "form/format" | "form/minimum" | "form/maximum" | "form/exclusiveMinimum" | "form/exclusiveMaximum" | "form/multipleOf" | "form/minItems" | "form/maxItems" | "form/uniqueItems" | "form/minProperties" | "form/maxProperties" | "x-form/assert" | "form/addItem" | "form/removeItem";
+  contract: "contract/not-found" | "contract/method-not-allowed" | "contract/body-too-large" | "contract/unsupported-media" | "contract/malformed-json" | "contract/invalid-input" | "contract/idempotency-key-required" | "contract/handler-failed" | "contract/idempotency-conflict" | "contract/invalid-output" | "contract/malformed-path" | "contract/malformed-query" | "contract/not-implemented" | "contract/precondition-failed" | "contract/invalid-header" | "contract/handler-error" | "contract/client-invalid-input" | "contract/network" | "contract/cancelled" | "contract/invalid-response" | "contract/key-storage-failed" | "contract/undeclared-response" | "contract/not-a-contract" | "contract/incompatible" | "contract/host-failed" | "contract/local-handler-failed" | "contract/unknown-operation" | "contract/port-timeout" | "contract/malformed-frame" | "contract/channel-closed" | "contract/not-a-stream" | "contract/invalid-snapshot" | "contract/seq-regression" | "contract/stream-error" | "contract/heartbeat-missed" | "contract/slow-consumer" | "contract/reconnect-exhausted";
+}
+export interface MessageParameters {
+  "type": "type" | "types";
+  "required": "missingProperty";
+  "minimum": "comparison" | "limit";
+  "maximum": "comparison" | "limit";
+  "exclusiveMinimum": "comparison" | "limit";
+  "exclusiveMaximum": "comparison" | "limit";
+  "multipleOf": "multipleOf";
+  "minLength": "limit";
+  "maxLength": "limit";
+  "pattern": "pattern";
+  "additionalProperties": "additionalProperty";
+  "minProperties": "limit";
+  "maxProperties": "limit";
+  "minItems": "limit";
+  "maxItems": "limit";
+  "uniqueItems": never;
+  "contains": never;
+  "items": never;
+  "allOf": never;
+  "anyOf": never;
+  "oneOf": never;
+  "not": never;
+  "format": "format";
+  "if": never;
+  "then": never;
+  "else": never;
+  "false schema": never;
+  "$query": "code" | "docPath";
+  "JQ2001": "code" | "docPath";
+  "JQ2003": "code" | "docPath";
+  "form/required": never;
+  "form/type": "type";
+  "form/const": "constValue";
+  "form/enum": "enumValues";
+  "form/minLength": "len" | "limit";
+  "form/maxLength": "len" | "limit";
+  "form/pattern": "pattern";
+  "form/format": "format";
+  "form/minimum": "limit";
+  "form/maximum": "limit";
+  "form/exclusiveMinimum": "limit";
+  "form/exclusiveMaximum": "limit";
+  "form/multipleOf": "multipleOf";
+  "form/minItems": "limit";
+  "form/maxItems": "limit";
+  "form/uniqueItems": never;
+  "form/minProperties": "limit";
+  "form/maxProperties": "limit";
+  "x-form/assert": never;
+  "form/addItem": never;
+  "form/removeItem": never;
+  "contract/not-found": never;
+  "contract/method-not-allowed": "allow";
+  "contract/body-too-large": "limit" | "op";
+  "contract/unsupported-media": "media" | "op";
+  "contract/malformed-json": "op";
+  "contract/invalid-input": "op";
+  "contract/idempotency-key-required": "op";
+  "contract/handler-failed": "op";
+  "contract/idempotency-conflict": "kind" | "op";
+  "contract/invalid-output": "op";
+  "contract/malformed-path": never;
+  "contract/malformed-query": never;
+  "contract/not-implemented": "op";
+  "contract/precondition-failed": "op";
+  "contract/invalid-header": "header" | "op";
+  "contract/handler-error": "code" | "op";
+  "contract/client-invalid-input": "op";
+  "contract/network": "name" | "op";
+  "contract/cancelled": "op";
+  "contract/invalid-response": "op";
+  "contract/key-storage-failed": "op";
+  "contract/undeclared-response": "op" | "status";
+  "contract/not-a-contract": "id";
+  "contract/incompatible": "client" | "id" | "server";
+  "contract/host-failed": "op";
+  "contract/local-handler-failed": "op";
+  "contract/unknown-operation": never;
+  "contract/port-timeout": "ms" | "op";
+  "contract/malformed-frame": "op";
+  "contract/channel-closed": "op";
+  "contract/not-a-stream": "op";
+  "contract/invalid-snapshot": "op";
+  "contract/seq-regression": "op";
+  "contract/stream-error": "code" | "op";
+  "contract/heartbeat-missed": "ms" | "op";
+  "contract/slow-consumer": "op";
+  "contract/reconnect-exhausted": "attempts" | "lastCode" | "op";
+}

package/types/messages.d.ts

@@ -0,0 +1,32 @@
+import type { Json } from './schema.js';
+import type { CatalogIds, MessageParameters } from './message-vocabulary.js';
+export type { CatalogIds, MessageParameters } from './message-vocabulary.js';
+export type CatalogSource = keyof CatalogIds | 'all';
+export type Msgid<S extends CatalogSource = 'all'> = S extends keyof CatalogIds ? CatalogIds[S] : keyof MessageParameters;
+export type CatalogDocument<I extends string = Msgid> = Readonly<Record<I, string>>;
+type Present<D> = string extends keyof D ? never : {
+  [K in keyof D]-?: {} extends Pick<D, K> ? never : K
+}[keyof D] & string;
+// A union-valued id adds one unknown member, not every member of that union.
+type SingleId<I, Whole = I> = I extends unknown ? [Whole] extends [I] ? I : never : never;
+export const CATALOGS: { readonly [S in keyof CatalogIds]: { readonly [I in CatalogIds[S]]: readonly (I extends keyof MessageParameters ? MessageParameters[I] : never)[] } };
+export class CatalogBuilder<S extends CatalogSource = 'all', P extends string = never> {
+  protected constructor();
+  readonly __source: S;
+  readonly __present: P;
+  entry<I extends Msgid<S>>(id: I, template: string): CatalogBuilder<S, P | SingleId<I>>;
+  entries<const D extends Partial<Record<Msgid<S>, string>>>(values: D & Record<Exclude<keyof D, Msgid<S>>, never>): CatalogBuilder<S, P | Present<D>>;
+  partial(): CatalogDocument<P>;
+  complete(this: Exclude<Msgid<S>, P> extends never ? CatalogBuilder<S, P> : never): CatalogDocument<Msgid<S>>;
+  toJSON(this: Exclude<Msgid<S>, P> extends never ? CatalogBuilder<S, P> : never): CatalogDocument<Msgid<S>>;
+}
+export function catalog<S extends CatalogSource = 'all'>(source?: S, locale?: string): CatalogBuilder<S>;
+/** Raw drafts remain subject to runtime key/placeholder checks at either exit. */
+export function from<const D extends Record<string, string>, S extends CatalogSource = 'all'>(document: D, options?: { readonly source?: S; readonly locale?: string }): CatalogBuilder<S, Present<D>>;
+export function inline(template: string): string;
+export interface MessageSpec<I extends Msgid = Msgid> {
+  readonly $msgid: I;
+  readonly message?: string;
+  readonly params?: [MessageParameters[I]] extends [never] ? Readonly<Record<string, never>> : Readonly<Partial<Record<MessageParameters[I], Json>>>;
+}
+export function message<I extends Msgid>(id: I, options?: Omit<MessageSpec<I>, '$msgid'>): MessageSpec<I>;