@gzl10/nexus-sdk 0.12.7 → 0.13.0

package/dist/entity-kPgsCMdR.d.ts

@@ -0,0 +1,1504 @@
+import { Knex } from 'knex';
+import { Request, Router, RequestHandler, Response } from 'express';
+import { L as LocalizedString, i as FieldDefinition, E as EntityIndex } from './field-CngHXora.js';
+import { Logger } from 'pino';
+
+/**
+ * Server-Sent Events (SSE) types
+ * @module sse
+ */
+/**
+ * SSE helper for streaming responses
+ */
+interface SSEHelper {
+    /**
+     * Start an SSE stream
+     * @param res - Express response object
+     * @param handler - Async function that sends events
+     * @param options - Stream options
+     */
+    stream(res: unknown, // Response type from Express, kept generic to avoid dependency
+    handler: (send: SSESender) => Promise<void>, options?: SSEOptions): Promise<void>;
+}
+/**
+ * Sender object for emitting SSE events
+ */
+interface SSESender {
+    /**
+     * Send a data event
+     * @param data - Data to send (will be JSON stringified)
+     * @param event - Optional event name (client listens with addEventListener)
+     * @param id - Optional event ID (for reconnection with Last-Event-ID)
+     */
+    send(data: unknown, event?: string, id?: string): void;
+    /**
+     * Send a comment (useful for keep-alive)
+     * @param text - Comment text
+     */
+    comment(text: string): void;
+    /**
+     * Close the stream
+     */
+    close(): void;
+}
+/**
+ * Options for SSE stream
+ */
+interface SSEOptions {
+    /**
+     * Retry interval in ms for client reconnection (default: 3000)
+     */
+    retry?: number;
+    /**
+     * Keep-alive interval in ms (default: 30000, 0 to disable)
+     */
+    keepAlive?: number;
+    /**
+     * Callback when client disconnects
+     */
+    onClose?: () => void;
+}
+/**
+ * Configuration for batch/long-running actions.
+ * When set on an ActionDefinition, the action uses SSE for progress reporting.
+ */
+interface BatchConfig {
+    /** Mark this action as a batch/long-running process */
+    batch: true;
+    /** Timeout in ms (default: 300000 = 5min). UI shows countdown. */
+    timeout?: number;
+}
+/**
+ * Progress event sent via SSE during batch action execution.
+ * Events are sent with the named event 'batch'.
+ */
+interface BatchProgressEvent {
+    /** Current status of the batch process */
+    status: 'started' | 'progress' | 'completed' | 'error';
+    /** Progress percentage 0-100 */
+    percent?: number;
+    /** Current step number */
+    step?: number;
+    /** Total number of steps */
+    totalSteps?: number;
+    /** Human-readable message for the current operation */
+    message?: string;
+    /** Log entries (warnings, info, partial results) */
+    logs?: BatchLogEntry[];
+    /** Final result data (only on 'completed') */
+    result?: unknown;
+    /** Error details (only on 'error') */
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Individual log entry emitted during batch processing
+ */
+interface BatchLogEntry {
+    level: 'info' | 'warn' | 'error';
+    message: string;
+    timestamp?: string;
+}
+
+/**
+ * Base types shared across the SDK
+ */
+
+/**
+ * Base authenticated request with user and CASL abilities (generic).
+ * Use AuthRequest for the pre-typed version.
+ */
+interface BaseAuthRequest<TUser = unknown, TAbility = unknown> extends Request {
+    user: TUser;
+    ability: TAbility;
+}
+/**
+ * Base user without a password for plugin use.
+ * Used to type relations with users (e.g., author, created_by).
+ * Note: Multi-role support - roles are loaded via user_roles pivot table.
+ */
+interface BaseUser {
+    id: string;
+    name: string;
+    email: string;
+    created_at: Date;
+    updated_at: Date;
+    created_by: string | null;
+    updated_by: string | null;
+    /** Extensibility: allows custom user properties */
+    [key: string]: unknown;
+}
+/**
+ * Pagination parameters for queries
+ */
+interface PaginationParams {
+    page: number;
+    limit: number;
+}
+/**
+ * Extended pagination parameters with offset (used internally)
+ */
+interface PaginationParamsWithOffset extends PaginationParams {
+    /** Offset for database query */
+    offset: number;
+}
+/**
+ * Generic paginated result
+ */
+interface PaginatedResult<T> {
+    items: T[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+    hasNext: boolean;
+}
+/**
+ * Standard validation error detail for API responses
+ */
+interface ValidationDetail {
+    path: string;
+    message: string;
+}
+
+/**
+ * CASL Authorization types
+ */
+
+/**
+ * Standard CASL authorization actions.
+ *
+ * - `manage` - Full access (superuser wildcard, includes all actions)
+ * - `create` - Create new records
+ * - `read` - Read/view records
+ * - `update` - Modify existing records
+ * - `delete` - Remove records
+ * - `execute` - Execute actions/operations on records
+ */
+type CaslAction = 'manage' | 'create' | 'read' | 'update' | 'delete' | 'execute' | (string & {});
+/**
+ * CASL permission definition for a specific role.
+ *
+ * Defines what actions a role can perform on an entity,
+ * optionally with conditions and field restrictions.
+ */
+interface RolePermission {
+    /** Actions this role can perform on the entity */
+    actions: CaslAction[];
+    /** CASL conditions to filter which records the permission applies to */
+    conditions?: Record<string, unknown>;
+    /** Restrict permission to specific fields. null = all fields allowed */
+    fields?: string[] | null;
+    /** If true, this is a denial rule (cannot) instead of allow (can) */
+    inverted?: boolean;
+}
+/**
+ * CASL authorization configuration for an entity.
+ *
+ * Defines role-based access control (RBAC) using CASL.
+ * Permissions are evaluated at runtime for each request.
+ */
+interface EntityCaslConfig {
+    /** CASL subject name. Default: inferred from table */
+    subject?: string;
+    /** Role-based permissions. Keys are role names or '*' wildcard */
+    permissions?: Record<string, RolePermission | RolePermission[]>;
+    /** Fields excluded from 'read' permission unless explicitly granted */
+    sensitiveFields?: string[];
+}
+/**
+ * Generic interface for CASL ability.
+ *
+ * Provides permission checking without directly depending on @casl/ability package.
+ */
+interface AbilityLike {
+    /** Check if action is allowed on subject */
+    can: (action: string, subject: unknown) => boolean;
+    /** Check if action is denied on subject */
+    cannot: (action: string, subject: unknown) => boolean;
+}
+/**
+ * CASL ForbiddenError instance for throwing permission errors.
+ */
+interface ForbiddenErrorInstance {
+    /** Throws ForbiddenError if action is not allowed on subject */
+    throwUnlessCan: (action: string, subject: unknown) => void;
+}
+/**
+ * CASL ForbiddenError constructor for creating error instances.
+ */
+interface ForbiddenErrorConstructor {
+    /** Creates a ForbiddenErrorInstance bound to an ability */
+    from: (ability: any) => ForbiddenErrorInstance;
+}
+/**
+ * CASL abilities API available in module context.
+ *
+ * Allows modules to use CASL for authorization without importing @casl/ability directly.
+ */
+interface ModuleAbilities {
+    /** Creates CASL ability instance for a user based on their roles */
+    defineAbilityFor: (user: {
+        id: string;
+    } | null, ...args: unknown[]) => unknown;
+    /** Serializes CASL rules for client-side authorization (frontend) */
+    packRules: (ability: unknown) => unknown[];
+    /** Wraps an object as CASL subject for instance-level permission checks */
+    subject: (type: string, object: Record<string, unknown>) => unknown;
+    /** ForbiddenError constructor for throwUnlessCan pattern */
+    ForbiddenError: ForbiddenErrorConstructor;
+}
+/**
+ * Pre-typed authenticated request with BaseUser and AbilityLike.
+ *
+ * Use this type for route handlers that require authentication.
+ */
+type AuthRequest = BaseAuthRequest<BaseUser, AbilityLike>;
+
+/**
+ * Query and filter types for data access
+ */
+
+/**
+ * Filter operators for advanced filtering
+ *
+ * @example
+ * // Simple equality (shorthand)
+ * { status: 'active' }
+ *
+ * // With operators
+ * { name: { $contains: 'john' } }
+ * { age: { $gte: 18 } }
+ */
+interface FilterOperators {
+    /** Equal (default if no operator) */
+    $eq?: unknown;
+    /** Not equal */
+    $ne?: unknown;
+    /** Greater than */
+    $gt?: number | string | Date;
+    /** Greater than or equal */
+    $gte?: number | string | Date;
+    /** Less than */
+    $lt?: number | string | Date;
+    /** Less than or equal */
+    $lte?: number | string | Date;
+    /** Contains (LIKE %value%) */
+    $contains?: string;
+    /** Starts with (LIKE value%) */
+    $startswith?: string;
+    /** Ends with (LIKE %value) */
+    $endswith?: string;
+    /** In array */
+    $in?: unknown[];
+    /** Not in array */
+    $nin?: unknown[];
+    /** Is null (true = IS NULL, false = IS NOT NULL) */
+    $isnull?: boolean;
+}
+/**
+ * Filter value can be:
+ * - Primitive (shorthand for $eq)
+ * - Array (shorthand for $in)
+ * - Object with operators
+ */
+type FilterValue = string | number | boolean | null | unknown[] | FilterOperators;
+/**
+ * Query parameters for entity list operations
+ */
+interface EntityQuery {
+    page?: number;
+    limit?: number;
+    sort?: string;
+    order?: 'asc' | 'desc';
+    search?: string;
+    /** Filters with optional operators */
+    filters?: Record<string, unknown>;
+}
+/**
+ * Database adapter interface for normalized data access.
+ *
+ * Abstracts database operations using standardized types.
+ */
+interface DatabaseAdapter {
+    /**
+     * Find multiple records with optional filtering, sorting, and pagination.
+     */
+    findMany<T = unknown>(table: string, query?: EntityQuery): Promise<PaginatedResult<T>>;
+    /**
+     * Find a single record by filters.
+     */
+    findOne<T = unknown>(table: string, filters: Record<string, unknown>): Promise<T | null>;
+    /**
+     * Find a single record by ID.
+     */
+    findById<T = unknown>(table: string, id: string): Promise<T | null>;
+    /**
+     * Count records matching filters.
+     */
+    count(table: string, filters?: Record<string, unknown>): Promise<number>;
+    /**
+     * Insert a new record.
+     */
+    insert<T = unknown>(table: string, data: Record<string, unknown>): Promise<T>;
+    /**
+     * Update a record by ID.
+     */
+    update<T = unknown>(table: string, id: string, data: Record<string, unknown>): Promise<T>;
+    /**
+     * Delete a record by ID.
+     */
+    delete(table: string, id: string): Promise<boolean>;
+    /**
+     * Execute operations within a transaction.
+     */
+    transaction<T>(fn: (trx: DatabaseAdapter) => Promise<T>): Promise<T>;
+    /**
+     * Raw access to the underlying database driver.
+     */
+    raw: unknown;
+    insertWithTtl?<T = unknown>(table: string, data: Record<string, unknown>, ttlSeconds: number): Promise<T>;
+    setTtl?(table: string, id: string, ttlSeconds: number): Promise<boolean>;
+    getTtl?(table: string, id: string): Promise<number | null>;
+    cleanupExpiredIds?(table: string): Promise<number>;
+}
+
+/**
+ * Schema adapter types for DDL operations
+ */
+/**
+ * Column information returned by schema introspection.
+ */
+interface SchemaColumnInfo {
+    /** Column name */
+    name: string;
+    /** Database type (varchar, integer, text, etc.) */
+    type: string;
+    /** Whether the column allows NULL values */
+    nullable: boolean;
+    /** Default value if any */
+    defaultValue: unknown;
+}
+/**
+ * Column builder for defining column properties.
+ * Methods return `this` for chaining.
+ */
+interface SchemaColumnBuilder {
+    /** Mark as primary key */
+    primary(): SchemaColumnBuilder;
+    /** Add unique constraint */
+    unique(): SchemaColumnBuilder;
+    /** Add index */
+    index(): SchemaColumnBuilder;
+    /** Allow NULL values */
+    nullable(): SchemaColumnBuilder;
+    /** Disallow NULL values */
+    notNullable(): SchemaColumnBuilder;
+    /** Set default value */
+    defaultTo(value: unknown): SchemaColumnBuilder;
+    /** Add foreign key reference */
+    references(column: string): SchemaColumnBuilder;
+    /** Target table for foreign key */
+    inTable(table: string): SchemaColumnBuilder;
+    /** On delete behavior for foreign key */
+    onDelete(action: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION'): SchemaColumnBuilder;
+}
+/**
+ * Table builder for creating tables.
+ */
+interface SchemaTableBuilder {
+    string(name: string, size?: number): SchemaColumnBuilder;
+    text(name: string): SchemaColumnBuilder;
+    integer(name: string): SchemaColumnBuilder;
+    bigInteger(name: string): SchemaColumnBuilder;
+    decimal(name: string, precision?: number, scale?: number): SchemaColumnBuilder;
+    boolean(name: string): SchemaColumnBuilder;
+    date(name: string): SchemaColumnBuilder;
+    datetime(name: string): SchemaColumnBuilder;
+    timestamp(name: string): SchemaColumnBuilder;
+    json(name: string): SchemaColumnBuilder;
+    jsonb(name: string): SchemaColumnBuilder;
+    uuid(name: string): SchemaColumnBuilder;
+    enum(name: string, values: readonly string[]): SchemaColumnBuilder;
+    binary(name: string, length?: number): SchemaColumnBuilder;
+    float(name: string, precision?: number, scale?: number): SchemaColumnBuilder;
+    specificType(name: string, type: string): SchemaColumnBuilder;
+    timestamps(): void;
+    index(columns: string | string[], indexName?: string): void;
+    unique(columns: string | string[], constraintName?: string): void;
+    primary(columns: string | string[], constraintName?: string): void;
+    foreign(column: string): SchemaForeignKeyBuilder;
+    increments(name?: string): SchemaColumnBuilder;
+    bigIncrements(name?: string): SchemaColumnBuilder;
+}
+/**
+ * Foreign key builder for defining references.
+ */
+interface SchemaForeignKeyBuilder {
+    references(column: string): SchemaForeignKeyBuilder;
+    inTable(table: string): SchemaForeignKeyBuilder;
+    onDelete(action: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION'): SchemaForeignKeyBuilder;
+    onUpdate(action: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION'): SchemaForeignKeyBuilder;
+}
+/**
+ * Alter table builder extends table builder with modification operations.
+ */
+interface SchemaAlterTableBuilder extends SchemaTableBuilder {
+    dropColumn(name: string): void;
+    renameColumn(from: string, to: string): void;
+}
+/**
+ * Schema adapter interface for normalized DDL operations.
+ */
+interface SchemaAdapter {
+    hasTable(tableName: string): Promise<boolean>;
+    hasColumn(tableName: string, columnName: string): Promise<boolean>;
+    getColumns(tableName: string): Promise<SchemaColumnInfo[]>;
+    createTable(tableName: string, builder: (t: SchemaTableBuilder) => void): Promise<void>;
+    alterTable(tableName: string, builder: (t: SchemaAlterTableBuilder) => void): Promise<void>;
+    dropTable(tableName: string): Promise<void>;
+    addTimestamps(tableName: string): Promise<void>;
+    addAuditFields(tableName: string): Promise<void>;
+    addColumnIfMissing(tableName: string, columnName: string, type: string): Promise<boolean>;
+    /** Raw access to the underlying schema builder */
+    raw: unknown;
+}
+
+/**
+ * Entity service types and hooks
+ */
+
+/**
+ * Base interface for all entity services.
+ */
+interface BaseEntityService<T = unknown> {
+    /** Gets paginated list of records */
+    findAll(query?: EntityQuery): Promise<PaginatedResult<T>>;
+    /** Gets a single record by ID */
+    findById(id: string): Promise<T | null>;
+    /** The entity definition this service operates on */
+    readonly definition: EntityDefinition;
+}
+/**
+ * Service for Collection entities with full CRUD.
+ */
+interface CollectionEntityService<T = unknown> extends BaseEntityService<T> {
+    create(data: Partial<T>, userId?: string): Promise<T>;
+    update(id: string, data: Partial<T>, userId?: string): Promise<T>;
+    delete(id: string): Promise<void>;
+}
+/**
+ * Service for Temp entities with TTL expiration.
+ */
+interface TempEntityService<T = unknown> extends BaseEntityService<T> {
+    create(data: Partial<T>): Promise<T>;
+    update(id: string, data: Partial<T>, extendTtl?: boolean): Promise<T>;
+    delete(id: string): Promise<void>;
+    extendTtl(id: string, additionalSeconds?: number): Promise<T>;
+    cleanup(): Promise<number>;
+    getRemainingTtl(id: string): Promise<number | null>;
+    isValid(id: string): Promise<boolean>;
+}
+/**
+ * Service for Event entities (append-only).
+ */
+interface EventEntityService<T = unknown> extends BaseEntityService<T> {
+    create(data: Partial<T>): Promise<T>;
+    append(data: Partial<T>): Promise<T>;
+    runRetentionCleanup(): Promise<number>;
+    findByDateRange(start: Date, end: Date, query?: EntityQuery): Promise<PaginatedResult<T>>;
+}
+/**
+ * Service for Single entities (global configuration).
+ */
+interface SingleEntityService<T = unknown> extends BaseEntityService<T> {
+    get(): Promise<T | null>;
+    update(data: Partial<T>, userId?: string): Promise<T>;
+}
+/**
+ * Service for Config entities (scoped key-value).
+ */
+interface ConfigEntityService<T = unknown> extends BaseEntityService<T> {
+    get(key: string): Promise<T | null>;
+    set(key: string, value: unknown, userId?: string): Promise<T>;
+    getAll(): Promise<Record<string, unknown>>;
+}
+/** Service for Reference entities (read-only) */
+type ReferenceEntityService<T = unknown> = BaseEntityService<T>;
+/** Service for View entities (SQL views, read-only) */
+type ViewEntityService<T = unknown> = BaseEntityService<T>;
+/** Service for Computed entities */
+type ComputedEntityService<T = unknown> = BaseEntityService<T>;
+/** Service for External entities */
+type ExternalEntityService<T = unknown> = BaseEntityService<T>;
+/** Service for Virtual entities */
+type VirtualEntityService<T = unknown> = BaseEntityService<T>;
+/**
+ * Service for Action entities.
+ */
+interface ActionEntityService<T = unknown> {
+    execute(data: Partial<T>): Promise<unknown>;
+    readonly definition: EntityDefinition;
+}
+/**
+ * Hooks to customize entity service behavior.
+ */
+interface EntityServiceHooks<T = unknown> {
+    beforeCreate?: (data: Partial<T>) => Promise<Partial<T>> | Partial<T>;
+    afterCreate?: (record: T) => Promise<void> | void;
+    beforeUpdate?: (id: string, data: Partial<T>) => Promise<Partial<T>> | Partial<T>;
+    afterUpdate?: (record: T) => Promise<void> | void;
+    beforeDelete?: (id: string) => Promise<void> | void;
+    afterDelete?: (id: string) => Promise<void> | void;
+    afterFindById?: (record: T | null) => Promise<T | null> | T | null;
+    afterFindAll?: (result: PaginatedResult<T>) => Promise<PaginatedResult<T>> | PaginatedResult<T>;
+}
+/**
+ * Options for createEntityService
+ */
+interface CreateEntityServiceOptions<T = unknown> {
+    hooks?: EntityServiceHooks<T>;
+}
+/**
+ * Role management service interface.
+ */
+interface BaseRolesService {
+    findAll(query?: EntityQuery): Promise<PaginatedResult<unknown>>;
+    findById(id: string): Promise<unknown>;
+    findByName(name: string): Promise<unknown | undefined>;
+    create(data: Record<string, unknown>, userId?: string): Promise<unknown>;
+    update(id: string, data: Record<string, unknown>, userId?: string): Promise<unknown>;
+    delete(id: string): Promise<void>;
+}
+/**
+ * User management service interface.
+ */
+interface BaseUsersService {
+    findAll(query?: EntityQuery): Promise<PaginatedResult<unknown>>;
+    findById(id: string): Promise<unknown>;
+    findByIdWithRoles(id: string): Promise<unknown | null>;
+    create(data: Record<string, unknown>, userId?: string): Promise<unknown>;
+    update(id: string, data: Record<string, unknown>, userId?: string): Promise<unknown>;
+    delete(id: string): Promise<void>;
+    getRoleIds(userId: string): Promise<string[]>;
+    getRoleNames(userId: string): Promise<string[]>;
+    getUserRoles(userId: string): Promise<unknown[]>;
+    assignRole(userId: string, roleId: string): Promise<void>;
+    removeRole(userId: string, roleId: string): Promise<void>;
+    setRoles(userId: string, roleIds: string[]): Promise<void>;
+    roles: BaseRolesService;
+}
+/**
+ * Email sending options.
+ */
+interface SendMailOptions {
+    to: string | string[];
+    subject: string;
+    title?: string;
+    message?: string;
+    html?: string;
+    text?: string;
+    from?: string;
+    replyTo?: string;
+    actions?: Array<{
+        label: string;
+        url: string;
+    }>;
+    logoUrl?: string;
+    attachments?: Array<{
+        filename: string;
+        content: Buffer | string;
+        contentType?: string;
+    }>;
+}
+/**
+ * Result from sending an email.
+ */
+interface SendMailResult {
+    messageId: string;
+    accepted: string[];
+    rejected: string[];
+}
+/**
+ * Email service interface.
+ */
+interface BaseMailService {
+    send(options: SendMailOptions): Promise<SendMailResult | null>;
+    verify(): Promise<boolean>;
+}
+/**
+ * Error reporter interface for external monitoring.
+ */
+interface LoggerReporter {
+    captureException: (error: Error, context?: Record<string, unknown>) => void;
+}
+/**
+ * Core services available via ctx.services.
+ */
+interface CoreServices {
+    logger?: LoggerReporter;
+    users?: BaseUsersService;
+    mail?: BaseMailService;
+    [key: string]: unknown;
+}
+
+/**
+ * Module and Plugin manifest types
+ */
+
+/**
+ * Available categories for organizing modules in the UI sidebar.
+ */
+type Category = 'content' | 'data' | 'assets' | 'messaging' | 'jobs' | 'ai' | 'analytics' | 'integrations' | 'commerce' | 'security' | 'legal' | 'settings';
+/**
+ * Metadata for a category including display information.
+ */
+interface CategoryMeta {
+    label: LocalizedString;
+    icon: string;
+    order: number;
+}
+/**
+ * Registry of all categories with their metadata.
+ */
+declare const CATEGORIES: Record<Category, CategoryMeta>;
+/**
+ * Categories sorted by their display order for sidebar rendering.
+ */
+declare const CATEGORY_ORDER: Category[];
+/**
+ * Cross-module action injection descriptor.
+ * Allows a module to inject actions into entities owned by other modules.
+ */
+interface ActionInjection {
+    /** Target module and entity to inject the action into */
+    target: {
+        module: string;
+        entity: string;
+    };
+    /** The action definition to inject into the target entity's actions[] */
+    action: ActionDefinition;
+}
+/**
+ * Module manifest defining a Nexus module.
+ */
+interface ModuleManifest {
+    /** Unique module identifier */
+    name: string;
+    /** Display name for UI (singular) */
+    label?: LocalizedString;
+    /** Display name for UI (plural) */
+    labelPlural?: LocalizedString;
+    /** Iconify MDI icon identifier */
+    icon?: string;
+    /** Module description for documentation */
+    description?: LocalizedString;
+    /** Module type */
+    type?: 'core' | 'plugin' | 'auth-plugin' | 'custom';
+    /** Category for sidebar grouping */
+    category: Category;
+    /** Other module names that must be loaded before this one */
+    dependencies?: string[];
+    /** Requirements that must be met to enable this module */
+    required?: ModuleRequirements;
+    /** Database migration function */
+    migrate?: (ctx: ModuleContext) => Promise<void>;
+    /** Seed function for initial/reference data */
+    seed?: (ctx: ModuleContext) => Promise<void>;
+    /** Initialization function called on app startup */
+    init?: (ctx: ModuleContext) => void;
+    /** Factory function returning Express router with custom routes */
+    routes?: (ctx: ModuleContext) => Router;
+    /** API route prefix. Default: `/{name}` */
+    routePrefix?: string;
+    /** Entity definitions */
+    definitions?: EntityDefinition[];
+    /** Custom route definitions for OpenAPI documentation */
+    customRoutes?: CustomRouteDefinition[];
+    /** Actions to inject into entities of other modules */
+    injectActions?: ActionInjection[];
+}
+/**
+ * Application manifest with module and plugin registry.
+ */
+interface AppManifest {
+    name: string;
+    version: string;
+    modules: ModuleManifest[];
+    plugins?: PluginManifest[];
+}
+/**
+ * Environment variable definition for plugin installation.
+ */
+interface PluginEnvVar {
+    name: string;
+    description: LocalizedString;
+    required: boolean;
+    default?: string;
+    example?: string;
+    pattern?: string;
+    sensitive?: boolean;
+}
+/**
+ * Configuration field definition for plugin settings.
+ */
+interface PluginConfigField {
+    key: string;
+    label: LocalizedString;
+    description?: LocalizedString;
+    type: 'string' | 'number' | 'boolean' | 'select' | 'json';
+    default?: unknown;
+    required?: boolean;
+    options?: Array<{
+        value: string;
+        label: LocalizedString;
+        icon?: string;
+    }>;
+}
+/**
+ * Plugin configuration schema.
+ */
+interface PluginConfigSchema {
+    fields: PluginConfigField[];
+    category?: LocalizedString;
+}
+/**
+ * Plugin setup/installation information.
+ */
+interface PluginSetupInfo {
+    steps?: LocalizedString[];
+    docsUrl?: string;
+    postInstall?: (ctx: ModuleContext) => Promise<void>;
+    prerequisites?: LocalizedString[];
+    caveats?: LocalizedString[];
+}
+/**
+ * Plugin manifest defining a distributable Nexus plugin package.
+ */
+interface PluginManifest {
+    /** Plugin npm package name */
+    name: string;
+    /** Short code prefix for tables (3-4 uppercase chars) */
+    code: string;
+    /** Display label (singular) */
+    label: LocalizedString;
+    /** Display label (plural) */
+    labelPlural?: LocalizedString;
+    /** Iconify MDI icon */
+    icon?: string;
+    /** Category for sidebar grouping */
+    category: Category;
+    /** Plugin version following SemVer */
+    version: string;
+    /** Plugin description */
+    description: LocalizedString;
+    /** Modules bundled in this plugin */
+    modules: ModuleManifest[];
+    /** Other plugin package names that must be loaded before this one */
+    dependencies?: string[];
+    /** Environment variables required or used by this plugin */
+    envVars?: PluginEnvVar[];
+    /** Configuration schema for plugin settings */
+    config?: PluginConfigSchema;
+    /** Peer dependencies required */
+    peerDependencies?: Record<string, string>;
+    /** Installation and setup information */
+    setup?: PluginSetupInfo;
+    /** Absolute path to plugin's migrations directory. Use import.meta.dirname to resolve. */
+    migrationsDir?: string;
+}
+/**
+ * Options for registerPlugin()
+ */
+interface RegisterPluginOptions {
+    /** If true, no HTTP routes will be mounted for this plugin */
+    disableEndpoints?: boolean;
+}
+
+/**
+ * Module context types
+ */
+
+/**
+ * Generic validation schema interface compatible with Zod.
+ */
+interface ValidationSchema {
+    parse: (data: unknown) => unknown;
+}
+/**
+ * Schemas for the validation middleware.
+ */
+interface ValidateSchemas {
+    body?: ValidationSchema;
+    query?: ValidationSchema;
+    params?: ValidationSchema;
+}
+/**
+ * Configuration options for rate limiting middleware.
+ */
+interface RateLimitOptions {
+    windowMs?: number;
+    max?: number;
+    message?: string;
+}
+/**
+ * Middleware factories available in module context.
+ */
+interface ModuleMiddlewares {
+    validate: (schemas: ValidateSchemas) => RequestHandler;
+    rateLimit: (options?: RateLimitOptions) => RequestHandler;
+    [key: string]: RequestHandler | ((...args: any[]) => RequestHandler) | undefined;
+}
+/**
+ * Minimal EventEmitter interface.
+ */
+interface EventEmitterLike {
+    emit: (event: string, ...args: unknown[]) => boolean;
+    on: (event: string, listener: (...args: unknown[]) => void) => this;
+    off: (event: string, listener: (...args: unknown[]) => void) => this;
+    once: (event: string, listener: (...args: unknown[]) => void) => this;
+    onAny?: (listener: (event: string, ...args: unknown[]) => void) => this;
+}
+/**
+ * Cryptographic utilities for password handling.
+ */
+interface ContextCrypto {
+    hashPassword: (password: string) => Promise<string>;
+    verifyPassword: (password: string, hash: string) => Promise<boolean>;
+    DUMMY_HASH: string;
+}
+/**
+ * LRU Cache options.
+ */
+interface ContextLRUCacheOptions {
+    maxEntries?: number;
+    defaultTTL?: number;
+}
+/**
+ * LRU Cache instance interface.
+ */
+interface ContextLRUCache<T = unknown> {
+    get(key: string): T | null;
+    set(key: string, value: T, ttl?: number): void;
+    delete(key: string): boolean;
+    has(key: string): boolean;
+    clear(): void;
+}
+/**
+ * Cache utilities available in module context.
+ */
+interface ContextCache {
+    createLRUCache: <T = unknown>(options?: ContextLRUCacheOptions) => ContextLRUCache<T>;
+}
+/**
+ * Socket.IO Server interface (minimal)
+ */
+interface SocketIOServer {
+    to(room: string): SocketIOBroadcastOperator;
+    in(room: string): SocketIOBroadcastOperator;
+    emit(event: string, ...args: unknown[]): boolean;
+    sockets: {
+        sockets: Map<string, unknown>;
+    };
+}
+/**
+ * Socket.IO Broadcast Operator interface
+ */
+interface SocketIOBroadcastOperator {
+    emit(event: string, ...args: unknown[]): void;
+    fetchSockets(): Promise<unknown[]>;
+}
+/**
+ * Socket.IO API for real-time communication.
+ */
+interface ContextSocket {
+    getIO: () => SocketIOServer;
+    isInitialized: () => boolean;
+    isUserConnected: (userId: string) => boolean;
+    getUserSocketCount: (userId: string) => number;
+    getConnectedUsers: () => string[];
+    joinUserToRoom: (userId: string, room: string) => boolean;
+    removeUserFromRoom: (userId: string, room: string) => boolean;
+    joinSocketToRoom: (socketId: string, room: string) => boolean;
+    removeSocketFromRoom: (socketId: string, room: string) => boolean;
+    getRoomMembers: (room: string) => Promise<string[]>;
+    getRoomSize: (room: string) => Promise<number>;
+    getUserRooms: (userId: string) => string[];
+    roomExists: (room: string) => Promise<boolean>;
+    emitToRoom: (room: string, event: string, data: unknown) => boolean;
+    emitToUser: (userId: string, event: string, data: unknown) => boolean;
+    emitToRole: (roleId: string, event: string, data: unknown) => boolean;
+    emitToAll: (event: string, data: unknown) => boolean;
+    emitToAuthenticated: (event: string, data: unknown) => boolean;
+    broadcastToRoom: (room: string, exceptUserIds: string | string[], event: string, data: unknown) => boolean;
+}
+/**
+ * Helper utilities available in module context.
+ */
+interface ContextHelpers {
+    generateId: () => string;
+    addTimestamps: (table: Knex.CreateTableBuilder, db: Knex) => void;
+    addAuditFieldsIfMissing: (db: Knex, tableName: string) => Promise<void>;
+    addSoftDeleteFieldIfMissing: (db: Knex, tableName: string) => Promise<void>;
+    addConfigDefaultField: (db: Knex, tableName: string) => Promise<void>;
+    addColumnIfMissing: (db: Knex, tableName: string, columnName: string, columnBuilder: (table: Knex.AlterTableBuilder) => void) => Promise<boolean>;
+    getLibPath: () => string;
+    getProjectPath: () => string;
+    nowTimestamp: (db: Knex) => string;
+    formatTimestamp: (db: Knex, date?: Date) => string;
+    safeJsonParse: <T>(jsonString: string, fallback: T, context?: Record<string, unknown>) => T;
+    getPagination: (query?: EntityQuery) => PaginationParamsWithOffset;
+    applySearchFilter: (qb: Knex.QueryBuilder, definition: EntityDefinition, search: string) => Knex.QueryBuilder;
+    buildPaginatedResult: <T>(items: T[], total: number, pagination: PaginationParamsWithOffset) => PaginatedResult<T>;
+}
+/**
+ * Entity controller with CRUD operation handlers.
+ */
+type EntityHandler = (req: Request, res: Response) => Promise<void>;
+interface EntityController {
+    list: EntityHandler;
+    get: EntityHandler;
+    create?: EntityHandler;
+    update?: EntityHandler;
+    delete?: EntityHandler;
+    execute?: EntityHandler;
+}
+/**
+ * Core utilities namespace.
+ */
+interface CoreContext {
+    logger: Logger;
+    errors: {
+        AppError: new (message: string, statusCode?: number, details?: unknown) => Error & {
+            details?: unknown;
+        };
+        NotFoundError: new (message?: string) => Error;
+        UnauthorizedError: new (codeOrMessage?: string, message?: string) => Error;
+        ForbiddenError: new (message?: string) => Error;
+        ConflictError: new (message?: string) => Error;
+        ValidationError: new (message?: string, details?: ValidationDetail[]) => Error & {
+            details: ValidationDetail[];
+        };
+        codes: Record<string, string>;
+    };
+    crypto: ContextCrypto;
+    cache: ContextCache;
+    socket: ContextSocket;
+    sse: SSEHelper;
+    abilities: ModuleAbilities;
+    events: EventEmitterLike;
+    middleware: ModuleMiddlewares;
+    createRouter: () => Router;
+    generateId: () => string;
+    generateIdByType: (type?: 'ulid' | 'uuid' | 'nanoid' | 'cuid2' | 'auto' | 'custom') => string | undefined;
+    getLibPath: () => string;
+    getProjectPath: () => string;
+    safeJsonParse: <T>(jsonString: string, fallback: T, context?: Record<string, unknown>) => T;
+}
+/**
+ * Database namespace.
+ */
+interface DbContext {
+    knex: Knex;
+    adapter: DatabaseAdapter;
+    schema: SchemaAdapter;
+    addTimestamps: (table: Knex.CreateTableBuilder, db: Knex) => void;
+    addAuditFieldsIfMissing: (db: Knex, tableName: string) => Promise<void>;
+    addSoftDeleteFieldIfMissing: (db: Knex, tableName: string) => Promise<void>;
+    addConfigDefaultField: (db: Knex, tableName: string) => Promise<void>;
+    addColumnIfMissing: (db: Knex, tableName: string, columnName: string, columnBuilder: (table: Knex.AlterTableBuilder) => void) => Promise<boolean>;
+    nowTimestamp: (db: Knex) => string;
+    formatTimestamp: (db: Knex, date?: Date) => string;
+    applySearchFilter: (qb: Knex.QueryBuilder, definition: EntityDefinition, search: string) => Knex.QueryBuilder;
+    getPagination: (query?: EntityQuery) => PaginationParamsWithOffset;
+    buildPaginatedResult: <T>(items: T[], total: number, pagination: PaginationParamsWithOffset) => PaginatedResult<T>;
+}
+/**
+ * Runtime namespace.
+ */
+interface RuntimeContext {
+    createEntityService: <T = unknown>(definition: EntityDefinition, options?: CreateEntityServiceOptions<T>) => BaseEntityService<T>;
+    createEntityServiceAsync: <T = unknown>(definition: EntityDefinition, options?: CreateEntityServiceOptions<T>) => Promise<BaseEntityService<T>>;
+    createEntityController: (service: BaseEntityService, definition: EntityDefinition) => EntityController;
+    createEntityRouter: (controller: EntityController, definition: EntityDefinition) => Router;
+}
+/**
+ * Configuration namespace.
+ */
+interface ConfigContext {
+    env: {
+        NODE_ENV: 'development' | 'production' | 'test';
+        PORT: number;
+        DATABASE_URL: string;
+        CORS_ORIGIN: string;
+        REDIS_URL?: string;
+        REDIS_PREFIX: string;
+        ADMIN_EMAIL?: string;
+        ADMIN_PASSWORD?: string;
+        BACKEND_URL?: string;
+        COOKIE_DOMAIN?: string;
+        TZ: string;
+        TRUST_PROXY: boolean;
+        [key: string]: unknown;
+    };
+    resolved: Record<string, unknown>;
+}
+
+/**
+ * Engine namespace.
+ */
+interface EngineContext {
+    getModules: () => ModuleManifest[];
+    getPlugins: () => PluginManifest[];
+    getModuleSubjects: (mod: ModuleManifest) => string[];
+    getRegisteredSubjects: () => string[];
+    getCoreModules: () => ModuleManifest[];
+    getUserModules: () => ModuleManifest[];
+    getCoreManifest: () => AppManifest;
+    getUserManifest: () => AppManifest | null;
+    hasUserApp: () => boolean;
+    getSubjectForTable: (table: string) => string | undefined;
+}
+/**
+ * Services registry namespace.
+ */
+interface ServicesContext {
+    register: (name: string, service: unknown) => void;
+    get: <T = unknown>(name: string) => T;
+    getOptional: <T = unknown>(name: string) => T | undefined;
+    has: (name: string) => boolean;
+    getBySuffix: <T = unknown>(suffix: string) => Array<{
+        name: string;
+        service: T;
+    }>;
+    [name: string]: unknown;
+}
+/**
+ * Adapters registry namespace.
+ */
+interface AdaptersContext {
+    register: (name: string, dataAdapter: DatabaseAdapter, schemaAdapter?: SchemaAdapter) => void;
+    get: <T extends DatabaseAdapter = DatabaseAdapter>(name?: string) => T;
+    getSchema: <T extends SchemaAdapter = SchemaAdapter>(name?: string) => T | undefined;
+    has: (name: string) => boolean;
+}
+/**
+ * Module context providing access to all Nexus services and utilities.
+ */
+interface ModuleContext {
+    core: CoreContext;
+    db: DbContext;
+    runtime: RuntimeContext;
+    config: ConfigContext;
+    engine: EngineContext;
+    services: ServicesContext;
+    adapters: AdaptersContext;
+    createRouter: () => Router;
+}
+/**
+ * HTTP method for custom routes
+ */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+/**
+ * Parameter definition for path or query parameters
+ */
+interface RouteParameterDefinition {
+    type: 'string' | 'integer' | 'boolean' | 'number';
+    description?: LocalizedString;
+    required?: boolean;
+    default?: string | number | boolean;
+    enum?: Array<string | number>;
+}
+/**
+ * Response schema definition for custom routes
+ */
+interface RouteResponseDefinition {
+    type: 'object' | 'array' | 'string' | 'boolean' | 'number';
+    properties?: Record<string, FieldDefinition>;
+    items?: {
+        $ref?: string;
+        type?: 'object' | 'string' | 'number' | 'boolean';
+        properties?: Record<string, FieldDefinition>;
+    };
+    description?: LocalizedString;
+}
+/**
+ * Custom route definition for OpenAPI documentation.
+ */
+interface CustomRouteDefinition {
+    method: HttpMethod;
+    path: string;
+    summary: LocalizedString;
+    description?: LocalizedString;
+    input?: Record<string, FieldDefinition>;
+    output?: RouteResponseDefinition;
+    params?: Record<string, RouteParameterDefinition>;
+    query?: Record<string, RouteParameterDefinition>;
+    auth?: boolean;
+    operationId?: string;
+    tags?: string[];
+}
+
+/**
+ * Entity definition types - discriminated union for all entity types
+ */
+
+/**
+ * Display mode for entity list views in the UI.
+ */
+type DisplayMode = 'table' | 'list' | 'masonry' | 'tree';
+/**
+ * All available entity type identifiers.
+ */
+type EntityType = 'collection' | 'single' | 'external' | 'virtual' | 'computed' | 'view' | 'reference' | 'config' | 'event' | 'temp' | 'action' | 'tree' | 'dag';
+/**
+ * Requirements that must be met to activate a module.
+ */
+interface ModuleRequirements {
+    /** Environment variables that must be defined */
+    env?: string[];
+    /** Other modules that must be loaded first */
+    modules?: string[];
+}
+/**
+ * Unified action definition for module, entity, and row-level actions.
+ */
+interface ActionDefinition {
+    /** Unique key for the action route */
+    key: string;
+    /** Display name for the action button/form */
+    label: LocalizedString;
+    /** Iconify icon identifier (default: 'mdi:play') */
+    icon?: string;
+    /** Entity type marker - required for standalone actions in module.definitions[] */
+    type?: 'action';
+    /** Action scope: module, entity, or row */
+    scope?: 'module' | 'entity' | 'row';
+    /** HTTP method for the action endpoint (default: 'POST') */
+    method?: 'GET' | 'POST' | 'DELETE' | 'PUT' | 'PATCH';
+    /** Custom middleware (e.g., multer for file uploads, rate limiting) */
+    middleware?: (ctx: ModuleContext) => RequestHandler | RequestHandler[];
+    /** Handler function that executes the action logic */
+    handler?: (ctx: ModuleContext, input: unknown, req?: Request, res?: Response) => Promise<unknown>;
+    /** Zod schema for validating input before execution */
+    inputSchema?: ValidationSchema;
+    /** Zod schema documenting the response structure */
+    outputSchema?: ValidationSchema;
+    /** Fields to select from the record (row-level only) */
+    select?: string[];
+    /** Form fields for UI generation */
+    fields?: Record<string, FieldDefinition>;
+    /** UI sidebar ordering (default: 999) */
+    order?: number;
+    /** HTTP status code for success response (default: 200) */
+    successStatus?: number;
+    /** Show action result in a modal (default: false — silent toast only) */
+    showResult?: boolean;
+    /** Skip authentication for this action */
+    skipAuth?: boolean;
+    /** CASL authorization configuration */
+    casl?: EntityCaslConfig | {
+        action?: string;
+        conditions?: Record<string, unknown>;
+    };
+    /** Batch/long-running action configuration. When set, action uses SSE for progress. */
+    batch?: BatchConfig;
+}
+/** @deprecated Use ActionDefinition instead */
+type EntityAction = ActionDefinition;
+/** Standalone action for module.definitions[] - requires type: 'action' */
+type StandaloneAction = ActionDefinition & {
+    type: 'action';
+};
+/**
+ * Base properties shared by all EntityDefinition types.
+ * @internal
+ */
+interface BaseEntityDefinition {
+    /** Database table name with module prefix */
+    table: string;
+    /** Display name for the UI (singular form) */
+    label: LocalizedString;
+    /** Display name for the UI (plural form) */
+    labelPlural?: LocalizedString;
+    /** Iconify MDI icon identifier */
+    icon?: string;
+    /** Field definitions keyed by field name */
+    fields: Record<string, FieldDefinition>;
+    /** CASL authorization configuration */
+    casl?: EntityCaslConfig;
+    /** If true, all endpoints are publicly accessible without authentication (default-deny) */
+    public?: boolean;
+    /** API route prefix */
+    routePrefix?: string;
+    /** UI sidebar ordering (default: 999) */
+    order?: number;
+    /** UI display mode */
+    displayMode?: DisplayMode;
+    /** Default sort configuration */
+    defaultSort?: {
+        field: string;
+        order: 'asc' | 'desc';
+    };
+    /** If true, hides from UI sidebar */
+    hidden?: boolean;
+    /** Middleware applied to all routes */
+    middleware?: (ctx: ModuleContext) => RequestHandler | RequestHandler[];
+    /** External adapter name for this entity's data source */
+    adapter?: string;
+}
+/**
+ * Collection entity - the most common entity type with full CRUD operations.
+ */
+interface CollectionEntityDefinition extends BaseEntityDefinition {
+    type?: 'collection';
+    /** Field used as display label in dropdowns */
+    labelField: string;
+    /** Auto-add created_at and updated_at timestamp columns */
+    timestamps?: boolean;
+    /** Auto-add created_by and updated_by user reference columns */
+    audit?: boolean;
+    /** Composite database indexes */
+    indexes?: EntityIndex[];
+    /** Use soft delete (deleted_at column) */
+    softDelete?: boolean;
+    /** Custom actions that operate on entity records */
+    actions?: ActionDefinition[];
+    /** Show "Create" button in UI */
+    allowCreate?: boolean;
+    /** Allow editing in UI */
+    allowEdit?: boolean;
+}
+/**
+ * Singleton entity - stores a single record in the shared sys_settings table.
+ */
+interface SingleEntityDefinition {
+    type: 'single';
+    /** Unique key in sys_settings table */
+    key: string;
+    label: LocalizedString;
+    labelPlural?: LocalizedString;
+    icon?: string;
+    fields: Record<string, FieldDefinition>;
+    /** Default values applied when the setting is first accessed */
+    defaults?: Record<string, unknown>;
+    casl?: EntityCaslConfig;
+    /** If true, all endpoints are publicly accessible without authentication (default-deny) */
+    public?: boolean;
+    routePrefix?: string;
+    actions?: EntityAction[];
+}
+/**
+ * Seed data configuration for reference/tree/dag entities.
+ */
+interface SeedConfig {
+    source: 'inline' | 'url' | 'file' | 'api';
+    data?: Array<Record<string, unknown>>;
+    url?: string;
+    file?: string;
+    uniqueKey?: string;
+    syncSchedule?: string;
+    headers?: Record<string, string>;
+    dataPath?: string;
+    transform?: string;
+}
+/**
+ * Reference entity - catalogs for lookups and dropdowns.
+ */
+interface ReferenceEntityDefinition extends BaseEntityDefinition {
+    type: 'reference';
+    labelField: string;
+    timestamps?: boolean;
+    indexes?: EntityIndex[];
+    seed?: Array<Record<string, unknown>> | SeedConfig;
+    allowCreate?: boolean;
+    allowEdit?: boolean;
+    allowDelete?: boolean;
+}
+/**
+ * Tree entity - hierarchical data with parent-child relationships.
+ */
+interface TreeEntityDefinition extends BaseEntityDefinition {
+    type: 'tree';
+    labelField?: string;
+    timestamps?: boolean;
+    audit?: boolean;
+    indexes?: EntityIndex[];
+    softDelete?: boolean;
+    actions?: EntityAction[];
+    seed: Array<Record<string, unknown>> | SeedConfig;
+    allowCreate?: boolean;
+    allowEdit?: boolean;
+    allowDelete?: boolean;
+    allowDragDrop?: boolean;
+}
+/**
+ * DAG entity - Directed Acyclic Graph with multiple parents.
+ */
+interface DagEntityDefinition extends BaseEntityDefinition {
+    type: 'dag';
+    labelField?: string;
+    timestamps?: boolean;
+    audit?: boolean;
+    indexes?: EntityIndex[];
+    softDelete?: boolean;
+    actions?: EntityAction[];
+    seed: Array<Record<string, unknown>> | SeedConfig;
+    parentsTable?: string;
+    allowCreate?: boolean;
+    allowEdit?: boolean;
+    allowDelete?: boolean;
+    allowDragDrop?: boolean;
+}
+/**
+ * Retention policy for automatic data cleanup.
+ */
+interface RetentionPolicy {
+    /** Delete records older than N seconds */
+    seconds?: number;
+    /** Delete records older than N days */
+    days?: number;
+    /** Keep only the most recent N records */
+    maxRows?: number;
+}
+/**
+ * Extended retention policy for temp entities.
+ */
+interface TempRetentionPolicy extends RetentionPolicy {
+    /** Field that stores the expiration timestamp */
+    expiresField?: string;
+}
+/**
+ * Event entity - append-only logs for audit trails.
+ */
+interface EventEntityDefinition extends BaseEntityDefinition {
+    type: 'event';
+    labelField: string;
+    timestamps?: boolean;
+    retention?: RetentionPolicy;
+    actions?: ActionDefinition[];
+}
+/** @deprecated Use ActionDefinition with `type: 'action'` instead */
+type ActionEntityDefinition = ActionDefinition & {
+    type: 'action';
+};
+/**
+ * External entity - read-only data from external APIs.
+ */
+interface ExternalEntityDefinition {
+    type: 'external';
+    label: LocalizedString;
+    labelPlural?: LocalizedString;
+    icon?: string;
+    labelField: string;
+    fields: Record<string, FieldDefinition>;
+    adapter: string;
+    table: string;
+    source?: Record<string, unknown>;
+    cache?: {
+        ttl: number;
+        key?: string;
+        invalidateOn?: string[];
+    };
+    casl?: EntityCaslConfig;
+    /** If true, all endpoints are publicly accessible without authentication (default-deny) */
+    public?: boolean;
+    routePrefix?: string;
+    order?: number;
+    displayMode?: DisplayMode;
+}
+/**
+ * Virtual entity - data aggregation across multiple sources.
+ */
+interface VirtualEntityDefinition {
+    type: 'virtual';
+    label: LocalizedString;
+    labelPlural?: LocalizedString;
+    icon?: string;
+    labelField: string;
+    fields: Record<string, FieldDefinition>;
+    sources: string[];
+    resolver?: (sources: Record<string, unknown[]>, ctx: ModuleContext) => unknown[] | Promise<unknown[]>;
+    casl?: EntityCaslConfig;
+    /** If true, all endpoints are publicly accessible without authentication (default-deny) */
+    public?: boolean;
+    routePrefix?: string;
+    order?: number;
+    displayMode?: DisplayMode;
+}
+/**
+ * Computed entity - dynamically calculated data like KPIs.
+ */
+interface ComputedEntityDefinition {
+    type: 'computed';
+    label: LocalizedString;
+    labelPlural?: LocalizedString;
+    icon?: string;
+    labelField?: string;
+    fields: Record<string, FieldDefinition>;
+    compute?: (ctx: ModuleContext, params?: Record<string, unknown>) => Promise<unknown[]>;
+    cache?: {
+        ttl: number;
+        invalidateOn?: string[];
+    };
+    isSingle?: boolean;
+    casl?: EntityCaslConfig;
+    /** If true, all endpoints are publicly accessible without authentication (default-deny) */
+    public?: boolean;
+    routePrefix?: string;
+    order?: number;
+    displayMode?: DisplayMode;
+    actions?: ActionDefinition[];
+    defaultSort?: {
+        field: string;
+        order: 'asc' | 'desc';
+    };
+    hidden?: boolean;
+}
+/**
+ * View entity - read-only database view or projection.
+ */
+interface ViewEntityDefinition {
+    type: 'view';
+    table: string;
+    label: LocalizedString;
+    labelPlural?: LocalizedString;
+    icon?: string;
+    labelField: string;
+    fields: Record<string, FieldDefinition>;
+    sourceEntity?: string;
+    query?: string | ((db: Knex) => Knex.QueryBuilder);
+    casl?: EntityCaslConfig;
+    /** If true, all endpoints are publicly accessible without authentication (default-deny) */
+    public?: boolean;
+    routePrefix?: string;
+    order?: number;
+}
+/**
+ * Config entity - scoped configuration settings.
+ */
+interface ConfigEntityDefinition extends BaseEntityDefinition {
+    type: 'config';
+    scopeField?: string;
+    scope?: 'global' | 'module' | 'tenant' | 'user';
+    defaults?: Record<string, unknown>;
+    timestamps?: boolean;
+    audit?: boolean;
+}
+/**
+ * Temporary entity - short-lived data with automatic expiration.
+ */
+interface TempEntityDefinition extends BaseEntityDefinition {
+    type: 'temp';
+    retention: TempRetentionPolicy;
+    labelField?: string;
+    indexes?: EntityIndex[];
+}
+/**
+ * Union of all entity definitions
+ */
+type EntityDefinition = CollectionEntityDefinition | SingleEntityDefinition | ExternalEntityDefinition | VirtualEntityDefinition | ComputedEntityDefinition | ViewEntityDefinition | ReferenceEntityDefinition | TreeEntityDefinition | DagEntityDefinition | ConfigEntityDefinition | EventEntityDefinition | TempEntityDefinition | ActionEntityDefinition;
+
+export { type ActionEntityDefinition as $, type ActionDefinition as A, type BatchConfig as B, type Category as C, type DisplayMode as D, type EntityType as E, type ForbiddenErrorInstance as F, type FilterValue as G, type EntityQuery as H, type DatabaseAdapter as I, type SchemaColumnInfo as J, type SchemaColumnBuilder as K, type SchemaTableBuilder as L, type ModuleAbilities as M, type SchemaForeignKeyBuilder as N, type SchemaAlterTableBuilder as O, type PaginationParams as P, type SchemaAdapter as Q, type ReferenceEntityDefinition as R, type SingleEntityDefinition as S, type TempEntityDefinition as T, type ModuleRequirements as U, type ViewEntityDefinition as V, type EntityAction as W, type StandaloneAction as X, type SeedConfig as Y, type RetentionPolicy as Z, type TempRetentionPolicy as _, type EntityDefinition as a, type BaseEntityService as a0, type CollectionEntityService as a1, type TempEntityService as a2, type EventEntityService as a3, type SingleEntityService as a4, type ConfigEntityService as a5, type ReferenceEntityService as a6, type ViewEntityService as a7, type ComputedEntityService as a8, type ExternalEntityService as a9, type CoreContext as aA, type DbContext as aB, type RuntimeContext as aC, type ConfigContext as aD, type EngineContext as aE, type ServicesContext as aF, type AdaptersContext as aG, type ModuleContext as aH, type HttpMethod as aI, type RouteParameterDefinition as aJ, type RouteResponseDefinition as aK, type CustomRouteDefinition as aL, type CategoryMeta as aM, type ActionInjection as aN, type ModuleManifest as aO, type AppManifest as aP, type PluginEnvVar as aQ, type PluginConfigField as aR, type PluginConfigSchema as aS, type PluginSetupInfo as aT, type PluginManifest as aU, type RegisterPluginOptions as aV, CATEGORIES as aW, CATEGORY_ORDER as aX, type VirtualEntityService as aa, type ActionEntityService as ab, type EntityServiceHooks as ac, type CreateEntityServiceOptions as ad, type BaseRolesService as ae, type BaseUsersService as af, type SendMailOptions as ag, type SendMailResult as ah, type BaseMailService as ai, type LoggerReporter as aj, type CoreServices as ak, type ValidationSchema as al, type ValidateSchemas as am, type RateLimitOptions as an, type ModuleMiddlewares as ao, type EventEmitterLike as ap, type ContextCrypto as aq, type ContextLRUCacheOptions as ar, type ContextLRUCache as as, type ContextCache as at, type SocketIOServer as au, type SocketIOBroadcastOperator as av, type ContextSocket as aw, type ContextHelpers as ax, type EntityHandler as ay, type EntityController as az, type CollectionEntityDefinition as b, type EventEntityDefinition as c, type ConfigEntityDefinition as d, type TreeEntityDefinition as e, type DagEntityDefinition as f, type ExternalEntityDefinition as g, type VirtualEntityDefinition as h, type ComputedEntityDefinition as i, type SSEHelper as j, type SSESender as k, type SSEOptions as l, type BatchProgressEvent as m, type BatchLogEntry as n, type BaseAuthRequest as o, type BaseUser as p, type PaginationParamsWithOffset as q, type PaginatedResult as r, type ValidationDetail as s, type CaslAction as t, type RolePermission as u, type EntityCaslConfig as v, type AbilityLike as w, type ForbiddenErrorConstructor as x, type AuthRequest as y, type FilterOperators as z };