@aurorajs.dev/catalyst-cli 1.0.0

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

@@ -0,0 +1,44 @@
+/** Boolean predicates for individual properties. */
+import type { Property } from './model.js';
+export declare const isRelationship: (p: Property) => boolean;
+export declare const isOneToMany: (p: Property) => boolean;
+export declare const isManyToOne: (p: Property) => boolean;
+export declare const isManyToMany: (p: Property) => boolean;
+export declare const isOneToOne: (p: Property) => boolean;
+export declare const isPrimaryKey: (p: Property) => boolean;
+export declare const isNullable: (p: Property) => boolean;
+export declare const isAutoIncrement: (p: Property) => boolean;
+export declare const isReadonly: (p: Property) => boolean;
+export declare const isI18n: (p: Property) => boolean;
+export declare const isPivot: (p: Property) => boolean;
+export declare const isBinary: (p: Property) => boolean;
+export declare const isTimezone: (p: Property) => boolean;
+export declare const isUnaccent: (p: Property) => boolean;
+export declare const hasQuotation: (p: Property) => boolean;
+/** Property maps to a @Column in Sequelize. */
+export declare const hasColumnDecorator: (p: Property) => boolean;
+/** Property maps to a @HasOne decorator. */
+export declare const hasHasOneDecorator: (p: Property) => boolean;
+/** Property maps to a @BelongsTo decorator. */
+export declare const hasBelongsToDecorator: (p: Property) => boolean;
+/** Property maps to a @HasMany decorator. */
+export declare const hasHasManyDecorator: (p: Property) => boolean;
+/** Property maps to a @BelongsToMany decorator. */
+export declare const hasBelongsToManyDecorator: (p: Property) => boolean;
+export declare const hasBelongsToDecoratorProperty: (p: Property) => boolean;
+export declare const hasBelongsToManyDecoratorProperty: (p: Property) => boolean;
+export declare const hasColumnDecoratorProperty: (p: Property) => boolean;
+export declare const hasHasManyDecoratorProperty: (p: Property) => boolean;
+export declare const hasHasOneDecoratorProperty: (p: Property) => boolean;
+export declare const hasQuotationProperty: (p: Property) => boolean;
+export declare const isBinaryProperty: (p: Property) => boolean;
+export declare const isI18nAvailableLangsProperty: (prop: Property, _aggregateProperties?: Property[]) => boolean;
+export declare const isI18nRelationProperty: (_moduleNameOrProp: Property | string, propOrUndef?: Property) => boolean;
+export declare const isManyToManyRelationshipProperty: (p: Property) => boolean;
+export declare const isManyToOneRelationshipProperty: (p: Property) => boolean;
+export declare const isPivotProperty: (p: Property) => boolean;
+export declare const isPrimaryKeyProperty: (p: Property) => boolean;
+export declare const isTimezoneProperty: (p: Property) => boolean;
+export declare const isUnaccentProperty: (p: Property) => boolean;
+export { hasBelongsToDecoratorProperties, hasBelongsToManyDecoratorProperties, hasCompositePrimaryKeys, hasEnumProperties, hasForeignKeyDecoratorProperties, hasHasManyDecoratorProperties, hasHasOneDecoratorProperties, hasI18nProperties, hasIndexProperties, hasPivotProperties, } from './property-filters.js';
+export { isAllowProperty } from './property-mappers.js';

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

