@danceroutine/tango-orm 1.11.0 → 1.11.2

package/dist/manager/ManagerLike.d.ts

@@ -1,34 +0,0 @@
-import type { QNode } from '../query/domain/QNode';
-import type { FilterInput } from '../query/domain/FilterInput';
-import type { QuerySet } from '../query/index';
-import type { TableMeta } from '../query/domain/index';
-/**
- * Public manager contract consumed by Tango resources and applications.
- */
-export interface ManagerLike<TModelRow extends Record<string, unknown>, TSourceModel = unknown> {
-    readonly meta: TableMeta;
-    query(): QuerySet<TModelRow, TModelRow, TSourceModel>;
-    all(): QuerySet<TModelRow, TModelRow, TSourceModel>;
-    getOrCreate(args: {
-        where: FilterInput<TModelRow> | QNode<TModelRow>;
-        defaults?: Partial<TModelRow>;
-    }): Promise<{
-        record: TModelRow;
-        created: boolean;
-    }>;
-    updateOrCreate(args: {
-        where: FilterInput<TModelRow> | QNode<TModelRow>;
-        defaults?: Partial<TModelRow>;
-        update?: Partial<TModelRow>;
-    }): Promise<{
-        record: TModelRow;
-        created: boolean;
-        updated: boolean;
-    }>;
-    findById(id: TModelRow[keyof TModelRow]): Promise<TModelRow | null>;
-    getOrThrow(id: TModelRow[keyof TModelRow]): Promise<TModelRow>;
-    create(input: Partial<TModelRow>): Promise<TModelRow>;
-    update(id: TModelRow[keyof TModelRow], patch: Partial<TModelRow>): Promise<TModelRow>;
-    delete(id: TModelRow[keyof TModelRow]): Promise<void>;
-    bulkCreate(inputs: Partial<TModelRow>[]): Promise<TModelRow[]>;
-}

package/dist/manager/ModelManager.d.ts

