@danceroutine/tango-schema 0.1.0 → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Pedro Del Moral Lopez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,122 @@
+# @danceroutine/tango-schema
+
+`@danceroutine/tango-schema` defines Tango models, structural metadata, and model-owned write lifecycle hooks.
+
+A Tango model is the shared contract that the ORM, migrations, resources, OpenAPI generation, and code generation read from. The schema package keeps those layers aligned by giving them one model definition to build on.
+
+## Install
+
+```bash
+pnpm add @danceroutine/tango-schema zod
+```
+
+## Quick start
+
+```ts
+import { z } from 'zod';
+import { Model, t } from '@danceroutine/tango-schema';
+
+const PostSchema = z.object({
+    id: t.primaryKey(z.number().int()),
+    title: z.string(),
+    slug: z.string(),
+    content: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+
+export const PostModel = Model({
+    namespace: 'blog',
+    name: 'Post',
+    schema: PostSchema,
+    hooks: {
+        async beforeCreate({ data }) {
+            const now = new Date().toISOString();
+
+            return {
+                ...data,
+                createdAt: now,
+                updatedAt: now,
+            };
+        },
+        async beforeUpdate({ patch }) {
+            return {
+                ...patch,
+                updatedAt: new Date().toISOString(),
+            };
+        },
+    },
+});
+```
+
+`PostModel` becomes the source of truth for:
+
+- field metadata and primary-key identity
+- relation and index metadata
+- migration generation
+- `Model.objects` manager attachment in the ORM
+- model-owned write lifecycle hooks
+
+## Model lifecycle hooks
+
+Model hooks live on the model definition through `hooks`. They run inside `Model.objects`, which means the same persistence rules apply across serializers, viewsets, scripts, and direct manager usage.
+
+Use model hooks for persistence rules such as:
+
+- timestamp stamping
+- slug generation that should apply for every write path
+- default persisted values
+- normalization that belongs to the record itself
+
+The write hook surface includes:
+
+- `beforeCreate` and `afterCreate`
+- `beforeUpdate` and `afterUpdate`
+- `beforeDelete` and `afterDelete`
+- `beforeBulkCreate` and `afterBulkCreate`
+
+`before*` hooks may return normalized data to persist. `after*` hooks are for observation and side effects after the write succeeds.
+
+## How the schema package fits with serializers
+
+Serializers stay Zod-backed and continue to own request validation, update validation, and output representation.
+
+Model hooks serve a different role. They hold persistence rules that should run for every caller of `Model.objects`, even when the write does not come from a resource.
+
+That split keeps the model responsible for record lifecycle behavior while the serializer stays focused on the HTTP-facing contract.
+
+## Public API
+
+The root export includes:
+
+- `Model`
+- `RelationBuilder`
+- `ModelRegistry`
+- metadata helpers such as `t`, `m`, `c`, and `i`
+- model and relation domain types
+- model write hook types such as `ModelWriteHooks`
+
+The root import is the normal entrypoint for application code. The `domain` and `model` subpaths are available when you want narrower imports.
+
+## Documentation
+
+- Official documentation: <https://tangowebframework.dev>
+- Models and schema topic: <https://tangowebframework.dev/topics/models-and-schema>
+- Model lifecycle hooks topic: <https://tangowebframework.dev/topics/model-lifecycle-hooks>
+- Schema API reference: <https://tangowebframework.dev/reference/schema-api>
+
+## Development
+
+```bash
+pnpm --filter @danceroutine/tango-schema build
+pnpm --filter @danceroutine/tango-schema typecheck
+pnpm --filter @danceroutine/tango-schema test
+```
+
+For the wider contributor workflow, use:
+
+- <https://tangowebframework.dev/contributing>
+
+## License
+
+MIT

package/dist/domain/DeleteReferentialAction.d.ts

@@ -1,2 +1 @@
-import { InternalReferentialAction } from './internal/InternalReferentialAction';
-export type DeleteReferentialAction = typeof InternalReferentialAction.CASCADE | typeof InternalReferentialAction.SET_NULL | typeof InternalReferentialAction.RESTRICT | typeof InternalReferentialAction.NO_ACTION;
+export type DeleteReferentialAction = 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';

