@aurorajs.dev/catalyst-cli 1.0.2 → 1.1.3

package/dist/generator/domain/model.js

@@ -3,9 +3,6 @@
  * `{bc}.aurora.yaml`) and intermediate representations used while rendering templates.
  * Types here have no behaviour — helpers live in sibling files (`property-*.ts`, `utils/code-gen.ts`).
  */
-// Re-exported from widget-type.ts for backwards-compatible imports.
-import { WidgetType } from './widget-type.js';
-export { WidgetType };
 /**
  * Build a complete ModuleDefinitionSchema from a RelationshipPivot.
  * Every field is explicit — if ModuleDefinitionSchema gains a new required field,
@@ -26,3 +23,4 @@ export function buildPivotSchema(pivot) {
         moduleNames: pivot.moduleNames,
     };
 }
+export { WidgetType } from './widget-type.js';

package/dist/generator/domain/module-resolution.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolution primitive for cross-bounded-context relations
+ * (`generate-cross-bc-drizzle-relations`, design.md D3 "Resolution test",
+ * tasks.md group 4).
+ *
+ * A YAML declaration under `cliter/` is NOT evidence a relation's target
+ * exists: 12 of the 30 declared cross-BC references measured in T-4.1 have
+ * a YAML with no generated module at all. The only evidence that matters is
+ * whether the target's backend module has actually been generated — its
+ * `@app/<bc>/<module>/index.ts` barrel, the SAME barrel
+ * `buildBcRelationsModuleEntry`'s `importPath` names and
+ * `upsertBcRelationsFile`'s import anchor targets (HR-BARRELS-002). If that
+ * barrel is not on disk, upserting a cross-BC entry that imports its table
+ * symbol would produce a dangling import.
+ */
+/** Whether `boundedContextName`/`moduleName` has a generated backend module under `srcDir`. */
+export declare function isModuleGenerated(srcDir: string, boundedContextName: string, moduleName: string): boolean;

package/dist/generator/domain/module-resolution.js

@@ -0,0 +1,23 @@
+/**
+ * Resolution primitive for cross-bounded-context relations
+ * (`generate-cross-bc-drizzle-relations`, design.md D3 "Resolution test",
+ * tasks.md group 4).
+ *
+ * A YAML declaration under `cliter/` is NOT evidence a relation's target
+ * exists: 12 of the 30 declared cross-BC references measured in T-4.1 have
+ * a YAML with no generated module at all. The only evidence that matters is
+ * whether the target's backend module has actually been generated — its
+ * `@app/<bc>/<module>/index.ts` barrel, the SAME barrel
+ * `buildBcRelationsModuleEntry`'s `importPath` names and
+ * `upsertBcRelationsFile`'s import anchor targets (HR-BARRELS-002). If that
+ * barrel is not on disk, upserting a cross-BC entry that imports its table
+ * symbol would produce a dangling import.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { toKebabCase } from '../utils/string-utils.js';
+/** Whether `boundedContextName`/`moduleName` has a generated backend module under `srcDir`. */
+export function isModuleGenerated(srcDir, boundedContextName, moduleName) {
+    const barrelPath = path.join(srcDir, '@app', toKebabCase(boundedContextName), toKebabCase(moduleName), 'index.ts');
+    return fs.existsSync(barrelPath);
+}

package/dist/generator/domain/operation-names.d.ts

@@ -0,0 +1,17 @@
+export interface StandardOperationNames {
+    opCreate: string;
+    opDelete: string;
+    opDeleteById: string;
+    opFind: string;
+    opFindById: string;
+    opGet: string;
+    opInsert: string;
+    opPaginate: string;
+    opUpdate: string;
+    opUpdateById: string;
+}
+export declare function getStandardOperationNames(schema: {
+    boundedContextName: string;
+    moduleName: string;
+    moduleNames: string;
+}): StandardOperationNames;

package/dist/generator/domain/operation-names.js

