@danceroutine/tango-orm 1.11.1 → 1.11.3

package/dist/query/QuerySet.d.ts

@@ -1,215 +0,0 @@
-import type { DBClient } from '../connection/clients/DBClient';
-import type { Adapter } from '../connection/adapters/Adapter';
-import type { QuerySetState } from './domain/QuerySetState';
-import type { TableMeta } from './domain/TableMeta';
-import type { QNode } from './domain/QNode';
-import { QueryResult } from './domain/QueryResult';
-import type { OrderToken } from './domain/OrderToken';
-import type { OrderSpec } from './domain/OrderSpec';
-import type { FilterInput } from './domain/FilterInput';
-import type { CompiledQuery } from './domain/CompiledQuery';
-import type { GeneratedHydratedRelationMap, GeneratedPrefetchRelatedPathKeys, GeneratedSelectRelatedPathKeys, HydratedQueryResult, ManyRelationHydrationCardinality, MaybeHydratedRelationMap, PrefetchRelatedRelations, RelationKeys, SelectRelatedRelations, SingleRelationHydrationCardinality } from './domain/RelationTyping';
-/**
- * Query execution seam consumed by `QuerySet`.
- *
- * Application code usually reaches this through `Model.objects` or testing
- * fixtures rather than implementing it directly.
- *
- * @template TModel - The model row type returned by the database client
- */
-export interface QueryExecutor<TModel> {
-    meta: TableMeta;
-    client: DBClient;
-    adapter: Adapter;
-    run(compiled: CompiledQuery): Promise<TModel[]>;
-    /**
-     * Optional hook invoked by `QuerySet` after a record has been
-     * materialized so executors can attach related-manager accessors
-     * (such as the many-to-many related manager) onto the record.
-     *
-     * The optional `modelKey` argument lets the executor route the attach
-     * call to the correct model when the record belongs to a related
-     * model rather than the executor's own source model. Implementations
-     * must not overwrite existing properties on the record so prior
-     * hydration assignments survive the attach pass.
-     */
-    attachPersistedRecordAccessors?(record: Record<string, unknown>, modelKey?: string): void;
-}
-type QueryShapeFunction<TInput, TOutput> = (row: TInput) => TOutput;
-type QueryShapeParser<TInput, TOutput> = {
-    parse: (row: TInput) => TOutput;
-};
-type QueryShape<TInput> = QueryShapeFunction<TInput, unknown> | QueryShapeParser<TInput, unknown>;
-type QueryShapeOutput<TInput, TShape> = TShape extends QueryShapeFunction<TInput, infer TOutput> ? TOutput : TShape extends QueryShapeParser<TInput, infer TOutput> ? TOutput : never;
-type ProjectedResult<TModel extends Record<string, unknown>, TKeys extends readonly (keyof TModel)[]> = number extends TKeys['length'] ? TModel : [TKeys[number]] extends [never] ? TModel : Pick<TModel, TKeys[number]>;
-/**
- * Django-inspired query builder for constructing and executing database queries.
- * Provides a fluent API for filtering, ordering, pagination, projection, and
- * nested relation hydration.
- *
- * @template TModel - The full model row type used for query composition
- * @template TBaseResult - The selected base-row shape returned by execution methods
- * @template TSourceModel - The source Tango model used for typed relation metadata
- * @template THydrated - Relation properties accumulated by eager-loading calls
- *
- * @example
- * ```typescript
- * const users = await TodoModel.objects
- *   .query()
- *   .filter({ active: true })
- *   .filter(Q.or({ role: 'admin' }, { role: 'moderator' }))
- *   .orderBy('-createdAt')
- *   .limit(10)
- *   .fetch();
- * ```
- */
-export declare abstract class QuerySet<TModel extends Record<string, unknown>, TBaseResult extends Record<string, unknown> = TModel, TSourceModel = unknown, THydrated extends Record<string, unknown> = Record<never, never>> implements AsyncIterable<HydratedQueryResult<TBaseResult, THydrated>> {
-    [Symbol.asyncIterator]: () => AsyncIterator<HydratedQueryResult<TBaseResult, THydrated>>;
-    protected executor: QueryExecutor<TModel>;
-    protected state: QuerySetState<TModel, TSourceModel>;
-    static readonly BRAND: "tango.orm.query_set";
-    readonly __tangoBrand: typeof QuerySet.BRAND;
-    private evaluationCache?;
-    constructor(executor: QueryExecutor<TModel>, state?: QuerySetState<TModel, TSourceModel>);
-    /**
-     * Create another queryset of the same runtime family with the supplied
-     * query state. Concrete subclasses implement this so fluent calls keep
-     * their subclass-specific execution behavior instead of falling back to
-     * the standard queryset implementation.
-     */
-    protected abstract spawn<TNextBaseResult extends Record<string, unknown> = TBaseResult, TNextHydrated extends Record<string, unknown> = THydrated>(state: QuerySetState<TModel, TSourceModel>): QuerySet<TModel, TNextBaseResult, TSourceModel, TNextHydrated>;
-    /**
-     * Narrow an unknown value to `QuerySet`.
-     */
-    static isQuerySet<TModel extends Record<string, unknown>, TResult extends Record<string, unknown> = TModel>(value: unknown): value is QuerySet<TModel, TResult>;
-    /**
-     * Translate user-facing order tokens like `'name'` or `'-createdAt'` into
-     * the internal `OrderSpec` array used by `QuerySetState`.
-     *
-     * Exposed as `protected` so subclasses can compose the same parse logic
-     * when they need to return their own concrete type from `orderBy` without
-     * reaching into a base-class instance's protected state.
-     */
-    protected static buildOrderSpecs<T extends Record<string, unknown>>(tokens: readonly OrderToken<T>[]): OrderSpec<T>[];
-    private static invertOrderSpec;
-    /**
-     * Add a filter expression to the query.
-     *
-     * Multiple `filter()` calls are composed with `AND`.
-     */
-    filter(q: FilterInput<TModel, TSourceModel> | QNode<TModel, TSourceModel>): QuerySet<TModel, TBaseResult, TSourceModel, THydrated>;
-    /**
-     * Add an exclusion expression to the query.
-     *
-     * Exclusions are translated to `NOT (...)` predicates.
-     */
-    exclude(q: FilterInput<TModel, TSourceModel> | QNode<TModel, TSourceModel>): QuerySet<TModel, TBaseResult, TSourceModel, THydrated>;
-    /**
-     * Apply ordering tokens such as `'name'` or `'-createdAt'`.
-     */
-    orderBy(...tokens: OrderToken<TModel>[]): QuerySet<TModel, TBaseResult, TSourceModel, THydrated>;
-    /**
-     * Limit the maximum number of rows returned.
-     */
-    limit(n: number): QuerySet<TModel, TBaseResult, TSourceModel, THydrated>;
-    /**
-     * Skip the first `n` rows.
-     */
-    offset(n: number): QuerySet<TModel, TBaseResult, TSourceModel, THydrated>;
-    /**
-     * Restrict selected fields and narrow the fetched row type when the
-     * selected keys are known precisely at the call site.
-     *
-     * Empty selections reset back to the full model row, and repeated
-     * `select(...)` calls replace the previous projection rather than
-     * intersecting it.
-     */
-    select<const TKeys extends readonly (keyof TModel)[]>(fields: TKeys): QuerySet<TModel, ProjectedResult<TModel, TKeys>, TSourceModel, THydrated>;
-    select(fields: readonly (keyof TModel)[]): QuerySet<TModel, ProjectedResult<TModel, readonly (keyof TModel)[]>, TSourceModel, THydrated>;
-    /**
-     * Hydrate single-valued relation paths through SQL joins.
-     *
-     * Forward `belongsTo` relations can be inferred from the source model's
-     * field-authored relation metadata. Reverse `hasOne` relations can be
-     * selected with a target model generic when the target model points back to
-     * the source model. Generated relation typing also enables nested `__`
-     * path keys for applications that keep the app-local registry current.
-     */
-    selectRelated<TTargetModel = undefined, const TRelationName extends RelationKeys<SelectRelatedRelations<TSourceModel, NoInfer<TTargetModel>>> | GeneratedSelectRelatedPathKeys<TSourceModel> = RelationKeys<SelectRelatedRelations<TSourceModel, NoInfer<TTargetModel>>> | GeneratedSelectRelatedPathKeys<TSourceModel>>(...rels: readonly TRelationName[]): QuerySet<TModel, TBaseResult, TSourceModel, THydrated & MaybeHydratedRelationMap<TSourceModel, SelectRelatedRelations<TSourceModel, NoInfer<TTargetModel>>, Extract<TRelationName, RelationKeys<SelectRelatedRelations<TSourceModel, NoInfer<TTargetModel>>>>, SingleRelationHydrationCardinality> & GeneratedHydratedRelationMap<TSourceModel, Extract<TRelationName, GeneratedSelectRelatedPathKeys<TSourceModel>>>>;
-    /**
-     * Hydrate collection-rooted relation paths with follow-up queries.
-     *
-     * Reverse `hasMany` relations can be prefetched with a target model generic
-     * when the target model points back to the source model. Generated relation
-     * typing also enables nested `__` path keys for applications that keep the
-     * app-local registry current.
-     */
-    prefetchRelated<TTargetModel = undefined, const TRelationName extends RelationKeys<PrefetchRelatedRelations<TSourceModel, NoInfer<TTargetModel>>> | GeneratedPrefetchRelatedPathKeys<TSourceModel> = RelationKeys<PrefetchRelatedRelations<TSourceModel, NoInfer<TTargetModel>>> | GeneratedPrefetchRelatedPathKeys<TSourceModel>>(...rels: readonly TRelationName[]): QuerySet<TModel, TBaseResult, TSourceModel, THydrated & MaybeHydratedRelationMap<TSourceModel, PrefetchRelatedRelations<TSourceModel, NoInfer<TTargetModel>>, Extract<TRelationName, RelationKeys<PrefetchRelatedRelations<TSourceModel, NoInfer<TTargetModel>>>>, ManyRelationHydrationCardinality> & GeneratedHydratedRelationMap<TSourceModel, Extract<TRelationName, GeneratedPrefetchRelatedPathKeys<TSourceModel>>>>;
-    all(): QuerySet<TModel, TBaseResult, TSourceModel, THydrated>;
-    /**
-     * Execute the query and optionally shape each row.
-     *
-     * When the queryset has been narrowed by `select(...)`, rows passed to the
-     * shaping callback or parser use that narrowed fetched-row type.
-     */
-    fetch(): Promise<QueryResult<HydratedQueryResult<TBaseResult, THydrated>>>;
-    fetch<Out>(shape: QueryShapeFunction<HydratedQueryResult<TBaseResult, THydrated>, Out>): Promise<QueryResult<Out>>;
-    fetch<Out>(shape: QueryShapeParser<HydratedQueryResult<TBaseResult, THydrated>, Out>): Promise<QueryResult<Out>>;
-    fetch<TShape extends QueryShape<HydratedQueryResult<TBaseResult, THydrated>> | undefined>(shape: TShape): Promise<QueryResult<HydratedQueryResult<TBaseResult, THydrated> | QueryShapeOutput<HydratedQueryResult<TBaseResult, THydrated>, NonNullable<TShape>>>>;
-    /**
-     * Async iterable surface for `for await (... of queryset)`.
-     *
-     * Evaluates this queryset on first use by awaiting `fetch()` without
-     * arguments, then yields each element from that materialized result.
-     * Later async iterations over the same queryset instance reuse the cached
-     * materialized result instead of issuing another database round-trip.
-     */
-    [Symbol.asyncIterator](): AsyncIterator<HydratedQueryResult<TBaseResult, THydrated>>;
-    /**
-     * Execute the query and return the first row, or `null`.
-     *
-     * As with `fetch(...)`, parser and function overloads receive the current
-     * fetched-row type after any `select(...)` projection narrowing.
-     */
-    fetchOne(): Promise<HydratedQueryResult<TBaseResult, THydrated> | null>;
-    fetchOne<Out>(shape: QueryShapeFunction<HydratedQueryResult<TBaseResult, THydrated>, Out>): Promise<Out | null>;
-    fetchOne<Out>(shape: QueryShapeParser<HydratedQueryResult<TBaseResult, THydrated>, Out>): Promise<Out | null>;
-    fetchOne<TShape extends QueryShape<HydratedQueryResult<TBaseResult, THydrated>> | undefined>(shape: TShape): Promise<HydratedQueryResult<TBaseResult, THydrated> | QueryShapeOutput<HydratedQueryResult<TBaseResult, THydrated>, NonNullable<TShape>> | null>;
-    first(): Promise<HydratedQueryResult<TBaseResult, THydrated> | null>;
-    first<Out>(shape: QueryShapeFunction<HydratedQueryResult<TBaseResult, THydrated>, Out>): Promise<Out | null>;
-    first<Out>(shape: QueryShapeParser<HydratedQueryResult<TBaseResult, THydrated>, Out>): Promise<Out | null>;
-    last(): Promise<HydratedQueryResult<TBaseResult, THydrated> | null>;
-    last<Out>(shape: QueryShapeFunction<HydratedQueryResult<TBaseResult, THydrated>, Out>): Promise<Out | null>;
-    last<Out>(shape: QueryShapeParser<HydratedQueryResult<TBaseResult, THydrated>, Out>): Promise<Out | null>;
-    get(q: FilterInput<TModel, TSourceModel> | QNode<TModel, TSourceModel>): Promise<HydratedQueryResult<TBaseResult, THydrated>>;
-    get<Out>(q: FilterInput<TModel, TSourceModel> | QNode<TModel, TSourceModel>, shape: QueryShapeFunction<HydratedQueryResult<TBaseResult, THydrated>, Out>): Promise<Out>;
-    get<Out>(q: FilterInput<TModel, TSourceModel> | QNode<TModel, TSourceModel>, shape: QueryShapeParser<HydratedQueryResult<TBaseResult, THydrated>, Out>): Promise<Out>;
-    /**
-     * Execute a `COUNT(*)` query for the current filtered state.
-     */
-    count(): Promise<number>;
-    /**
-     * Return whether at least one row matches the current query state.
-     */
-    exists(): Promise<boolean>;
-    private shapeFetchedRow;
-    private getOrCreateEvaluationCache;
-    private evaluateRows;
-    private normalizeRowsForSchemaParsing;
-    private normalizeHydratedRowsForParserShape;
-    private hydrateRows;
-    private primeManyToManyOwnerCache;
-    private attachRootRecordAccessors;
-    private hydrateJoinNodesForOwner;
-    private hydratePrefetchNode;
-    private chunkValues;
-    private groupOwnersByAccessor;
-    private canonicalizeEntity;
-    private normalizeTargetRow;
-    private normalizeColumnValue;
-    private isBooleanColumnType;
-    private normalizeSqliteBoolean;
-    private normalizeBooleanColumns;
-    private withoutHydrationState;
-}
-export {};