package/dist/domain/Model.d.ts

@@ -1,6 +1,22 @@
 import type { z } from 'zod';
 import type { ModelMetadata } from './ModelMetadata';
-export interface Model<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> {
+import type { ModelWriteHooks } from './ModelWriteHooks';
+declare const MODEL_AUGMENTATION_SCHEMA: unique symbol;
+type ModelAugmentationCarrier<TSchema extends z.ZodObject<z.ZodRawShape>> = {
+    readonly [MODEL_AUGMENTATION_SCHEMA]?: TSchema;
+};
+declare global {
+    interface TangoSchemaModelAugmentations<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> {
+    }
+}
+export interface ModelAugmentations<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> extends ModelAugmentationCarrier<TSchema>, TangoSchemaModelAugmentations<TSchema> {
+}
+export interface Model<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> extends ModelAugmentations<TSchema> {
     metadata: ModelMetadata;
     schema: TSchema;
+    /**
+     * Model-owned write lifecycle hooks preserved from the definition.
+     */
+    hooks?: ModelWriteHooks<z.output<TSchema>>;
 }
+export {};

package/dist/domain/ModelMetadata.d.ts

@@ -2,8 +2,15 @@ import type { Field } from './Field';
 import type { IndexDef } from './IndexDef';
 import type { RelationDef } from './RelationDef';
 export interface ModelMetadata {
+    namespace: string;
+    name: string;
+    key: string;
     table: string;
     fields: Field[];
     indexes?: IndexDef[];
     relations?: Record<string, RelationDef>;
+    ordering?: string[];
+    managed?: boolean;
+    defaultRelatedName?: string;
+    constraints?: unknown[];
 }

package/dist/domain/ModelWriteHooks.d.ts

@@ -0,0 +1,82 @@
+export interface ModelWriteHookManager<TModel extends Record<string, unknown>> {
+    create(input: Partial<TModel>): Promise<TModel>;
+    update(id: TModel[keyof TModel], patch: Partial<TModel>): Promise<TModel>;
+    delete(id: TModel[keyof TModel]): Promise<void>;
+    bulkCreate(inputs: Partial<TModel>[]): Promise<TModel[]>;
+}
+/**
+ * Structural model contract passed into write lifecycle hooks.
+ */
+export interface ModelHookModel<TModel extends Record<string, unknown>> {
+    metadata: {
+        table: string;
+    };
+    schema: {
+        parse(input: unknown): TModel;
+    };
+    hooks?: ModelWriteHooks<TModel>;
+}
+export interface BeforeCreateHookArgs<TModel extends Record<string, unknown>> {
+    data: Partial<TModel>;
+    model: ModelHookModel<TModel>;
+    manager: ModelWriteHookManager<TModel>;
+}
+export interface AfterCreateHookArgs<TModel extends Record<string, unknown>> {
+    record: TModel;
+    model: ModelHookModel<TModel>;
+    manager: ModelWriteHookManager<TModel>;
+}
+export interface BeforeUpdateHookArgs<TModel extends Record<string, unknown>> {
+    id: TModel[keyof TModel];
+    patch: Partial<TModel>;
+    current: TModel;
+    model: ModelHookModel<TModel>;
+    manager: ModelWriteHookManager<TModel>;
+}
+export interface AfterUpdateHookArgs<TModel extends Record<string, unknown>> {
+    id: TModel[keyof TModel];
+    patch: Partial<TModel>;
+    previous: TModel;
+    record: TModel;
+    model: ModelHookModel<TModel>;
+    manager: ModelWriteHookManager<TModel>;
+}
+export interface BeforeDeleteHookArgs<TModel extends Record<string, unknown>> {
+    id: TModel[keyof TModel];
+    current: TModel;
+    model: ModelHookModel<TModel>;
+    manager: ModelWriteHookManager<TModel>;
+}
+export interface AfterDeleteHookArgs<TModel extends Record<string, unknown>> {
+    id: TModel[keyof TModel];
+    previous: TModel;
+    model: ModelHookModel<TModel>;
+    manager: ModelWriteHookManager<TModel>;
+}
+export interface BeforeBulkCreateHookArgs<TModel extends Record<string, unknown>> {
+    rows: Partial<TModel>[];
+    model: ModelHookModel<TModel>;
+    manager: ModelWriteHookManager<TModel>;
+}
+export interface AfterBulkCreateHookArgs<TModel extends Record<string, unknown>> {
+    records: TModel[];
+    model: ModelHookModel<TModel>;
+    manager: ModelWriteHookManager<TModel>;
+}
+/**
+ * Async-capable model-owned write lifecycle hooks.
+ *
+ * Use model hooks for persistence rules that should apply everywhere the model
+ * is written, including serializers, viewsets, scripts, and direct manager
+ * calls.
+ */
+export interface ModelWriteHooks<TModel extends Record<string, unknown>> {
+    beforeCreate?(args: BeforeCreateHookArgs<TModel>): Promise<Partial<TModel> | void> | Partial<TModel> | void;
+    afterCreate?(args: AfterCreateHookArgs<TModel>): Promise<void> | void;
+    beforeUpdate?(args: BeforeUpdateHookArgs<TModel>): Promise<Partial<TModel> | void> | Partial<TModel> | void;
+    afterUpdate?(args: AfterUpdateHookArgs<TModel>): Promise<void> | void;
+    beforeDelete?(args: BeforeDeleteHookArgs<TModel>): Promise<void> | void;
+    afterDelete?(args: AfterDeleteHookArgs<TModel>): Promise<void> | void;
+    beforeBulkCreate?(args: BeforeBulkCreateHookArgs<TModel>): Promise<Partial<TModel>[] | void> | Partial<TModel>[] | void;
+    afterBulkCreate?(args: AfterBulkCreateHookArgs<TModel>): Promise<void> | void;
+}

package/dist/domain/UpdateReferentialAction.d.ts

@@ -1,2 +1 @@
-import { InternalReferentialAction } from './internal/InternalReferentialAction';
-export type UpdateReferentialAction = typeof InternalReferentialAction.CASCADE | typeof InternalReferentialAction.RESTRICT | typeof InternalReferentialAction.NO_ACTION;
+export type UpdateReferentialAction = 'CASCADE' | 'RESTRICT' | 'NO ACTION';

package/dist/domain/index.d.ts

@@ -9,4 +9,5 @@ export type { Field } from './Field';
 export type { IndexDef } from './IndexDef';
 export type { RelationDef } from './RelationDef';
 export type { ModelMetadata } from './ModelMetadata';
-export type { Model } from './Model';
+export type { Model, ModelAugmentations } from './Model';
+export type { ModelHookModel, ModelWriteHookManager, ModelWriteHooks, BeforeCreateHookArgs, AfterCreateHookArgs, BeforeUpdateHookArgs, AfterUpdateHookArgs, BeforeDeleteHookArgs, AfterDeleteHookArgs, BeforeBulkCreateHookArgs, AfterBulkCreateHookArgs, } from './ModelWriteHooks';

package/dist/domain-Cufz6y1q.js.map

@@ -1 +1 @@
-{"version":3,"file":"domain-Cufz6y1q.js","names":[],"sources":["../src/domain/index.ts"],"sourcesContent":["/**\n * Domain boundary barrel: centralizes this subdomain's public contract.\n */\n\nexport type { FieldType } from './FieldType';\nexport type { DeleteReferentialAction } from './DeleteReferentialAction';\nexport type { UpdateReferentialAction } from './UpdateReferentialAction';\nexport type { RelationType } from './RelationType';\nexport type { Field } from './Field';\nexport type { IndexDef } from './IndexDef';\nexport type { RelationDef } from './RelationDef';\nexport type { ModelMetadata } from './ModelMetadata';\nexport type { Model } from './Model';\n"],"mappings":""}
+{"version":3,"file":"domain-Cufz6y1q.js","names":[],"sources":["../src/domain/index.ts"],"sourcesContent":["/**\n * Domain boundary barrel: centralizes this subdomain's public contract.\n */\n\nexport type { FieldType } from './FieldType';\nexport type { DeleteReferentialAction } from './DeleteReferentialAction';\nexport type { UpdateReferentialAction } from './UpdateReferentialAction';\nexport type { RelationType } from './RelationType';\nexport type { Field } from './Field';\nexport type { IndexDef } from './IndexDef';\nexport type { RelationDef } from './RelationDef';\nexport type { ModelMetadata } from './ModelMetadata';\nexport type { Model, ModelAugmentations } from './Model';\nexport type {\n    ModelHookModel,\n    ModelWriteHookManager,\n    ModelWriteHooks,\n    BeforeCreateHookArgs,\n    AfterCreateHookArgs,\n    BeforeUpdateHookArgs,\n    AfterUpdateHookArgs,\n    BeforeDeleteHookArgs,\n    AfterDeleteHookArgs,\n    BeforeBulkCreateHookArgs,\n    AfterBulkCreateHookArgs,\n} from './ModelWriteHooks';\n"],"mappings":""}

package/dist/index.d.ts

@@ -4,5 +4,5 @@
  */
 export * as domain from './domain/index';
 export * as model from './model/index';
-export type { DeleteReferentialAction, Field, FieldType, IndexDef, ModelMetadata, RelationDef, RelationType, UpdateReferentialAction, } from './domain/index';
-export { Model, RelationBuilder, type ModelDefinition } from './model/index';
+export type { DeleteReferentialAction, Field, FieldType, IndexDef, ModelHookModel, ModelAugmentations, ModelMetadata, ModelWriteHookManager, ModelWriteHooks, BeforeCreateHookArgs, AfterCreateHookArgs, BeforeUpdateHookArgs, AfterUpdateHookArgs, BeforeDeleteHookArgs, AfterDeleteHookArgs, BeforeBulkCreateHookArgs, AfterBulkCreateHookArgs, RelationDef, RelationType, UpdateReferentialAction, } from './domain/index';
+export { Model, RelationBuilder, ModelRegistry, registerModelAugmentor, Constraints, Decorators, Indexes, Meta, c, i, m, t, type ModelDefinition, } from './model/index';

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Model, RelationBuilder, model_exports } from "./model-DE1qDItF.js";
+import { Constraints, Decorators, Indexes, Meta, Model, ModelRegistry, RelationBuilder, model_exports, registerModelAugmentor } from "./model-DI8lQH1W.js";
 import { domain_exports } from "./domain-Cufz6y1q.js";
 