@@ -0,0 +1,27 @@
+/**
+ * The ten standard GraphQL operation names a module emits, derived from
+ * `boundedContextName`/`moduleName`/`moduleNames` with the SAME `<Bc><Op><Mod(s)>`
+ * PascalCase formula `__module_name__.graphql.ts.eta` spells out literally in its
+ * `gql` bodies. Extracted so the front-end operation-name collision guard
+ * (`validateOperationNameCollision`, `front.handler.ts`) and the template consume
+ * ONE derivation and cannot silently diverge (harden-generator-emission-contract,
+ * section 3).
+ */
+import { toPascalCase } from '../utils/string-utils.js';
+export function getStandardOperationNames(schema) {
+    const bcPascal = toPascalCase(schema.boundedContextName);
+    const modPascal = toPascalCase(schema.moduleName);
+    const modsPascal = toPascalCase(schema.moduleNames);
+    return {
+        opCreate: `${bcPascal}Create${modPascal}`,
+        opDelete: `${bcPascal}Delete${modsPascal}`,
+        opDeleteById: `${bcPascal}Delete${modPascal}ById`,
+        opFind: `${bcPascal}Find${modPascal}`,
+        opFindById: `${bcPascal}Find${modPascal}ById`,
+        opGet: `${bcPascal}Get${modsPascal}`,
+        opInsert: `${bcPascal}Create${modsPascal}`,
+        opPaginate: `${bcPascal}Paginate${modsPascal}`,
+        opUpdate: `${bcPascal}Update${modsPascal}`,
+        opUpdateById: `${bcPascal}Update${modPascal}ById`,
+    };
+}

package/dist/generator/domain/pivot.js

@@ -15,8 +15,8 @@ import { DELETED_AT_FIELD, TIMESTAMP_FIELDS } from './config.js';
 const SYSTEM_PROPERTY_NAMES = new Set([
     'id',
     'rowId',
-    ...TIMESTAMP_FIELDS,
     ...DELETED_AT_FIELD,
+    ...TIMESTAMP_FIELDS,
 ]);
 /**
  * Returns true iff the schema represents a pivot aggregate auto-derived from
@@ -57,11 +57,21 @@ export const getPivotFrontendExcludedFiles = (modKebab) => [
     `${modKebab}-form.component.ts`,
     `${modKebab}-form-embed.component.ts`,
     `${modKebab}-list-actions-cell.component.ts`,
+    // i18n translations cell: the pivot path builds its own excludedFiles and
+    // never goes through the main module's !hasI18nProperties gate — without
+    // this entry, generating any module with an m2m pivot writes an orphaned,
+    // unreferenced translations cell for the pivot (pivots have no list
+    // component and cannot be i18n).
+    `${modKebab}-list-translations-cell.component.ts`,
     `${modKebab}.columns.ts`,
     // Pivot's barrel re-exports `<mod>.columns`. With columns excluded, the
     // barrel would dangle (TS2305). Skip it entirely; nothing imports the
     // pivot's barrel (verified by grep).
     `index.ts`,
+    // The data-access leaf barrel re-exports `<mod>.resolvers`, which is excluded
+    // above. Emitting a barrel that references a non-emitted file would dangle
+    // (TS2307). Skip it for the same reason as the module index.ts.
+    `data-access/index.ts`,
     // Pivot resolvers are dead code: pivots have no standalone routes (no list /
     // detail components that consume a route resolver). The emitted resolvers
     // file imports `<mod>.columns` which is excluded above, so emitting it

package/dist/generator/domain/property-filters.d.ts

@@ -1,7 +1,10 @@
 import type { AdditionalApi, Property } from './model.js';
 export { getAdditionalApiFileName, getClassNameAdditionalApi, getResolverNameAdditionalApi, } from '../utils/additional-api.js';
 export { type ColumnSizing, getColumnSizingForProperty, } from './column-width.js';
+export { getDialogWidthClass } from './dialog-width.js';
 export { getDisplayField, getDisplayFieldExpr, getDisplayFieldFirstIdentifier, } from './display-field.js';
+export { getFormHtmlId } from './form-id.js';
+export { getStandardOperationNames, type StandardOperationNames, } from './operation-names.js';
 export { getPivotFrontendExcludedFiles, getPivotFrontendKeptFiles, isPivotAggregate, } from './pivot.js';
 /** Base filter: no timestamps, no one-to-many, no one-to-one without field */
 declare function baseWriteFilter(props: Property[]): Property[];
@@ -19,11 +22,18 @@ export declare const hasIndexProperties: (props: Property[]) => boolean;
 export declare const hasIndexI18nProperties: (props: Property[]) => boolean;
 export declare const hasPivotProperties: (props: Property[]) => boolean;
 export declare const hasCompositePrimaryKeys: (props: Property[]) => boolean;
