@pylonts/dsl 1.0.6 → 1.1.2

package/README.md

@@ -21,6 +21,7 @@ project（地图：应用与 API 拓扑）
 - [prototype.md](./docs/prototype.md) — 页面原型（概要设计）
 - [table.md](./docs/table.md) — 定义表（详细设计）
 - [dto.md](./docs/dto.md) — 定义 DTO
+- [curd.md](./docs/curd.md) — 管理端 CRUD 页面标准（CurdSchema）
 - [enum.md](./docs/enum.md) — 定义枚举
 - [driver.md](./docs/driver.md) — driver 模式与产物生成
-- [mysql-connection.md](./docs/mysql-connection.md) — MySQL 连接说明
+- [mysql-connection.md](./docs/mysql-connection.md) — MySQL 连接说明

package/dist/action.d.ts

@@ -0,0 +1,7 @@
+import { SchemaBase } from './dsl.js';
+/** An action a user can perform on a page (e.g. submit, approve, reject).
+ *  Subclasses use `type` as the discriminator. */
+export interface ActionSchema extends SchemaBase {
+    type: string;
+}
+export declare function defineAction(name: string, description?: string): ActionSchema;

package/dist/action.js

@@ -0,0 +1,3 @@
+export function defineAction(name, description) {
+    return { name, description, type: 'gesture' };
+}

package/dist/asset.d.ts

@@ -0,0 +1,48 @@
+/**
+ * defineAsset — registry for reusable project assets (utils, components, flows, pages, hooks).
+ *
+ * Each asset declares its name, category, import path, tags, and optional usage example.
+ * CLI scans all asset declarations, supports query (by tag/category) and generate (import links).
+ *
+ *   // assets/utils.assets.ts
+ *   import { defineAsset } from '@pylonts/dsl';
+ *   export const formatAmt = defineAsset({
+ *     name: 'formatAmt',
+ *     category: 'util',
+ *     tags: ['amount', 'format'],
+ *     import: { name: 'formatAmt', from: '@/utils/amount' },
+ *     example: 'formatAmt(12345) => "12,345.00"',
+ *   });
+ *
+ *   // CLI:
+ *   // pylonts gen asset list --tag form       → all form-related assets
+ *   // pylonts gen asset import formatAmt      → import { formatAmt } from '@/utils/amount';
+ */
+export type AssetCategory = 'util' | 'component' | 'flow' | 'page' | 'hook';
+export interface AssetImport {
+    /** Named export, e.g. 'formatAmt' */
+    name: string;
+    /** Module path, e.g. '@/utils/amount' */
+    from: string;
+}
+export interface AssetConfig {
+    name: string;
+    category: AssetCategory;
+    tags: string[];
+    import: AssetImport;
+    description?: string;
+    /** One-liner usage example */
+    example?: string;
+    /** Link to detailed docs */
+    see?: string;
+}
+export interface AssetDef {
+    name: string;
+    category: AssetCategory;
+    tags: string[];
+    import: AssetImport;
+    description?: string;
+    example?: string;
+    see?: string;
+}
+export declare function defineAsset(config: AssetConfig): AssetDef;

package/dist/asset.js

@@ -0,0 +1,31 @@
+/**
+ * defineAsset — registry for reusable project assets (utils, components, flows, pages, hooks).
+ *
+ * Each asset declares its name, category, import path, tags, and optional usage example.
+ * CLI scans all asset declarations, supports query (by tag/category) and generate (import links).
+ *
+ *   // assets/utils.assets.ts
+ *   import { defineAsset } from '@pylonts/dsl';
+ *   export const formatAmt = defineAsset({
+ *     name: 'formatAmt',
+ *     category: 'util',
+ *     tags: ['amount', 'format'],
+ *     import: { name: 'formatAmt', from: '@/utils/amount' },
+ *     example: 'formatAmt(12345) => "12,345.00"',
+ *   });
+ *
+ *   // CLI:
+ *   // pylonts gen asset list --tag form       → all form-related assets
+ *   // pylonts gen asset import formatAmt      → import { formatAmt } from '@/utils/amount';
+ */
+export function defineAsset(config) {
+    return {
+        name: config.name,
+        category: config.category,
+        tags: config.tags,
+        import: config.import,
+        description: config.description,
+        example: config.example,
+        see: config.see,
+    };
+}