package/dist/query/compiler/QueryCompiler.d.ts

@@ -1,49 +0,0 @@
-import type { QuerySetState } from '../domain/QuerySetState';
-import type { TableMeta } from '../domain/TableMeta';
-import type { CompiledHydrationNode, CompiledPrefetchQuery, CompiledQuery } from '../domain/CompiledQuery';
-import type { Adapter } from '../../connection/adapters/Adapter';
-/**
- * Compiles immutable `QuerySet` state into parameterized SQL and recursive
- * hydration execution artifacts.
- */
-export declare class QueryCompiler {
-    private meta;
-    private adapter;
-    static readonly BRAND: "tango.orm.query_compiler";
-    readonly __tangoBrand: typeof QueryCompiler.BRAND;
-    private readonly placeholders;
-    constructor(meta: TableMeta, adapter: Adapter);
-    static isQueryCompiler(value: unknown): value is QueryCompiler;
-    compile<T, TSourceModel = unknown>(state: QuerySetState<T, TSourceModel>): CompiledQuery;
-    compilePrefetch(node: CompiledHydrationNode, sourceValues: readonly (string | number)[]): CompiledPrefetchQuery;
-    compileManyToManyTargets(node: CompiledHydrationNode, targetIds: readonly (string | number)[]): {
-        sql: string;
-        params: readonly unknown[];
-    };
-    private compileManyToManyPrefetch;
-    private compileHydrationNode;
-    private validateHydrationRelation;
-    private buildRootHiddenSelects;
-    private validatePrefetchTarget;
-    private collectNestedJoinSql;
-    private validatePrefetchJoinTarget;
-    private validateInternalAlias;
-    private buildJoinAlias;
-    private buildPrefetchBaseAlias;
-    private buildHydrationColumnAlias;
-    private buildPrefetchSourceAlias;
-    private buildFilterAlias;
-    private sanitizeRelationPath;
-    private assertInternalAliasDoesNotCollide;
-    private compileQNode;
-    private compileAtom;
-    private compileAnd;
-    private compileOr;
-    private compileNot;
-    private compileRelationFilter;
-    private buildRelationFilterExists;
-    private lookupToSQL;
-    private normalizeParam;
-    private collectStateFilterKeys;
-    private collectNodeFilterKeys;
-}