@@ -1,97 +0,0 @@
-import type { ModelWriteHooks } from '@danceroutine/tango-schema';
-import type { Model as SchemaModel } from '@danceroutine/tango-schema/domain';
-import type { QNode } from '../query/domain/QNode';
-import type { FilterInput, TableMeta } from '../query/domain/index';
-import type { QuerySet } from '../query/index';
-import type { TangoRuntime } from '../runtime/TangoRuntime';
-import type { ManagerLike } from './ManagerLike';
-import { ManyToManyRelatedManager } from './relations/ManyToManyRelatedManager';
-type ModelMetadataLike = Omit<SchemaModel['metadata'], 'key' | 'namespace' | 'fields'> & {
-    key?: string;
-    namespace?: string;
-    fields: Array<{
-        name: string;
-        type: string;
-        primaryKey?: boolean;
-    }>;
-};
-type ModelLike<TModelRow extends Record<string, unknown>> = {
-    metadata: ModelMetadataLike;
-    schema: {
-        parse(input: unknown): TModelRow;
-    };
-    hooks?: ModelWriteHooks<TModelRow>;
-};
-/**
- * Model-backed data access API exposed as `Model.objects`.
- */
-export declare class ModelManager<TModelRow extends Record<string, unknown>, TSourceModel = unknown> implements ManagerLike<TModelRow, TSourceModel> {
-    static readonly BRAND: "tango.orm.model_manager";
-    readonly __tangoBrand: typeof ModelManager.BRAND;
-    private readonly queryExecutor;
-    private readonly mutationCompiler;
-    private readonly model;
-    private readonly client;
-    private readonly adapter;
-    private readonly runtime;
-    constructor(model: ModelLike<TModelRow>, runtime: TangoRuntime);
-    get meta(): TableMeta;
-    /**
-     * Narrow an unknown value to `ModelManager`.
-     */
-    static isModelManager<TModelRow extends Record<string, unknown>>(value: unknown): value is ModelManager<TModelRow>;
-    private static createTableMeta;
-    private static mergeCreatePayloadFromWhere;
-    private static countDefinedValues;
-    private static collectPlainFieldsFromQNode;
-    private static omitLookupKeysFromAtom;
-    private static mergeCompatiblePartials;
-    query(): QuerySet<TModelRow, TModelRow, TSourceModel>;
-    all(): QuerySet<TModelRow, TModelRow, TSourceModel>;
-    findById(id: TModelRow[keyof TModelRow]): Promise<TModelRow | null>;
-    getOrThrow(id: TModelRow[keyof TModelRow]): Promise<TModelRow>;
-    getOrCreate(args: {
-        where: FilterInput<TModelRow> | QNode<TModelRow>;
-        defaults?: Partial<TModelRow>;
-    }): Promise<{
-        record: TModelRow;
-        created: boolean;
-    }>;
-    updateOrCreate(args: {
-        where: FilterInput<TModelRow> | QNode<TModelRow>;
-        defaults?: Partial<TModelRow>;
-        update?: Partial<TModelRow>;
-    }): Promise<{
-        record: TModelRow;
-        created: boolean;
-        updated: boolean;
-    }>;
-    create(input: Partial<TModelRow>): Promise<TModelRow>;
-    update(id: TModelRow[keyof TModelRow], patch: Partial<TModelRow>): Promise<TModelRow>;
-    delete(id: TModelRow[keyof TModelRow]): Promise<void>;
-    /**
-     * Build a {@link ManyToManyRelatedManager} bound to a single owner record
-     * for the supplied many-to-many relation. The returned manager performs
-     * its INSERT/DELETE writes through the shared runtime-bound client, so
-     * mutations enroll in any active `transaction.atomic(...)` boundary.
-     */
-    createManyToManyRelatedManager<TTarget extends Record<string, unknown>>(relationName: string, ownerPrimaryKey: unknown): ManyToManyRelatedManager<TTarget>;
-    bulkCreate(inputs: Partial<TModelRow>[]): Promise<TModelRow[]>;
-    /**
-     * Attach a {@link ManyToManyRelatedManager} as a non-enumerable property
-     * for every persisted many-to-many relation declared on the supplied
-     * record's model. Existing properties are left untouched so that prior
-     * hydration writes (such as prefetched arrays) survive the attach pass
-     * during the incremental rollout of related-manager hydration.
-     */
-    private attachOwnRelatedManagers;
-    private attachManyToManyRelatedManagers;
-    private resolveManagerForModelKey;
-    private resolveTargetExecutor;
-    private resolveTargetManager;
-    private requireManyToManyEdge;
-    private runBeforeCreate;
-    private runBeforeUpdate;
-    private getHookTransaction;
-}
-export {};

package/dist/manager/internal/MutationCompiler.d.ts

@@ -1,23 +0,0 @@
-import type { CompiledQuery } from '../../query/domain/index';
-import type { Adapter } from '../../connection/adapters/Adapter';
-import type { ValidatedDeleteSqlPlan, ValidatedInsertSqlPlan, ValidatedSelectSqlPlan, ValidatedUpdateSqlPlan } from '../../validation/SQLValidationEngine';
-export declare const InternalDuplicateInsertPolicy: {
-    readonly ERROR: "error";
-    readonly IGNORE: "ignore";
-};
-export type DuplicateInsertPolicy = (typeof InternalDuplicateInsertPolicy)[keyof typeof InternalDuplicateInsertPolicy];
-/**
- * Internal compiler for manager-owned INSERT/UPDATE/DELETE statements.
- */
-export declare class MutationCompiler {
-    private readonly adapter;
-    private readonly placeholders;
-    constructor(adapter: Adapter);
-    compileInsert(plan: ValidatedInsertSqlPlan, values: readonly unknown[]): CompiledQuery;
-    compileUpdate(plan: ValidatedUpdateSqlPlan, values: readonly unknown[], id: unknown): CompiledQuery;
-    compileDelete(plan: ValidatedDeleteSqlPlan, id: unknown): CompiledQuery;
-    compileDeleteByJoinKeys(plan: ValidatedSelectSqlPlan, leftFilterKey: string, rightFilterKey: string, leftValue: unknown, rightValue: unknown): CompiledQuery;
-    compileBulkInsert(plan: ValidatedInsertSqlPlan, valueRows: ReadonlyArray<ReadonlyArray<unknown>>): CompiledQuery;
-    compileInsertJoinLinks(plan: ValidatedInsertSqlPlan, sourceKey: string, targetKey: string, ownerValue: unknown, targetValues: readonly unknown[], duplicatePolicy: DuplicateInsertPolicy): CompiledQuery;
-    compileDeleteJoinLinks(plan: ValidatedSelectSqlPlan, leftFilterKey: string, rightFilterKey: string, leftValue: unknown, rightValues: readonly unknown[]): CompiledQuery;
-}