-export { Model, RelationBuilder, domain_exports as domain, model_exports as model };
+export { Constraints, Decorators, Indexes, Meta, Model, ModelRegistry, RelationBuilder, Constraints as c, domain_exports as domain, Indexes as i, Meta as m, model_exports as model, registerModelAugmentor, Decorators as t };

package/dist/model/ModelAugmentorRegistry.d.ts

@@ -0,0 +1,11 @@
+import type { z } from 'zod';
+import type { Model } from '../domain/Model';
+export type ModelAugmentor = <TSchema extends z.ZodObject<z.ZodRawShape>>(model: Model<TSchema>) => void;
+/**
+ * Register a model augmentor that runs for existing and future models.
+ */
+export declare function registerModelAugmentor(augmentor: ModelAugmentor): () => void;
+/**
+ * Apply all registered augmentors to a model before it is returned publicly.
+ */
+export declare function applyModelAugmentors<TSchema extends z.ZodObject<z.ZodRawShape>>(model: Model<TSchema>): Model<TSchema>;

package/dist/model/ModelDefinition.d.ts

@@ -1,10 +1,21 @@
 import { z } from 'zod';
 import type { Field, IndexDef, RelationDef } from '../domain/index';
+import type { ModelWriteHooks } from '../domain/index';
 import type { RelationBuilder } from './RelationBuilder';
 export interface ModelDefinition<TSchema extends z.ZodObject<z.ZodRawShape>> {
-    table: string;
+    namespace: string;
+    name: string;
+    table?: string;
     schema: TSchema;
     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<z.output<TSchema>>;
 }