-export declare const hasForeignKeyDecoratorProperties: (props: Property[]) => boolean;
-export declare const hasBelongsToManyDecoratorProperties: (props: Property[]) => boolean;
-export declare const hasHasManyDecoratorProperties: (props: Property[]) => boolean;
-export declare const hasHasOneDecoratorProperties: (props: Property[]) => boolean;
-export declare const hasBelongsToDecoratorProperties: (props: Property[]) => boolean;
+/**
+ * True when at least one property owns a physical FK column — many-to-one or
+ * one-to-one (successor of `hasForeignKeyDecoratorProperties`, which decided
+ * whether the Sequelize model imported the `ForeignKey` decorator). In
+ * Drizzle a FK is an inline `.references(...)` on the column itself, so this
+ * decides whether the schema template adds that modifier — no import needed.
+ */
+export declare const hasDrizzleForeignKeyColumnProperties: (props: Property[]) => boolean;
+export declare const hasDrizzleManyToManyRelationProperties: (props: Property[]) => boolean;
+export declare const hasDrizzleManyRelationProperties: (props: Property[]) => boolean;
+export declare const hasDrizzleOneRelationInverseProperties: (props: Property[]) => boolean;
+export declare const hasDrizzleOneRelationOwnerProperties: (props: Property[]) => boolean;
 export declare const getI18nProperties: (props: Property[]) => Property[];
 export declare const getNotI18nProperties: (props: Property[]) => Property[];
 export declare const getEnumProperties: (props: Property[]) => Property[];
@@ -146,6 +156,59 @@ export declare function getAdditionalApiQueries(apis: AdditionalApi[]): Addition
 export declare function getAdditionalApiMutations(apis: AdditionalApi[]): AdditionalApi[];
 export declare function hasAdditionalApiQueries(apis: AdditionalApi[]): boolean;
 export declare function hasAdditionalApiMutations(apis: AdditionalApi[]): boolean;
+/**
+ * Returns true when the given operation is listed in the schema's
+ * `excludedOperations` array. Handles a missing or empty array gracefully.
+ *
+ * Templates call: it.filters.isOperationExcluded(it.schema, 'delete')
+ */
+export declare function isOperationExcluded(schema: {
+    excludedOperations?: string[];
+}, operation: string): boolean;
+/**
+ * Suffix-match a bare file name against the module's excludedFiles list.
+ * Returns true when the file is NOT excluded (i.e. it SHALL be emitted /
+ * re-exported). Mirrors the endsWith semantics of isFilePathAllowed, but takes a
+ * bare file name (e.g. 'user-detail.component.ts') because frontend barrel
+ * templates only know the bare name, not the full repo-relative path.
+ *
+ * The anchor `endsWith('/' + fileName)` prevents false positives between names
+ * where one is a textual suffix of another (e.g. 'list.component.ts' vs
+ * 'user-list.component.ts').
+ *
+ * Templates call: it.filters.isAllowFile('user-detail.component.ts', it.schema.excludedFiles)
+ */
+export declare function isAllowFile(fileName: string, excludedFiles?: string[]): boolean;
+/**
+ * Whether `<mod>-form.component.ts` is emitted for this module — the ONE
+ * shared predicate BOTH the file emitter (`front.handler.ts`, which folds
+ * this into `options.excludedFiles` before the template walk) and the
+ * features barrel (`features/index.ts.eta`) must consume, so the two can
+ * never disagree again.
+ *
+ * Measured divergence (harden-generator-emission-contract, section 5
+ * follow-up #7 amendment): the follow-up added the dialog/create/updateById
+ * condition below to the file emitter ONLY. The barrel kept calling
+ * `isAllowFile` directly, which only sees the module's own declared
+ * `excludedFiles` — so a dialog-mode module with both `create` and
+ * `updateById` excluded got a barrel that `export * from` a file the
+ * generator never wrote, breaking the frontend build.
+ *
+ * `<mod>-form.component.ts` is NOT emitted when:
+ *  - it appears in the module's own `excludedFiles` (author opted out); OR
+ *  - `front.detailMode: dialog` AND both `create` and `updateById` are
+ *    excluded — no affordance is left to open the dialog the form would
+ *    have been embedded in (mirrors the list template's `dialogEmitted`
+ *    derivation).
+ */
+export declare function isFormComponentEmitted(schema: {
+    excludedFiles?: string[];
+    excludedOperations?: string[];
+    front?: {
+        detailMode?: string;
+    };
+    moduleName: string;
+}): boolean;
 /**
  * Unified path exclusion check for templates.
  * Evaluates both `excludedFiles` and `excludedOperations` from the schema.

package/dist/generator/domain/property-filters.js

@@ -7,13 +7,16 @@
  */
 import { v4 as uuidv4, v5 as uuidv5 } from 'uuid';
 import { isPathAllowedByExclusions } from '../utils/path-allowed.js';
