@danceroutine/tango-schema 1.11.0 → 1.11.2

package/dist/index-DXFf5XNn.d.ts

@@ -0,0 +1,747 @@
+import { E as Field, O as UpdateReferentialAction, S as ModelWriteHooks, T as IndexDef, a as PersistedModelOutput, c as DecoratedFieldKind, i as ModelKeyOf, k as DeleteReferentialAction, l as InternalDecoratedFieldKind, n as Model$1, o as RelationDecoratedSchema, s as ZodTypeAny, w as RelationDef } from "./index-Bhh0b304.js";
+import { z } from "zod";
+
+//#region src/model/decorators/domain/ModelRef.d.ts
+declare const TANGO_TYPED_MODEL_REF_TARGET: unique symbol;
+interface TypedModelRef<TModel extends Model$1 = Model$1> {
+  readonly key: ModelKeyOf<TModel>;
+  readonly [TANGO_TYPED_MODEL_REF_TARGET]?: TModel;
+}
+type ModelRef<TModel extends Model$1 = Model$1> = string | TModel | (() => TModel) | TypedModelRef<TModel>;
+type ModelRefTarget<TRef> = TRef extends TypedModelRef<infer TModel> ? TModel : TRef extends (() => infer TModel) ? TModel extends Model$1 ? TModel : never : TRef extends Model$1 ? TRef : never;
+declare function createTypedModelRef<TModel extends Model$1>(key: ModelKeyOf<TModel>): TypedModelRef<TModel>;
+declare function isTypedModelRef(value: unknown): value is TypedModelRef;
+//#endregion
+//#region src/model/decorators/domain/TangoFieldMeta.d.ts
+/**
+ * Options attached to a {@link TangoFieldMeta.references} block for foreign-key-style fields.
+ */
+interface ReferentialOptions {
+  /**
+   * Column on the **referenced** model that this link targets. When omitted, the target model’s
+   * primary key is used.
+   */
+  column?: string;
+  /** `ON DELETE` action for the underlying foreign key constraint. */
+  onDelete?: DeleteReferentialAction;
+  /** `ON UPDATE` action for the underlying foreign key constraint. */
+  onUpdate?: UpdateReferentialAction;
+}
+/**
+ * Field-level metadata attached to a Zod schema via decorators. Migrations and relation wiring
+ * read this shape when inferring columns, constraints, and graph edges.
+ */
+interface TangoFieldMeta {
+  /** Marks the backing column as the table primary key. */
+  primaryKey?: boolean;
+  /** Adds a uniqueness constraint at the database layer. */
+  unique?: boolean;
+  /** `NOT NULL` for the stored column when applicable. */
+  notNull?: boolean;
+  /** Creates a btree index on the stored column. */
+  dbIndex?: boolean;
+  /**
+   * Database column name. When set, migrations and DDL use this instead of the object property
+   * name.
+   */
+  dbColumn?: string;
+  /**
+   * Application-level default used by schema inference and validation (`DEFAULT` clause is
+   * derived separately unless {@link dbDefault} is set).
+   */
+  default?: string | {
+    now: true;
+  } | null;
+  /** Raw SQL expression for the column’s `DEFAULT` in generated DDL. */
+  dbDefault?: string;
+  /** Human-oriented description for forms, admin UIs, and generated docs. */
+  helpText?: string;
+  /** Enumerated allowed values when the field is presented as a choice list. */
+  choices?: readonly unknown[];
+  /** Runtime validators applied when coercing or checking incoming values. */
+  validators?: readonly ((value: unknown) => unknown)[];
+  /** Map of validator key to user-facing error message overrides. */
+  errorMessages?: Record<string, string>;
+  /**
+   * Declares how this field relates to another model: plain FK (`target`), optional explicit
+   * many-to-many through model (`through`), and the through-side field names that pair the source
+   * and target endpoints.
+   */
+  references?: {
+    /** Symbolic reference to the related model (same resolution rules as elsewhere in schema). */target: ModelRef;
+    options?: ReferentialOptions; /** Explicit join model for a many-to-many when not using an implicit through table. */
+    through?: ModelRef;
+    /**
+     * Schema field key on the through model that holds the foreign key **from** this model’s
+     * side of the association.
+     */
+    throughSourceFieldName?: string;
+    /**
+     * Schema field key on the through model that holds the foreign key **to** the related
+     * model’s side of the association.
+     */
+    throughTargetFieldName?: string;
+  };
+  /**
+   * Classifies decorated relation endpoints (`foreignKey`, `oneToOne`, `manyToMany`) for
+   * normalization and graph construction.
+   */
+  relationKind?: DecoratedFieldKind;
+  /**
+   * Preferred name for the forward edge from this model toward {@link references.target}
+   * (overrides inferred naming).
+   */
+  forwardName?: string;
+  /**
+   * Preferred name for the reverse edge back from the related model (overrides inferred naming).
+   */
+  reverseName?: string;
+}
+//#endregion
+//#region src/model/decorators/domain/RelationDecoratorConfig.d.ts
+/**
+ * Config object for `t.foreignKey(...)`.
+ *
+ * The config object is the preferred second-argument form for relation
+ * decorators. Omit `field` to keep Tango's default schema inference.
+ */
+interface ForeignKeyDecoratorConfig<TField extends ZodTypeAny = ZodTypeAny> extends ReferentialOptions {
+  field?: TField;
+  name?: string;
+  relatedName?: string;
+}
+/**
+ * Config object for `t.oneToOne(...)`.
+ *
+ * The config object is the preferred second-argument form for relation
+ * decorators. Omit `field` to keep Tango's default schema inference.
+ */
+interface OneToOneDecoratorConfig<TField extends ZodTypeAny = ZodTypeAny> extends ReferentialOptions {
+  field?: TField;
+  name?: string;
+  relatedName?: string;
+}
+/**
+ * Config object for `t.manyToMany(...)`.
+ *
+ * The config object is the preferred second-argument form for relation
+ * decorators. Omit `field` to keep Tango's default schema inference.
+ */
+interface ManyToManyDecoratorConfig<TField extends ZodTypeAny = ZodTypeAny> {
+  field?: TField;
+  name?: string;
+  relatedName?: never;
+  through?: ModelRef;
+  throughSourceFieldName?: string;
+  throughTargetFieldName?: string;
+}
+//#endregion
+//#region src/model/decorators/Decorators.d.ts
+interface FieldDecoratorBuilder<TField extends ZodTypeAny> {
+  defaultValue(value: string | {
+    now: true;
+  } | null): FieldDecoratorBuilder<TField>;
+  dbDefault(value: string): FieldDecoratorBuilder<TField>;
+  dbColumn(name: string): FieldDecoratorBuilder<TField>;
+  dbIndex(): FieldDecoratorBuilder<TField>;
+  choices(values: readonly unknown[]): FieldDecoratorBuilder<TField>;
+  validators(...values: readonly ((value: unknown) => unknown)[]): FieldDecoratorBuilder<TField>;
+  helpText(text: string): FieldDecoratorBuilder<TField>;
+  errorMessages(map: Record<string, string>): FieldDecoratorBuilder<TField>;
+  build(): TField;
+}
+type ConfigName<TConfig> = TConfig extends {
+  name: infer TName extends string;
+} ? TName : undefined;
+type ConfigRelatedName<TConfig> = TConfig extends {
+  relatedName: infer TRelatedName extends string;
+} ? TRelatedName : undefined;
+type UnaryFieldDecorator = {
+  <T extends ZodTypeAny>(schema: T): T;
+  <T extends ZodTypeAny>(): (input: T) => T;
+};
+type RelationshipDecorator = {
+  <TRef extends ModelRef, T extends ZodTypeAny, const TConfig extends ForeignKeyDecoratorConfig<T> & {
+    field: T;
+  }>(target: TRef, config: TConfig): RelationDecoratedSchema<T, 'foreignKey', ModelRefTarget<TRef>, ConfigName<TConfig>, ConfigRelatedName<TConfig>>;
+  <TRef extends ModelRef, const TConfig extends ForeignKeyDecoratorConfig<z.ZodNumber> | undefined>(target: TRef, config?: TConfig): RelationDecoratedSchema<z.ZodNumber, 'foreignKey', ModelRefTarget<TRef>, ConfigName<TConfig>, ConfigRelatedName<TConfig>>;
+  /**
+   * @deprecated Use `t.foreignKey(target, { field: schema, ...options })` instead.
+   */
+  <T extends ZodTypeAny>(target: ModelRef, schema: T, options?: ReferentialOptions): RelationDecoratedSchema<T, 'foreignKey'>;
+};
+type OneToOneRelationshipDecorator = {
+  <TRef extends ModelRef, T extends ZodTypeAny, const TConfig extends OneToOneDecoratorConfig<T> & {
+    field: T;
+  }>(target: TRef, config: TConfig): RelationDecoratedSchema<T, 'oneToOne', ModelRefTarget<TRef>, ConfigName<TConfig>, ConfigRelatedName<TConfig>>;
+  <TRef extends ModelRef, const TConfig extends OneToOneDecoratorConfig<z.ZodNumber> | undefined>(target: TRef, config?: TConfig): RelationDecoratedSchema<z.ZodNumber, 'oneToOne', ModelRefTarget<TRef>, ConfigName<TConfig>, ConfigRelatedName<TConfig>>;
+  /**
+   * @deprecated Use `t.oneToOne(target, { field: schema, ...options })` instead.
+   */
+  <T extends ZodTypeAny>(target: ModelRef, schema: T, options?: ReferentialOptions): RelationDecoratedSchema<T, 'oneToOne'>;
+};
+type ManyToManyDecorator = {
+  <TRef extends ModelRef, T extends ZodTypeAny, const TConfig extends ManyToManyDecoratorConfig<T> & {
+    field: T;
+  }>(target: TRef, config: TConfig): RelationDecoratedSchema<T, 'manyToMany', ModelRefTarget<TRef>, ConfigName<TConfig>, undefined>;
+  <TRef extends ModelRef, const TConfig extends ManyToManyDecoratorConfig<z.ZodArray<z.ZodNumber>> | undefined>(target: TRef, config?: TConfig): RelationDecoratedSchema<z.ZodArray<z.ZodNumber>, 'manyToMany', ModelRefTarget<TRef>, ConfigName<TConfig>, undefined>;
+  /**
+   * @deprecated Use `t.manyToMany(target, { field: schema, name })` instead.
+   */
+  <T extends ZodTypeAny>(target: ModelRef, schema: T): RelationDecoratedSchema<T, 'manyToMany'>;
+};
+interface TangoDecorators {
+  field: <T extends ZodTypeAny>(schema: T) => FieldDecoratorBuilder<T>;
+  modelRef: <TModel extends Model$1>(key: ModelKeyOf<TModel>) => TypedModelRef<TModel>;
+  primaryKey: UnaryFieldDecorator;
+  unique: UnaryFieldDecorator;
+  null: UnaryFieldDecorator;
+  notNull: UnaryFieldDecorator;
+  default: <T extends ZodTypeAny>(schema: T, value: string | {
+    now: true;
+  } | null) => T;
+  dbDefault: <T extends ZodTypeAny>(schema: T, value: string) => T;
+  dbColumn: <T extends ZodTypeAny>(schema: T, name: string) => T;
+  dbIndex: <T extends ZodTypeAny>(schema: T) => T;
+  choices: <T extends ZodTypeAny>(schema: T, values: readonly unknown[]) => T;
+  validators: <T extends ZodTypeAny>(schema: T, ...values: readonly ((value: unknown) => unknown)[]) => T;
+  helpText: <T extends ZodTypeAny>(schema: T, text: string) => T;
+  errorMessages: <T extends ZodTypeAny>(schema: T, map: Record<string, string>) => T;
+  foreignKey: RelationshipDecorator;
+  oneToOne: OneToOneRelationshipDecorator;
+  manyToMany: ManyToManyDecorator;
+}
+declare const Decorators: TangoDecorators;
+declare namespace index_d_exports$5 {
+  export { DecoratedFieldKind, Decorators, FieldDecoratorBuilder, ForeignKeyDecoratorConfig, InternalDecoratedFieldKind, ManyToManyDecoratorConfig, ModelRef, ModelRefTarget, OneToOneDecoratorConfig, ReferentialOptions, RelationDecoratedSchema, TangoDecorators, TangoFieldMeta, TypedModelRef, ZodTypeAny, createTypedModelRef, isTypedModelRef, Decorators as t };
+}
+//#endregion
+//#region src/model/meta/Meta.d.ts
+type ModelConstraint = {
+  kind: string;
+  [key: string]: unknown;
+};
+type ModelMetaFragment = {
+  ordering?: string[];
+  managed?: boolean;
+  defaultRelatedName?: string;
+  indexes?: IndexDef[];
+  constraints?: ModelConstraint[];
+};
+declare const Meta: {
+  ordering(...fields: string[]): ModelMetaFragment;
+  managed(value: boolean): ModelMetaFragment;
+  defaultRelatedName(value: string): ModelMetaFragment;
+  indexes(...indexes: IndexDef[]): ModelMetaFragment;
+  constraints(...constraints: ModelConstraint[]): ModelMetaFragment;
+  uniqueTogether(...sets: string[][]): ModelMetaFragment;
+  indexTogether(...sets: string[][]): ModelMetaFragment;
+  merge(...fragments: readonly ModelMetaFragment[]): ModelMetaFragment;
+};
+declare namespace index_d_exports$4 {
+  export { Meta, ModelConstraint, ModelMetaFragment, Meta as m };
+}
+//#endregion
+//#region src/model/constraints/Constraints.d.ts
+type ConstraintDefinition = {
+  kind: string;
+  [key: string]: unknown;
+};
+declare const Constraints: {
+  unique(fields: string[], options?: {
+    name?: string;
+    where?: string;
+  }): ConstraintDefinition;
+  check(condition: string, options?: {
+    name?: string;
+  }): ConstraintDefinition;
+  exclusion(definition: {
+    using?: string;
+    elements: string[];
+    where?: string;
+    name?: string;
+  }): ConstraintDefinition;
+};
+//#endregion
+//#region src/model/constraints/Indexes.d.ts
+declare const Indexes: {
+  index(on: string[], options?: Omit<IndexDef, "on">): IndexDef;
+};
+declare namespace index_d_exports$3 {
+  export { ConstraintDefinition, Constraints, Indexes, Constraints as c, Indexes as i };
+}
+//#endregion
+//#region src/model/fields/FinalizedStorageArtifacts.d.ts
+interface FinalizedStorageModel {
+  key: string;
+  table: string;
+  fields: readonly Field[];
+  pk: string;
+}
+interface FinalizedStorageArtifacts {
+  version: number;
+  byModel: ReadonlyMap<string, FinalizedStorageModel>;
+}
+//#endregion
+//#region src/model/relations/RelationSpec.d.ts
+declare const InternalRelationPublicKind: {
+  readonly BELONGS_TO: "belongsTo";
+  readonly HAS_ONE: "hasOne";
+  readonly HAS_MANY: "hasMany";
+  readonly MANY_TO_MANY: "manyToMany";
+};
+declare const InternalRelationStorageStrategy: {
+  readonly REFERENCE: "reference";
+  readonly REVERSE_REFERENCE: "reverse_reference";
+  readonly MANY_TO_MANY: "many_to_many";
+};
+declare const InternalRelationCardinality: {
+  readonly SINGLE: "single";
+  readonly MANY: "many";
+};
+declare const InternalRelationProvenance: {
+  readonly FIELD_DECORATOR: "field-decorator";
+  readonly RELATIONS_API: "relations-api";
+  readonly SYNTHESIZED_REVERSE: "synthesized-reverse";
+};
+type RelationPublicKind = (typeof InternalRelationPublicKind)[keyof typeof InternalRelationPublicKind];
+type RelationStorageStrategy = (typeof InternalRelationStorageStrategy)[keyof typeof InternalRelationStorageStrategy];
+type RelationCardinality = (typeof InternalRelationCardinality)[keyof typeof InternalRelationCardinality];
+type RelationProvenance = (typeof InternalRelationProvenance)[keyof typeof InternalRelationProvenance];
+//#endregion
+//#region src/model/relations/ResolvedRelationGraph.d.ts
+/**
+ * Fully resolved relation edge published by the registry after storage
+ * artifacts are finalized.
+ *
+ * This is the resolution-stage shape consumed by ORM-facing relation metadata.
+ * Each descriptor has final naming, cardinality, key mapping, and capability
+ * flags that describe whether the edge is currently migratable, queryable, and
+ * hydratable.
+ */
+interface ResolvedRelationDescriptor {
+  edgeId: string;
+  sourceModelKey: string;
+  targetModelKey: string;
+  name: string;
+  inverseEdgeId?: string;
+  kind: RelationPublicKind;
+  storageStrategy: RelationStorageStrategy;
+  cardinality: RelationCardinality;
+  localFieldName?: string;
+  targetFieldName?: string;
+  throughModelKey?: string;
+  throughTable?: string;
+  throughSourceFieldName?: string;
+  throughTargetFieldName?: string;
+  throughSourceKey?: string;
+  throughTargetKey?: string;
+  capabilities: {
+    migratable: boolean;
+    queryable: boolean;
+    hydratable: boolean;
+  };
+  provenance: RelationProvenance;
+  alias: string;
+  ambiguity?: string;
+}
+/**
+ * Registry-scoped relation graph built from normalized relation descriptors,
+ * explicit relation names, and finalized storage artifacts.
+ *
+ * This is the canonical resolved relation view for query planning and future
+ * hydration work. It is versioned because relation resolution is scoped to a
+ * specific registry snapshot.
+ */
+interface ResolvedRelationGraph {
+  version: number;
+  byModel: ReadonlyMap<string, ReadonlyMap<string, ResolvedRelationDescriptor>>;
+  byEdgeId: ReadonlyMap<string, ResolvedRelationDescriptor>;
+}
+//#endregion
+//#region src/model/registry/ResolvedRelationGraphSnapshot.d.ts
+/**
+ * Serializable snapshot of a single relation edge from the resolved relation
+ * graph. Snapshots are the stable, build-time wire format consumed by codegen
+ * and by tooling that compares the graph across runs.
+ *
+ * A snapshot row captures both the abstract edge identity (who connects to
+ * whom, under what public name) and the physical storage details (local
+ * fields, join columns, through-model coordinates) needed to translate the
+ * edge into SQL later.
+ */
+type ResolvedRelationGraphSnapshotRelation = {
+  /**
+   * Stable identifier for this edge within the graph. Used to cross-reference
+   * an edge with its inverse and to detect drift between snapshots.
+   */
+  edgeId: string; /** Model key of the endpoint that owns this edge in the resolved graph. */
+  sourceModelKey: string; /** Model key of the endpoint this edge points at. */
+  targetModelKey: string;
+  /**
+   * Public relation name exposed to application code and query builders
+   * (for example `author` or `tags`).
+   */
+  name: string;
+  /**
+   * Identifier of the paired edge on the opposite endpoint, when one exists.
+   * Bidirectional relations populate this; one-way edges leave it unset.
+   */
+  inverseEdgeId?: string;
+  /**
+   * Public relation kind (`belongsTo`, `hasMany`, `manyToMany`, ...).
+   */
+  kind: RelationPublicKind;
+  /**
+   * How the edge is physically stored. Distinguishes direct foreign-key
+   * references from reverse references and join-table backed relations.
+   */
+  storageStrategy: RelationStorageStrategy; /** Whether the edge yields one target (`single`) or many (`many`). */
+  cardinality: RelationCardinality;
+  /**
+   * Owner-side column that stores the foreign key, when the edge is backed
+   * by a local reference column.
+   */
+  localFieldName?: string;
+  /**
+   * Target-side column the foreign key resolves against, when applicable.
+   */
+  targetFieldName?: string;
+  /**
+   * Model key of the synthesized or user-provided through model for
+   * many-to-many edges.
+   */
+  throughModelKey?: string; /** Physical join-table name for many-to-many edges. */
+  throughTable?: string; /** Through-model schema field on the source side, if resolved. */
+  throughSourceFieldName?: string; /** Through-model schema field on the target side, if resolved. */
+  throughTargetFieldName?: string;
+  /**
+   * Physical join-table column that stores the owner-side primary key for
+   * many-to-many edges.
+   */
+  throughSourceKey?: string;
+  /**
+   * Physical join-table column that stores the target-side primary key for
+   * many-to-many edges.
+   */
+  throughTargetKey?: string;
+  /**
+   * Alias used when the edge participates in SQL joins. Derived
+   * deterministically so compiled SQL is stable across runs.
+   */
+  alias: string;
+  /**
+   * What this edge is allowed to participate in. The builder uses these
+   * flags to decide whether migrations emit DDL, queries can select over
+   * the edge, and hydration can populate the related attribute.
+   */
+  capabilities: {
+    /** Whether migration tooling should emit DDL for this edge. */migratable: boolean; /** Whether the edge can appear as a hop in a query path. */
+    queryable: boolean; /** Whether hydrators can populate the related attribute on a row. */
+    hydratable: boolean;
+  };
+};
+/**
+ * Snapshot of one model's relation edges. Grouping edges by source model
+ * lets codegen walk the graph model-by-model without having to re-index.
+ */
+type ResolvedRelationGraphSnapshotModel = {
+  /** Model key these relations source from. */key: string; /** Resolved outgoing relation edges in registration order. */
+  relations: ResolvedRelationGraphSnapshotRelation[];
+};
+/**
+ * Top-level serializable snapshot of the resolved relation graph for a
+ * registry. Written to disk by codegen and diffed across runs to detect
+ * registry drift.
+ */
+type ResolvedRelationGraphSnapshot = {
+  /** Per-model relation snapshots in registration order. */models: ResolvedRelationGraphSnapshotModel[];
+};
+//#endregion
+//#region src/model/registry/ModelRegistry.d.ts
+/**
+ * Registry that resolves Tango models by stable identity.
+ *
+ * The default shared registry is convenient for application bootstrapping
+ * within one schema package instance, while dedicated instances are useful in
+ * tests and tooling. Explicit active-registry binding stays process-shared so
+ * tooling can construct models across separate schema package copies without
+ * relying on the ambient default registry.
+ */
+declare class ModelRegistry {
+  private static globalRegistry?;
+  private readonly models;
+  private version;
+  private storageCache?;
+  private relationGraphCache?;
+  private lastRelationRegistryDriftCheckVersion?;
+  /**
+   * Return the shared default registry used by `Model(...)` for this schema
+   * package instance.
+   */
+  static global(): ModelRegistry;
+  /**
+   * Return the registry currently bound to model construction work.
+   *
+   * This explicit binding is process-shared so code that imports separate
+   * schema package copies can still participate in one construction flow.
+   */
+  static active(): ModelRegistry;
+  /**
+   * Run work with a specific registry bound as the active construction target.
+   */
+  static runWithRegistry<T>(registry: ModelRegistry, work: () => Promise<T> | T): Promise<T>;
+  /**
+   * Register a model on the shared global registry.
+   */
+  static register(model: Model$1): void;
+  /**
+   * Register several models on the shared global registry.
+   */
+  static registerMany(models: readonly Model$1[]): void;
+  /**
+   * Resolve a model from the shared registry by namespace and name.
+   */
+  static get(namespace: string, name: string): Model$1 | undefined;
+  /**
+   * Resolve a model from the shared registry by its `namespace/name` key.
+   */
+  static getByKey(key: string): Model$1 | undefined;
+  /**
+   * Resolve any supported model reference form against the shared registry.
+   */
+  static resolveRef(ref: ModelRef): Model$1;
+  /**
+   * Clear the shared registry, which is mainly useful in tests.
+   */
+  static clear(): void;
+  /**
+   * Return the owning registry for a model.
+   */
+  static getOwner(model: {
+    metadata: {
+      key?: string;
+    };
+  } & object): ModelRegistry;
+  private static runtimeGlobal;
+  private static activeRegistryStorage;
+  /**
+   * Register a model on this registry instance.
+   */
+  register(model: Model$1): void;
+  /**
+   * Register several models on this registry instance.
+   */
+  registerMany(models: readonly Model$1[]): void;
+  /**
+   * Resolve a model from this registry instance by namespace and name.
+   */
+  get(namespace: string, name: string): Model$1 | undefined;
+  /**
+   * Resolve a model from this registry instance by its `namespace/name` key.
+   */
+  getByKey(key: string): Model$1 | undefined;
+  /**
+   * Resolve a string, callback, or direct model reference into a model object.
+   */
+  resolveRef(ref: ModelRef): Model$1;
+  /**
+   * Finalize storage-only artifacts for all models in this registry.
+   */
+  finalizeStorageArtifacts(): FinalizedStorageArtifacts;
+  /**
+   * Return finalized storage fields for a specific model.
+   */
+  getFinalizedFields(model: Model$1 | string): readonly Field[];
+  /**
+   * Resolve the registry's relation graph from finalized storage artifacts.
+   */
+  getResolvedRelationGraph(): ResolvedRelationGraph;
+  /**
+   * Return a canonical snapshot of the resolved relation graph.
+   */
+  getResolvedRelationGraphSnapshot(): ResolvedRelationGraphSnapshot;
+  /**
+   * Return a deterministic fingerprint for the resolved relation graph.
+   */
+  getResolvedRelationGraphFingerprint(): string;
+  /**
+   * Remove all registered models from this registry instance.
+   */
+  clear(): void;
+  /**
+   * Return all registered models in insertion order.
+   */
+  values(): readonly Model$1[];
+  private bumpVersion;
+  private stripImplicitManyToManyModels;
+  private freezeFields;
+  private inferPrimaryKeyName;
+  private mergeStorageFields;
+  private warnOnGeneratedRelationRegistryDrift;
+  private shouldCheckGeneratedRelationRegistry;
+  private readGeneratedRelationRegistryArtifact;
+  private isPartialRegistrySnapshot;
+}
+//#endregion
+//#region src/resolveSchemaModuleEntrypoint.d.ts
+/**
+ * Resolve the current package root entrypoint for `@danceroutine/tango-schema`.
+ *
+ * Tooling loaders alias app-side `@danceroutine/tango-schema` imports back to
+ * this path so project modules reuse the same schema package instance across
+ * workspace-source and published-dist environments.
+ */
+declare function resolveSchemaModuleEntrypoint(): string;
+/**
+ * Return explicit Jiti alias entries for the schema package root and its
+ * public subpaths so app modules always reuse the same schema package instance.
+ *
+ * @internal
+ * Exported for Tango tooling/framework consumption only. This helper exists so
+ * Tango loaders can force app modules to reuse the active schema package
+ * instance during module execution. It is not intended as a stable application
+ * API, and the alias map may be more permissive than the package exports
+ * surface by design.
+ */
+declare function createSchemaModuleAliases(): Record<string, string>;
+//#endregion
+//#region src/model/registry/GeneratedRelationRegistryArtifact.d.ts
+declare const GENERATED_RELATION_REGISTRY_DIRNAME = ".tango";
+declare const GENERATED_RELATION_REGISTRY_TYPES_FILENAME = "relations.generated.d.ts";
+declare const GENERATED_RELATION_REGISTRY_METADATA_FILENAME = "relations.generated.json";
+declare const GENERATED_RELATION_REGISTRY_METADATA_VERSION = 1;
+type GeneratedRelationRegistryArtifact = {
+  version: typeof GENERATED_RELATION_REGISTRY_METADATA_VERSION;
+  fingerprint: string;
+  snapshot: ResolvedRelationGraphSnapshot;
+};
+//#endregion
+//#region src/model/registry/ResolvedRelationGraphArtifactFactory.d.ts
+/**
+ * Build canonical serialized artifacts from a resolved relation graph.
+ *
+ * Generation, drift detection, and related tooling all need the same stable
+ * snapshot shape and fingerprinting rules, so that work lives behind one class
+ * instead of a pair of free functions.
+ */
+declare class ResolvedRelationGraphArtifactFactory {
+  static createSnapshot(graph: ResolvedRelationGraph): ResolvedRelationGraphSnapshot;
+  static createFingerprint(value: ResolvedRelationGraph | ResolvedRelationGraphSnapshot): string;
+}
+declare namespace index_d_exports$2 {
+  export { GENERATED_RELATION_REGISTRY_DIRNAME, GENERATED_RELATION_REGISTRY_METADATA_FILENAME, GENERATED_RELATION_REGISTRY_METADATA_VERSION, GENERATED_RELATION_REGISTRY_TYPES_FILENAME, GeneratedRelationRegistryArtifact, ModelRegistry, ResolvedRelationGraphArtifactFactory, ResolvedRelationGraphSnapshot, ResolvedRelationGraphSnapshotModel, ResolvedRelationGraphSnapshotRelation, createSchemaModuleAliases, resolveSchemaModuleEntrypoint };
+}
+//#endregion
+//#region src/model/relations/RelationBuilder.d.ts
+/**
+ * Public authoring DSL for model-level named relations.
+ *
+ * This is the first stage of the relations subdomain. Application code uses it
+ * inside `relations: (r) => ({ ... })` to declare stable relation names and
+ * resolve ambiguity that field decorators alone cannot express.
+ *
+ * Later internal stages normalize these authored definitions and combine them
+ * with field-authored relation metadata to build the resolved relation graph.
+ */
+declare class RelationBuilder {
+  /** Declare a one-to-many relation from this model to `target`. */
+  hasMany(target: string, foreignKey: string): RelationDef;
+  /** Declare an owning relation to a parent model. */
+  belongsTo(target: string, foreignKey: string, localKey?: string): RelationDef;
+  /** Declare a one-to-one relation from this model to `target`. */
+  hasOne(target: string, foreignKey: string): RelationDef;
+}
+declare namespace index_d_exports$1 {
+  export { RelationBuilder };
+}
+//#endregion
+//#region src/model/ModelDefinition.d.ts
+interface ModelDefinition<TSchema extends z.ZodObject<z.ZodRawShape>> {
+  namespace: string;
+  name: string;
+  table?: string;
+  schema: TSchema;
+  registry?: ModelRegistry;
+  fields?: Field[];
+  indexes?: IndexDef[];
+  relations?: (builder: RelationBuilder) => Record<string, RelationDef>;
+  ordering?: string[];
+  managed?: boolean;
+  defaultRelatedName?: string;
+  constraints?: unknown[];
+  /**
+   * Model-owned write lifecycle hooks that run inside `Model.objects`.
+   */
+  hooks?: ModelWriteHooks<PersistedModelOutput<TSchema>>;
+}
+//#endregion
+//#region src/model/relations/ImplicitManyToManyIdentifier.d.ts
+/**
+ * Single source of truth for identity of Tango-synthesized many-to-many
+ * through models. Other parts of the schema package interact with synthesized
+ * models exclusively through this class so they do not have to know the
+ * namespace or digest scheme those keys encode.
+ */
+declare class ImplicitManyToManyIdentifier {
+  private static readonly NAMESPACE;
+  /**
+   * Stable model key for the synthesized through model connecting
+   * `sourceModelKey` to `targetModelKey` via the schema field
+   * `sourceSchemaFieldKey`.
+   *
+   * The returned key is deterministic across runs so storage and hydration
+   * artifacts stay stable as long as the inputs match.
+   */
+  static getModelKey(sourceModelKey: string, sourceSchemaFieldKey: string, targetModelKey: string): string;
+  /**
+   * Deterministic short digest used to derive the physical join-table name
+   * for a synthesized through model. Shorter than the model-key digest so
+   * table names stay within common SQL identifier limits.
+   */
+  static getTableBaseDigest(sourceModelKey: string, sourceSchemaFieldKey: string, targetModelKey: string): string;
+  /**
+   * True when `modelKey` was produced by {@link getModelKey} and therefore
+   * identifies a synthesized through model. Callers use this instead of
+   * comparing namespace prefixes so the namespace remains an implementation
+   * detail of this class.
+   */
+  static isImplicitManyToManyModel(modelKey: string): boolean;
+  /**
+   * Namespace under which synthesized through models are registered.
+   * Exposed so {@link ImplicitManyToManyThroughFactory} can construct the
+   * model with the correct namespace. External callers that want to ask
+   * "is this an implicit model" should prefer {@link isImplicitManyToManyModel}.
+   */
+  static getNamespace(): string;
+  /**
+   * Extract the `m2m_<digest>` component of a synthesized model key so the
+   * factory can register the through model with a deterministic name while
+   * keeping the namespace owned by this class.
+   */
+  static getModelName(modelKey: string): string;
+  private static digest;
+}
+//#endregion
+//#region src/model/Model.d.ts
+/**
+ * Creates a model definition with metadata and schema validation.
+ * Automatically finalizes field types through the owning model registry.
+ */
+declare function Model<const TNamespace extends string, const TName extends string, TSchema extends z.ZodObject<z.ZodRawShape>>(definition: ModelDefinition<TSchema> & {
+  namespace: TNamespace;
+  name: TName;
+}): Model$1<TSchema, `${TNamespace}/${TName}`>;
+//#endregion
+//#region src/model/ModelAugmentorRegistry.d.ts
+type ModelAugmentor = <TSchema extends z.ZodObject<z.ZodRawShape>, TKey extends string>(model: Model$1<TSchema, TKey>) => void;
+/**
+ * Register a model augmentor that runs for existing and future models.
+ */
+declare function registerModelAugmentor(augmentor: ModelAugmentor): () => void;
+declare namespace index_d_exports {
+  export { ConstraintDefinition, Constraints, DecoratedFieldKind, Decorators, FieldDecoratorBuilder, ForeignKeyDecoratorConfig, GENERATED_RELATION_REGISTRY_DIRNAME, GENERATED_RELATION_REGISTRY_METADATA_FILENAME, GENERATED_RELATION_REGISTRY_METADATA_VERSION, GENERATED_RELATION_REGISTRY_TYPES_FILENAME, GeneratedRelationRegistryArtifact, ImplicitManyToManyIdentifier, Indexes, InternalDecoratedFieldKind, ManyToManyDecoratorConfig, Meta, Model, ModelConstraint, ModelDefinition, ModelMetaFragment, ModelRef, ModelRefTarget, ModelRegistry, OneToOneDecoratorConfig, RelationBuilder, RelationDecoratedSchema, ResolvedRelationGraphArtifactFactory, ResolvedRelationGraphSnapshot, ResolvedRelationGraphSnapshotModel, ResolvedRelationGraphSnapshotRelation, TangoDecorators, TypedModelRef, Constraints as c, index_d_exports$3 as constraints, createSchemaModuleAliases, createTypedModelRef, index_d_exports$5 as decorators, Indexes as i, isTypedModelRef, Meta as m, index_d_exports$4 as meta, registerModelAugmentor, index_d_exports$2 as registry, index_d_exports$1 as relations, resolveSchemaModuleEntrypoint, Decorators as t };
+}
+//#endregion
+export { Decorators as A, isTypedModelRef as B, ConstraintDefinition as C, ModelConstraint as D, Meta as E, OneToOneDecoratorConfig as F, ModelRef as I, ModelRefTarget as L, TangoDecorators as M, ForeignKeyDecoratorConfig as N, ModelMetaFragment as O, ManyToManyDecoratorConfig as P, TypedModelRef as R, Indexes as S, index_d_exports$4 as T, ModelRegistry as _, ModelDefinition as a, ResolvedRelationGraphSnapshotRelation as b, index_d_exports$2 as c, GENERATED_RELATION_REGISTRY_METADATA_FILENAME as d, GENERATED_RELATION_REGISTRY_METADATA_VERSION as f, resolveSchemaModuleEntrypoint as g, createSchemaModuleAliases as h, ImplicitManyToManyIdentifier as i, FieldDecoratorBuilder as j, index_d_exports$5 as k, ResolvedRelationGraphArtifactFactory as l, GeneratedRelationRegistryArtifact as m, registerModelAugmentor as n, index_d_exports$1 as o, GENERATED_RELATION_REGISTRY_TYPES_FILENAME as p, Model as r, RelationBuilder as s, index_d_exports as t, GENERATED_RELATION_REGISTRY_DIRNAME as u, ResolvedRelationGraphSnapshot as v, Constraints as w, index_d_exports$3 as x, ResolvedRelationGraphSnapshotModel as y, createTypedModelRef as z };
+//# sourceMappingURL=index-DXFf5XNn.d.ts.map