package/dist/model/RelationBuilder.d.ts

@@ -1,6 +1,12 @@
 import type { RelationDef } from '../domain/index';
+/**
+ * Fluent helper for declaring model relation metadata.
+ */
 export 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;
 }

package/dist/model/constraints/Constraints.d.ts

@@ -0,0 +1,19 @@
+export type ConstraintDefinition = {
+    kind: string;
+    [key: string]: unknown;
+};
+export 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;
+};

package/dist/model/constraints/Indexes.d.ts

@@ -0,0 +1,4 @@
+import type { IndexDef } from '../../domain/index';
+export declare const Indexes: {
+    index(on: string[], options?: Omit<IndexDef, "on">): IndexDef;
+};

package/dist/model/constraints/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Domain boundary barrel: centralizes this subdomain's public contract.
+ */
+export { Constraints, Constraints as c } from './Constraints';
+export type { ConstraintDefinition } from './Constraints';
+export { Indexes, Indexes as i } from './Indexes';

package/dist/model/decorators/Decorators.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import type { ModelRef, ReferentialOptions, ZodTypeAny } from './types';
+type UnaryFieldDecorator = {
+    <T extends ZodTypeAny>(schema: T): T;
+    <T extends ZodTypeAny>(): (input: T) => T;
+};
+type RelationshipDecorator = {
+    <T extends ZodTypeAny>(target: ModelRef, schema: T, options?: ReferentialOptions): T;
+    (target: ModelRef, options?: ReferentialOptions): z.ZodNumber;
+};
+type ManyToManyDecorator = {
+    <T extends ZodTypeAny>(target: ModelRef, schema: T): T;
+    (target: ModelRef): z.ZodArray<z.ZodNumber>;
+};
+export interface TangoDecorators {
+    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: RelationshipDecorator;
+    manyToMany: ManyToManyDecorator;
+}
+export declare const Decorators: TangoDecorators;
+export {};