package/dist/query/compiler/index.d.ts

@@ -1,4 +0,0 @@
-/**
- * Domain boundary barrel: centralizes this subdomain's public contract.
- */
-export { QueryCompiler } from './QueryCompiler';

package/dist/query/domain/CompiledQuery.d.ts

@@ -1,209 +0,0 @@
-import type { RelationHydrationLoadMode } from './RelationMeta';
-import type { RelationHydrationCardinality } from './RelationTyping';
-import { InternalPrefetchQueryKind } from './internal/InternalPrefetchQueryKind';
-/**
- * Result of compiling a {@link QuerySet} into an executable SQL statement plus
- * the hydration plan the executor needs to reshape flat rows into nested
- * relation graphs.
- */
-export interface CompiledQuery {
-    /**
-     * Parameterized SQL string ready for `client.query(...)`. Identifiers and
-     * relation names are pre-validated; values never appear inline.
-     */
-    sql: string;
-    /**
-     * Parameter values bound to the SQL statement in the same order the
-     * placeholders appear.
-     */
-    params: readonly unknown[];
-    /**
-     * Optional hydration plan produced when the query declared selected or
-     * prefetched relations. Absent for plain row reads that do no
-     * relation-shaping work.
-     */
-    hydrationPlan?: CompiledHydrationPlanRoot;
-}
-/**
- * Top-level hydration plan for a compiled query. Groups the join-time
- * hydration nodes (emitted inline with the root query) with the prefetch
- * hydration nodes (executed as follow-up queries after the root rows land).
- */
-export interface CompiledHydrationPlanRoot {
-    /**
-     * The relation paths the caller originally requested via
-     * `selectRelated(...)` / `prefetchRelated(...)`. Retained for diagnostic
-     * messages and snapshot stability.
-     */
-    requestedPaths: readonly string[];
-    /**
-     * Column aliases on the root query that exist solely to support hydration
-     * (for example, join-mirrored primary keys). The hydrator strips these
-     * before handing rows back to application code.
-     */
-    hiddenRootAliases: readonly string[];
-    /**
-     * Hydration nodes whose rows arrive joined into the root query's result
-     * set. Each node describes how to fold those joined columns back into a
-     * nested relation attribute.
-     */
-    joinNodes: readonly CompiledHydrationNode[];
-    /**
-     * Hydration nodes that require a follow-up prefetch query after the root
-     * rows land. Each node drives one or more `compilePrefetch(...)` calls.
-     */
-    prefetchNodes: readonly CompiledHydrationNode[];
-}
-/**
- * Recursive description of how to hydrate one relation edge and its
- * descendants. The same node shape is used for join-loaded and
- * prefetch-loaded relations; {@link loadMode} distinguishes them.
- */
-export interface CompiledHydrationNode {
-    /** Stable identifier for this node in the plan. */
-    nodeId: string;
-    /**
-     * Public relation name as declared in the schema, mirrored onto the
-     * hydrated record (for example, `author` or `tags`).
-     */
-    relationName: string;
-    /**
-     * Dot-less path expression that reaches this node from the root, used in
-     * error messages and plan diagnostics.
-     */
-    relationPath: string;
-    /** Model key of the owner side of this edge. */
-    ownerModelKey: string;
-    /** Model key of the target side of this edge. */
-    targetModelKey: string;
-    /** Join-inline vs follow-up prefetch load strategy. */
-    loadMode: RelationHydrationLoadMode;
-    /** Whether this edge yields one target or many. */
-    cardinality: RelationHydrationCardinality;
-    /**
-     * Owner-side column whose value scopes the hydration read. For
-     * foreign-key relations this is the local column; for many-to-many this
-     * is the owner primary key.
-     */
-    sourceKey: string;
-    /**
-     * Column alias on the root SQL row that surfaces `sourceKey` to the
-     * hydrator after projection.
-     */
-    ownerSourceAccessor: string;
-    /**
-     * Target-side column that matches `sourceKey` during resolution.
-     */
-    targetKey: string;
-    /** Target table name for the related rows. */
-    targetTable: string;
-    /** Primary-key column name on the target table. */
-    targetPrimaryKey: string;
-    /** Join table name for many-to-many edges. */
-    throughTable?: string;
-    /**
-     * Join-table column storing the owner-side primary key for many-to-many
-     * edges.
-     */
-    throughSourceKey?: string;
-    /**
-     * Join-table column storing the target-side primary key for many-to-many
-     * edges.
-     */
-    throughTargetKey?: string;
-    /**
-     * SQL type of the owner-side join column, used to validate compiled
-     * placeholder values.
-     */
-    throughSourceColumnType?: string;
-    /**
-     * SQL type of the target-side join column, used to validate compiled
-     * placeholder values.
-     */
-    throughTargetColumnType?: string;
-    /**
-     * Column map for the target table keyed by column name. Used by the
-     * hydrator to materialize target rows and by the compiler to emit a
-     * stable projection.
-     */
-    targetColumns: Record<string, string>;
-    /**
-     * Ordered trail of relation names that led to this node. Used to produce
-     * precise error messages when a hydration plan fails to compile.
-     */
-    provenance: readonly string[];
-    /** Child nodes whose rows arrive joined with this node's rows. */
-    joinChildren: readonly CompiledHydrationNode[];
-    /** Child nodes that require their own follow-up prefetch. */
-    prefetchChildren: readonly CompiledHydrationNode[];
-    /** SQL join descriptor attached when this node is loaded inline. */
-    join?: CompiledJoinHydrationDescriptor;
-}
-/**
- * Join-specific details for a hydration node loaded inline with its parent
- * query. Captures the alias the compiler emitted for the joined table and
- * the column aliases under which each projected column appears in the result
- * row.
- */
-export interface CompiledJoinHydrationDescriptor {
-    /** SQL alias emitted for the joined table. */
-    alias: string;
-    /**
-     * Aliases for each projected target column, keyed by column name.
-     * Ensures the hydrator can pull the column out of the flat SQL row.
-     */
-    columns: Record<string, string>;
-}
-/**
- * Discriminated union describing a prefetch query that must run after the
- * root rows load. `direct` is a one-shot select against the target table;
- * `manyToMany` is a two-phase plan that first reads join rows, then loads
- * the target rows by primary key.
- */
-export type CompiledPrefetchQuery = {
-    /** Marks a single-query prefetch against the target table. */
-    kind: typeof InternalPrefetchQueryKind.DIRECT;
-    /** Parameterized select statement to execute. */
-    sql: string;
-    /** Parameter values bound to the statement. */
-    params: readonly unknown[];
-    /**
-     * Target column whose value matches the owner-side `sourceKey`. The
-     * hydrator buckets the returned rows by this column.
-     */
-    targetKey: string;
-    /** Column map for the target rows the hydrator will materialize. */
-    targetColumns: Record<string, string>;
-} | {
-    /**
-     * Marks a two-phase many-to-many prefetch: the join-row query runs
-     * first, then a follow-up target query resolves the actual rows by
-     * primary key.
-     */
-    kind: typeof InternalPrefetchQueryKind.MANY_TO_MANY;
-    /**
-     * SQL for the first phase: select owner/target id pairs from the
-     * join table.
-     */
-    throughSql: string;
-    /** Parameter values bound to the join-row statement. */
-    throughParams: readonly unknown[];
-    /**
-     * Alias the compiler assigned to the owner-side join column in the
-     * join-row result set. The hydrator uses it to group targets by
-     * owner.
-     */
-    ownerAlias: string;
-    /**
-     * Alias the compiler assigned to the target-side join column in
-     * the join-row result set. The hydrator uses it to assemble the
-     * target primary-key list for phase two.
-     */
-    targetAlias: string;
-    /** Target table name for the phase-two read. */
-    targetTable: string;
-    /** Primary-key column on the target table for the phase-two read. */
-    targetPrimaryKey: string;
-    /** Column map for the target rows the hydrator will materialize. */
-    targetColumns: Record<string, string>;
-};