@@ -0,0 +1,54 @@
+/** Boolean predicates for individual properties. */
+import { QUOTATION_TYPES, UNACCENT_MAP } from './config.js';
+export const isRelationship = (p) => p.type === 'relationship';
+export const isOneToMany = (p) => p.relationship?.type === 'one-to-many';
+export const isManyToOne = (p) => p.relationship?.type === 'many-to-one';
+export const isManyToMany = (p) => p.relationship?.type === 'many-to-many';
+export const isOneToOne = (p) => p.relationship?.type === 'one-to-one';
+export const isPrimaryKey = (p) => Boolean(p.primaryKey);
+export const isNullable = (p) => Boolean(p.nullable);
+export const isAutoIncrement = (p) => Boolean(p.autoIncrement);
+export const isReadonly = (p) => Boolean(p.readonly);
+export const isI18n = (p) => Boolean(p.isI18n);
+export const isPivot = (p) => Boolean(p.aggregateName && p.modulePath);
+export const isBinary = (p) => p.type === 'blob' || p.type === 'blob.medium' || p.type === 'blob.long';
+export const isTimezone = (p) => {
+    if (p.applyTimezone === false)
+        return false;
+    return p.type === 'timestamp';
+};
+export const isUnaccent = (p) => UNACCENT_MAP[p.type] ?? false;
+export const hasQuotation = (p) => QUOTATION_TYPES[p.type] ?? false;
+/** Property maps to a @Column in Sequelize. */
+export const hasColumnDecorator = (p) => p.relationship?.type !== 'one-to-many' &&
+    p.relationship?.type !== 'many-to-many' &&
+    !(p.relationship?.type === 'one-to-one' && !p.relationship.field);
+/** Property maps to a @HasOne decorator. */
+export const hasHasOneDecorator = (p) => p.relationship?.type === 'one-to-one' && !p.relationship.field;
+/** Property maps to a @BelongsTo decorator. */
+export const hasBelongsToDecorator = (p) => (p.relationship?.type === 'many-to-one' && Boolean(p.relationship.field)) ||
+    (p.relationship?.type === 'one-to-one' && Boolean(p.relationship?.field));
+/** Property maps to a @HasMany decorator. */
+export const hasHasManyDecorator = (p) => p.relationship?.type === 'one-to-many';
+/** Property maps to a @BelongsToMany decorator. */
+export const hasBelongsToManyDecorator = (p) => p.relationship?.type === 'many-to-many';
+export const hasBelongsToDecoratorProperty = hasBelongsToDecorator;
+export const hasBelongsToManyDecoratorProperty = hasBelongsToManyDecorator;
+export const hasColumnDecoratorProperty = hasColumnDecorator;
+export const hasHasManyDecoratorProperty = hasHasManyDecorator;
+export const hasHasOneDecoratorProperty = hasHasOneDecorator;
+export const hasQuotationProperty = hasQuotation;
+export const isBinaryProperty = isBinary;
+export const isI18nAvailableLangsProperty = (prop, _aggregateProperties) => prop.name === 'availableLangs' && prop.isI18n === true;
+export const isI18nRelationProperty = (_moduleNameOrProp, propOrUndef) => {
+    const prop = typeof _moduleNameOrProp === 'string' ? propOrUndef : _moduleNameOrProp;
+    return prop.isI18n === true;
+};
+export const isManyToManyRelationshipProperty = isManyToMany;
+export const isManyToOneRelationshipProperty = isManyToOne;
+export const isPivotProperty = isPivot;
+export const isPrimaryKeyProperty = isPrimaryKey;
+export const isTimezoneProperty = isTimezone;
+export const isUnaccentProperty = isUnaccent;
+export { hasBelongsToDecoratorProperties, hasBelongsToManyDecoratorProperties, hasCompositePrimaryKeys, hasEnumProperties, hasForeignKeyDecoratorProperties, hasHasManyDecoratorProperties, hasHasOneDecoratorProperties, hasI18nProperties, hasIndexProperties, hasPivotProperties, } from './property-filters.js';
+export { isAllowProperty } from './property-mappers.js';

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

@@ -0,0 +1,17 @@
+/**
+ * Angular ReactiveForms validator generation from Property metadata.
+ * Each helper returns stringified validator expressions ready to emit verbatim.
+ */
+import type { Property } from './model.js';
+/**
+ * Build the list of Angular `Validators.*` expressions for the generated form control.
+ *
+ * Primary-key ids (`type === 'id'` with no `widget`) are opaque and never editable — they
+ * skip validators entirely. In `new` mode `useGraphqlCreate` auto-generates the UUID; in
+ * `edit` mode the id comes intact from the resolver. Validators here would only fight
+ * the framework.
+ *
+ * Foreign-key ids (`type === 'id'` WITH a `widget`, e.g. `select` / `grid-select-element`
+ * since SPEC-09) ARE user-editable, so they get the normal validators.
+ */
+export declare function getValidators(property: Property): string[];

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