-import { toCamelCase } from '../utils/string-utils.js';
-import { DELETED_AT_FIELD, TIMESTAMP_FIELDS } from './config.js';
-import { hasBelongsToDecorator, hasBelongsToManyDecorator, hasColumnDecorator, hasHasManyDecorator, hasHasOneDecorator, isPivot, } from './property-predicates.js';
+import { toCamelCase, toKebabCase } from '../utils/string-utils.js';
+import { DELETED_AT_FIELD, DETAIL_MODE, TIMESTAMP_FIELDS } from './config.js';
+import { isDrizzleColumn, isDrizzleManyRelation, isDrizzleManyToManyRelation, isDrizzleOneRelationInverse, isDrizzleOneRelationOwner, isPivot, isReadonly, isSecretProperty, } from './property-predicates.js';
 import { WidgetType } from './widget-type.js';
 export { getAdditionalApiFileName, getClassNameAdditionalApi, getResolverNameAdditionalApi, } from '../utils/additional-api.js';
 export { getColumnSizingForProperty, } from './column-width.js';
+export { getDialogWidthClass } from './dialog-width.js';
 export { getDisplayField, getDisplayFieldExpr, getDisplayFieldFirstIdentifier, } from './display-field.js';
+export { getFormHtmlId } from './form-id.js';
+export { getStandardOperationNames, } from './operation-names.js';
 export { getPivotFrontendExcludedFiles, getPivotFrontendKeptFiles, isPivotAggregate, } from './pivot.js';
 const excludeTimestamps = (p) => !TIMESTAMP_FIELDS.includes(p.name);
 const excludeDeletedAt = (p) => !DELETED_AT_FIELD.includes(p.name);