package/dist/query/domain/Dialect.d.ts

@@ -1,2 +0,0 @@
-import type { InternalDialect } from './internal/InternalDialect';
-export type Dialect = (typeof InternalDialect)[keyof typeof InternalDialect];

package/dist/query/domain/Direction.d.ts

@@ -1,2 +0,0 @@
-import type { InternalDirection } from './internal/InternalDirection';
-export type Direction = (typeof InternalDirection)[keyof typeof InternalDirection];

package/dist/query/domain/FilterInput.d.ts

@@ -1,3 +0,0 @@
-import type { FilterKey } from './FilterKey';
-import type { FilterValue } from './FilterValue';
-export type FilterInput<T, TSourceModel = unknown> = Partial<Record<FilterKey<T, TSourceModel>, FilterValue>>;

package/dist/query/domain/FilterKey.d.ts

@@ -1,4 +0,0 @@
-import type { LookupType } from './LookupType';
-type ScalarFilterKey<T> = Extract<keyof T, string> | `${Extract<keyof T, string>}__${LookupType}`;
-export type FilterKey<T, _TSourceModel = unknown> = ScalarFilterKey<T> | string;
-export {};

package/dist/query/domain/FilterValue.d.ts

@@ -1 +0,0 @@
-export type FilterValue = string | number | boolean | Date | null | undefined | Array<string | number>;

