@prisma-next/mongo-query-ast 0.0.1 → 0.3.0-dev.147

package/dist/exports/index.d.mts

@@ -0,0 +1,763 @@
+import { Document, MongoValue } from "@prisma-next/mongo-value";
+import { PlanMeta } from "@prisma-next/contract/types";
+
+//#region src/ast-node.d.ts
+declare abstract class MongoAstNode {
+  abstract readonly kind: string;
+  protected freeze(): void;
+}
+//#endregion
+//#region src/filter-expressions.d.ts
+declare abstract class MongoFilterExpression extends MongoAstNode {
+  abstract accept<R>(visitor: MongoFilterVisitor<R>): R;
+  abstract rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr;
+  not(this: MongoFilterExpr): MongoNotExpr;
+}
+declare class MongoFieldFilter extends MongoFilterExpression {
+  readonly kind: "field";
+  readonly field: string;
+  readonly op: string;
+  readonly value: MongoValue;
+  constructor(field: string, op: string, value: MongoValue);
+  static of(field: string, op: string, value: MongoValue): MongoFieldFilter;
+  static eq(field: string, value: MongoValue): MongoFieldFilter;
+  static neq(field: string, value: MongoValue): MongoFieldFilter;
+  static gt(field: string, value: MongoValue): MongoFieldFilter;
+  static lt(field: string, value: MongoValue): MongoFieldFilter;
+  static gte(field: string, value: MongoValue): MongoFieldFilter;
+  static lte(field: string, value: MongoValue): MongoFieldFilter;
+  static in(field: string, values: ReadonlyArray<MongoValue>): MongoFieldFilter;
+  static isNull(field: string): MongoFieldFilter;
+  static isNotNull(field: string): MongoFieldFilter;
+  accept<R>(visitor: MongoFilterVisitor<R>): R;
+  rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr;
+}
+declare class MongoAndExpr extends MongoFilterExpression {
+  readonly kind: "and";
+  readonly exprs: ReadonlyArray<MongoFilterExpr>;
+  constructor(exprs: ReadonlyArray<MongoFilterExpr>);
+  static of(exprs: ReadonlyArray<MongoFilterExpr>): MongoAndExpr;
+  accept<R>(visitor: MongoFilterVisitor<R>): R;
+  rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr;
+}
+declare class MongoOrExpr extends MongoFilterExpression {
+  readonly kind: "or";
+  readonly exprs: ReadonlyArray<MongoFilterExpr>;
+  constructor(exprs: ReadonlyArray<MongoFilterExpr>);
+  static of(exprs: ReadonlyArray<MongoFilterExpr>): MongoOrExpr;
+  accept<R>(visitor: MongoFilterVisitor<R>): R;
+  rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr;
+}
+declare class MongoNotExpr extends MongoFilterExpression {
+  readonly kind: "not";
+  readonly expr: MongoFilterExpr;
+  constructor(expr: MongoFilterExpr);
+  accept<R>(visitor: MongoFilterVisitor<R>): R;
+  rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr;
+}
+declare class MongoExistsExpr extends MongoFilterExpression {
+  readonly kind: "exists";
+  readonly field: string;
+  readonly exists: boolean;
+  constructor(field: string, exists: boolean);
+  static exists(field: string): MongoExistsExpr;
+  static notExists(field: string): MongoExistsExpr;
+  accept<R>(visitor: MongoFilterVisitor<R>): R;
+  rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr;
+}
+declare class MongoExprFilter extends MongoFilterExpression {
+  readonly kind: "expr";
+  readonly aggExpr: MongoAggExpr;
+  constructor(aggExpr: MongoAggExpr);
+  static of(aggExpr: MongoAggExpr): MongoExprFilter;
+  accept<R>(visitor: MongoFilterVisitor<R>): R;
+  rewrite(rewriter: MongoFilterRewriter): MongoFilterExpr;
+}
+type MongoFilterExpr = MongoFieldFilter | MongoAndExpr | MongoOrExpr | MongoNotExpr | MongoExistsExpr | MongoExprFilter;
+//#endregion
+//#region src/stages.d.ts
+type MongoGroupId = null | MongoAggExpr | Readonly<Record<string, MongoAggExpr>>;
+type MongoProjectionValue = 0 | 1 | MongoAggExpr;
+declare abstract class MongoStageNode extends MongoAstNode {
+  abstract accept<R>(visitor: MongoStageVisitor<R>): R;
+  abstract rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoMatchStage extends MongoStageNode {
+  readonly kind: "match";
+  readonly filter: MongoFilterExpr;
+  constructor(filter: MongoFilterExpr);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoProjectStage extends MongoStageNode {
+  readonly kind: "project";
+  readonly projection: Readonly<Record<string, MongoProjectionValue>>;
+  constructor(projection: Record<string, MongoProjectionValue>);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoSortStage extends MongoStageNode {
+  readonly kind: "sort";
+  readonly sort: Readonly<Record<string, 1 | -1>>;
+  constructor(sort: Record<string, 1 | -1>);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(_context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoLimitStage extends MongoStageNode {
+  readonly kind: "limit";
+  readonly limit: number;
+  constructor(limit: number);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(_context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoSkipStage extends MongoStageNode {
+  readonly kind: "skip";
+  readonly skip: number;
+  constructor(skip: number);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(_context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoLookupStage extends MongoStageNode {
+  readonly kind: "lookup";
+  readonly from: string;
+  readonly localField: string | undefined;
+  readonly foreignField: string | undefined;
+  readonly as: string;
+  readonly pipeline: ReadonlyArray<MongoPipelineStage> | undefined;
+  readonly let_: Readonly<Record<string, MongoAggExpr>> | undefined;
+  constructor(options: {
+    from: string;
+    localField?: string;
+    foreignField?: string;
+    as: string;
+    pipeline?: ReadonlyArray<MongoPipelineStage>;
+    let_?: Record<string, MongoAggExpr>;
+  });
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoUnwindStage extends MongoStageNode {
+  readonly kind: "unwind";
+  readonly path: string;
+  readonly preserveNullAndEmptyArrays: boolean;
+  readonly includeArrayIndex: string | undefined;
+  constructor(path: string, preserveNullAndEmptyArrays: boolean, includeArrayIndex?: string);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(_context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoGroupStage extends MongoStageNode {
+  readonly kind: "group";
+  readonly groupId: MongoGroupId;
+  readonly accumulators: Readonly<Record<string, MongoAggAccumulator>>;
+  constructor(groupId: MongoGroupId, accumulators: Record<string, MongoAggAccumulator>);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoAddFieldsStage extends MongoStageNode {
+  readonly kind: "addFields";
+  readonly fields: Readonly<Record<string, MongoAggExpr>>;
+  constructor(fields: Record<string, MongoAggExpr>);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoReplaceRootStage extends MongoStageNode {
+  readonly kind: "replaceRoot";
+  readonly newRoot: MongoAggExpr;
+  constructor(newRoot: MongoAggExpr);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoCountStage extends MongoStageNode {
+  readonly kind: "count";
+  readonly field: string;
+  constructor(field: string);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(_context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoSortByCountStage extends MongoStageNode {
+  readonly kind: "sortByCount";
+  readonly expr: MongoAggExpr;
+  constructor(expr: MongoAggExpr);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoSampleStage extends MongoStageNode {
+  readonly kind: "sample";
+  readonly size: number;
+  constructor(size: number);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(_context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoRedactStage extends MongoStageNode {
+  readonly kind: "redact";
+  readonly expr: MongoAggExpr;
+  constructor(expr: MongoAggExpr);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoOutStage extends MongoStageNode {
+  readonly kind: "out";
+  readonly collection: string;
+  readonly db: string | undefined;
+  constructor(collection: string, db?: string);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(_context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoUnionWithStage extends MongoStageNode {
+  readonly kind: "unionWith";
+  readonly collection: string;
+  readonly pipeline: ReadonlyArray<MongoPipelineStage> | undefined;
+  constructor(collection: string, pipeline?: ReadonlyArray<MongoPipelineStage>);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoBucketStage extends MongoStageNode {
+  readonly kind: "bucket";
+  readonly groupBy: MongoAggExpr;
+  readonly boundaries: ReadonlyArray<unknown>;
+  readonly default_: unknown;
+  readonly output: Readonly<Record<string, MongoAggAccumulator>> | undefined;
+  constructor(options: {
+    groupBy: MongoAggExpr;
+    boundaries: ReadonlyArray<unknown>;
+    default_?: unknown;
+    output?: Record<string, MongoAggAccumulator>;
+  });
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoBucketAutoStage extends MongoStageNode {
+  readonly kind: "bucketAuto";
+  readonly groupBy: MongoAggExpr;
+  readonly buckets: number;
+  readonly output: Readonly<Record<string, MongoAggAccumulator>> | undefined;
+  readonly granularity: string | undefined;
+  constructor(options: {
+    groupBy: MongoAggExpr;
+    buckets: number;
+    output?: Record<string, MongoAggAccumulator>;
+    granularity?: string;
+  });
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoGeoNearStage extends MongoStageNode {
+  readonly kind: "geoNear";
+  readonly near: unknown;
+  readonly distanceField: string;
+  readonly spherical: boolean | undefined;
+  readonly maxDistance: number | undefined;
+  readonly minDistance: number | undefined;
+  readonly query: MongoFilterExpr | undefined;
+  readonly key: string | undefined;
+  readonly distanceMultiplier: number | undefined;
+  readonly includeLocs: string | undefined;
+  constructor(options: {
+    near: unknown;
+    distanceField: string;
+    spherical?: boolean;
+    maxDistance?: number;
+    minDistance?: number;
+    query?: MongoFilterExpr;
+    key?: string;
+    distanceMultiplier?: number;
+    includeLocs?: string;
+  });
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoFacetStage extends MongoStageNode {
+  readonly kind: "facet";
+  readonly facets: Readonly<Record<string, ReadonlyArray<MongoPipelineStage>>>;
+  constructor(facets: Record<string, ReadonlyArray<MongoPipelineStage>>);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoGraphLookupStage extends MongoStageNode {
+  readonly kind: "graphLookup";
+  readonly from: string;
+  readonly startWith: MongoAggExpr;
+  readonly connectFromField: string;
+  readonly connectToField: string;
+  readonly as: string;
+  readonly maxDepth: number | undefined;
+  readonly depthField: string | undefined;
+  readonly restrictSearchWithMatch: MongoFilterExpr | undefined;
+  constructor(options: {
+    from: string;
+    startWith: MongoAggExpr;
+    connectFromField: string;
+    connectToField: string;
+    as: string;
+    maxDepth?: number;
+    depthField?: string;
+    restrictSearchWithMatch?: MongoFilterExpr;
+  });
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoMergeStage extends MongoStageNode {
+  readonly kind: "merge";
+  readonly into: string | {
+    readonly db: string;
+    readonly coll: string;
+  };
+  readonly on: string | ReadonlyArray<string> | undefined;
+  readonly whenMatched: string | ReadonlyArray<MongoUpdatePipelineStage> | undefined;
+  readonly whenNotMatched: string | undefined;
+  constructor(options: {
+    into: string | {
+      db: string;
+      coll: string;
+    };
+    on?: string | ReadonlyArray<string>;
+    whenMatched?: string | ReadonlyArray<MongoUpdatePipelineStage>;
+    whenNotMatched?: string;
+  });
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+interface MongoWindowField {
+  readonly operator: MongoAggExpr;
+  readonly window?: {
+    readonly documents?: readonly [number, number];
+    readonly range?: {
+      readonly start: unknown;
+      readonly end: unknown;
+      readonly unit?: string;
+    };
+  };
+}
+declare class MongoSetWindowFieldsStage extends MongoStageNode {
+  readonly kind: "setWindowFields";
+  readonly partitionBy: MongoAggExpr | undefined;
+  readonly sortBy: Readonly<Record<string, 1 | -1>> | undefined;
+  readonly output: Readonly<Record<string, MongoWindowField>>;
+  constructor(options: {
+    partitionBy?: MongoAggExpr;
+    sortBy?: Record<string, 1 | -1>;
+    output: Record<string, MongoWindowField>;
+  });
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+interface MongoDensifyRange {
+  readonly step: number;
+  readonly unit?: string;
+  readonly bounds: 'full' | 'partition' | readonly [unknown, unknown];
+}
+declare class MongoDensifyStage extends MongoStageNode {
+  readonly kind: "densify";
+  readonly field: string;
+  readonly partitionByFields: ReadonlyArray<string> | undefined;
+  readonly range: MongoDensifyRange;
+  constructor(options: {
+    field: string;
+    partitionByFields?: ReadonlyArray<string>;
+    range: MongoDensifyRange;
+  });
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(_context: MongoStageRewriterContext): MongoPipelineStage;
+}
+interface MongoFillOutput {
+  readonly method?: string;
+  readonly value?: MongoAggExpr;
+}
+declare class MongoFillStage extends MongoStageNode {
+  readonly kind: "fill";
+  readonly partitionBy: MongoAggExpr | undefined;
+  readonly partitionByFields: ReadonlyArray<string> | undefined;
+  readonly sortBy: Readonly<Record<string, 1 | -1>> | undefined;
+  readonly output: Readonly<Record<string, MongoFillOutput>>;
+  constructor(options: {
+    partitionBy?: MongoAggExpr;
+    partitionByFields?: ReadonlyArray<string>;
+    sortBy?: Record<string, 1 | -1>;
+    output: Record<string, MongoFillOutput>;
+  });
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoSearchStage extends MongoStageNode {
+  readonly kind: "search";
+  readonly index: string | undefined;
+  readonly config: Readonly<Record<string, unknown>>;
+  constructor(config: Record<string, unknown>, index?: string);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(_context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoSearchMetaStage extends MongoStageNode {
+  readonly kind: "searchMeta";
+  readonly index: string | undefined;
+  readonly config: Readonly<Record<string, unknown>>;
+  constructor(config: Record<string, unknown>, index?: string);
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(_context: MongoStageRewriterContext): MongoPipelineStage;
+}
+declare class MongoVectorSearchStage extends MongoStageNode {
+  readonly kind: "vectorSearch";
+  readonly index: string;
+  readonly path: string;
+  readonly queryVector: ReadonlyArray<number>;
+  readonly numCandidates: number;
+  readonly limit: number;
+  readonly filter: Readonly<Record<string, unknown>> | undefined;
+  constructor(options: {
+    index: string;
+    path: string;
+    queryVector: ReadonlyArray<number>;
+    numCandidates: number;
+    limit: number;
+    filter?: Record<string, unknown>;
+  });
+  accept<R>(visitor: MongoStageVisitor<R>): R;
+  rewrite(_context: MongoStageRewriterContext): MongoPipelineStage;
+}
+type MongoUpdatePipelineStage = MongoAddFieldsStage | MongoProjectStage | MongoReplaceRootStage;
+type MongoPipelineStage = MongoMatchStage | MongoProjectStage | MongoSortStage | MongoLimitStage | MongoSkipStage | MongoLookupStage | MongoUnwindStage | MongoGroupStage | MongoAddFieldsStage | MongoReplaceRootStage | MongoCountStage | MongoSortByCountStage | MongoSampleStage | MongoRedactStage | MongoOutStage | MongoUnionWithStage | MongoBucketStage | MongoBucketAutoStage | MongoGeoNearStage | MongoFacetStage | MongoGraphLookupStage | MongoMergeStage | MongoSetWindowFieldsStage | MongoDensifyStage | MongoFillStage | MongoSearchStage | MongoSearchMetaStage | MongoVectorSearchStage;
+//#endregion
+//#region src/visitors.d.ts
+interface MongoAggExprVisitor<R> {
+  fieldRef(expr: MongoAggFieldRef): R;
+  literal(expr: MongoAggLiteral): R;
+  operator(expr: MongoAggOperator): R;
+  accumulator(expr: MongoAggAccumulator): R;
+  cond(expr: MongoAggCond): R;
+  switch_(expr: MongoAggSwitch): R;
+  filter(expr: MongoAggArrayFilter): R;
+  map(expr: MongoAggMap): R;
+  reduce(expr: MongoAggReduce): R;
+  let_(expr: MongoAggLet): R;
+  mergeObjects(expr: MongoAggMergeObjects): R;
+}
+interface MongoAggExprRewriter {
+  fieldRef?(expr: MongoAggFieldRef): MongoAggExpr;
+  literal?(expr: MongoAggLiteral): MongoAggExpr;
+  operator?(expr: MongoAggOperator): MongoAggExpr;
+  accumulator?(expr: MongoAggAccumulator): MongoAggExpr;
+  cond?(expr: MongoAggCond): MongoAggExpr;
+  switch_?(expr: MongoAggSwitch): MongoAggExpr;
+  filter?(expr: MongoAggArrayFilter): MongoAggExpr;
+  map?(expr: MongoAggMap): MongoAggExpr;
+  reduce?(expr: MongoAggReduce): MongoAggExpr;
+  let_?(expr: MongoAggLet): MongoAggExpr;
+  mergeObjects?(expr: MongoAggMergeObjects): MongoAggExpr;
+}
+interface MongoFilterVisitor<R> {
+  field(expr: MongoFieldFilter): R;
+  and(expr: MongoAndExpr): R;
+  or(expr: MongoOrExpr): R;
+  not(expr: MongoNotExpr): R;
+  exists(expr: MongoExistsExpr): R;
+  expr(expr: MongoExprFilter): R;
+}
+interface MongoFilterRewriter {
+  field?(expr: MongoFieldFilter): MongoFilterExpr;
+  and?(expr: MongoAndExpr): MongoFilterExpr;
+  or?(expr: MongoOrExpr): MongoFilterExpr;
+  not?(expr: MongoNotExpr): MongoFilterExpr;
+  exists?(expr: MongoExistsExpr): MongoFilterExpr;
+  expr?(expr: MongoExprFilter): MongoFilterExpr;
+}
+interface MongoStageRewriterContext {
+  filter?: MongoFilterRewriter;
+  aggExpr?: MongoAggExprRewriter;
+}
+interface MongoStageVisitor<R> {
+  match(stage: MongoMatchStage): R;
+  project(stage: MongoProjectStage): R;
+  sort(stage: MongoSortStage): R;
+  limit(stage: MongoLimitStage): R;
+  skip(stage: MongoSkipStage): R;
+  lookup(stage: MongoLookupStage): R;
+  unwind(stage: MongoUnwindStage): R;
+  group(stage: MongoGroupStage): R;
+  addFields(stage: MongoAddFieldsStage): R;
+  replaceRoot(stage: MongoReplaceRootStage): R;
+  count(stage: MongoCountStage): R;
+  sortByCount(stage: MongoSortByCountStage): R;
+  sample(stage: MongoSampleStage): R;
+  redact(stage: MongoRedactStage): R;
+  out(stage: MongoOutStage): R;
+  unionWith(stage: MongoUnionWithStage): R;
+  bucket(stage: MongoBucketStage): R;
+  bucketAuto(stage: MongoBucketAutoStage): R;
+  geoNear(stage: MongoGeoNearStage): R;
+  facet(stage: MongoFacetStage): R;
+  graphLookup(stage: MongoGraphLookupStage): R;
+  merge(stage: MongoMergeStage): R;
+  setWindowFields(stage: MongoSetWindowFieldsStage): R;
+  densify(stage: MongoDensifyStage): R;
+  fill(stage: MongoFillStage): R;
+  search(stage: MongoSearchStage): R;
+  searchMeta(stage: MongoSearchMetaStage): R;
+  vectorSearch(stage: MongoVectorSearchStage): R;
+}
+//#endregion
+//#region src/aggregation-expressions.d.ts
+type AggRecordArgs = Readonly<Record<string, MongoAggExpr | ReadonlyArray<MongoAggExpr>>>;
+declare function isExprArray(args: MongoAggExpr | ReadonlyArray<MongoAggExpr> | AggRecordArgs): args is ReadonlyArray<MongoAggExpr>;
+declare function isRecordArgs(args: MongoAggExpr | ReadonlyArray<MongoAggExpr> | AggRecordArgs): args is AggRecordArgs;
+declare abstract class MongoAggExprNode extends MongoAstNode {
+  abstract accept<R>(visitor: MongoAggExprVisitor<R>): R;
+  abstract rewrite(rewriter: MongoAggExprRewriter): MongoAggExpr;
+}
+declare class MongoAggFieldRef extends MongoAggExprNode {
+  readonly kind: "fieldRef";
+  readonly path: string;
+  constructor(path: string);
+  static of(path: string): MongoAggFieldRef;
+  accept<R>(visitor: MongoAggExprVisitor<R>): R;
+  rewrite(rewriter: MongoAggExprRewriter): MongoAggExpr;
+}
+declare class MongoAggLiteral extends MongoAggExprNode {
+  readonly kind: "literal";
+  readonly value: unknown;
+  constructor(value: unknown);
+  static of(value: unknown): MongoAggLiteral;
+  accept<R>(visitor: MongoAggExprVisitor<R>): R;
+  rewrite(rewriter: MongoAggExprRewriter): MongoAggExpr;
+}
+declare class MongoAggOperator extends MongoAggExprNode {
+  readonly kind: "operator";
+  readonly op: string;
+  readonly args: MongoAggExpr | ReadonlyArray<MongoAggExpr> | AggRecordArgs;
+  constructor(op: string, args: MongoAggExpr | ReadonlyArray<MongoAggExpr> | AggRecordArgs);
+  static of(op: string, args: MongoAggExpr | ReadonlyArray<MongoAggExpr> | AggRecordArgs): MongoAggOperator;
+  static add(...args: ReadonlyArray<MongoAggExpr>): MongoAggOperator;
+  static subtract(left: MongoAggExpr, right: MongoAggExpr): MongoAggOperator;
+  static multiply(...args: ReadonlyArray<MongoAggExpr>): MongoAggOperator;
+  static divide(dividend: MongoAggExpr, divisor: MongoAggExpr): MongoAggOperator;
+  static concat(...args: ReadonlyArray<MongoAggExpr>): MongoAggOperator;
+  static toLower(expr: MongoAggExpr): MongoAggOperator;
+  static toUpper(expr: MongoAggExpr): MongoAggOperator;
+  static size(expr: MongoAggExpr): MongoAggOperator;
+  accept<R>(visitor: MongoAggExprVisitor<R>): R;
+  rewrite(rewriter: MongoAggExprRewriter): MongoAggExpr;
+}
+declare class MongoAggAccumulator extends MongoAggExprNode {
+  readonly kind: "accumulator";
+  readonly op: string;
+  readonly arg: MongoAggExpr | AggRecordArgs | null;
+  constructor(op: string, arg: MongoAggExpr | AggRecordArgs | null);
+  static of(op: string, arg: MongoAggExpr | AggRecordArgs | null): MongoAggAccumulator;
+  static sum(expr: MongoAggExpr): MongoAggAccumulator;
+  static avg(expr: MongoAggExpr): MongoAggAccumulator;
+  static min(expr: MongoAggExpr): MongoAggAccumulator;
+  static max(expr: MongoAggExpr): MongoAggAccumulator;
+  static first(expr: MongoAggExpr): MongoAggAccumulator;
+  static last(expr: MongoAggExpr): MongoAggAccumulator;
+  static push(expr: MongoAggExpr): MongoAggAccumulator;
+  static addToSet(expr: MongoAggExpr): MongoAggAccumulator;
+  static count(): MongoAggAccumulator;
+  static stdDevPop(expr: MongoAggExpr): MongoAggAccumulator;
+  static stdDevSamp(expr: MongoAggExpr): MongoAggAccumulator;
+  accept<R>(visitor: MongoAggExprVisitor<R>): R;
+  rewrite(rewriter: MongoAggExprRewriter): MongoAggExpr;
+}
+declare class MongoAggCond extends MongoAggExprNode {
+  readonly kind: "cond";
+  readonly condition: MongoAggExpr;
+  readonly then_: MongoAggExpr;
+  readonly else_: MongoAggExpr;
+  constructor(condition: MongoAggExpr, then_: MongoAggExpr, else_: MongoAggExpr);
+  static of(condition: MongoAggExpr, then_: MongoAggExpr, else_: MongoAggExpr): MongoAggCond;
+  accept<R>(visitor: MongoAggExprVisitor<R>): R;
+  rewrite(rewriter: MongoAggExprRewriter): MongoAggExpr;
+}
+interface MongoAggSwitchBranch {
+  readonly case_: MongoAggExpr;
+  readonly then_: MongoAggExpr;
+}
+declare class MongoAggSwitch extends MongoAggExprNode {
+  readonly kind: "switch";
+  readonly branches: ReadonlyArray<MongoAggSwitchBranch>;
+  readonly default_: MongoAggExpr;
+  constructor(branches: ReadonlyArray<MongoAggSwitchBranch>, default_: MongoAggExpr);
+  static of(branches: ReadonlyArray<MongoAggSwitchBranch>, default_: MongoAggExpr): MongoAggSwitch;
+  accept<R>(visitor: MongoAggExprVisitor<R>): R;
+  rewrite(rewriter: MongoAggExprRewriter): MongoAggExpr;
+}
+declare class MongoAggArrayFilter extends MongoAggExprNode {
+  readonly kind: "filter";
+  readonly input: MongoAggExpr;
+  readonly cond: MongoAggExpr;
+  readonly as: string;
+  constructor(input: MongoAggExpr, cond: MongoAggExpr, as: string);
+  static of(input: MongoAggExpr, cond: MongoAggExpr, as: string): MongoAggArrayFilter;
+  accept<R>(visitor: MongoAggExprVisitor<R>): R;
+  rewrite(rewriter: MongoAggExprRewriter): MongoAggExpr;
+}
+declare class MongoAggMap extends MongoAggExprNode {
+  readonly kind: "map";
+  readonly input: MongoAggExpr;
+  readonly in_: MongoAggExpr;
+  readonly as: string;
+  constructor(input: MongoAggExpr, in_: MongoAggExpr, as: string);
+  static of(input: MongoAggExpr, in_: MongoAggExpr, as: string): MongoAggMap;
+  accept<R>(visitor: MongoAggExprVisitor<R>): R;
+  rewrite(rewriter: MongoAggExprRewriter): MongoAggExpr;
+}
+declare class MongoAggReduce extends MongoAggExprNode {
+  readonly kind: "reduce";
+  readonly input: MongoAggExpr;
+  readonly initialValue: MongoAggExpr;
+  readonly in_: MongoAggExpr;
+  constructor(input: MongoAggExpr, initialValue: MongoAggExpr, in_: MongoAggExpr);
+  static of(input: MongoAggExpr, initialValue: MongoAggExpr, in_: MongoAggExpr): MongoAggReduce;
+  accept<R>(visitor: MongoAggExprVisitor<R>): R;
+  rewrite(rewriter: MongoAggExprRewriter): MongoAggExpr;
+}
+declare class MongoAggLet extends MongoAggExprNode {
+  readonly kind: "let";
+  readonly vars: Readonly<Record<string, MongoAggExpr>>;
+  readonly in_: MongoAggExpr;
+  constructor(vars: Record<string, MongoAggExpr>, in_: MongoAggExpr);
+  static of(vars: Record<string, MongoAggExpr>, in_: MongoAggExpr): MongoAggLet;
+  accept<R>(visitor: MongoAggExprVisitor<R>): R;
+  rewrite(rewriter: MongoAggExprRewriter): MongoAggExpr;
+}
+declare class MongoAggMergeObjects extends MongoAggExprNode {
+  readonly kind: "mergeObjects";
+  readonly exprs: ReadonlyArray<MongoAggExpr>;
+  constructor(exprs: ReadonlyArray<MongoAggExpr>);
+  static of(exprs: ReadonlyArray<MongoAggExpr>): MongoAggMergeObjects;
+  accept<R>(visitor: MongoAggExprVisitor<R>): R;
+  rewrite(rewriter: MongoAggExprRewriter): MongoAggExpr;
+}
+type MongoAggExpr = MongoAggFieldRef | MongoAggLiteral | MongoAggOperator | MongoAggAccumulator | MongoAggCond | MongoAggSwitch | MongoAggArrayFilter | MongoAggMap | MongoAggReduce | MongoAggLet | MongoAggMergeObjects;
+//#endregion
+//#region src/raw-commands.d.ts
+declare class RawAggregateCommand extends MongoAstNode {
+  readonly kind: "rawAggregate";
+  readonly collection: string;
+  readonly pipeline: ReadonlyArray<Document>;
+  constructor(collection: string, pipeline: ReadonlyArray<Document>);
+}
+declare class RawInsertOneCommand extends MongoAstNode {
+  readonly kind: "rawInsertOne";
+  readonly collection: string;
+  readonly document: Document;
+  constructor(collection: string, document: Document);
+}
+declare class RawInsertManyCommand extends MongoAstNode {
+  readonly kind: "rawInsertMany";
+  readonly collection: string;
+  readonly documents: ReadonlyArray<Document>;
+  constructor(collection: string, documents: ReadonlyArray<Document>);
+}
+declare class RawUpdateOneCommand extends MongoAstNode {
+  readonly kind: "rawUpdateOne";
+  readonly collection: string;
+  readonly filter: Document;
+  readonly update: Document | ReadonlyArray<Document>;
+  constructor(collection: string, filter: Document, update: Document | ReadonlyArray<Document>);
+}
+declare class RawUpdateManyCommand extends MongoAstNode {
+  readonly kind: "rawUpdateMany";
+  readonly collection: string;
+  readonly filter: Document;
+  readonly update: Document | ReadonlyArray<Document>;
+  constructor(collection: string, filter: Document, update: Document | ReadonlyArray<Document>);
+}
+declare class RawDeleteOneCommand extends MongoAstNode {
+  readonly kind: "rawDeleteOne";
+  readonly collection: string;
+  readonly filter: Document;
+  constructor(collection: string, filter: Document);
+}
+declare class RawDeleteManyCommand extends MongoAstNode {
+  readonly kind: "rawDeleteMany";
+  readonly collection: string;
+  readonly filter: Document;
+  constructor(collection: string, filter: Document);
+}
+declare class RawFindOneAndUpdateCommand extends MongoAstNode {
+  readonly kind: "rawFindOneAndUpdate";
+  readonly collection: string;
+  readonly filter: Document;
+  readonly update: Document | ReadonlyArray<Document>;
+  readonly upsert: boolean;
+  constructor(collection: string, filter: Document, update: Document | ReadonlyArray<Document>, upsert: boolean);
+}
+declare class RawFindOneAndDeleteCommand extends MongoAstNode {
+  readonly kind: "rawFindOneAndDelete";
+  readonly collection: string;
+  readonly filter: Document;
+  constructor(collection: string, filter: Document);
+}
+type RawMongoCommand = RawAggregateCommand | RawInsertOneCommand | RawInsertManyCommand | RawUpdateOneCommand | RawUpdateManyCommand | RawDeleteOneCommand | RawDeleteManyCommand | RawFindOneAndUpdateCommand | RawFindOneAndDeleteCommand;
+//#endregion
+//#region src/commands.d.ts
+type MongoUpdateSpec = Record<string, MongoValue> | ReadonlyArray<MongoUpdatePipelineStage>;
+declare class InsertOneCommand extends MongoAstNode {
+  readonly kind: "insertOne";
+  readonly collection: string;
+  readonly document: Record<string, MongoValue>;
+  constructor(collection: string, document: Record<string, MongoValue>);
+}
+declare class UpdateOneCommand extends MongoAstNode {
+  readonly kind: "updateOne";
+  readonly collection: string;
+  readonly filter: MongoFilterExpr;
+  readonly update: MongoUpdateSpec;
+  constructor(collection: string, filter: MongoFilterExpr, update: MongoUpdateSpec);
+}
+declare class DeleteOneCommand extends MongoAstNode {
+  readonly kind: "deleteOne";
+  readonly collection: string;
+  readonly filter: MongoFilterExpr;
+  constructor(collection: string, filter: MongoFilterExpr);
+}
+declare class InsertManyCommand extends MongoAstNode {
+  readonly kind: "insertMany";
+  readonly collection: string;
+  readonly documents: ReadonlyArray<Record<string, MongoValue>>;
+  constructor(collection: string, documents: ReadonlyArray<Record<string, MongoValue>>);
+}
+declare class UpdateManyCommand extends MongoAstNode {
+  readonly kind: "updateMany";
+  readonly collection: string;
+  readonly filter: MongoFilterExpr;
+  readonly update: MongoUpdateSpec;
+  constructor(collection: string, filter: MongoFilterExpr, update: MongoUpdateSpec);
+}
+declare class DeleteManyCommand extends MongoAstNode {
+  readonly kind: "deleteMany";
+  readonly collection: string;
+  readonly filter: MongoFilterExpr;
+  constructor(collection: string, filter: MongoFilterExpr);
+}
+declare class FindOneAndUpdateCommand extends MongoAstNode {
+  readonly kind: "findOneAndUpdate";
+  readonly collection: string;
+  readonly filter: MongoFilterExpr;
+  readonly update: MongoUpdateSpec;
+  readonly upsert: boolean;
+  constructor(collection: string, filter: MongoFilterExpr, update: MongoUpdateSpec, upsert: boolean);
+}
+declare class FindOneAndDeleteCommand extends MongoAstNode {
+  readonly kind: "findOneAndDelete";
+  readonly collection: string;
+  readonly filter: MongoFilterExpr;
+  constructor(collection: string, filter: MongoFilterExpr);
+}
+declare class AggregateCommand extends MongoAstNode {
+  readonly kind: "aggregate";
+  readonly collection: string;
+  readonly pipeline: ReadonlyArray<MongoPipelineStage>;
+  constructor(collection: string, pipeline: ReadonlyArray<MongoPipelineStage>);
+}
+type AnyMongoCommand = InsertOneCommand | InsertManyCommand | UpdateOneCommand | UpdateManyCommand | DeleteOneCommand | DeleteManyCommand | FindOneAndUpdateCommand | FindOneAndDeleteCommand | AggregateCommand | RawMongoCommand;
+//#endregion
+//#region src/query-plan.d.ts
+declare const __mongoQueryPlanRow: unique symbol;
+interface MongoQueryPlan<Row = unknown> {
+  readonly collection: string;
+  readonly command: AnyMongoCommand;
+  readonly meta: PlanMeta;
+  readonly [__mongoQueryPlanRow]?: Row;
+}
+//#endregion
+export { type AggRecordArgs, AggregateCommand, type AnyMongoCommand, DeleteManyCommand, DeleteOneCommand, FindOneAndDeleteCommand, FindOneAndUpdateCommand, InsertManyCommand, InsertOneCommand, MongoAddFieldsStage, MongoAggAccumulator, MongoAggArrayFilter, MongoAggCond, type MongoAggExpr, type MongoAggExprRewriter, type MongoAggExprVisitor, MongoAggFieldRef, MongoAggLet, MongoAggLiteral, MongoAggMap, MongoAggMergeObjects, MongoAggOperator, MongoAggReduce, MongoAggSwitch, type MongoAggSwitchBranch, MongoAndExpr, MongoBucketAutoStage, MongoBucketStage, MongoCountStage, type MongoDensifyRange, MongoDensifyStage, MongoExistsExpr, MongoExprFilter, MongoFacetStage, MongoFieldFilter, type MongoFillOutput, MongoFillStage, type MongoFilterExpr, type MongoFilterRewriter, type MongoFilterVisitor, MongoGeoNearStage, MongoGraphLookupStage, type MongoGroupId, MongoGroupStage, MongoLimitStage, MongoLookupStage, MongoMatchStage, MongoMergeStage, MongoNotExpr, MongoOrExpr, MongoOutStage, type MongoPipelineStage, MongoProjectStage, type MongoProjectionValue, type MongoQueryPlan, MongoRedactStage, MongoReplaceRootStage, MongoSampleStage, MongoSearchMetaStage, MongoSearchStage, MongoSetWindowFieldsStage, MongoSkipStage, MongoSortByCountStage, MongoSortStage, type MongoStageRewriterContext, type MongoStageVisitor, MongoUnionWithStage, MongoUnwindStage, type MongoUpdatePipelineStage, type MongoUpdateSpec, MongoVectorSearchStage, type MongoWindowField, RawAggregateCommand, RawDeleteManyCommand, RawDeleteOneCommand, RawFindOneAndDeleteCommand, RawFindOneAndUpdateCommand, RawInsertManyCommand, RawInsertOneCommand, type RawMongoCommand, RawUpdateManyCommand, RawUpdateOneCommand, UpdateManyCommand, UpdateOneCommand, isExprArray, isRecordArgs };
+//# sourceMappingURL=index.d.mts.map