@@ -59,12 +62,19 @@ export const hasIndexProperties = (props) => props?.some((p) => (p.index === 'in
 export const hasIndexI18nProperties = (props) => props?.some((p) => (p.index === 'index' || p.index === 'unique') && p.isI18n);
 export const hasPivotProperties = (props) => props?.some(isPivot);
 export const hasCompositePrimaryKeys = (props) => props.filter((p) => p.primaryKey).length > 1;
-export const hasForeignKeyDecoratorProperties = (props) => props?.some((p) => (hasColumnDecorator(p) && p.relationship?.type === 'one-to-one') ||
-    (hasColumnDecorator(p) && p.relationship?.type === 'many-to-one'));
-export const hasBelongsToManyDecoratorProperties = (props) => props?.some(hasBelongsToManyDecorator);
-export const hasHasManyDecoratorProperties = (props) => props?.some(hasHasManyDecorator);
-export const hasHasOneDecoratorProperties = (props) => props?.some(hasHasOneDecorator);
-export const hasBelongsToDecoratorProperties = (props) => props?.some(hasBelongsToDecorator);
+/**
+ * True when at least one property owns a physical FK column — many-to-one or
+ * one-to-one (successor of `hasForeignKeyDecoratorProperties`, which decided
+ * whether the Sequelize model imported the `ForeignKey` decorator). In
+ * Drizzle a FK is an inline `.references(...)` on the column itself, so this
+ * decides whether the schema template adds that modifier — no import needed.
+ */
+export const hasDrizzleForeignKeyColumnProperties = (props) => props?.some((p) => (isDrizzleColumn(p) && p.relationship?.type === 'one-to-one') ||
+    (isDrizzleColumn(p) && p.relationship?.type === 'many-to-one'));
+export const hasDrizzleManyToManyRelationProperties = (props) => props?.some(isDrizzleManyToManyRelation);
+export const hasDrizzleManyRelationProperties = (props) => props?.some(isDrizzleManyRelation);
+export const hasDrizzleOneRelationInverseProperties = (props) => props?.some(isDrizzleOneRelationInverse);
+export const hasDrizzleOneRelationOwnerProperties = (props) => props?.some(isDrizzleOneRelationOwner);
 export const getI18nProperties = (props) => props?.filter((p) => p.isI18n);
 export const getNotI18nProperties = (props) => props?.filter((p) => !p.isI18n);
 export const getEnumProperties = (props) => props?.filter((p) => p.type === 'enum' ||
@@ -78,7 +88,12 @@ export const getIntegerProperties = (props) => props?.filter((p) => p.type === '
 export const getIntegerUnsignedProperties = (props) => props?.filter((p) => p.type === 'int' && p.unsigned);
 export const getMaxLengthProperties = (props) => props?.filter((p) => Boolean(p.maxLength));
 export const getMinLengthProperties = (props) => props?.filter((p) => Boolean(p.minLength));
-export const getIndexesProperties = (props) => props?.filter((p) => p.index);
+// isI18n columns never live on the base table under `i18nStrategy: 'table'`
+// (they move to the `<agg>_i18n` companion table) — an index built from this
+// list feeds the BASE table's Drizzle schema, so it must exclude them the
+// same way `hasIndexProperties` already does, or the emitted index references
+// a column that doesn't exist on that table.
+export const getIndexesProperties = (props) => props?.filter((p) => p.index && !p.isI18n);
 export const getPrimaryKeyProperties = (props) => props
     ?.filter((p) => p.primaryKey)
     .filter((p, i, arr) => arr.findIndex((o) => o.name === p.name) === i);
@@ -181,6 +196,8 @@ export const getFormDetailFieldsProperties = (props) => props
     .filter((p) => p.name !== 'id')
     .filter((p) => p.name !== 'rowId')
     .filter((p) => !p.widget?.isDetailHidden)
+    .filter((p) => !isSecretProperty(p))
+    .filter((p) => !isReadonly(p))
     .sort((a, b) => {
     const va = a.widget?.detailSort ?? Number.POSITIVE_INFINITY;
     const vb = b.widget?.detailSort ?? Number.POSITIVE_INFINITY;
@@ -221,7 +238,9 @@ export const hasFormTabsProperties = (props) => getTabsFromProperties(props).len
 export const getFormGroupFieldsProperties = (props) => props
     ?.filter((p) => excludeTimestamps(p))
     .filter((p) => excludeOneToOneWithoutField(p))
-    .filter((p) => p.name !== 'availableLangs' && p.name !== 'rowId' && p.name !== 'meta');
+    .filter((p) => p.name !== 'availableLangs' && p.name !== 'rowId' && p.name !== 'meta')
+    .filter((p) => !isSecretProperty(p))
+    .filter((p) => !isReadonly(p));
 export const getFormGroupFieldsIsNotI18nProperties = (props) => getFormGroupFieldsProperties(props).filter((p) => !p.isI18n);
 const byWidget = (type) => (props) => props?.filter((p) => p.widget?.type === type);
 export const getSelectWidgetsProperties = byWidget(WidgetType.SELECT);
@@ -277,6 +296,9 @@ function getPropertyImports(p) {
         case 'date': {
             return ['MatDatepickerModule'];
         }
+        case 'dateTime': {
+            return ['AuDatetimePickerComponent'];
+        }
         case 'enum': {
             return ['MatSelectModule'];
         }
@@ -287,7 +309,8 @@ function getPropertyImports(p) {
             return getRelationshipPropertyImports(p);
         }
         case 'timestamp': {
-            return ['MtxDatetimepickerModule'];
+            // timestamp is now a numeric epoch — no date/time picker import needed.
+            return [];
         }
         default: {
             return [];
@@ -350,6 +373,68 @@ export function hasAdditionalApiQueries(apis) {
 export function hasAdditionalApiMutations(apis) {
     return getAdditionalApiMutations(apis).length > 0;
 }
+/**
+ * Returns true when the given operation is listed in the schema's
+ * `excludedOperations` array. Handles a missing or empty array gracefully.
+ *
+ * Templates call: it.filters.isOperationExcluded(it.schema, 'delete')
+ */
+export function isOperationExcluded(schema, operation) {
+    return (schema.excludedOperations ?? []).includes(operation);
+}
+/**
+ * Suffix-match a bare file name against the module's excludedFiles list.
+ * Returns true when the file is NOT excluded (i.e. it SHALL be emitted /
+ * re-exported). Mirrors the endsWith semantics of isFilePathAllowed, but takes a
+ * bare file name (e.g. 'user-detail.component.ts') because frontend barrel
+ * templates only know the bare name, not the full repo-relative path.
+ *
+ * The anchor `endsWith('/' + fileName)` prevents false positives between names
+ * where one is a textual suffix of another (e.g. 'list.component.ts' vs
+ * 'user-list.component.ts').
+ *
+ * Templates call: it.filters.isAllowFile('user-detail.component.ts', it.schema.excludedFiles)
+ */
+export function isAllowFile(fileName, excludedFiles) {
+    if (!excludedFiles || excludedFiles.length === 0)
+        return true;
+    return !excludedFiles.some((excluded) => excluded === fileName || excluded.endsWith(`/${fileName}`));
+}
+/**
+ * Whether `<mod>-form.component.ts` is emitted for this module — the ONE
+ * shared predicate BOTH the file emitter (`front.handler.ts`, which folds
+ * this into `options.excludedFiles` before the template walk) and the
+ * features barrel (`features/index.ts.eta`) must consume, so the two can
+ * never disagree again.
+ *
+ * Measured divergence (harden-generator-emission-contract, section 5
+ * follow-up #7 amendment): the follow-up added the dialog/create/updateById
+ * condition below to the file emitter ONLY. The barrel kept calling
+ * `isAllowFile` directly, which only sees the module's own declared
+ * `excludedFiles` — so a dialog-mode module with both `create` and
+ * `updateById` excluded got a barrel that `export * from` a file the
+ * generator never wrote, breaking the frontend build.
+ *
+ * `<mod>-form.component.ts` is NOT emitted when:
+ *  - it appears in the module's own `excludedFiles` (author opted out); OR
+ *  - `front.detailMode: dialog` AND both `create` and `updateById` are
+ *    excluded — no affordance is left to open the dialog the form would
+ *    have been embedded in (mirrors the list template's `dialogEmitted`
+ *    derivation).
+ */
+export function isFormComponentEmitted(schema) {
+    const modKebab = toKebabCase(schema.moduleName);
+    if (!isAllowFile(`${modKebab}-form.component.ts`, schema.excludedFiles)) {
+        return false;
+    }
+    if (schema.front?.detailMode === DETAIL_MODE.DIALOG) {
+        const createExcluded = isOperationExcluded(schema, 'create');
+        const updateByIdExcluded = isOperationExcluded(schema, 'updateById');
+        if (createExcluded && updateByIdExcluded)
+            return false;
+    }
+    return true;
+}
 /**
  * Unified path exclusion check for templates.
  * Evaluates both `excludedFiles` and `excludedOperations` from the schema.

package/dist/generator/domain/property-mappers.d.ts

@@ -32,7 +32,8 @@ export declare function getEnumUnionLiteralType(property: Property): string;
 export declare function getReferenceKey(property: Property): string;
 /** Get the default value for a property, formatted for code output. */
 export declare function getDefaultValue(property: Property): unknown;
-export declare function getSequelizeType(property: Property): string;
+/** Drizzle `pgTable` column builder expression for a property (successor of `getSequelizeType`). */
+export declare function getDrizzleColumn(property: Property): string;
 export declare function getJavascriptType(property: Property): string;
 export declare function getJavascriptModelType(property: Property): string;
 declare function getJavascriptCrudType(property: Property): string;
@@ -68,19 +69,51 @@ export declare function getGenderKeyFromPropertyRelationship(modulePath: string)
 export declare function getPropertiesFromPropertyRelationship(modulePath: string): null | Property[];
 /** Get full schema from a relationship modulePath. */
 export declare function getSchemaFromPropertyRelationship(modulePath: string): ModuleDefinitionSchema | null;
+/**
+ * Same as {@link getSchemaFromPropertyRelationship}, but THROWS a clear,
+ * actionable error instead of swallowing the load failure into `null`.
+ *
+ * Reserved for call sites where a missing/malformed related schema MUST fail
+ * loudly at render time — e.g. a template that then does
+ * `for (const p of relatedSchema.aggregateProperties)` on the result. Letting
+ * `null`/`undefined` flow into a `for...of` produces an opaque
+ * `TypeError: undefined is not iterable`, which names neither the offending
+ * relationship nor the modulePath that failed to resolve. This wraps
+ * `parseBoundedContextModule`/`loadSchema`'s own error (e.g. "Schema file not
+ * found: <path>") with the raw `modulePath` string (exactly as declared in
+ * the YAML, forward-slash form, OS-independent) so the message is greppable
+ * regardless of which of the two underlying calls failed.
+ */
+export declare function requireSchemaFromPropertyRelationship(modulePath: string): ModuleDefinitionSchema;
 /** CSS column class for a form group field based on property type/length. */
 export declare function calculateFormGroupCol(property: Property): string;
-/** Whether a property should be rendered (filters out internal i18n fields, etc.). */
+/**
+ * Whether a property should be rendered (filters out internal i18n fields,
+ * etc.).
+ *
+ * `i18nStrategy` (design.md D6, add-i18n-table-codegen change, group 3)
+ * gates which allow-rule an `isI18n: true` property follows:
+ * - `embedded` (default — matches `schema.i18nStrategy ?? 'embedded'`
+ *   elsewhere, e.g. `handler-utils.ts`'s `buildOptions`): the field persists
+ *   as the derived per-locale jsonb map on the PARENT row, so it is always
+ *   allowed except for the reserved structural names below.
+ * - `table`: the field is a plain scalar COLUMN on the companion table
+ *   (design.md D1/D3), written/read via `Content-Language` — it behaves like
+ *   ANY other property for allow-purposes, so it falls through to the
+ *   generic autoIncrement/readonly/relationship checks instead of the
+ *   embedded-only early return.
+ */
 export declare function isAllowProperty(moduleName: string, property: Property, options?: {
     allowAutoIncrement?: boolean;
     allowManyToManyRelationShip?: boolean;
     allowOneToManyRelationShip?: boolean;
     allowReadonly?: boolean;
+    i18nStrategy?: 'embedded' | 'table';
 }): boolean;
 /** Returns 'I18n' (or 'i18n-' when `kebab`) if the property is i18n, otherwise empty string. */
 export declare function addI18nPropertySignature(property: Property, kebab?: boolean): string;
-/** Wrapper for getSequelizeType that accepts an optional config argument (ignored). */
-export declare function getPropertySequelizeType(property: Property, _config?: unknown): string;
+/** Wrapper for getDrizzleColumn that accepts an optional config argument (ignored). */
+export declare function getPropertyDrizzleColumn(property: Property, _config?: unknown): string;
 export type FieldSchemaEntry = {
     cardinality: 'many' | 'one';
     kind: 'relation';
@@ -94,12 +127,41 @@ export type FieldSchemaEntry = {
     maxLength?: number;
     name: string;
     nullable?: boolean;
+    readonly?: boolean;
     rules?: {
         minLength: number;
+        translationKey?: string;
     };
     type: string;
 };
-export declare function buildFieldSchemaEntries(properties: Property[]): FieldSchemaEntry[];
+/**
+ * `i18nStrategy` (design.md D6, add-i18n-table-codegen change, group 3)
+ * defaults to `'embedded'` — matching `schema.i18nStrategy ?? 'embedded'`
+ * elsewhere (e.g. `handler-utils.ts`'s `buildOptions`) — so every existing
+ * caller that doesn't pass it keeps the pre-existing jsonb-map behaviour for
+ * `isI18n: true` properties. Under `'table'`, those properties are plain
+ * scalar columns on the companion table (design.md D1) and are typed/named
+ * exactly like any other scalar entry.
+ */
+/**
+ * Owning-schema identity needed to derive the i18n `translationKey` of the
+ * required-many-to-many sibling entry (design.md D2/D4) — NOT carried by
+ * `Property` itself (`prop.aggregateName` is optional and unset by the
+ * schema-loader for top-level properties; see resolveFieldName's fallback).
+ * Callers that never emit a required-m2m sibling (e.g. existing unit tests
+ * asserting the `relation`-only shape) can omit this — the sibling branch
+ * simply doesn't fire without a `nullable === false` many-to-many property.
+ *
+ * `moduleName` (NOT `aggregateName`) is the segment that goes into the key —
+ * revised post-Judgment-Day round 1 (F3, user-approved): matches the
+ * hand-written production precedent and avoids duplicating the bounded
+ * context, which is already present via `boundedContextName`.
+ */
+export interface FieldSchemaOwnerContext {
+    boundedContextName?: string;
+    moduleName?: string;
+}
+export declare function buildFieldSchemaEntries(properties: Property[], i18nStrategy?: 'embedded' | 'table', owner?: FieldSchemaOwnerContext): FieldSchemaEntry[];
 export declare function buildFieldSchemaImports(entries: FieldSchemaEntry[]): ImportStatement[];
 export declare const getDefaultValueProperty: typeof getDefaultValue;
 export declare const getDtoTypeProperty: typeof getDtoType;