@flusys/nestjs-entity-builder 9.1.2 → 9.2.1

package/services/definition-bundle.service.d.ts

@@ -1,9 +1,10 @@
-import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type ILoggedUserInfo, type IPermissionActionRegistry } from '@flusys/nestjs-shared/interfaces';
 import { type ExportBundleDto } from '../dtos/definition-bundle.dto.js';
 import { type IBundleExport, type IBundleImportPlan, type IBundleImportResult, type IImportBundleRequest } from '../interfaces/definition-bundle.interface.js';
 import { EntityBuilderConfigService } from './entity-builder-config.service.js';
 import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
 import { FlowDefinitionService } from './flow-definition.service.js';
+import { SchemaDialectAdapterService } from './schema-dialect-adapter.service.js';
 import { SchemaEvolutionService } from './schema-evolution.service.js';
 import { SchemaSyncService } from './schema-sync.service.js';
 export declare class DefinitionBundleService {
@@ -12,12 +13,15 @@ export declare class DefinitionBundleService {
     private readonly schemaSync;
     private readonly evolution;
     private readonly flows;
-    constructor(provider: EntityBuilderDataSourceProvider, config: EntityBuilderConfigService, schemaSync: SchemaSyncService, evolution: SchemaEvolutionService, flows: FlowDefinitionService);
-    private variables;
+    private readonly dialect;
+    private readonly actionRegistry?;
+    constructor(provider: EntityBuilderDataSourceProvider, config: EntityBuilderConfigService, schemaSync: SchemaSyncService, evolution: SchemaEvolutionService, flows: FlowDefinitionService, dialect: SchemaDialectAdapterService, actionRegistry?: IPermissionActionRegistry | undefined);
     export(dto: ExportBundleDto): Promise<IBundleExport>;
+    private leftBehind;
     private loadEntities;
     planImport(dto: IImportBundleRequest, user: ILoggedUserInfo | null): Promise<IBundleImportPlan>;
     private buildPlan;
+    private addPermissionWarnings;
     private relationNotYetCreated;
     private previewEntityStep;
     private diffFlows;
@@ -25,8 +29,11 @@ export declare class DefinitionBundleService {
     private createRequest;
     private changeRequest;
     applyImport(dto: IImportBundleRequest, user: ILoggedUserInfo | null): Promise<IBundleImportResult>;
+    private withImportLock;
+    private runImport;
     private applyEntityStep;
     private idIsFree;
     private freeFieldIds;
     private applyFlowStep;
+    private deactivateFlow;
 }

package/services/entity-builder-config.service.d.ts

@@ -9,6 +9,9 @@ export declare class EntityBuilderConfigService implements IModuleConfigService
     isMultiTenant(): boolean;
     getOptions(): EntityBuilderModuleOptions;
     getConfig(): import("../index.js").IEntityBuilderConfig | undefined;
+    isFastUpdatesEnabled(): boolean;
+    isPartialIndexesEnabled(): boolean;
     isDesignerReadOnly(): boolean;
+    getCodeModules(): Record<string, string>;
     getBundleVariables(): Record<string, string>;
 }

package/services/entity-builder-datasource.provider.d.ts

@@ -19,6 +19,7 @@ export declare class EntityBuilderDataSourceProvider extends MultiTenantDataSour
     protected createDataSourceFromConfig(config: IDatabaseConfig): Promise<DataSource>;
     getDriver(): Promise<SupportedDbDriver>;
     registerDynamicSchema(schema: EntitySchema): Promise<void>;
+    registerDynamicSchemas(schemas: EntitySchema[]): Promise<void>;
     getDynamicRepository<T extends ObjectLiteral>(schema: EntitySchema<T>): Promise<Repository<T>>;
     getQueryRunner(): Promise<QueryRunner>;
 }

package/services/entity-flow-scaffold.d.ts

@@ -15,11 +15,12 @@ export interface IEntityFlowSource {
     label: string;
     fields: IEntityFlowField[];
 }
-type FlowInputLabel = 'id' | 'ids' | 'search';
+type FlowInputLabel = 'id';
 export interface IEntityFlowTexts {
     names?: Partial<Record<EntityFlowEndpoint, string>>;
     inputLabels?: Partial<Record<FlowInputLabel, string>>;
     noMatchMessage?: string;
+    deleteOnlyMessage?: string;
 }
 export declare const ENTITY_FLOW_PATHS: Record<EntityFlowEndpoint, string>;
 export declare const entityFlowSlug: (entityCode: string) => string;