package/dist/model/decorators/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Domain boundary barrel: centralizes this subdomain's public contract.
+ */
+export { Decorators, Decorators as t } from './Decorators';
+export type { TangoDecorators } from './Decorators';
+export type { ModelRef, ReferentialOptions, TangoFieldMeta, ZodTypeAny } from './types';

package/dist/model/decorators/types.d.ts

@@ -0,0 +1,29 @@
+import type { z } from 'zod';
+import type { DeleteReferentialAction, Model, UpdateReferentialAction } from '../../domain/index';
+export type ModelRef = string | Model | (() => Model);
+export interface ReferentialOptions {
+    column?: string;
+    onDelete?: DeleteReferentialAction;
+    onUpdate?: UpdateReferentialAction;
+}
+export interface TangoFieldMeta {
+    primaryKey?: boolean;
+    unique?: boolean;
+    notNull?: boolean;
+    dbIndex?: boolean;
+    dbColumn?: string;
+    default?: string | {
+        now: true;
+    } | null;
+    dbDefault?: string;
+    helpText?: string;
+    choices?: readonly unknown[];
+    validators?: readonly ((value: unknown) => unknown)[];
+    errorMessages?: Record<string, string>;
+    references?: {
+        target: ModelRef;
+        options?: ReferentialOptions;
+    };
+    relationKind?: 'foreignKey' | 'oneToOne' | 'manyToMany';
+}
+export type ZodTypeAny = z.ZodTypeAny;

package/dist/model/index.d.ts

@@ -4,3 +4,11 @@
 export type { ModelDefinition } from './ModelDefinition';
 export { RelationBuilder } from './RelationBuilder';
 export { Model } from './Model';
+export { registerModelAugmentor } from './ModelAugmentorRegistry';
+export { Decorators, t } from './decorators/index';
+export type { TangoDecorators } from './decorators/index';
+export { Meta, m } from './meta/index';
+export type { ModelConstraint, ModelMetaFragment } from './meta/index';
+export { Constraints, Indexes, c, i } from './constraints/index';
+export type { ConstraintDefinition } from './constraints/index';
+export { ModelRegistry } from './registry/ModelRegistry';

package/dist/model/index.js

@@ -1,3 +1,3 @@
-import { Model, RelationBuilder } from "../model-DE1qDItF.js";
+import { Constraints, Decorators, Indexes, Meta, Model, ModelRegistry, RelationBuilder, registerModelAugmentor } from "../model-DI8lQH1W.js";
 