@@ -0,0 +1,42 @@
+/**
+ * Angular ReactiveForms validator generation from Property metadata.
+ * Each helper returns stringified validator expressions ready to emit verbatim.
+ */
+/**
+ * Build the list of Angular `Validators.*` expressions for the generated form control.
+ *
+ * Primary-key ids (`type === 'id'` with no `widget`) are opaque and never editable — they
+ * skip validators entirely. In `new` mode `useGraphqlCreate` auto-generates the UUID; in
+ * `edit` mode the id comes intact from the resolver. Validators here would only fight
+ * the framework.
+ *
+ * Foreign-key ids (`type === 'id'` WITH a `widget`, e.g. `select` / `grid-select-element`
+ * since SPEC-09) ARE user-editable, so they get the normal validators.
+ */
+export function getValidators(property) {
+    if (property.type === 'id' && !property.widget)
+        return [];
+    // Many-to-many relationship — FormControl holds `string[]` of FK ids.
+    // Non-nullable means "at least one selection"; Angular's built-in
+    // `Validators.required` rejects null but accepts `[]`, so pair it with
+    // `arrayMinLengthValidator(1)` (hand-authored in @aurora/validators).
+    if (property.relationship?.type === 'many-to-many') {
+        return property.nullable
+            ? []
+            : ['Validators.required', 'arrayMinLengthValidator(1)'];
+    }
+    const validators = [];
+    if (!property.nullable && property.type !== 'boolean') {
+        validators.push('Validators.required');
+    }
+    if (property.maxLength) {
+        validators.push(`Validators.maxLength(${property.maxLength})`);
+    }
+    if (property.minLength) {
+        validators.push(`Validators.minLength(${property.minLength})`);
+    }
+    if (property.length !== undefined && property.length > 0) {
+        validators.push(`Validators.minLength(${property.length})`, `Validators.maxLength(${property.length})`);
+    }
+    return validators;
+}

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

@@ -0,0 +1,26 @@
+/**
+ * SPEC-14 form field width helpers.
+ * Uniform 12-column grid (`grid-cols-1 md:grid-cols-12`); no tiers.
+ * `getDefaultSpan` returns 1..12; `resolveFieldSpan` honors `widget.span` when declared;
+ * `applyAutoExpand` expands the last field of any incomplete final row per container.
+ */
+import type { Property } from './model.js';
+/**
+ * Default column span for a property when no `widget.span` override is
+ * declared. The table is type-based; `maxLength` is consulted ONLY for
+ * `varchar` (the one type where character length is a useful proxy of
+ * typical UI width).
+ */
+export declare function getDefaultSpan(property: Property): number;
+/**
+ * Resolves final desktop span: honors `widget.span` when declared, else `getDefaultSpan`.
+ * Out-of-range overrides are clamped to [1, 12] with a `console.warn` (defense in depth — the
+ * JSON schema also validates the range, but this catches pre-schema YAMLs and custom loaders).
+ */
+export declare function resolveFieldSpan(property: Property): number;
+/**
+ * Auto-expand pass for one container (form, group, or tab). Walks left-to-right tracking a row
+ * accumulator, wraps on overflow, and expands the last field to fill any incomplete final row.
+ * Pure — invoked once per container, returns a new array of the same length.
+ */
+export declare function applyAutoExpand(spans: number[]): number[];

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