package/dist/query/domain/LookupType.d.ts

@@ -1,2 +0,0 @@
-import type { InternalLookupType } from './internal/InternalLookupType';
-export type LookupType = (typeof InternalLookupType)[keyof typeof InternalLookupType];

package/dist/query/domain/OrderSpec.d.ts

@@ -1,5 +0,0 @@
-import type { Direction } from '.';
-export interface OrderSpec<T> {
-    by: keyof T;
-    dir: Direction;
-}

package/dist/query/domain/OrderToken.d.ts

@@ -1 +0,0 @@
-export type OrderToken<T> = keyof T | `-${string & keyof T}`;

package/dist/query/domain/QNode.d.ts

@@ -1,9 +0,0 @@
-import type { FilterInput } from './FilterInput';
-import type { InternalQNodeType } from './internal/InternalQNodeType';
-export type QNodeType = (typeof InternalQNodeType)[keyof typeof InternalQNodeType];
-export interface QNode<T, TSourceModel = unknown> {
-    kind: QNodeType;
-    where?: FilterInput<T, TSourceModel>;
-    nodes?: QNode<T, TSourceModel>[];
-    node?: QNode<T, TSourceModel>;
-}

package/dist/query/domain/QueryResult.d.ts

@@ -1,35 +0,0 @@
-/**
- * Values materialized by {@link QuerySet.fetch}, iterable like an array plus `length`, `map`, `at`, and `toArray`.
- *
- * Prefer iteration or `items` over the deprecated `results` getter, which warns once per process when accessed.
- */
-export declare class QueryResult<T> implements Iterable<T> {
-    /**
-     * Sync iteration over materialized rows.
-     */
-    [Symbol.iterator]: () => Iterator<T>;
-    static readonly BRAND: "tango.orm.query_result";
-    readonly __tangoBrand: typeof QueryResult.BRAND;
-    readonly items: readonly T[];
-    constructor(items: readonly T[]);
-    /**
-     * Runtime narrowing for values that may be a plain array or a `QueryResult` instance.
-     */
-    static isQueryResult<T>(value: unknown): value is QueryResult<T>;
-    /**
-     * Sync iteration over materialized rows.
-     */
-    [Symbol.iterator](): Iterator<T>;
-    /** Number of materialized rows. */
-    get length(): number;
-    /** Same as `Array#map` on the materialized rows. */
-    map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: unknown): U[];
-    /** Indexed read with support for negative indices, like `Array#at`. */
-    at(index: number): T | undefined;
-    /** Returns a shallow copy of the materialized rows as a plain array. */
-    toArray(): T[];
-    /**
-     * @deprecated Use iteration, `length`, `map`, or `toArray()` instead.
-     */
-    get results(): readonly T[];
-}