package/dist/manager/internal/RuntimeBoundClient.d.ts

@@ -1,20 +0,0 @@
-import type { DBClient } from '../../connection/index';
-import type { TangoRuntime } from '../../runtime/index';
-/**
- * DB client proxy that resolves either the active transaction lease or the
- * runtime autocommit path lazily.
- */
-export declare class RuntimeBoundClient implements DBClient {
-    private readonly runtime;
-    constructor(runtime: TangoRuntime);
-    query<T = unknown>(sql: string, params?: readonly unknown[]): Promise<{
-        rows: T[];
-    }>;
-    begin(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    createSavepoint(_name: string): Promise<void>;
-    releaseSavepoint(_name: string): Promise<void>;
-    rollbackToSavepoint(_name: string): Promise<void>;
-    close(): Promise<void>;
-}

package/dist/manager/registerModelObjects.d.ts

@@ -1,5 +0,0 @@
-/**
- * Install the schema model augmentor that exposes `Model.objects`.
- * This registration is idempotent so multiple Tango entrypoints can safely call it.
- */
-export declare function registerModelObjects(): void;

package/dist/manager/relations/ManyToManyRelatedManager.d.ts

@@ -1,181 +0,0 @@
-import type { DBClient } from '../../connection/clients/DBClient';
-import type { TableMeta } from '../../query/domain/index';
-import type { Adapter } from '../../connection/adapters/Adapter';
-import type { QueryExecutor, QuerySet } from '../../query/index';
-import type { OrmSqlSafetyAdapter } from '../../validation/OrmSqlSafetyAdapter';
-import type { MutationCompiler } from '../internal/MutationCompiler';
-import { ThroughTableManager } from './internal/ThroughTableManager';
-/**
- * Accepted target reference shapes for {@link ManyToManyRelatedManager.add},
- * {@link ManyToManyRelatedManager.remove}, and
- * {@link ManyToManyRelatedManager.set}.
- *
- * Application code may pass a target record, a primary-key carrier object, or
- * a bare primary-key value.
- *
- * @template TTarget - The persisted target record shape.
- */
-export type ManyToManyTargetRef<TTarget extends Record<string, unknown>> = TTarget | {
-    readonly [pk: string]: unknown;
-} | string | number;
-/**
- * Inputs accepted by the {@link ManyToManyRelatedManager.create} factory. The
- * factory owns the wiring between relation metadata, the SQL safety adapter,
- * and the {@link ThroughTableManager}, so callers only supply context they
- * already have on hand.
- */
-export interface ManyToManyRelatedManagerCreateInputs<TTarget extends Record<string, unknown>> {
-    /** Persisted primary-key value of the owning record. */
-    ownerPrimaryKey: unknown;
-    /** Relation name on the owning model (for error messages). */
-    relationName: string;
-    /** Display name of the owning model (for error messages). */
-    ownerModelLabel: string;
-    /** Resolved relation edge metadata for the many-to-many relation. */
-    relation: NonNullable<TableMeta['relations']>[string];
-    /** Through-model column metadata used to derive the join-table descriptor. */
-    throughModelFields: ReadonlyArray<{
-        name: string;
-        type: string;
-        primaryKey?: boolean;
-    }>;
-    /** Runtime-bound database client shared with the owning manager. */
-    client: DBClient;
-    /** Shared {@link MutationCompiler} configured for the active dialect. */
-    mutationCompiler: MutationCompiler;
-    /** Active database adapter. Supplies placeholder formatting and dialect flags. */
-    adapter: Adapter;
-    /** SQL safety adapter shared with the owning manager. */
-    sqlSafetyAdapter: OrmSqlSafetyAdapter;
-    /** Lazy resolver returning the target model's {@link QueryExecutor}. */
-    targetExecutorProvider: () => QueryExecutor<TTarget> | null;
-    /** Model-manager-backed create path for new target records. */
-    createTarget: (input: Partial<TTarget>) => Promise<TTarget>;
-    /** Internal transaction runner used for multi-target membership writes. */
-    runAtomic: <T>(work: () => Promise<T>) => Promise<T>;
-}
-interface ManyToManyRelatedManagerInternalInputs<TTarget extends Record<string, unknown>> {
-    ownerPrimaryKey: unknown;
-    relationName: string;
-    ownerModelLabel: string;
-    targetPrimaryKeyField: string;
-    throughTableManager: ThroughTableManager;
-    targetExecutorProvider: () => QueryExecutor<TTarget> | null;
-    createTarget: (input: Partial<TTarget>) => Promise<TTarget>;
-    runAtomic: <T>(work: () => Promise<T>) => Promise<T>;
-}
-/**
- * Django-style related manager exposed on materialized model records for each
- * many-to-many relation.
- *
- * Use the manager to add or remove join-table membership and to query the
- * related target rows. The owning record's primary key and the relation name
- * are bound when the manager is attached, so application code does not need
- * to pass them on every call.
- *
- * Prefetched memberships seed an internal cache that the queryset returned
- * from `all()` short-circuits to without re-querying. Mutations through
- * `add`, `remove`, `set`, `clear`, and `create` invalidate the cache so
- * subsequent reads observe the updated membership. `set(...)` applies
- * Django-shaped replacement semantics:
- * it diffs the current relation membership against the supplied targets,
- * removes any missing links, and inserts any new links inside one atomic
- * write boundary. `clear()` removes every join row for the owner, and
- * `create(...)` persists a new target row plus its join-row link inside one
- * atomic boundary.
- *
- * @template TTarget - The persisted target record shape returned by `all()`.
- */
-export declare class ManyToManyRelatedManager<TTarget extends Record<string, unknown>> {
-    private readonly inputs;
-    private static readonly BRAND;
-    readonly __tangoBrand: typeof ManyToManyRelatedManager.BRAND;
-    private prefetchCache;
-    /**
-     * Constructor is internal. Application and ORM code must build instances
-     * through {@link ManyToManyRelatedManager.create}, which owns the wiring
-     * between relation metadata and the backing through-table mutator. The
-     * testing package exposes a fixture for unit tests that need a custom
-     * mutator.
-     */
-    constructor(inputs: ManyToManyRelatedManagerInternalInputs<TTarget>);
-    /**
-     * Narrow an unknown value to {@link ManyToManyRelatedManager}.
-     */
-    static isManyToManyRelatedManager<TTarget extends Record<string, unknown>>(value: unknown): value is ManyToManyRelatedManager<TTarget>;
-    /**
-     * Build a {@link ManyToManyRelatedManager} bound to a single owner record.
-     * The factory derives the join-table descriptor from the relation edge and
-     * through-model fields, wires a {@link ThroughTableManager} against the
-     * supplied runtime-bound client, and returns a manager whose `add`,
-     * `remove`, `clear`, `create`, and `all` methods enroll in any active
-     * `transaction.atomic(...)` boundary.
-     */
-    static create<TTarget extends Record<string, unknown>>(inputs: ManyToManyRelatedManagerCreateInputs<TTarget>): ManyToManyRelatedManager<TTarget>;
-    /**
-     * Insert join-table rows linking the owning record to the supplied
-     * targets. Duplicate links are ignored so repeated `add(...)` calls are
-     * idempotent. When multiple targets are supplied, Tango performs the
-     * membership write inside one `transaction.atomic(...)` boundary.
-     */
-    add(...targets: ManyToManyTargetRef<TTarget>[]): Promise<void>;
-    /**
-     * Delete join-table rows linking the owning record to the supplied
-     * targets. When multiple targets are supplied, Tango performs the
-     * membership write inside one `transaction.atomic(...)` boundary.
-     */
-    remove(...targets: ManyToManyTargetRef<TTarget>[]): Promise<void>;
-    /**
-     * Delete every join-table row linked to the owning record and invalidate
-     * any prefetched membership cache after the delete succeeds.
-     */
-    clear(): Promise<void>;
-    /**
-     * Create a new target record through the related model's manager and link
-     * it to the owning record inside one `transaction.atomic(...)` boundary.
-     * This preserves target-manager hooks and defaults while preventing a
-     * created target row from leaking if the join-row insert fails.
-     */
-    create(input: Partial<TTarget>): Promise<TTarget>;
-    /**
-     * Replace the current relation membership with exactly the supplied
-     * targets. Duplicate inputs are collapsed before diffing against the
-     * current through-table rows, so repeated values do not trigger extra
-     * writes. Calling `set()` with no targets clears the relation.
-     *
-     * When replacement requires writes, Tango performs the delete/insert
-     * sequence inside one `transaction.atomic(...)` boundary.
-     */
-    set(...targets: ManyToManyTargetRef<TTarget>[]): Promise<void>;
-    /**
-     * Return a {@link QuerySet} for the related target rows of this many-to-many
-     * relation. When the relation was already loaded by `prefetchRelated(...)`,
-     * the first `fetch()` resolves with the cached materialization without
-     * re-querying. Mutating the membership through `add`/`remove`/`set`/
-     * `clear`/`create` invalidates that cache.
-     */
-    all(): QuerySet<TTarget>;
-    /**
-     * Replace the prefetch cache with the supplied target rows. Called by the
-     * many-to-many prefetch path so a follow-up `all()` resolves without an
-     * extra database round-trip.
-     */
-    primePrefetchCache(targets: readonly TTarget[]): void;
-    /**
-     * Drop any cached prefetch results. Mutating helpers call this so reads
-     * after an `add`/`remove`/`set`/`clear`/`create` go back to the database.
-     */
-    invalidateCache(): void;
-    /**
-     * Snapshot of the current prefetch cache, exposed for diagnostics and
-     * focused unit testing. Returns a fresh array copy so callers cannot
-     * mutate the manager's internal state.
-     */
-    snapshotCache(): readonly TTarget[] | null;
-    private insertTargetPrimaryKeys;
-    private deleteTargetPrimaryKeys;
-    private resolveTargetPrimaryKeys;
-    private resolveTargetPrimaryKey;
-    private canonicalizePrimaryKey;
-}
-export {};

package/dist/manager/relations/ManyToManyRelatedQuerySet.d.ts

@@ -1,62 +0,0 @@
-import type { QueryResult } from '../../query/domain/QueryResult';
-import type { QuerySetState } from '../../query/domain/QuerySetState';
-import type { QueryExecutor } from '../../query/index';
-import { QuerySet } from '../../query/index';
-/**
- * Hooks supplied by {@link ManyToManyRelatedManager} so the queryset returned
- * from `all()` can short-circuit to the prefetch cache, scope the SQL query
- * to the owner via the join table, and filter targets by the resolved primary
- * keys.
- *
- * Application code does not construct this bridge directly; it is wired by
- * the related manager when `all()` is called.
- */
-export interface ManyToManyRelatedQuerySetBridge<TTarget extends Record<string, unknown>> {
-    getCache(): readonly TTarget[] | null;
-    fetchTargetIds(): Promise<readonly (string | number)[]>;
-    targetPrimaryKeyField: string;
-}
-type ShapeFunction<TInput, Out> = (row: TInput) => Out;
-type ShapeParser<TInput, Out> = {
-    parse: (row: TInput) => Out;
-};
-/**
- * {@link QuerySet} returned by `post.tags.all()` on a many-to-many related
- * manager.
- *
- * Behaves like a normal `QuerySet` over the target model from an application
- * developer's perspective: you can chain `filter`, `exclude`, `orderBy`,
- * `limit`, `offset`, and terminate with `fetch`, `fetchOne`, or `count`.
- * Each chainable call returns another `ManyToManyRelatedQuerySet` so the
- * chain keeps the membership scoping of the owning record.
- *
- * Two behaviors differ from a plain `QuerySet` and matter to application
- * developers:
- *
- * - When the relation was loaded by `prefetchRelated(...)` and no chainable
- *   state has been added (no `filter`, `orderBy`, etc.), `fetch()` and
- *   `count()` resolve from the prefetch cache without issuing SQL.
- * - Mutating the membership via `post.tags.add(tag)` or
- *   `post.tags.remove(tag)` invalidates that cache so follow-up reads go
- *   back to the database.
- *
- * @example
- * ```ts
- * const post = await PostModel.objects.getOrThrow(postId);
- * await post.tags.add(tag);
- * const tags = await post.tags.all().filter({ color: 'red' }).orderBy('name').fetch();
- * ```
- *
- * @template TTarget - The persisted target record shape (e.g. `Tag`).
- */
-export declare class ManyToManyRelatedQuerySet<TTarget extends Record<string, unknown>> extends QuerySet<TTarget> {
-    private readonly bridge;
-    constructor(executor: QueryExecutor<TTarget>, bridge: ManyToManyRelatedQuerySetBridge<TTarget>, state?: QuerySetState<TTarget>);
-    fetch<Out>(shape?: ShapeFunction<TTarget, Out> | ShapeParser<TTarget, Out>): Promise<QueryResult<TTarget | Out>>;
-    fetchOne<Out>(shape?: ShapeFunction<TTarget, Out> | ShapeParser<TTarget, Out>): Promise<TTarget | Out | null>;
-    count(): Promise<number>;
-    protected spawn<TNextBaseResult extends Record<string, unknown>, TNextHydrated extends Record<string, unknown>>(state: QuerySetState<TTarget>): QuerySet<TTarget, TNextBaseResult, unknown, TNextHydrated>;
-    private isStateTrivial;
-    private scopedState;
-}
-export {};

package/dist/manager/relations/MaterializedModelRecord.d.ts

@@ -1,28 +0,0 @@
-import type { z } from 'zod';
-import type { Model, PersistedModelOutput } from '@danceroutine/tango-schema/domain';
-import type { DecoratedFieldKind, InternalDecoratedFieldKind, RelationDecoratedSchema } from '@danceroutine/tango-schema/model';
-import type { ManyToManyRelatedManager } from './ManyToManyRelatedManager';
-type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
-type AnyModel = Model<z.ZodObject<z.ZodRawShape>, string>;
-type SchemaShape<TSchema> = TSchema extends z.ZodObject<infer TShape> ? TShape : never;
-type RelationKindOf<TField> = TField extends RelationDecoratedSchema<z.ZodTypeAny, infer TKind extends DecoratedFieldKind, AnyModel, string | undefined, string | undefined> ? TKind : never;
-type RelationTarget<TField> = TField extends RelationDecoratedSchema<z.ZodTypeAny, DecoratedFieldKind, infer TTarget, string | undefined, string | undefined> ? TTarget : never;
-type RelationPublishedName<TField, TFallback extends string> = TField extends RelationDecoratedSchema<z.ZodTypeAny, DecoratedFieldKind, AnyModel, infer TName extends string | undefined, string | undefined> ? TName extends string ? TName : TFallback : TFallback;
-type ModelRow<TTarget> = TTarget extends Model<infer TSchema extends z.ZodObject<z.ZodRawShape>, string> ? PersistedModelOutput<TSchema> : never;
-type ManyToManyKeysOfShape<TShape extends z.ZodRawShape> = Extract<{
-    [K in keyof TShape]: IsAny<TShape[K]> extends true ? never : [RelationKindOf<TShape[K]>] extends [never] ? never : [RelationKindOf<TShape[K]>] extends [typeof InternalDecoratedFieldKind.MANY_TO_MANY] ? K : never;
-}[keyof TShape], string>;
-type ManyToManyManagers<TShape extends z.ZodRawShape> = {
-    readonly [K in ManyToManyKeysOfShape<TShape> as K extends keyof TShape ? RelationPublishedName<TShape[K], K> : never]: K extends keyof TShape ? RelationTarget<TShape[K]> extends AnyModel ? ManyToManyRelatedManager<ModelRow<RelationTarget<TShape[K]>>> : never : never;
-};
-/**
- * Persisted model record shape returned by ORM read and write paths.
- *
- * Combines the column-level {@link PersistedModelOutput} with a per-relation
- * {@link ManyToManyRelatedManager} for every many-to-many field declared on the
- * source schema. The manager properties are attached as non-enumerable accessors
- * at runtime, so `JSON.stringify` and structural equality checks only see the
- * column data.
- */
-export type MaterializedModelRecord<TSchema extends z.ZodObject<z.ZodRawShape>> = PersistedModelOutput<TSchema> & ManyToManyManagers<SchemaShape<TSchema>>;
-export {};

package/dist/manager/relations/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Domain boundary barrel: centralizes ORM relation managers attached to
- * materialized model records.
- */
-export { ManyToManyRelatedQuerySet } from './ManyToManyRelatedQuerySet';
-export type { ManyToManyRelatedQuerySetBridge } from './ManyToManyRelatedQuerySet';
-export { ManyToManyRelatedManager } from './ManyToManyRelatedManager';
-export type { ManyToManyRelatedManagerCreateInputs, ManyToManyTargetRef } from './ManyToManyRelatedManager';
-export type { MaterializedModelRecord } from './MaterializedModelRecord';

package/dist/manager/relations/internal/ThroughTableManager.d.ts

@@ -1,85 +0,0 @@
-import type { DBClient } from '../../../connection/clients/DBClient';
-import type { TableMeta } from '../../../query/domain/index';
-import type { Adapter } from '../../../connection/adapters/Adapter';
-import { OrmSqlSafetyAdapter } from '../../../validation/OrmSqlSafetyAdapter';
-import { MutationCompiler, type DuplicateInsertPolicy } from '../../internal/MutationCompiler';
-/**
- * Resolved through-table descriptor used by {@link ThroughTableManager}. The
- * descriptor is derived once from a relation edge plus its through-model
- * metadata, then reused for every link insert, delete, and read.
- */
-export interface ThroughTableLinkDescriptor {
-    /** Physical join-table name validated against SQL identifier safety rules. */
-    table: string;
-    /** Primary-key column name on the join table. */
-    primaryKey: string;
-    /** Full column map for the join table, used by the SQL safety adapter. */
-    columns: Record<string, string>;
-    /** Join-table column that stores the owner-side primary-key value. */
-    sourceColumn: string;
-    /** Join-table column that stores the target-side primary-key value. */
-    targetColumn: string;
-}
-/**
- * Inputs accepted by {@link ThroughTableManager.fromRelation}.
- */
-export interface ThroughTableManagerFromRelationInputs {
-    relation: NonNullable<TableMeta['relations']>[string];
-    throughModelFields: ReadonlyArray<{
-        name: string;
-        type: string;
-        primaryKey?: boolean;
-    }>;
-    client: DBClient;
-    mutationCompiler: MutationCompiler;
-    adapter: Adapter;
-    sqlSafetyAdapter: OrmSqlSafetyAdapter;
-}
-export interface InsertLinkOptions {
-    onDuplicate?: DuplicateInsertPolicy;
-}
-/**
- * Internal helper that issues the INSERT, DELETE, and SELECT statements for
- * a single many-to-many join table. Centralizes SQL safety validation and
- * compilation so {@link ManyToManyRelatedManager} implementations only deal
- * in primary-key values.
- */
-export declare class ThroughTableManager {
-    private readonly client;
-    private readonly mutationCompiler;
-    private readonly descriptor;
-    private readonly adapter;
-    private readonly sqlSafetyAdapter;
-    constructor(client: DBClient, mutationCompiler: MutationCompiler, descriptor: ThroughTableLinkDescriptor, adapter: Adapter, sqlSafetyAdapter?: OrmSqlSafetyAdapter);
-    /**
-     * Derive a {@link ThroughTableLinkDescriptor} from the through-model
-     * metadata exposed by a many-to-many relation edge.
-     */
-    static buildLinkDescriptor(relation: NonNullable<TableMeta['relations']>[string], throughModelFields: ReadonlyArray<{
-        name: string;
-        type: string;
-        primaryKey?: boolean;
-    }>): ThroughTableLinkDescriptor;
-    /**
-     * Convenience factory that derives the join-table descriptor from the
-     * relation edge and instantiates a {@link ThroughTableManager} in one
-     * step.
-     */
-    static fromRelation(inputs: ThroughTableManagerFromRelationInputs): ThroughTableManager;
-    /**
-     * Read every target primary-key value linked to the supplied owner via
-     * the join table. Used by ManyToManyRelatedManager.all to scope
-     * follow-up target queries to the current owner.
-     */
-    selectTargetIdsForOwner(ownerPrimaryKey: unknown): Promise<readonly (string | number)[]>;
-    insertLink(ownerPrimaryKey: unknown, targetPrimaryKey: unknown, options?: InsertLinkOptions): Promise<void>;
-    insertLinks(ownerPrimaryKey: unknown, targetPrimaryKeys: readonly unknown[], options?: InsertLinkOptions): Promise<void>;
-    deleteLink(ownerPrimaryKey: unknown, targetPrimaryKey: unknown): Promise<void>;
-    deleteLinks(ownerPrimaryKey: unknown, targetPrimaryKeys: readonly unknown[]): Promise<void>;
-    /**
-     * Delete every join-table row linked to one owner record. Used by
-     * `ManyToManyRelatedManager.clear()` so the related manager can clear a
-     * relation without first loading the current target ids.
-     */
-    deleteAllLinksForOwner(ownerPrimaryKey: unknown): Promise<void>;
-}

package/dist/query/ModelQuerySet.d.ts

@@ -1,20 +0,0 @@
-/**
- * Maintainer note: model-backed and specialized relation-backed querysets
- * share the fluent API through `QuerySet.spawn(...)`. This concrete class
- * owns the direct "compile the accumulated state and execute it" path, while
- * subclasses preserve specialized execution behavior by returning their own
- * queryset family from `spawn(...)`.
- */
-import type { QuerySetState } from './domain/QuerySetState';
-import type { QueryExecutor } from './QuerySet';
-import { QuerySet } from './QuerySet';
-/**
- * Concrete `QuerySet` implementation returned by `Model.objects.query()`.
- *
- * It executes the accumulated queryset state directly against the bound
- * model executor.
- */
-export declare class ModelQuerySet<TModel extends Record<string, unknown>, TBaseResult extends Record<string, unknown> = TModel, TSourceModel = unknown, THydrated extends Record<string, unknown> = Record<never, never>> extends QuerySet<TModel, TBaseResult, TSourceModel, THydrated> {
-    constructor(executor: QueryExecutor<TModel>, state?: QuerySetState<TModel, TSourceModel>);
-    protected spawn<TNextBaseResult extends Record<string, unknown> = TBaseResult, TNextHydrated extends Record<string, unknown> = THydrated>(state: QuerySetState<TModel, TSourceModel>): ModelQuerySet<TModel, TNextBaseResult, TSourceModel, TNextHydrated>;
-}

package/dist/query/QBuilder.d.ts

@@ -1,29 +0,0 @@
-import type { QNode } from './domain/QNode';
-import type { FilterInput } from './domain/FilterInput';
-/**
- * Static builder for composing boolean query expressions.
- *
- * This mirrors Django's `Q(...)` composition patterns and is intended
- * for ergonomic construction of nested `AND`/`OR`/`NOT` trees.
- */
-export declare class QBuilder {
-    static readonly BRAND: "tango.orm.q_builder";
-    readonly __tangoBrand: typeof QBuilder.BRAND;
-    /**
-     * Narrow an unknown value to `QBuilder`.
-     */
-    static isQBuilder(value: unknown): value is QBuilder;
-    /**
-     * Combine multiple filter fragments using logical `AND`.
-     */
-    static and<T, TSourceModel = unknown>(...nodes: Array<FilterInput<T, TSourceModel> | QNode<T, TSourceModel>>): QNode<T, TSourceModel>;
-    /**
-     * Combine multiple filter fragments using logical `OR`.
-     */
-    static or<T, TSourceModel = unknown>(...nodes: Array<FilterInput<T, TSourceModel> | QNode<T, TSourceModel>>): QNode<T, TSourceModel>;
-    /**
-     * Negate a filter fragment using logical `NOT`.
-     */
-    static not<T, TSourceModel = unknown>(node: FilterInput<T, TSourceModel> | QNode<T, TSourceModel>): QNode<T, TSourceModel>;
-    private static wrapNode;
-}