-export { Model, RelationBuilder };
+export { Constraints, Decorators, Indexes, Meta, Model, ModelRegistry, RelationBuilder, Constraints as c, Indexes as i, Meta as m, registerModelAugmentor, Decorators as t };

package/dist/model/inferFields.d.ts

@@ -1,3 +1,10 @@
 import { z } from 'zod';
 import type { Field } from '../domain/index';
-export declare function inferFieldsFromSchema(schema: z.ZodObject<z.ZodRawShape>): Field[];
+import { ModelRegistry } from './registry/ModelRegistry';
+export type InferFieldsOptions = {
+    registry?: ModelRegistry;
+};
+/**
+ * Infer Tango field metadata from a Zod object schema and any attached field decorators.
+ */
+export declare function inferFieldsFromSchema(schema: z.ZodObject<z.ZodRawShape>, options?: InferFieldsOptions): Field[];

package/dist/model/internal/FieldMetadataStore.d.ts

@@ -0,0 +1,3 @@
+import type { TangoFieldMeta, ZodTypeAny } from '../decorators/types';
+export declare function getFieldMetadata(schema: ZodTypeAny): TangoFieldMeta | undefined;
+export declare function setFieldMetadata(schema: ZodTypeAny, meta: TangoFieldMeta): void;

package/dist/model/meta/Meta.d.ts

@@ -0,0 +1,22 @@
+import type { IndexDef } from '../../domain/index';
+export type ModelConstraint = {
+    kind: string;
+    [key: string]: unknown;
+};
+export type ModelMetaFragment = {
+    ordering?: string[];
+    managed?: boolean;
+    defaultRelatedName?: string;
+    indexes?: IndexDef[];
+    constraints?: ModelConstraint[];
+};
+export 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;
+};

package/dist/model/meta/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Domain boundary barrel: centralizes this subdomain's public contract.
+ */
+export { Meta, Meta as m } from './Meta';
+export type { ModelConstraint, ModelMetaFragment } from './Meta';

package/dist/model/registry/ModelRegistry.d.ts

@@ -0,0 +1,68 @@
+import type { Model } from '../../domain/index';
+import type { ModelRef } from '../decorators/types';
+/**
+ * Registry that resolves Tango models by stable identity.
+ *
+ * The global registry is convenient for application bootstrapping, while
+ * dedicated instances are useful in tests and tooling.
+ */
+export declare class ModelRegistry {
+    private static globalRegistry?;
+    private readonly models;
+    /**
+     * Return the shared process-wide registry used by `Model(...)`.
+     */
+    static global(): ModelRegistry;
+    /**
+     * Register a model on the shared global registry.
+     */
+    static register(model: Model): void;
+    /**
+     * Register several models on the shared global registry.
+     */
+    static registerMany(models: readonly Model[]): void;
+    /**
+     * Resolve a model from the shared registry by namespace and name.
+     */
+    static get(namespace: string, name: string): Model | undefined;
+    /**
+     * Resolve a model from the shared registry by its `namespace/name` key.
+     */
+    static getByKey(key: string): Model | undefined;
+    /**
+     * Resolve any supported model reference form against the shared registry.
+     */
+    static resolveRef(ref: ModelRef): Model;
+    /**
+     * Clear the shared registry, which is mainly useful in tests.
+     */
+    static clear(): void;
+    /**
+     * Register a model on this registry instance.
+     */
+    register(model: Model): void;
+    /**
+     * Register several models on this registry instance.
+     */
+    registerMany(models: readonly Model[]): void;
+    /**
+     * Resolve a model from this registry instance by namespace and name.
+     */
+    get(namespace: string, name: string): Model | undefined;
+    /**
+     * Resolve a model from this registry instance by its `namespace/name` key.
+     */
+    getByKey(key: string): Model | undefined;
+    /**
+     * Resolve a string, callback, or direct model reference into a model object.
+     */
+    resolveRef(ref: ModelRef): Model;
+    /**
+     * Remove all registered models from this registry instance.
+     */
+    clear(): void;
+    /**
+     * Return all registered models in insertion order.
+     */
+    values(): readonly Model[];
+}