package/dist/query/domain/QuerySetState.d.ts

@@ -1,13 +0,0 @@
-import type { OrderSpec } from './OrderSpec';
-import type { QNode } from './QNode';
-export interface QuerySetState<T, TSourceModel = unknown> {
-    q?: QNode<T, TSourceModel>;
-    excludes?: QNode<T, TSourceModel>[];
-    order?: OrderSpec<T>[];
-    limit?: number;
-    offset?: number;
-    cursor?: string | null;
-    selectRelated?: string[];
-    prefetchRelated?: string[];
-    select?: (keyof T)[];
-}

package/dist/query/domain/RelationMeta.d.ts

@@ -1,56 +0,0 @@
-import type { InternalRelationKind } from './internal/InternalRelationKind';
-import type { RelationHydrationCardinality } from './RelationTyping';
-import type { TableMeta } from './TableMeta';
-export type RelationKind = (typeof InternalRelationKind)[keyof typeof InternalRelationKind];
-export declare const InternalRelationHydrationLoadMode: {
-    readonly JOIN: "join";
-    readonly PREFETCH: "prefetch";
-};
-export type RelationHydrationLoadMode = (typeof InternalRelationHydrationLoadMode)[keyof typeof InternalRelationHydrationLoadMode];
-export interface RelationHydrationCapabilities {
-    queryable: boolean;
-    hydratable: boolean;
-    joinable: boolean;
-    prefetchable: boolean;
-}
-/**
- * Runtime relation metadata consumed by validation, planning, compilation, and
- * hydration.
- */
-export interface RelationMeta {
-    /** Stable edge identity from the resolved relation graph. */
-    edgeId: string;
-    /** Model key that owns the public relation name. */
-    sourceModelKey: string;
-    /** Model key reached by traversing this relation. */
-    targetModelKey: string;
-    /** Public relation kind such as belongsTo or hasMany. */
-    kind: RelationKind;
-    /** Hydration cardinality used by eager-loading APIs. */
-    cardinality: RelationHydrationCardinality;
-    /** Capability flags distilled from the resolved relation graph. */
-    capabilities: RelationHydrationCapabilities;
-    /** Physical table storing the target model rows. */
-    table: string;
-    /** Owner-side column used to attach or query related rows. */
-    sourceKey: string;
-    /** Target-side column matched against the source key. */
-    targetKey: string;
-    /** Many-to-many through table name when applicable. */
-    throughTable?: string;
-    throughModelKey?: string;
-    /** Many-to-many through column that matches the owner source key. */
-    throughSourceKey?: string;
-    /** Many-to-many through column that matches the target primary key. */
-    throughTargetKey?: string;
-    throughSourceColumnType?: string;
-    throughTargetColumnType?: string;
-    /** Primary key column for the target model. */
-    targetPrimaryKey: string;
-    /** Target model columns and their storage types. */
-    targetColumns: Record<string, string>;
-    /** Deterministic alias base used by join compilation. */
-    alias: string;
-    /** Recursive target metadata used for nested planning. */
-    targetMeta?: TableMeta;
-}