@jarenjs/linq 0.67.0 → 0.72.0

package/src/schema/emit.js

@@ -118,7 +118,10 @@ export function reachesNormalizer(builder, seen = new Set()) {
   for (const [key] of st.annotations) {
     if (NORMALIZER_KEYS.includes(key)) return true;
   }
-  return children(st).some((child) => reachesNormalizer(child, seen));
+  const keywordChildren = (value) => isSchemaBuilder(value) ? reachesNormalizer(value, seen)
+    : value !== null && typeof value === 'object' && Object.values(value).some(keywordChildren);
+  return Object.values(st.keywords).some(keywordChildren)
+    || children(st).some((child) => reachesNormalizer(child, seen));
 }
 
 /** Every builder one state holds directly (lazy thunks resolved). */
@@ -215,6 +218,12 @@ function emitNode(builder, ctx, at) {
   const st = builder.state;
   let node = emitCore(builder, st, ctx, at);
   if (st.nullable) node = nullableOf(node, st);
+  for (const key of Object.keys(st.keywords)) {
+    const value = st.keywords[key];
+    setObjectMember(node, key, emitKeyword(value, ctx, `${at}/${token(key)}`, key));
+  }
+  if (st.nullable && TYPED[st.kind] !== undefined && Array.isArray(node.enum)
+    && !node.enum.includes(null)) node.enum = [...node.enum, null];
   if (st.checks.length > 0) {
     node.$query = st.checks.length === 1 ? st.checks[0] : { $and: st.checks };
   }
@@ -222,6 +231,19 @@ function emitNode(builder, ctx, at) {
   return node;
 }
 
+/** Emit schema-valued keywords in the root's shared definition context. */
+function emitKeyword(value, ctx, at, keyword) {
+  if (isSchemaBuilder(value)) {
+    if (['not', 'unevaluatedProperties', 'unevaluatedItems', 'dependentSchemas', 'dependencies', 'contentSchema'].includes(keyword))
+      refuseNormalizerUnder(value, keyword, at);
+    return emitNode(value, ctx, at);
+  }
+  if (Array.isArray(value)) return value.map((v, i) => emitKeyword(v, ctx, `${at}/${i}`, keyword));
+  if (value !== null && typeof value === 'object')
+    return Object.fromEntries(Object.keys(value).map((k) => [k, emitKeyword(value[k], ctx, `${at}/${token(k)}`, keyword)]));
+  return value;
+}
+
 /** Fold `null` into a typed node; wrap an untyped one in `anyOf`. */
 function nullableOf(node, st) {
   if (TYPED[st.kind] !== undefined) {
@@ -238,12 +260,6 @@ function nullableOf(node, st) {
   return { anyOf: [node, { type: 'null' }] };
 }
 
-/** The constraint keywords a builder collected, in the order set. */
-function withKeywords(node, st) {
-  for (const key of Object.keys(st.keywords)) node[key] = st.keywords[key];
-  return node;
-}
-
 /**
  * The kind-specific core of a node: `type` and the structural
  * keywords, with the collected constraints after them.
@@ -256,7 +272,7 @@ function withKeywords(node, st) {
 function emitCore(builder, st, ctx, at) {
   switch (st.kind) {
     case 'string': case 'number': case 'integer': case 'boolean': case 'null':
-      return withKeywords({ type: st.kind }, st);
+      return { type: st.kind };
     case 'literal':
       return { const: st.value };
     case 'enum':
@@ -293,20 +309,20 @@ function emitCore(builder, st, ctx, at) {
         node.propertyNames = emitNode(st.names, ctx, `${at}/propertyNames`);
       }
       if (st.dependent !== null) node.dependentRequired = cloneJson(st.dependent);
-      return withKeywords(node, st);
+      return node;
     }
     case 'record':
-      return withKeywords({
+      return {
         type: 'object',
         additionalProperties: emitNode(st.values, ctx, `${at}/additionalProperties`),
-      }, st);
+      };
     case 'array': {
       const node = { type: 'array', items: emitNode(st.items, ctx, `${at}/items`) };
       if (st.contains !== null) {
         refuseNormalizerUnder(st.contains, 'contains()', `${at}/contains`);
         node.contains = emitNode(st.contains, ctx, `${at}/contains`);
       }
-      return withKeywords(node, st);
+      return node;
     }
     case 'tuple': {
       const node = {
@@ -315,7 +331,7 @@ function emitCore(builder, st, ctx, at) {
       };
       if (st.rest !== null) node.items = emitNode(st.rest, ctx, `${at}/items`);
       node.minItems = st.items.length;
-      return withKeywords(node, st);
+      return node;
     }
     case 'union': case 'discriminated': {
       const keyword = st.kind === 'union' ? 'anyOf' : 'oneOf';

package/types/ai.d.ts

@@ -0,0 +1,56 @@
+import type { Json } from './schema.js';
+import type { ExprBase, UnknownExpr } from './index.js';
+export type Query = Json | ((value: UnknownExpr) => ExprBase<unknown> | Json);
+export interface ChunkOptions { readonly strategy?: 'size' | 'line' | 'separator'; readonly size?: number }
+export interface GrepOptions { readonly pattern: string; readonly flags?: 'i' | 'm' | 'im' | ''; readonly limit?: number }
+export interface AnswerOptions { readonly chars?: number }
+export interface ReduceOptions { readonly outputSchema?: Json }
+export interface StepOptions {
+  chunk: ChunkOptions; grep: GrepOptions; select: { readonly query: Json };
+  stat: {}; peek: {}; map: { readonly prompt: string }; reduce: { readonly query: Json } & ReduceOptions; answer: AnswerOptions;
+}
+export type Operation = keyof StepOptions;
+export type Step<K extends Operation, F extends string = string, N extends string = string> = {
+  readonly op: K; readonly from: F;
+} & (K extends 'answer' ? {} : { readonly as: N }) & StepOptions[K];
+export type StepDocument = { [K in Operation]: Step<K> }[Operation];
+export interface ProgramDocument { readonly steps: readonly StepDocument[] }
+export function chunk<const F extends string, const N extends string>(from: F, as: N, options?: ChunkOptions): Step<'chunk', F, N>;
+export function grep<const F extends string, const N extends string>(from: F, as: N, options: GrepOptions): Step<'grep', F, N>;
+export function select<const F extends string, const N extends string>(from: F, as: N, query: Query): Step<'select', F, N>;
+export function stat<const F extends string, const N extends string>(from: F, as: N): Step<'stat', F, N>;
+export function peek<const F extends string, const N extends string>(from: F, as: N): Step<'peek', F, N>;
+export function map<const F extends string, const N extends string>(from: F, as: N, prompt: string): Step<'map', F, N>;
+export function reduce<const F extends string, const N extends string>(from: F, as: N, query: Query, options?: ReduceOptions): Step<'reduce', F, N>;
+export function answer<const F extends string>(from: F, options?: AnswerOptions): Step<'answer', F>;
+
+type Kind = Exclude<Operation, 'answer'> | 'slot';
+type Bindings = Record<string, Kind>;
+type Names<B, K extends Kind = Kind> = { [N in keyof B]: B[N] extends K ? N : never }[keyof B] & string;
+type Single<B> = Names<B, Exclude<Kind, 'chunk' | 'map'>>;
+type Fresh<B, N extends string> = N extends keyof B ? B[N] extends 'slot' ? N : never : N;
+type Add<B, N extends string, K extends Kind> = Omit<B, N> & Record<N, K>;
+type InputFor<B, K extends Operation> = K extends 'reduce' ? Names<B, 'map'> : K extends 'select' | 'answer' ? Single<B> : Names<B>;
+type StepKeys<K extends Operation> = 'op' | 'from' | (K extends 'answer' ? never : 'as') | keyof StepOptions[K];
+type CheckStep<B, T extends StepDocument> = Exclude<keyof T, StepKeys<T['op']>> extends never ? T['from'] extends InputFor<B, T['op']>
+  ? T extends { readonly as: infer N extends string } ? N extends Fresh<B, N> ? unknown : never : unknown : never : never;
+type AfterStep<B, T extends StepDocument> = T extends { readonly as: infer N extends string; readonly op: infer K extends Kind } ? Add<B, N, K> : B;
+export class ProgramBuilder<B extends Bindings = {}, Done extends boolean = false> {
+  protected constructor();
+  readonly __bindings: B;
+  readonly __done: Done;
+  readonly schema: ProgramDocument;
+  toJSON(): ProgramDocument;
+  step<const T extends StepDocument>(this: ProgramBuilder<B, false>, step: T & CheckStep<B, T>): ProgramBuilder<AfterStep<B, T>, T['op'] extends 'answer' ? true : false>;
+  chunk<N extends string>(this: ProgramBuilder<B, false>, from: Names<B>, as: Fresh<B, N>, options?: ChunkOptions): ProgramBuilder<Add<B, N, 'chunk'>>;
+  grep<N extends string>(this: ProgramBuilder<B, false>, from: Names<B>, as: Fresh<B, N>, options: GrepOptions): ProgramBuilder<Add<B, N, 'grep'>>;
+  select<N extends string>(this: ProgramBuilder<B, false>, from: Single<B>, as: Fresh<B, N>, query: Query): ProgramBuilder<Add<B, N, 'select'>>;
+  stat<N extends string>(this: ProgramBuilder<B, false>, from: Names<B>, as: Fresh<B, N>): ProgramBuilder<Add<B, N, 'stat'>>;
+  peek<N extends string>(this: ProgramBuilder<B, false>, from: Names<B>, as: Fresh<B, N>): ProgramBuilder<Add<B, N, 'peek'>>;
+  map<N extends string>(this: ProgramBuilder<B, false>, from: Names<B>, as: Fresh<B, N>, prompt: string): ProgramBuilder<Add<B, N, 'map'>>;
+  reduce<N extends string>(this: ProgramBuilder<B, false>, from: Names<B, 'map'>, as: Fresh<B, N>, query: Query, options?: ReduceOptions): ProgramBuilder<Add<B, N, 'reduce'>>;
+  answer(this: ProgramBuilder<B, false>, from: Single<B>, options?: AnswerOptions): ProgramBuilder<B, true>;
+}
+export function program<const S extends readonly string[] = []>(slots?: S): ProgramBuilder<Record<S[number], 'slot'>>;
+/** Raw documents make no binding-order or terminal-state inference. */
+export function from(document: ProgramDocument): ProgramBuilder<Record<string, Kind>, boolean>;

package/types/charts.d.ts

@@ -0,0 +1,438 @@
+// 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 = 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;
+}
+
+
+/**
+ * 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: [number, number, ...Array<number>];
+  label?: string;
+  value?: 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" | { method?: "lttb" | "minmax"; target?: number; width?: number; pixelRatio?: number; [key: string]: unknown; };
+
+/**
+ * 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;
+}
+
+
+/**
+ * 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?: { window: number; slide?: number; [key: string]: unknown; };
+  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;