package/dist/bases.d.ts

@@ -1,5 +1,9 @@
-import type { DtoMessage, ImportRef } from './dto';
+import type { DtoMessage, ImportBase, ImportRef } from './dto.js';
 /** Paginated query request base — renders `import { PageRequest } from '@pylonts/core'` + Intersect */
-export declare const PageRequest: ImportRef;
+export declare const PageRequest: ImportBase;
 /** Paginated list response base — renders `import { PageResult } from '@pylonts/core'` + `PageResult(<row>)` */
 export declare const PageResult: (row: DtoMessage) => ImportRef;
+/** Paged rows type base without generic args — renders `import { PagedRows } from '@pylonts/core'` */
+export declare const PagedRows: ImportBase;
+/** Paged rows type base — renders `import { PagedRows } from '@pylonts/core'` + `PagedRows(<row>)` */
+export declare const PageRows: (row: DtoMessage) => ImportRef;

package/dist/bases.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PageResult = exports.PageRequest = void 0;
 // Named base-schema references for common protocol DTOs.
 //
 // These are ImportRef metadata (not re-exports of the actual TypeBox schemas):
@@ -10,11 +7,18 @@ exports.PageResult = exports.PageRequest = void 0;
 // `import { PageRequest } from '@pylonts/dsl'` therefore gives .include() an
 // already-resolved reference — no static analysis or name lookup needed.
 /** Paginated query request base — renders `import { PageRequest } from '@pylonts/core'` + Intersect */
-exports.PageRequest = { from: '@pylonts/core', name: 'PageRequest' };
+export const PageRequest = { from: '@pylonts/core', name: 'PageRequest' };
 /** Paginated list response base — renders `import { PageResult } from '@pylonts/core'` + `PageResult(<row>)` */