@@ -0,0 +1,117 @@
+/**
+ * SPEC-14 form field width helpers.
+ * Uniform 12-column grid (`grid-cols-1 md:grid-cols-12`); no tiers.
+ * `getDefaultSpan` returns 1..12; `resolveFieldSpan` honors `widget.span` when declared;
+ * `applyAutoExpand` expands the last field of any incomplete final row per container.
+ */
+import { WidgetType } from './widget-type.js';
+const MIN_SPAN = 1;
+const MAX_SPAN = 12;
+/**
+ * Default column span for a property when no `widget.span` override is
+ * declared. The table is type-based; `maxLength` is consulted ONLY for
+ * `varchar` (the one type where character length is a useful proxy of
+ * typical UI width).
+ */
+export function getDefaultSpan(property) {
+    // Relational widgets — dispatched in form-body.eta — have their own
+    // sizing intent that overrides the underlying primitive type.
+    const widgetType = property.widget?.type;
+    if (widgetType === WidgetType.GRID_SELECT_ELEMENT)
+        return 12;
+    if (widgetType === WidgetType.GRID_SELECT_MULTIPLE_ELEMENTS)
+        return 12;
+    if (widgetType === WidgetType.ASYNC_SEARCH_SELECT)
+        return 6;
+    if (widgetType === WidgetType.SELECT || widgetType === WidgetType.MULTIPLE_SELECT)
+        return 4;
+    switch (property.type) {
+        case 'array': {
+            if (property.arrayOptions?.type === 'enum') {
+                const optionCount = property.arrayOptions.enumOptions?.length ?? 0;
+                return optionCount > 5 ? 4 : 3;
+            }
+            return 12;
+        }
+        case 'bigint':
+        case 'decimal':
+        case 'float':
+        case 'int':
+        case 'smallint': {
+            return 4;
+        }
+        case 'boolean':
+        case 'date':
+        case 'timestamp': {
+            return 3;
+        }
+        case 'char':
+        case 'varchar': {
+            const maxLen = property.maxLength ?? property.length;
+            if (maxLen === undefined || maxLen > 80)
+                return 12;
+            if (maxLen <= 30)
+                return 4;
+            return 6;
+        }
+        case 'enum': {
+            const optionCount = property.enumOptions?.length ?? 0;
+            return optionCount > 5 ? 4 : 3;
+        }
+        case 'id': {
+            // FK with a relational widget is handled above; bare id without widget
+            // is not rendered (filtered by form-body.eta) — defensive default.
+            return 4;
+        }
+        case 'password': {
+            return 6;
+        }
+        case 'text': {
+            return 12;
+        }
+        default: {
+            return 12;
+        }
+    }
+}
+/**
+ * Resolves final desktop span: honors `widget.span` when declared, else `getDefaultSpan`.
+ * Out-of-range overrides are clamped to [1, 12] with a `console.warn` (defense in depth — the
+ * JSON schema also validates the range, but this catches pre-schema YAMLs and custom loaders).
+ */
+export function resolveFieldSpan(property) {
+    const explicit = property.widget?.span;
+    if (typeof explicit === 'number') {
+        if (explicit < MIN_SPAN || explicit > MAX_SPAN) {
+            console.warn(`[SPEC-14] widget.span out of range for property '${property.name}': ${explicit}. Clamping to [${MIN_SPAN}, ${MAX_SPAN}].`);
+            return Math.max(MIN_SPAN, Math.min(MAX_SPAN, explicit));
+        }
+        return explicit;
+    }
+    return getDefaultSpan(property);
+}
+/**
+ * Auto-expand pass for one container (form, group, or tab). Walks left-to-right tracking a row
+ * accumulator, wraps on overflow, and expands the last field to fill any incomplete final row.
+ * Pure — invoked once per container, returns a new array of the same length.
+ */
+export function applyAutoExpand(spans) {
+    if (spans.length === 0)
+        return [];
+    const result = [...spans];
+    let rowAcc = 0;
+    for (const span of spans) {
+        if (rowAcc + span > MAX_SPAN)
+            rowAcc = 0; // wrap to a fresh row
+        rowAcc += span;
+        if (rowAcc === MAX_SPAN)
+            rowAcc = 0; // row exactly full → reset for next
+    }
+    // Final row incomplete? Expand the last field to fill the remainder.
+    if (rowAcc > 0 && rowAcc < MAX_SPAN) {
+        const lastIdx = spans.length - 1;
+        const remaining = MAX_SPAN - (rowAcc - result[lastIdx]);
+        result[lastIdx] = remaining;
+    }
+    return result;
+}

package/dist/generator/domain/schema-loader.d.ts

@@ -0,0 +1,13 @@
+/** Loads and validates module definition schemas from YAML files. */
+import type { ModuleDefinitionSchema } from './model.js';
+/**
+ * Load a module definition schema from a YAML file.
+ *
+ * Expected path: `{cwd}/cliter/{boundedContext}/{moduleName}.aurora.yaml`
+ */
+export declare function loadSchema(boundedContextName: string, moduleName: string, cwd?: string): ModuleDefinitionSchema;
+export declare function saveSchema(schema: ModuleDefinitionSchema, cwd?: string): void;
+export declare function parseBoundedContextModule(input: string): {
+    boundedContextName: string;
+    moduleName: string;
+};

package/dist/generator/domain/schema-loader.js