package/services/entity-permission.service.d.ts

@@ -1,5 +1,6 @@
 import { type IPermissionActionRegistry } from '@flusys/nestjs-shared';
 import { EntityDefinition } from '../entities/entity-definition.entity.js';
+export declare const entityPermissionCodes: (entityCode: string) => string[];
 export declare class EntityPermissionService {
     private readonly actionRegistry?;
     constructor(actionRegistry?: IPermissionActionRegistry | undefined);

package/services/field-value-validator.d.ts

@@ -11,6 +11,13 @@ export interface IValidatableField {
     selectOptions: unknown[] | null;
     validationRules: Record<string, unknown> | null;
 }
+export declare const valueRulesOf: (field: {
+    code: string;
+    label?: string | null;
+    fieldType: FieldType;
+    selectOptions?: unknown[] | null;
+    validationRules?: Record<string, unknown> | null;
+}) => IValidatableField;
 export declare function validateRecord(fields: IValidatableField[], values: Record<string, unknown>, mode: 'insert' | 'update'): {
     values: Record<string, unknown>;
     errors: IFieldError[];

package/services/flow-definition.service.d.ts

@@ -10,9 +10,11 @@ import { FlowDefinition } from '../entities/flow-definition.entity.js';
 import { type IFlowValidationResult } from '../flow-engine/flow-graph.validator.js';
 import { type IFlowEndpoint, type IFlowSettings } from '../flow-engine/flow.types.js';
 import { type IFlowDefinition, type IFlowSnapshot, type IFlowVersion } from '../interfaces/flow-definition.interface.js';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
 import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
 export declare const defaultFlowPermissionCode: (slug: string) => string;
 export declare const flowPermissions: (endpoint: Pick<IFlowEndpoint, "permissions">, slug: string) => ILogicNode;
+export declare const asksExecutePermission: (endpoint: Pick<IFlowEndpoint, "authMode" | "permissions">) => boolean;
 export declare const flowNotFound: () => NotFoundException;
 export declare const isPublished: (flow: Pick<FlowDefinition, "version">) => boolean;
 export declare function snapshotOf(source: Partial<IFlowSnapshot>): IFlowSnapshot;
@@ -30,9 +32,11 @@ export declare class FlowDefinitionService extends ApiService<CreateFlowDefiniti
     private readonly notifications?;
     private readonly email?;
     private readonly companyAccess?;
-    constructor(cacheManager: HybridCache, utilsService: UtilsService, provider: EntityBuilderDataSourceProvider, permissionCache: SharedPermissionCacheService, actionRegistry?: IPermissionActionRegistry | undefined, notifications?: INotificationAdapter | undefined, email?: IEmailAdapter | undefined, companyAccess?: ICompanyAccessResolver | undefined);
+    private readonly config?;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, provider: EntityBuilderDataSourceProvider, permissionCache: SharedPermissionCacheService, actionRegistry?: IPermissionActionRegistry | undefined, notifications?: INotificationAdapter | undefined, email?: IEmailAdapter | undefined, companyAccess?: ICompanyAccessResolver | undefined, config?: EntityBuilderConfigService | undefined);
     findOrFail(id: string): Promise<FlowDefinition>;
     validate(settings: IFlowSettings): Promise<IFlowValidationResult>;
+    codePackages(): string[];
     private callersOf;
     private assertNotCalled;
     private assertCallersKept;
@@ -56,8 +60,12 @@ export declare class FlowDefinitionService extends ApiService<CreateFlowDefiniti
     restoreVersion(flowId: string, version: number, user: ILoggedUserInfo | null): Promise<FlowDefinition>;
     discardDraft(flowId: string, user: ILoggedUserInfo | null): Promise<FlowDefinition>;
     private saveDraft;
-    private clearCaches;
-    protected beforeDeleteOperation(dto: DeleteDto, user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
+    delete(option: DeleteDto, user: ILoggedUserInfo | null): Promise<null>;
+    protected beforeDeleteOperation(dto: DeleteDto, _user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
+    protected afterDeleteOperation(deleted: Array<{
+        id: string;
+    }>, _dto: DeleteDto, _user: ILoggedUserInfo | null, qr: QueryRunner): Promise<void>;
+    private deprovisionPermissions;
     private provisionPermissions;
 }
 export {};

package/services/flow-executor.service.d.ts

@@ -27,6 +27,7 @@ export declare class FlowExecutorService {
     private readonly email?;
     private readonly branchHierarchy?;
     private readonly logger;
+    private readonly inFlight;
     constructor(provider: EntityBuilderDataSourceProvider, ruleEngine: RuleEngineService, moduleRef: ModuleRef, permissionCache: SharedPermissionCacheService, config: EntityBuilderConfigService, companyAccess?: ICompanyAccessResolver | undefined, notifications?: INotificationAdapter | undefined, email?: IEmailAdapter | undefined, branchHierarchy?: IBranchHierarchyResolver | undefined);
     run(flow: IFlowSettings, options: IFlowRunOptions): Promise<IFlowRunResult>;
     private execute;
@@ -37,5 +38,7 @@ export declare class FlowExecutorService {
     private findCallable;
     private assertMayCall;
     private createEnv;
+    private publishAfterCommit;
+    whenPublished(): Promise<void>;
     private publishPendingEvents;
 }

package/services/flow-runtime.service.d.ts

@@ -1,4 +1,6 @@
+import { HybridCache } from '@flusys/nestjs-shared/classes';
 import { type ILoggedUserInfo, type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { type TestFlowDto } from '../dtos/flow.dto.js';
 import { FlowDefinition } from '../entities/flow-definition.entity.js';
 import { type IFlowRunResult } from '../flow-engine/flow-run.types.js';
@@ -19,8 +21,12 @@ export declare class FlowRuntimeService {
     private readonly executor;
     private readonly executions;
     private readonly definitions;
-    constructor(provider: EntityBuilderDataSourceProvider, executor: FlowExecutorService, executions: FlowExecutionService, definitions: FlowDefinitionService);
+    private readonly cache?;
+    private readonly utils?;
+    constructor(provider: EntityBuilderDataSourceProvider, executor: FlowExecutorService, executions: FlowExecutionService, definitions: FlowDefinitionService, cache?: HybridCache | undefined, utils?: UtilsService | undefined);
     findActive(slug: string): Promise<FlowDefinition | null>;
+    private activeFlowKey;
+    tenantScope(): string;
     handle(flow: FlowDefinition, endpoint: IFlowEndpoint, body: unknown, caller: IFlowCaller, user: ILoggedUserInfo | null): Promise<IFlowRunResult>;
     testRun(dto: TestFlowDto, user: ILoggedUserInfo | null, caller: IFlowCaller): Promise<{
         result: IFlowRunResult;

package/services/generic-entity-service.factory.d.ts

@@ -1,12 +1,16 @@
 import { type QueryRunner } from 'typeorm';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
 import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
 import { GenericEntityService } from './generic-entity.service.js';
 import { SchemaRegistryService } from './schema-registry.service.js';
 export declare class GenericEntityServiceFactory {
     private readonly schemaRegistry;
     private readonly dataSourceProvider;
-    constructor(schemaRegistry: SchemaRegistryService, dataSourceProvider: EntityBuilderDataSourceProvider);
+    private readonly config?;
+    private readonly relatedById;
+    constructor(schemaRegistry: SchemaRegistryService, dataSourceProvider: EntityBuilderDataSourceProvider, config?: EntityBuilderConfigService | undefined);
     forEntityCode(entityCode: string, queryRunner?: QueryRunner): Promise<GenericEntityService>;
     forEntityDefinitionId(entityDefinitionId: string, queryRunner?: QueryRunner): Promise<GenericEntityService>;
+    private related;
     private build;
 }

package/services/generic-entity.service.d.ts

@@ -1,4 +1,5 @@
 import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { BadRequestException } from '@nestjs/common';
 import { type EntitySchema, type QueryRunner } from 'typeorm';
 import { EntityDefinition } from '../entities/entity-definition.entity.js';
 import { FieldDefinition } from '../entities/field-definition.entity.js';
@@ -14,13 +15,19 @@ export interface IGenericQuery {
         currentPage: number;
         pageSize: number;
     };
+    withDeleted?: boolean;
 }
 export interface IGenericWriteOptions {
     queryRunner?: QueryRunner;
     publishEvents?: boolean;
+    statementTimeoutMs?: number;
 }
+export declare const statementTimeoutSql: (timeoutMs: number) => string;
 export declare const ACTOR_BRANCH_METADATA_KEY = "_actorBranchId";
 export declare function actorMetadata(user: ILoggedUserInfo | null): Record<string, unknown>;
+export interface IGenericEntityOptions {
+    fastUpdates?: boolean;
+}
 export type RelatedServiceResolver = (entityDefinitionId: string, queryRunner?: QueryRunner) => Promise<GenericEntityService>;
 export declare class GenericEntityService {
     private readonly definition;
@@ -28,35 +35,51 @@ export declare class GenericEntityService {
     private readonly fields;
     private readonly dataSourceProvider;
     private readonly resolveRelated?;
+    private readonly options;
     private repository?;
     private readonly activeFieldCodes;
     private readonly presentSystemColumns;
-    constructor(definition: EntityDefinition, schema: EntitySchema, fields: FieldDefinition[], dataSourceProvider: EntityBuilderDataSourceProvider, resolveRelated?: RelatedServiceResolver | undefined);
+    constructor(definition: EntityDefinition, schema: EntitySchema, fields: FieldDefinition[], dataSourceProvider: EntityBuilderDataSourceProvider, resolveRelated?: RelatedServiceResolver | undefined, options?: IGenericEntityOptions);
     get entityCode(): string;
     private validateValues;
     private throwIfInvalid;
+    private invalid;
     private assertRelationsExist;
+    private relatedNotFound;
+    private existingRelatedIds;
     private notFound;
     private auditFields;
-    private stampDeletedBy;
     private ensureActive;
     private repositoryFor;
     private ensureRepository;
     private validateKeys;
     insert(dto: Record<string, unknown>, user: ILoggedUserInfo | null, options?: IGenericWriteOptions): Promise<IGenericRecord>;
+    prepareInsert(dto: Record<string, unknown>): Record<string, unknown>;
+    firstMissingRelation(rows: Record<string, unknown>[], queryRunner: QueryRunner): Promise<{
+        index: number;
+        error: BadRequestException;
+    } | null>;
+    insertValidated(rows: Record<string, unknown>[], user: ILoggedUserInfo | null, options: IGenericWriteOptions & {
+        queryRunner: QueryRunner;
+    }): Promise<IGenericRecord[]>;
+    get batchInsertable(): boolean;
+    private missingRelations;
     update(dto: Record<string, unknown> & {
         id: string;
     }, user: ILoggedUserInfo | null, options?: IGenericWriteOptions): Promise<IGenericRecord>;
     private insertRow;
+    updateLoaded(row: IGenericRecord, dto: Record<string, unknown>, user: ILoggedUserInfo | null, options?: IGenericWriteOptions): Promise<IGenericRecord>;
     private updateRow;
     private assertUpdatable;
     delete(id: string, user: ILoggedUserInfo | null, options?: IGenericWriteOptions): Promise<'deleted' | 'purged'>;
     findById(id: string, options?: IGenericReadOptions): Promise<IGenericRecord>;
     exists(id: string, options?: IGenericReadOptions): Promise<boolean>;
+    existingIds(ids: string[], options?: IGenericReadOptions): Promise<Set<string>>;
     getAll(search: string | undefined, query: IGenericQuery, options?: IGenericReadOptions): Promise<{
         data: IGenericRecord[];
         total: number;
     }>;
+    private totalOf;
     private applyFilter;
     private conditionSql;
     private listOperand;

package/services/identifier-rules.d.ts

@@ -1,5 +1,4 @@
 import { type FieldType } from '../enums/field-type.enum.js';
-export declare const RESERVED_WORDS: Set<string>;
 export declare function assertValidIdentifier(code: string, kind: 'entity' | 'field'): void;
 export declare function assertIndexableField(field: {
     code: string;

package/services/save-loaded.d.ts

@@ -0,0 +1,2 @@
+import { type EntityTarget, type ObjectLiteral, type QueryRunner } from 'typeorm';
+export declare function saveLoaded<T extends ObjectLiteral>(queryRunner: QueryRunner, target: EntityTarget<T>, entity: T, databaseEntity: T): Promise<T>;

package/services/schema-change-executor.service.d.ts

@@ -29,6 +29,7 @@ export declare class SchemaChangeExecutor {
         plan: ISchemaChangePlan;
         outcome: ISchemaChangeOutcome;
     }>;
+    private invalidateDefinitions;
     private compensate;
     private withUndo;
     private logFailure;

package/services/schema-columns.d.ts

@@ -4,7 +4,10 @@ import { FieldType } from '../enums/field-type.enum.js';
 import { type SupportedDbDriver } from '../interfaces/schema-dialect-adapter.interface.js';
 import { type SchemaDialectAdapterService } from './schema-dialect-adapter.service.js';
 export declare const SYSTEM_COLUMN_NAMES: readonly ["id", "created_at", "updated_at", "deleted_at", "created_by_id", "updated_by_id", "deleted_by_id"];
-export declare const NON_INDEXABLE_FIELD_TYPES: readonly FieldType[];
+export declare const indexedByDefault: (spec: {
+    fieldType: FieldType;
+    isIndexed?: boolean | null;
+}) => boolean;
 export declare const isIndexableFieldType: (fieldType: FieldType) => boolean;
 export interface ISystemColumnFlags {
     isSoftDeleteEnabled: boolean;
@@ -15,7 +18,9 @@ export declare const softDeleteColumn: () => TableColumn;
 export declare const auditColumns: (driver: SupportedDbDriver) => TableColumn[];
 export declare const sameColumns: (columnNames: string[], expected: string[]) => boolean;
 export declare function indexName(prefix: 'idx' | 'uq', table: string, column: string, maxLength: number): string;
-export declare const plainIndex: (table: string, column: string, driver: SupportedDbDriver, adapter: SchemaDialectAdapterService) => TableIndex;
+export declare const LIVE_ROWS_WHERE = "\"deleted_at\" IS NULL";
+export declare const plainIndex: (table: string, column: string, driver: SupportedDbDriver, adapter: SchemaDialectAdapterService, liveOnly?: boolean) => TableIndex;
+export declare const isLiveRowsIndex: (index: Pick<TableIndex, "where">) => boolean;
 export declare const tableUnique: (table: string, column: string, driver: SupportedDbDriver, adapter: SchemaDialectAdapterService) => TableUnique;
 export declare function addUnique(qr: QueryRunner, table: Table, column: string, driver: SupportedDbDriver, adapter: SchemaDialectAdapterService): Promise<void>;
 export declare function buildFieldColumn(field: Pick<FieldDefinition, 'code' | 'fieldType' | 'dbType' | 'nullable' | 'unique'>, driver: SupportedDbDriver, adapter: SchemaDialectAdapterService, options: {

package/services/schema-dialect-adapter.service.d.ts

@@ -9,5 +9,7 @@ export declare class SchemaDialectAdapterService implements ISchemaDialectAdapte
     sqlLiteral(value: unknown, driver: SupportedDbDriver): string;
     lockName(lockKey: string): string;
     acquireEntityLock(queryRunner: QueryRunner, lockKey: string, driver: SupportedDbDriver): Promise<void>;
+    tryAcquireSessionLock(queryRunner: QueryRunner, lockKey: string, driver: SupportedDbDriver): Promise<boolean>;
+    releaseSessionLock(queryRunner: QueryRunner, lockKey: string, driver: SupportedDbDriver): Promise<void>;
     releaseEntityLock(queryRunner: QueryRunner, lockKey: string, driver: SupportedDbDriver): Promise<void>;
 }

package/services/schema-evolution.service.d.ts

@@ -6,6 +6,7 @@ import { EntityPermissionService } from './entity-permission.service.js';
 import { ReferenceScannerService } from './reference-scanner.service.js';
 import { SchemaChangeExecutor } from './schema-change-executor.service.js';
 import { type ISchemaChangeApplied, type ISchemaChangePlan } from './schema-change.types.js';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
 import { SchemaDialectAdapterService } from './schema-dialect-adapter.service.js';
 export type SchemaFindingKind = 'missing_table' | 'missing_column' | 'extra_column' | 'type_mismatch' | 'nullability_mismatch' | 'missing_index' | 'missing_unique' | 'stale_metadata';
 export interface ISchemaFinding extends IMessageRef {
@@ -28,13 +29,14 @@ export declare class SchemaEvolutionService {
     private readonly executor;
     private readonly references;
     private readonly permissions;
-    constructor(dataSourceProvider: EntityBuilderDataSourceProvider, adapter: SchemaDialectAdapterService, executor: SchemaChangeExecutor, references: ReferenceScannerService, permissions: EntityPermissionService);
+    private readonly config?;
+    constructor(dataSourceProvider: EntityBuilderDataSourceProvider, adapter: SchemaDialectAdapterService, executor: SchemaChangeExecutor, references: ReferenceScannerService, permissions: EntityPermissionService, config?: EntityBuilderConfigService | undefined);
     plan(request: SchemaChangeRequestDto, user: ILoggedUserInfo | null): Promise<ISchemaChangePlan>;
     apply(request: SchemaChangeRequestDto, user: ILoggedUserInfo | null, options?: {
         fieldId?: string;
     }): Promise<ISchemaChangeApplied>;
     inspect(entityDefinitionId: string): Promise<ISchemaCheckResult>;
-    history(entityDefinitionId: string, limit?: number): Promise<SchemaChangeLog[]>;
+    history(entityDefinitionId: string): Promise<SchemaChangeLog[]>;
     private loadEntity;
     private loadField;
     private definitions;
@@ -56,12 +58,16 @@ export declare class SchemaEvolutionService {
     private dropUniques;
     private hasUnique;
     private indexOn;
+    private liveOnly;
+    private hasPlainIndex;
+    private rebuildPlainIndex;
     private prepareAddField;
     private prepareUpdateField;
     private prepareDeprecateField;
     private prepareRestoreField;
     private preparePurgeField;
     private prepareUpdateEntity;
+    private reshapePlainIndexes;
     private relationsInto;
     private prepareDropEntity;
     private diff;

package/services/schema-registry.service.d.ts

@@ -1,12 +1,24 @@
 import { EntitySchema, type QueryRunner } from 'typeorm';
+import { EntityDefinition } from '../entities/entity-definition.entity.js';
+import { FieldDefinition } from '../entities/field-definition.entity.js';
 import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
 import { SchemaDialectAdapterService } from './schema-dialect-adapter.service.js';
+export interface IResolvedSchema {
+    schema: EntitySchema;
+    fields: FieldDefinition[];
+}
 export declare class SchemaRegistryService {
     private readonly dataSourceProvider;
     private readonly dialectAdapter;
     private static readonly cache;
+    private static readonly warming;
+    private readonly logger;
     constructor(dataSourceProvider: EntityBuilderDataSourceProvider, dialectAdapter: SchemaDialectAdapterService);
     getSchema(entityDefinitionId: string, queryRunner?: QueryRunner): Promise<EntitySchema>;
+    resolve(definition: EntityDefinition, queryRunner?: QueryRunner): Promise<IResolvedSchema>;
+    warmUp(queryRunner?: QueryRunner): Promise<void>;
+    private registerAll;
+    private store;
     invalidate(entityDefinitionId: string): void;
     private cacheKey;
     private buildEntitySchema;

package/services/schema-sync.service.d.ts

@@ -6,6 +6,7 @@ import { EntityPermissionService } from './entity-permission.service.js';
 import { FlowDefinitionService } from './flow-definition.service.js';
 import { SchemaChangeExecutor } from './schema-change-executor.service.js';
 import { type ISchemaChangePlan } from './schema-change.types.js';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
 import { SchemaDialectAdapterService } from './schema-dialect-adapter.service.js';
 export interface ICreatedEntity {
     definition: EntityDefinition;
@@ -21,8 +22,9 @@ export declare class SchemaSyncService {
     private readonly executor;
     private readonly entityPermissionService;
     private readonly flowDefinitionService;
+    private readonly config?;
     private readonly logger;
-    constructor(dataSourceProvider: EntityBuilderDataSourceProvider, dialectAdapter: SchemaDialectAdapterService, executor: SchemaChangeExecutor, entityPermissionService: EntityPermissionService, flowDefinitionService: FlowDefinitionService);
+    constructor(dataSourceProvider: EntityBuilderDataSourceProvider, dialectAdapter: SchemaDialectAdapterService, executor: SchemaChangeExecutor, entityPermissionService: EntityPermissionService, flowDefinitionService: FlowDefinitionService, config?: EntityBuilderConfigService | undefined);
     private validateCreateRequest;
     private createTarget;
     private createRun;

package/flow-engine/flow-code-sandbox.d.ts

@@ -1,5 +0,0 @@
-export interface ICodeRunResult {
-    output: unknown;
-    logs: string[];
-}
-export declare function runSandboxedCode(code: string, ctx: Record<string, unknown>, timeoutMs: number, node: string): Promise<ICodeRunResult>;