-const PageResult = (row) => ({
+export const PageResult = (row) => ({
     from: '@pylonts/core',
     name: 'PageResult',
     args: [row],
 });
-exports.PageResult = PageResult;
+/** Paged rows type base without generic args — renders `import { PagedRows } from '@pylonts/core'` */
+export const PagedRows = { from: '@pylonts/core', name: 'PagedRows' };
+/** Paged rows type base — renders `import { PagedRows } from '@pylonts/core'` + `PagedRows(<row>)` */
+export const PageRows = (row) => ({
+    from: '@pylonts/core',
+    name: 'PagedRows',
+    args: [row],
+});

package/dist/check-inheritance.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkInheritance = checkInheritance;
 /** snake_case → camelCase: order_no → orderNo; names without underscores are unchanged */
 function toCamelCase(name) {
     return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
@@ -24,7 +21,7 @@ function collectFields(mod) {
     return out;
 }
 /** Check one loaded DSL module (its exports) for inheritance gaps. */
-function checkInheritance(mod, file) {
+export function checkInheritance(mod, file) {
     const fields = collectFields(mod);
     if (fields.length === 0)
         return [];

package/dist/component.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaBase } from './dsl.js';
+import type { RefSchema } from './ref.js';
+import type { ActionSchema } from './action.js';
+import type { EventDataSchema } from './event.js';
+/** A component event trigger declaration. */
+export interface TriggerSchema extends SchemaBase {
+    /** Data the event carries (e.g. e.detail). */
+    eventData?: EventDataSchema;
+    /** Actions that fire when the event occurs. */
+    actions?: ActionSchema[];
+}
+/** A UI component declaration — a virtual schema that describes props and
+ *  event triggers, not a real renderable component.
+ *
+ *  properties: data bindings via RefSchema (or literal values).
+ *  triggers: event name → TriggerSchema bindings. */
+export interface ComponentSchema extends SchemaBase {
+    properties: Record<string, RefSchema | string | number | boolean>;
+    triggers: Record<string, TriggerSchema>;
+}

package/dist/component.js

@@ -0,0 +1 @@
+export {};

package/dist/convert.d.ts

@@ -0,0 +1,9 @@
+import type { SchemaBase } from './dsl.js';
+/** Declares post-call result → page data field mapping.
+ *  Driver generates per-item transform (e.g. .map()) before setData. */
+export interface ConvertSchema extends SchemaBase {
+    type: 'convert';
+    /** { targetField: sourceField } — renames or copies fields from call result. */
+    fields: Record<string, string>;
+}
+export declare function defineConvert(name: string, fields: Record<string, string>): ConvertSchema;

package/dist/convert.js

@@ -0,0 +1,3 @@
+export function defineConvert(name, fields) {
+    return { name, type: 'convert', fields };
+}

package/dist/curd.d.ts

@@ -0,0 +1,62 @@
+import { SchemaBase, Field, Operator } from './dsl.js';
+import { TableSchema } from './db.js';
+import { FrontAppSchema } from './project.js';
+import { ActionSchema } from './action.js';
+/** Mode of an action page: modal dialog or standalone route. */
+export type ActionPageMode = 'modal' | 'route';
+/** One CRUD action page (add / update / detail). */
+export interface ActionPage {
+    mode: ActionPageMode;
+    /** For add/update: when true, render as modal on list page; when false/undefined, render as standalone route page. */
+    modal?: boolean;
+    /** Fields rendered on this page. Required, non-empty — every field the
+     *  frontend shows must be listed explicitly. */
+    columns: Field[];
+}
+/** List page configuration. */
+export interface CurdListConfig {
+    /** List columns; required, non-empty. Every field the list shows must be
+     *  listed explicitly. May include cross-table fields via foreign refs. */
+    columns: Field[];
+    /** Fuzzy keyword search on this table's columns. */
+    keyword?: {
+        columns: Field[];
+    };
+    /** Default sort. Required — column and direction are both mandatory. */
+    orderBy: {
+        column: Field;
+        direction: 'asc' | 'desc';
+    };
+    /** Search condition fields; op defaults to 'eq'. */
+    searchFields?: {
+        field: Field;
+        op?: Operator;
+    }[];
+    /** Column header text overrides: Field.name → header text. */
+    columnTitles?: Record<string, string>;
+}
+/** Admin-only CRUD page standard: binds one entity table to a frontend
+ *  admin app. Drives generation of the list page plus optional
+ *  add/update/detail pages. */
+export interface CurdSchema extends SchemaBase {
+    /** The admin frontend app this CRUD belongs to (shared instance, type must be 'admin'). */
+    app: FrontAppSchema;
+    /** The bound entity table (shared instance). */
+    table: TableSchema;
+    /** List page Chinese title. */
+    title: string;
+    /** Sidebar menu section (group) this CRUD page belongs to. */
+    section: string;
+    /** Extra user actions on this page (beyond the standard CRUD). */
+    actions?: ActionSchema[];
+    /** Add/update/detail action pages. */
+    actionPages?: {
+        add?: ActionPage;
+        update?: ActionPage;
+        detail?: ActionPage;
+    };
+    list: CurdListConfig;
+}
+/** Defines an admin CRUD page standard. Runtime-validates admin app binding,
+ *  non-empty columns and table field ownership (same style as defineTable). */
+export declare function defineCurd(name: string, schema: Omit<CurdSchema, 'name'>): CurdSchema;

package/dist/curd.js

@@ -0,0 +1,31 @@
+function assertColumns(curd, pageName, columns) {
+    if (columns.length === 0) {
+        throw new Error(`curd ${curd.name}: ${pageName}.columns must be non-empty`);
+    }
+}
+function assertFieldsOwnTable(curd, label, fields) {
+    for (const f of fields) {
+        if (f.schema !== curd.table) {
+            throw new Error(`curd ${curd.name}: ${label} field ${f.name} does not belong to table ${curd.table.name}`);
+        }
+    }
+}
+/** Defines an admin CRUD page standard. Runtime-validates admin app binding,
+ *  non-empty columns and table field ownership (same style as defineTable). */
+export function defineCurd(name, schema) {
+    const curd = { name, ...schema };
+    if (curd.app.type !== 'admin') {
+        throw new Error(`curd ${name}: app ${curd.app.name} must be type 'admin' (got '${curd.app.type}')`);
+    }
+    if (!curd.section) {
+        throw new Error(`curd ${name}: section is required (sidebar menu group, e.g. '商户管理')`);
+    }
+    assertColumns(curd, 'list', curd.list.columns);
+    for (const [pageName, page] of Object.entries(curd.actionPages ?? {})) {
+        if (page)
+            assertColumns(curd, `actionPages.${pageName}`, page.columns);
+    }
+    assertFieldsOwnTable(curd, 'keyword', curd.list.keyword?.columns ?? []);
+    assertFieldsOwnTable(curd, 'orderBy', [curd.list.orderBy.column]);
+    return curd;
+}

package/dist/db-config.d.ts

@@ -0,0 +1,8 @@
+/** MySQL connection settings, loaded from mysql.config.ts at the project root. */
+export interface DbConfig {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+}

package/dist/db-config.js

@@ -0,0 +1 @@
+export {};

package/dist/db.d.ts

@@ -0,0 +1,56 @@
+import type { EntityPhrase } from './dictionary.js';
+import type { CollectionSchemaBase, EnumDef, Field } from './dsl.js';
+export type Index = {
+    name?: string;
+    columns: Field | Field[];
+    unique?: boolean;
+};
+export type ForeignKey = {
+    columns: Field | Field[];
+    references: Field | Field[];
+};
+export interface TableSchemaOptions<N extends string = string, C extends Record<string, Field> = Record<string, Field>, E extends Record<string, EnumDef> = Record<string, EnumDef>> {
+    description?: string;
+    paginated?: boolean;
+    actor?: boolean;
+    generator?: string;
+    autoIncrement?: Field;
+    /** 本表用于关联显示的名称字段（如 name / username）。被外键引用时，自动用该字段做 label 展示。 */
+    label?: Field;
+    primaryKey?: Field | Field[];
+    indexes?: Index[];
+    foreignKeys?: Record<string, ForeignKey>;
+    /** 引用的实体短语（词典条目）：本表归属的实体；关联表等多实体场景不需要 */
+    phrase?: EntityPhrase;
+    /** 本表引用的所有枚举定义（map，key 为枚举标识），显式声明供 gen-enums 收集 */
+    enums: E;
+    columns: C;
+}
+export declare class TableSchema<N extends string = string, C extends Record<string, Field> = Record<string, Field>, E extends Record<string, EnumDef> = Record<string, EnumDef>> implements CollectionSchemaBase {
+    type: string;
+    name: N;
+    description?: string;
+    /** 分页 */
+    paginated?: boolean;
+    /** 系统操作者（如小程序为 C 端用户，管理端为运营） */
+    actor?: boolean;
+    /** id 生成器 */
+    generator?: string;
+    /** 自增主键字段 */
+    autoIncrement?: Field;
+    primaryKey?: Field | Field[];
+    indexes?: Index[];
+    /** 外键，引用其他表的字段 */
+    foreignKeys?: Record<string, ForeignKey>;
+    /** 本表用于关联显示的名称字段（如 name / username）。被外键引用时，自动用该字段做 label 展示。 */
+    label?: Field;
+    /** 引用的实体短语（词典条目）：本表归属的实体；关联表等多实体场景不需要 */
+    phrase?: EntityPhrase;
+    /** 本表引用的所有枚举定义（map，key 为枚举标识），显式声明供 gen-enums 收集 */
+    enums: E;
+    columns: C;
+    constructor(name: N, options: TableSchemaOptions<N, C, E>);
+    /** True when the field is part of this table's primary key */
+    isPk(fieldRef: Field): boolean;
+}
+export declare function defineTable<N extends string, C extends Record<string, Field>, E extends Record<string, EnumDef> = Record<string, EnumDef>>(name: N, schema: TableSchemaOptions<N, C, E>): TableSchema<N, C, E>;

package/dist/db.js

@@ -0,0 +1,100 @@
+// DB table definitions.
+// Shape: { type: 'table', <extension fields> }
+export class TableSchema {
+    type = 'table';
+    name;
+    description;
+    /** 分页 */
+    paginated;
+    /** 系统操作者（如小程序为 C 端用户，管理端为运营） */
+    actor;
+    /** id 生成器 */
+    generator;
+    /** 自增主键字段 */
+    autoIncrement;
+    primaryKey;
+    indexes;
+    /** 外键，引用其他表的字段 */
+    foreignKeys;
+    /** 本表用于关联显示的名称字段（如 name / username）。被外键引用时，自动用该字段做 label 展示。 */
+    label;
+    /** 引用的实体短语（词典条目）：本表归属的实体；关联表等多实体场景不需要 */
+    phrase;
+    /** 本表引用的所有枚举定义（map，key 为枚举标识），显式声明供 gen-enums 收集 */
+    enums;
+    columns;
+    constructor(name, options) {
+        if (!options.enums) {
+            throw new Error(`table '${name}': enums is required — declare enums: {} when the table has no enums`);
+        }
+        this.name = name;
+        this.description = options.description;
+        this.paginated = options.paginated;
+        this.actor = options.actor;
+        this.generator = options.generator;
+        this.autoIncrement = options.autoIncrement;
+        this.primaryKey = options.primaryKey;
+        this.indexes = options.indexes;
+        this.foreignKeys = options.foreignKeys;
+        this.label = options.label;
+        this.phrase = options.phrase;
+        this.enums = options.enums;
+        this.columns = options.columns;
+    }
+    /** True when the field is part of this table's primary key */
+    isPk(fieldRef) {
+        if (this.primaryKey === undefined)
+            return false;
+        return Array.isArray(this.primaryKey)
+            ? this.primaryKey.includes(fieldRef)
+            : this.primaryKey === fieldRef;
+    }
+}
+export function defineTable(name, schema) {
+    const table = new TableSchema(name, schema);
+    if (table.generator && table.autoIncrement) {
+        throw new Error(`table '${name}': generator and autoIncrement are mutually exclusive`);
+    }
+    if (table.label && !Object.values(table.columns).includes(table.label)) {
+        throw new Error(`table '${name}': label field '${table.label.name}' must be one of the table's columns`);
+    }
+    for (const key of Object.keys(table.columns)) {
+        const field = table.columns[key];
+        if (field.schema && field.schema !== table) {
+            throw new Error(`field ${key}: belongs to table ${field.schema.name}, cannot reuse in table ${table.name}`);
+        }
+    }
+    for (const key of Object.keys(table.columns)) {
+        table.columns[key].name = key;
+        table.columns[key].schema = table;
+    }
+    for (const [fkName, fk] of Object.entries(table.foreignKeys ?? {})) {
+        const refs = Array.isArray(fk.references) ? fk.references : [fk.references];
+        const fields = Array.isArray(fk.columns) ? fk.columns : [fk.columns];
+        for (let i = 0; i < refs.length; i++) {
+            const ref = refs[i];
+            if (!ref.schema)
+                throw new Error(`foreign key ${fkName}: references field has no schema`);
+            if (ref.schema === table)
+                throw new Error(`foreign key ${fkName}: cannot reference own table ${table.name}`);
+            const phrase = ref.schema.phrase;
+            if (!phrase)
+                throw new Error(`foreign key ${fkName}: referenced table ${ref.schema.name} has no phrase, cannot check field naming`);
+            const expected = `${phrase.name}_${ref.name}`;
+            const fkField = fields[i];
+            if (fkField.name !== expected) {
+                throw new Error(`foreign key ${fkName}: field must be named ${expected} (phrase ${phrase.name} + ${ref.name}), got ${fkField.name}`);
+            }
+        }
+    }
+    for (const [idxKey, index] of Object.entries(table.indexes ?? {})) {
+        const cols = Array.isArray(index.columns) ? index.columns : [index.columns];
+        for (const col of cols) {
+            if (typeof col !== 'object' || col === null || typeof col.type !== 'string') {
+                const idxName = index.name ?? idxKey;
+                throw new Error(`index ${idxName}: columns must be Field instances (stringField()/intField()/...), got ${JSON.stringify(col)}`);
+            }
+        }
+    }
+    return table;
+}

package/dist/dictionary.d.ts

@@ -1,13 +1,34 @@
-import { SchemaBase } from './dsl';
+import { SchemaBase } from './dsl.js';
+/** Kind of a dictionary entry: which naming rule the phrase participates in. */
+export declare enum DictionaryEntryType {
+    Entity = "entity",
+    Business = "business"
+}
 /** A vocabulary entry. */
 export interface DictionaryEntry extends SchemaBase {
+    /**
+     * Entry kind. Entity phrases (abbreviation of an entity, e.g. mer) must be
+     * the FIRST segment of a field name; business phrases (attribute of an
+     * entity, e.g. rate) must be the LAST segment.
+     */
+    type: DictionaryEntryType;
     /** Display label (Chinese) for the term. */
     label?: string;
 }
+/** An entity phrase entry — type narrowed to Entity. */
+export interface EntityPhrase extends DictionaryEntry {
+    type: DictionaryEntryType.Entity;
+}
 /**
- * Explains a phrase — the returned entry IS the phrase. `name` is the phrase
- * itself (column-name stem, e.g. mer / bd / amt), not a full entity name;
+ * Explains an entity phrase — the returned entry IS the phrase. `name` is the
+ * phrase itself (column-name stem, e.g. mer / bd), not a full entity name;
  * label/description explain what it means. Convention: short phrase, not long
- * name.
+ * name. Entity phrases appear as the first segment of a field name (mer_id).
+ */
+export declare function defineEntityPhrase(extra: Omit<DictionaryEntry, 'type'>): EntityPhrase;
+/**
+ * Explains a business phrase (an attribute of an entity) — the returned entry
+ * IS the phrase. `name` is the phrase itself (column-name stem, e.g. amt /
+ * rate). Business phrases appear as the last segment of a field name (bd_rate).
  */
-export declare function definePhrase(extra: DictionaryEntry): DictionaryEntry;
+export declare function defineBusinessPhrase(extra: Omit<DictionaryEntry, 'type'>): DictionaryEntry;

package/dist/dictionary.js

@@ -1,12 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.definePhrase = definePhrase;
+// Dictionary definitions: vocabulary shared across the team — what a term
+// means and what it is called.
+/** Kind of a dictionary entry: which naming rule the phrase participates in. */
+export var DictionaryEntryType;
+(function (DictionaryEntryType) {
+    DictionaryEntryType["Entity"] = "entity";
+    DictionaryEntryType["Business"] = "business";
+})(DictionaryEntryType || (DictionaryEntryType = {}));
 /**
- * Explains a phrase — the returned entry IS the phrase. `name` is the phrase
- * itself (column-name stem, e.g. mer / bd / amt), not a full entity name;
+ * Explains an entity phrase — the returned entry IS the phrase. `name` is the
+ * phrase itself (column-name stem, e.g. mer / bd), not a full entity name;
  * label/description explain what it means. Convention: short phrase, not long
- * name.
+ * name. Entity phrases appear as the first segment of a field name (mer_id).
  */
-function definePhrase(extra) {
-    return extra;
+export function defineEntityPhrase(extra) {
+    return { type: DictionaryEntryType.Entity, ...extra };
+}
+/**
+ * Explains a business phrase (an attribute of an entity) — the returned entry
+ * IS the phrase. `name` is the phrase itself (column-name stem, e.g. amt /
+ * rate). Business phrases appear as the last segment of a field name (bd_rate).
+ */
+export function defineBusinessPhrase(extra) {
+    return { type: DictionaryEntryType.Business, ...extra };
 }

package/dist/dsl.d.ts

@@ -1,8 +1,15 @@
-import type { DictionaryEntry } from './dictionary';
+import type { ImportBase } from './import-base.js';
+import type { MockDescriptor } from './mock.js';
+/** Field query comparison operators (search field semantics). */
+export type Operator = 'eq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ne';
 export interface SchemaBase {
     name: string;
     description?: string;
 }
+/** Schema base for cross-file entities. importRef locates the generating module; inline schemas omit it. */
+export interface ImportableSchemaBase extends SchemaBase {
+    importRef?: ImportBase;
+}
 /** Field collection schemas (DB table vs DTO message); `type` is the discriminator */
 export interface CollectionSchemaBase extends SchemaBase {
     type: string;
@@ -13,13 +20,13 @@ export interface BaseField {
     label?: string;
     /** 字段描述 */
     description?: string;
-    /** 业务语义码（如 'merchant_name'），驱动 mock 生成等下游消费 */
-    semantic?: string;
     optional?: boolean;
     readOnly?: boolean;
     default?: string;
     /** 所属 schema（db 或 dto） */
     schema?: CollectionSchemaBase;
+    /** Pure-data mock descriptor for test data generation */
+    mock?: MockDescriptor;
 }
 interface StringField extends BaseField {
     type: 'string';
@@ -87,51 +94,6 @@ interface JsonField extends BaseField {
     jsType: 'object';
 }
 export type Field = StringField | TextField | IntField | BigintField | DecimalField | BooleanField | DateField | TimeField | DateTimeField | EnumField | JsonField;
-export type Index = {
-    name?: string;
-    fields: Field | Field[];
-    unique?: boolean;
-};
-export type ForeignKey = {
-    fields: Field | Field[];
-    references: Field | Field[];
-};
-export interface TableSchemaOptions {
-    description?: string;
-    paginated?: boolean;
-    actor?: boolean;
-    generator?: string;
-    autoIncrement?: Field;
-    primaryKey?: Field | Field[];
-    indexes?: Index[];
-    foreignKeys?: Record<string, ForeignKey>;
-    /** 引用的实体短语（词典条目）：本表归属的实体；关联表等多实体场景不需要 */
-    phrase?: DictionaryEntry;
-    fields: Record<string, Field>;
-}
-export declare class TableSchema implements CollectionSchemaBase {
-    type: string;
-    name: string;
-    description?: string;
-    /** 分页 */
-    paginated?: boolean;
-    /** 系统操作者（如小程序为 C 端用户，管理端为运营） */
-    actor?: boolean;
-    /** id 生成器 */
-    generator?: string;
-    /** 自增主键字段 */
-    autoIncrement?: Field;
-    primaryKey?: Field | Field[];
-    indexes?: Index[];
-    /** 外键，引用其他表的字段 */
-    foreignKeys?: Record<string, ForeignKey>;
-    /** 引用的实体短语（词典条目）：本表归属的实体；关联表等多实体场景不需要 */
-    phrase?: DictionaryEntry;
-    fields: Record<string, Field>;
-    constructor(name: string, options: TableSchemaOptions);
-    /** True when the field is part of this table's primary key */
-    isPk(fieldRef: Field): boolean;
-}
 type FieldExtras<T extends Field> = Omit<T, 'name' | 'type' | 'jsType'>;
 export declare function stringField(extra?: FieldExtras<StringField>): StringField;
 export declare function textField(extra?: FieldExtras<TextField>): TextField;
@@ -144,5 +106,4 @@ export declare function timeField(extra?: FieldExtras<TimeField>): TimeField;
 export declare function datetimeField(extra?: FieldExtras<DateTimeField>): DateTimeField;
 export declare function jsonField(extra?: FieldExtras<JsonField>): JsonField;
 export declare function enumField(extra: Omit<EnumField, 'name' | 'type' | 'jsType'>): EnumField;
-export declare function defineTable(name: string, schema: TableSchemaOptions): TableSchema;
 export {};