@@ -0,0 +1,144 @@
+/** Loads and validates module definition schemas from YAML files. */
+import fs from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
+import { DETAIL_MODE, GENDER, SCHEMA_DEFINITION_EXTENSION } from './config.js';
+/**
+ * Load a module definition schema from a YAML file.
+ *
+ * Expected path: `{cwd}/cliter/{boundedContext}/{moduleName}.aurora.yaml`
+ */
+export function loadSchema(boundedContextName, moduleName, cwd = process.cwd()) {
+    const yamlPath = path.join(cwd, 'cliter', boundedContextName, moduleName + SCHEMA_DEFINITION_EXTENSION);
+    if (!fs.existsSync(yamlPath)) {
+        throw new Error(`Schema file not found: ${yamlPath}`);
+    }
+    const raw = fs.readFileSync(yamlPath, 'utf8');
+    const parsed = YAML.parse(raw);
+    validateSchema(parsed);
+    return addDefaults(parsed);
+}
+export function saveSchema(schema, cwd = process.cwd()) {
+    const dir = path.join(cwd, 'cliter', schema.boundedContextName);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const yamlStr = YAML.stringify(stripDefaults(schema), {
+        lineWidth: 0,
+    });
+    fs.writeFileSync(path.join(dir, `${schema.moduleName}${SCHEMA_DEFINITION_EXTENSION}`), yamlStr, 'utf8');
+}
+export function parseBoundedContextModule(input) {
+    const [boundedContextName, moduleName] = input.split('/');
+    if (!boundedContextName || !moduleName) {
+        throw new Error(`Invalid format "${input}". Expected: bounded-context/module`);
+    }
+    return { boundedContextName, moduleName };
+}
+function validateSchema(obj) {
+    const required = [
+        ['boundedContextName', 'string'],
+        ['moduleName', 'string'],
+        ['moduleNames', 'string'],
+        ['aggregateName', 'string'],
+        ['hasOAuth', 'boolean'],
+        ['hasTenant', 'boolean'],
+        ['hasAuditing', 'boolean'],
+    ];
+    for (const [field, expectedType] of required) {
+        if (typeof obj[field] !== expectedType) {
+            throw new TypeError(`YAML schema error: "${field}" must be a ${expectedType} (got ${typeof obj[field]})`);
+        }
+    }
+    validateFrontBlock(obj);
+}
+function validateFrontBlock(obj) {
+    const front = obj.front;
+    if (front === undefined || front === null)
+        return;
+    if (typeof front !== 'object' || Array.isArray(front)) {
+        throw new TypeError(`YAML schema error in "${String(obj.moduleName)}": "front" must be an object`);
+    }
+    const frontObj = front;
+    const validDetailModes = [DETAIL_MODE.VIEW, DETAIL_MODE.DIALOG];
+    if (frontObj.detailMode !== undefined &&
+        !validDetailModes.includes(frontObj.detailMode)) {
+        throw new TypeError(`YAML schema error in "${String(obj.moduleName)}": "front.detailMode" must be one of ${validDetailModes.map(v => `'${v}'`).join(' | ')} (got ${JSON.stringify(frontObj.detailMode)})`);
+    }
+}
+function applyPropertyDefaults(properties) {
+    for (const property of properties) {
+        // UUID id properties default to length 36
+        if (property.type === 'id' && property.length === undefined) {
+            property.length = 36;
+        }
+        if (property.type === 'relationship' &&
+            property.relationship?.type === 'many-to-many' &&
+            Array.isArray(property.relationship.pivot?.aggregateProperties)) {
+            applyPropertyDefaults(property.relationship.pivot.aggregateProperties);
+        }
+    }
+}
+function addDefaults(schema) {
+    if (Array.isArray(schema.aggregateProperties)) {
+        applyPropertyDefaults(schema.aggregateProperties);
+    }
+    return {
+        ...schema,
+        additionalApis: schema.additionalApis ?? [],
+        excludedFiles: schema.excludedFiles ?? [],
+        excludedOperations: schema.excludedOperations ?? [],
+        front: {
+            ...schema.front,
+            detailMode: schema.front?.detailMode ?? DETAIL_MODE.VIEW,
+            // Default `masculine` so generators can read `schema.front.gender` without a nullish
+            // fallback. Stripped by `stripDefaults` before persisting.
+            gender: schema.front?.gender ?? GENDER.MASCULINE,
+        },
+    };
+}
+function stripPropertyDefaults(properties) {
+    for (const property of properties) {
+        // Length 36 on `id` is implied — strip before persisting
+        if (property.type === 'id' && property.length === 36) {
+            delete property.length;
+        }
+        if (property.type === 'relationship' &&
+            property.relationship?.type === 'many-to-many' &&
+            Array.isArray(property.relationship.pivot?.aggregateProperties)) {
+            stripPropertyDefaults(property.relationship.pivot.aggregateProperties);
+        }
+    }
+}
+function stripDefaults(schema) {
+    const { ...rest } = schema;
+    if (Array.isArray(rest.aggregateProperties)) {
+        stripPropertyDefaults(rest.aggregateProperties);
+    }
+    // Remove empty arrays to keep YAML clean
+    const result = rest;
+    if (Array.isArray(result.additionalApis) && result.additionalApis.length === 0) {
+        delete result.additionalApis;
+    }
+    if (Array.isArray(result.excludedFiles) && result.excludedFiles.length === 0) {
+        delete result.excludedFiles;
+    }
+    if (Array.isArray(result.excludedOperations) && result.excludedOperations.length === 0) {
+        delete result.excludedOperations;
+    }
+    // Strip implied `front.*` defaults; drop `front` entirely if empty so load → save round-trips
+    // produce the same YAML for modules that never declared any front fields.
+    if (result.front && typeof result.front === 'object') {
+        const front = result.front;
+        if (front.gender === GENDER.MASCULINE) {
+            delete front.gender;
+        }
+        if (front.detailMode === DETAIL_MODE.VIEW) {
+            delete front.detailMode;
+        }
+        if (Object.keys(front).length === 0) {
+            delete result.front;
+        }
+    }
+    return result;
+}

package/dist/generator/domain/types.d.ts

@@ -0,0 +1,9 @@
+/** Mirrors the `@aurora/types` utility surface used in the frontend. */
+/**
+ * Extracts the union of all values from a const object.
+ *
+ * @example
+ * const STATUS = { ACTIVE: 'ACTIVE', INACTIVE: 'INACTIVE' } as const;
+ * type Status = ValueOf<typeof STATUS>; // 'ACTIVE' | 'INACTIVE'
+ */
+export type ValueOf<T> = T[keyof T];

package/dist/generator/domain/types.js

@@ -0,0 +1,2 @@
+/** Mirrors the `@aurora/types` utility surface used in the frontend. */
+export {};

package/dist/generator/domain/widget-type.d.ts

@@ -0,0 +1,18 @@
+import type { ValueOf } from './types.js';
+/**
+ * Frontend widget kinds for properties with a `widget` block.
+ * Const-as-type: usable as runtime value (`WidgetType.SELECT === 'select'`) and
+ * as a TS type (`WidgetType` is the union of literal strings).
+ */
+export declare const WidgetType: {
+    readonly ASYNC_MULTIPLE_SEARCH_SELECT: "async-multiple-search-select";
+    readonly ASYNC_SEARCH_SELECT: "async-search-select";
+    readonly GRID_ELEMENTS_MANAGER: "grid-elements-manager";
+    readonly GRID_SELECT_ELEMENT: "grid-select-element";
+    readonly GRID_SELECT_MULTIPLE_ELEMENTS: "grid-select-multiple-elements";
+    readonly MULTIPLE_SEARCH_SELECT: "multiple-search-select";
+    readonly MULTIPLE_SELECT: "multiple-select";
+    readonly SEARCH_SELECT: "search-select";
+    readonly SELECT: "select";
+};
+export type WidgetType = ValueOf<typeof WidgetType>;

package/dist/generator/domain/widget-type.js

@@ -0,0 +1,16 @@
+/**
+ * Frontend widget kinds for properties with a `widget` block.
+ * Const-as-type: usable as runtime value (`WidgetType.SELECT === 'select'`) and
+ * as a TS type (`WidgetType` is the union of literal strings).
+ */
+export const WidgetType = {
+    ASYNC_MULTIPLE_SEARCH_SELECT: 'async-multiple-search-select',
+    ASYNC_SEARCH_SELECT: 'async-search-select',
+    GRID_ELEMENTS_MANAGER: 'grid-elements-manager',
+    GRID_SELECT_ELEMENT: 'grid-select-element',
+    GRID_SELECT_MULTIPLE_ELEMENTS: 'grid-select-multiple-elements',
+    MULTIPLE_SEARCH_SELECT: 'multiple-search-select',
+    MULTIPLE_SELECT: 'multiple-select',
+    SEARCH_SELECT: 'search-select',
+    SELECT: 'select',
+};

package/dist/generator/engine/code-writer/code-writer.d.ts

@@ -0,0 +1,79 @@
+import type { Property } from '../../domain/model.js';
+export interface CodeWriterOptions {
+    aggregateName: string;
+    apiDirectory: string;
+    appDirectory: string;
+    boundedContextName: string;
+    hasI18n: boolean;
+    moduleName: string;
+    moduleNames: string;
+    srcDirectory: string;
+}
+export declare class CodeWriter {
+    readonly aggregateName: string;
+    readonly apiDirectory: string;
+    readonly appDirectory: string;
+    readonly boundedContextName: string;
+    readonly hasI18n: boolean;
+    readonly moduleName: string;
+    readonly moduleNames: string;
+    readonly srcDirectory: string;
+    private project;
+    private savedFiles;
+    constructor(opts: CodeWriterOptions);
+    addSeedPermissions(): void;
+    declareBackApplicationItemsInModule(): void;
+    declareBackBoundedContextModuleInApplicationModule(): void;
+    declareFrontBoundedContext(): void;
+    declareFrontComponents(): void;
+    formatSavedFiles(): Promise<void>;
+    generateBackAppBoundedContextReferences(properties: Property[], excluded?: string[]): void;
+    generateBackTestingForeignReferences(properties: Property[]): void;
+    /**
+     * Emit `{bc}-icons.providers.ts` next to `{bc}.navigation.ts`. The aggregator exports a
+     * single object literal `{bcCamel}Icons` whose keys are every `lucide*` icon referenced
+     * by `NavItem.icon` / `NavSubItem.icon` in the navigation file (root + nested `items[]`),
+     * deduplicated and sorted alphabetically. The file is `@aurora-catalyst-generated` and is
+     * fully overwritten on each regen — no preservation regions, no incremental prune.
+     * No-op when `{bc}.navigation.ts` is missing or has no `{bcCamel}Navigation` declaration.
+     */
+    generateFrontIconsProviders(srcDirectory: string, boundedContextName: string): void;
+    /**
+     * Append a NavItem for the current module inside `{bc}.navigation.ts` of the admin dashboard.
+     * Idempotent — silently skips if the entry url already exists. No-op when the BC does not
+     * use the dashboard (file/variable/items array missing). When `outlineIcon` is provided
+     * it becomes the NavItem `icon`.
+     */
+    generateFrontNavigation(srcDirectory: string, boundedContextName: string, moduleName: string, moduleNames: string, outlineIcon?: string): void;
+    /**
+     * Ensure `{DASHBOARD_TRANSLATIONS}/navigation/{langCode}.json` contains a key for this module.
+     * Key is `toPascalCase(moduleNames)` — must match the `translation: 'navigation.{key}'`
+     * used by `generateFrontNavigation`. Missing keys get the PascalCase default placeholder.
+     * Writes JSON directly (not TS AST), so it does not flow through Prettier.
+     */
+    generateFrontNavigationTranslation(langCode: string): void;
+    generateFrontRoutes(): void;
+    /**
+     * Ensure the bounded-context i18n JSON for `langCode` has keys for every non-timestamp,
+     * non-id property of the aggregate, plus the fixed module-level keys
+     * (`Title`, `{Module}`, `{Module}Details`, `{Module}DetailsDescription`).
+     * Target: `{DASHBOARD_TRANSLATIONS}/{bcKebab}/{langCode}.json`. Outer key is the module
+     * in kebab-case; inner object is `Record<string, string>` (PascalCase keys).
+     * Missing entries get a PascalCase default placeholder; the English helper-text template
+     * is written for every language and translated manually afterwards.
+     * Writes JSON directly (not TS AST), so it does not flow through Prettier.
+     */
+    generateFrontTranslations(properties: Property[], langCode: string): void;
+    /**
+     * Idempotent bootstrap: ensure `nav-main.ts` imports `{bcCamel}Icons` from the aggregator
+     * and spreads `...{bcCamel}Icons` into the `provideIcons({...})` argument object. Mutates
+     * ONLY the import list and the `provideIcons` argument — never reorders, renames, or removes
+     * existing entries. Skips with a warning when `provideIcons` is invoked with anything other
+     * than an inline `ObjectLiteralExpression` (developer-customized shape).
+     */
+    registerBcAggregatorInNavMain(srcDirectory: string, boundedContextName: string): void;
+    registerFrontNavigation(): void;
+    private getModelArrayArgument;
+    private getModuleDecoratorArguments;
+    private saveAndTrack;
+}