@elyx-code/project-logic-tree 0.0.6384 → 0.0.6385

package/dist/index.d.ts

@@ -2,11 +2,13 @@ import { BinaryExpr } from 'sql-parser-cst';
 import { CloudProviders } from '@elyx-code/definitions';
 import { default as default_2 } from 'zod';
 import { DTOAction } from '@elyx-code/definitions';
+import { EventCallback } from '@elyx-code/common-ts-utils';
 import { Events } from '@elyx-code/common-ts-utils';
 import { Expr } from 'sql-parser-cst';
 import { ForSystemTimeAsOfExpr } from 'sql-parser-cst';
 import { FromClause } from 'sql-parser-cst';
 import { IDeploymentStepDefinition } from '@elyx-code/definitions';
+import { IEventsBus } from '@elyx-code/common-ts-utils';
 import { IInfrastructureResource } from '@elyx-code/definitions';
 import { ILiveMessageDTO } from '@elyx-code/definitions';
 import { InfrastructureResourceDetails } from '@elyx-code/definitions';
@@ -1462,6 +1464,8 @@ export declare enum BuiltInFunctionIds {
     AbortExecution = "base-abort-execution"
 }
 
+export declare type BuiltInFunctionsImplementationModule = Record<BuiltInFunctionIds, (entity: InternalCallState, inputs: IDynamicValue[]) => Promise<IExecutionResult>>;
+
 export declare type BuiltInSystemEntityState = PrimitiveEntityState | BuiltInBaseEntityState;
 
 export declare type BuiltInSystemEntityStateConstructor = typeof BuiltInBaseEntityState | typeof PrimitiveEntityState;
@@ -1771,7 +1775,7 @@ export declare const CHILDREN_TYPES: EntityType[];
 
 export declare function cloneProject(project: ProjectState, { enrich, }?: {
     enrich: boolean;
-}): ProjectState;
+}, parentContext?: IProjectInstanceParentContext): ProjectState;
 
 declare class ColumnRef implements ISearchNode {
     owner: SearchStatementState;
@@ -2482,6 +2486,12 @@ export declare const dateValueAutogenerationSchema: z_2.ZodUnion<[z_2.ZodObject<
     rangeEnd: null;
 }>]>;
 
+export declare const DEFAULT_EXECUTION_INSTANCE_PARENT_CONTEXT: IExecutionInstanceParentContext;
+
+export declare const DEFAULT_PROJECT_INSTANCE_PARENT_CONTEXT: IProjectInstanceParentContext;
+
+export declare const DEFAULT_PROJECT_STATIC_PARENT_CONTEXT: IProjectStaticParentContext;
+
 export declare const DEFAULT_UUID_MODULE: UUIDModule;
 
 export declare enum DefinitionEntityDependencyField {
@@ -2812,6 +2822,10 @@ export declare enum DynamicValueTypes {
 
 export declare const EDITABLE_PERSISTANCE_REPOSITORY_DEFAULTS: IEditableEntityPersistanceRepository;
 
+declare interface EditorContext extends ExtensionContextBase {
+    logic: ProjectLogicContext;
+}
+
 export declare class EfimeralValueStore implements IValueStoreClient {
     initialized: boolean;
     id: string;
@@ -3319,6 +3333,7 @@ export declare type ExecutableEntityTransfer = CallableEntityTransfer | EntryPoi
 export declare type ExecutableEntityTypesUnion = ExecutableEntity | ExecutableEntityTransfer | ExecutableEntityShallowTransfer | ExecutableEntityGenerationTarget;
 
 export declare class Execution extends Events {
+    readonly parentContext: IExecutionInstanceParentContext;
     project: ProjectState;
     entryPoint: TestableEntityState;
     state: ExecutionState;
@@ -3337,25 +3352,8 @@ export declare class Execution extends Events {
     onRemoveFromSkippedListCallback: null | ((entity: TestableEntityState) => void);
     onAddEntityCallback: null | ((entity: TestableEntityState) => void);
     onRemoveEntityCallback: null | ((entity: TestableEntityState) => void);
-    static searchImplementation: (entity: SearchState, inputs: IDynamicValue[]) => Promise<{
-        data: {
-            [columnName: string]: any;
-        } | null | {
-            [columnName: string]: any;
-        }[];
-        error: string | null;
-    }>;
-    static builtInFunctionImplementations: Record<BuiltInFunctionIds, (entity: InternalCallState, inputs: IDynamicValue[]) => Promise<IExecutionResult>>;
-    constructor(project: ProjectState, entities: TestableEntityState[], entryPoint: TestableEntityState, parentExecution?: Execution | null);
+    constructor(project: ProjectState, entities: TestableEntityState[], entryPoint: TestableEntityState, parentExecution?: Execution | null, parentContext?: IExecutionInstanceParentContext);
     get valueResolutionContext(): IValueResolutionContext;
-    static injectSearchImplementation(implementation: (entity: SearchState, inputs: IDynamicValue[]) => Promise<{
-        data: {
-            [columnName: string]: any;
-        } | null | {
-            [columnName: string]: any;
-        }[];
-        error: string | null;
-    }>): void;
     skip(entity: TestableEntityState): void;
     schedule(entity: TestableEntityState, inputs?: IDynamicValue[], client?: IExecutionClient): Promise<IExecutionResult | null>;
     mergeExernalValuesWithInternalInputs(externalValues: IDynamicValue[], entity: EntityState): IDynamicValue[];
@@ -3441,6 +3439,75 @@ export declare class ExplicitInfrastructureResource extends InfrastructureResour
     resolveDeterministicResourceId(): string;
 }
 
+declare type ExtensionContext = EditorContext;
+
+declare class ExtensionContextBase implements IExtensionContextBase {
+    readonly registry: ExtensionsRegistry;
+    readonly contextType: ExtensionContextType;
+    constructor(registry: ExtensionsRegistry, contextType: ExtensionContextType);
+    on<Arguments extends any[]>(eventName: string, callback: EventCallback<Arguments>): void;
+    emit<Arguments extends any[]>(eventName: string, ...args: Arguments): void;
+    off<Arguments extends any[]>(eventName: string, callback?: EventCallback<Arguments>): void;
+}
+
+declare enum ExtensionContextType {
+    Logic = "logic",
+    GUI = "gui",
+    Editor = "editor",
+    Compile = "compile"
+}
+
+declare interface ExtensionManifest {
+    id: string;
+    version: string;
+    description?: string;
+    initPriority?: ExtentionPriority;
+    permissions: ExtensionPermissions[];
+    contexts: ExtensionContextType[];
+    dependencies?: string[];
+}
+
+declare type ExtensionModule<T extends object = {}> = T & ExtensionModuleCore;
+
+declare interface ExtensionModuleCore {
+    /** Called once on editor startup */
+    init?(contexts: ExtensionContext[]): Promise<void> | void;
+    /** Cleanup hook */
+    destroy?(): Promise<void> | void;
+}
+
+declare enum ExtensionPermissions {
+    OnCompileBefore = "on:compile:before:DefinitionEntity",
+    OnCompileDefault = "on:compile:default:DefinitionEntity",
+    OnCompileAfter = "on:compile:after:DefinitionEntity",
+    EmitCompile = "emit:compile:DefinitionEntity",
+    DoEditorPublish = "do:editor:publish",
+    PostGUICanvasSlotNewToolbarButton = "write:gui:canvas:slot:toolbar-button",
+    ReadGUICanvasSlotToolbarButtons = "read:gui:canvas:slot:toolbar-buttons",
+    UpdateGUIGlobalTheme = "update:gui:global:theme"
+}
+
+declare class ExtensionsRegistry implements Omit<IEventsBus, 'destroy'> {
+    private events;
+    private extensions;
+    constructor(events?: Events);
+    get extensionInOrder(): RegisteredExtension[];
+    private requestContext;
+    requestModule<T>(moduleId: string): T;
+    register(manifest: ExtensionManifest, module: ExtensionModule): void;
+    initAll(): Promise<void>;
+    destroyAll(): Promise<void>;
+    on<Arguments extends any[]>(eventName: string, callback: EventCallback<Arguments>): void;
+    emit<Arguments extends any[]>(eventName: string, ...args: Arguments): void;
+    off<Arguments extends any[]>(eventName: string, callback?: EventCallback<Arguments>): void;
+}
+
+declare enum ExtentionPriority {
+    High = 1,
+    Normal = 5,
+    Low = 10
+}
+
 export declare function filterOutDuplicateEntities(entities: (EntityState | Element_2 | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget)[]): (Element_2 | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget | EntityState)[];
 
 export declare function filterOutDuplicateErrors(errors: (EntityGenerationError | EntityError)[]): EntityGenerationError[] | EntityError[];
@@ -8781,6 +8848,10 @@ export declare interface IBaseEventTransfer extends IBaseEvent_meta {
     calls: (CallableEntity | CallableEntityTransfer)[];
 }
 
+declare interface IBaseExtensionsContext {
+    onRequestModule: <T>(moduleId: string) => T;
+}
+
 export declare interface IBaseVariable extends IBaseVariableTransfer, IChildEntity {
     defaultValue: ILiteralValue | null;
     dataType: IDataType | null;
@@ -9254,7 +9325,7 @@ export declare interface IEditableEntityPersistanceRepository extends IReadOnlyE
     APILoadVersion<T extends Array<any> = any[]>(entityId: EntityId, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: T): Promise<ElementShallowTransfer | null>;
 }
 
-export declare interface IEditor extends IUndoableInterface, IValueResolutionContext {
+export declare interface IEditor extends IUndoableInterface, IValueResolutionContext, IProjectStaticParentContext, IProjectInstanceParentContext {
     ready: boolean;
     hasLoadedLogic: boolean;
     destroyed: boolean;
@@ -9271,6 +9342,7 @@ export declare interface IEditor extends IUndoableInterface, IValueResolutionCon
     socket: IWebsocketsClient;
     events: Events;
     publication: PublicationRun | null;
+    extensions: ExtensionsRegistry;
     onProjectHeadLoadedCallback: null | ((projectState: ProjectState) => void);
     onLogicLoadingCompleteCallback: null | ((chunk: any) => void);
     onRenderedCallback: null | (() => void);
@@ -9309,6 +9381,7 @@ export declare interface IEditor extends IUndoableInterface, IValueResolutionCon
     resolveInitialChildrenPositions(parent: CanvasEntityState | null, children: CanvasEntityState[], changeSet: ChangeSet | null): CanvasEntityState[];
     publish(): Promise<void>;
     loadActivePublication(publicationId: string): Promise<IPublication>;
+    requestModule<T = any>(moduleId: string): T | null;
 }
 
 export declare interface IEntityActionRequestPayload<P extends {
@@ -9376,6 +9449,9 @@ export declare interface IExecutionClient {
     onEntityExecuted?: (entity: TestableEntityState, result: IExecutionResult, context: IExecutionCallbackContext) => Promise<any>;
 }
 
+export declare interface IExecutionInstanceParentContext extends IBaseExtensionsContext {
+}
+
 export declare interface IExecutionResult {
     value: ExecutionTerminationType;
     entity: TestableEntityState;
@@ -9383,6 +9459,10 @@ export declare interface IExecutionResult {
     results: IDynamicValue[];
 }
 
+declare interface IExtensionContextBase extends Omit<IEventsBus, 'destroy'> {
+    registry: ExtensionsRegistry;
+}
+
 export declare interface IFile extends IPrimitiveEntity {
     name: PrimitiveTypes.File;
 }
@@ -9829,16 +9909,16 @@ export declare enum InfrastructureResourceStatus {
     Deleted = "deleted"
 }
 
-export declare function initBaseProjectEntity(data: IProjectTransfer): ProjectState;
+export declare function initBaseProjectEntity(data: IProjectTransfer, parentContext?: IProjectInstanceParentContext): ProjectState;
 
 export declare function initProject(data: IProjectTransfer, { enrich, }?: {
     enrich: boolean;
-}): ProjectState;
+}, parentContext?: IProjectInstanceParentContext): ProjectState;
 
 export declare function initProjectFromFetchResult(result: IProjectFetchResult, options?: {
     enrich?: boolean;
     shallowErrors?: boolean;
-}): ProjectState;
+}, parentContext?: IProjectInstanceParentContext): ProjectState;
 
 export declare enum InputMapDependencyField {
     Declaration = "declaration",
@@ -9925,7 +10005,7 @@ export declare class InputMapState extends VersionedState implements IInputMap,
     setParent(parent: PassThroughCallableEntityState, changeSet?: ChangeSet | null): InputMapState;
     setDataType(dataType: DataTypeState | null, changeSet?: ChangeSet | null): InputMapState;
     removeDataType(): InputMapState;
-    setDeclaration(declaration: ArgumentDeclarationState | PropertyState | ValueDescriptorState | null): InputMapState;
+    setDeclaration(declaration: ArgumentDeclarationState | PropertyState | ValueDescriptorState | null, changeSet?: ChangeSet | null): InputMapState;
     initChildren(changeSet?: ChangeSet | null): InputMapState;
     setValueWriter(valueWriter: ValueWritingEntityState | null, changeSet?: ChangeSet | null): InputMapState;
     removeValueWriter(changeSet?: ChangeSet | null): InputMapState;
@@ -10524,6 +10604,11 @@ export declare interface IProjectFetchResult {
 export declare interface IProjectGenerationTarget extends IProject_base {
 }
 
+export declare interface IProjectInstanceParentContext extends IProjectStaticParentContext {
+    onRequestActiveDynamicValue: (valueOwner: EntityWithValueState) => IDynamicValue | null;
+    events: Events;
+}
+
 export declare interface IProjectReference extends IGenericReference {
     entityType: EntityType.Project;
 }
@@ -10542,6 +10627,10 @@ export declare interface IProjectShallowTransfer extends IProject_meta {
     searches: ISearchReference[];
 }
 
+export declare interface IProjectStaticParentContext extends IBaseExtensionsContext {
+    events: Events;
+}
+
 export declare interface IProjectTransfer extends IProject_meta {
     projects: (IInstalledProject | IInstalledProjectTransfer)[];
     entities: (IDefinitionEntity | IDefinitionEntityTransfer)[];
@@ -12315,7 +12404,7 @@ export declare class OutputMapState extends VersionedState implements IOutputMap
     setParent(parent: PassThroughCallableEntityWithOutputsState, changeSet?: ChangeSet | null): OutputMapState;
     setDataType(dataType: DataTypeState | null, changeSet?: ChangeSet | null): OutputMapState;
     removeDataType(): OutputMapState;
-    setDeclaration(declaration: ReturnDeclarationState | PropertyState | ValueDescriptorState): OutputMapState;
+    setDeclaration(declaration: ReturnDeclarationState | PropertyState | ValueDescriptorState, changeSet?: ChangeSet | null): OutputMapState;
     initChildren(changeSet?: ChangeSet | null): OutputMapState;
     subscribe(): OutputMapState;
     unsubscribe(): OutputMapState;
@@ -12619,11 +12708,155 @@ export declare type ProjectDomain = string;
 
 export declare type ProjectFetchResult = null | IProjectFetchResult;
 
+declare class ProjectLogicContext extends ExtensionContextBase implements IProject {
+    private readonly _project;
+    constructor(registry: ExtensionsRegistry, _project: ProjectState);
+    readonly id: EntityId;
+    get type(): EntityType.Project;
+    get name(): string | null;
+    get description(): string | null;
+    get version(): string;
+    get createdAt(): string;
+    get previousVersion(): string | null;
+    get author(): string;
+    get deleted(): boolean;
+    get entities(): DefinitionEntityState[];
+    get projects(): InstalledProjectState[];
+    get functions(): FunctionDeclarationState[];
+    get events(): GlobalEventState[];
+    get variableDeclarations(): VariableDeclarationState[];
+    get variableInstances(): VariableInstanceState[];
+    get conditions(): ConditionState[];
+    get operations(): OperationState[];
+    get functionCalls(): FunctionCallState[];
+    get loops(): LoopState[];
+    get searches(): SearchState[];
+    get primitives(): PrimitiveEntityState[];
+    get builtInBaseEntities(): BuiltInBaseEntityState[];
+    get operationDeclarations(): ActionDescriptorState[];
+    get globalEventActionDescriptors(): ActionDescriptorState[];
+    get loopDeclarations(): ActionDescriptorState[];
+    get loopDeclarationsBodies(): ActionDescriptorState[];
+    get conditionDeclarations(): ActionDescriptorState[];
+    get valueDescriptors(): ValueDescriptorState[];
+    get dataTypes(): DataTypeState[];
+    get errors(): EntityError[];
+    get history(): ChangeSet[];
+    get undoableStackValueIndex(): number;
+    get knownVersions(): Map<string, EntityState> | null;
+    get activeVersion(): boolean;
+    get initialized(): boolean;
+    get startedInitialization(): boolean;
+    closePendingChangeSets(): Promise<void>;
+    closeChangeSet(changeSet: ChangeSet): Promise<void>;
+    toLatestChangeSet(author: string, timestamp: string, // ISO 8601 format
+    self: UserManagedEntityState | null, autoclose?: boolean, autoCloseActionName?: string): ChangeSet;
+    addChangeSet(changeSet: ChangeSet): ChangeSet;
+    discardChangeSet(changeSet: ChangeSet | null): ProjectState;
+    subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    unsubscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    syncDependents(changeSet?: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRemoved(_dependency: UserManagedEntityState, _field: string, _changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRestored(_dependency: UserManagedEntityState, _field: string, _changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
+    captureVersion(): ProjectState;
+    restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ProjectState>>;
+    updateWithShallowTransfer(transfer: IProjectShallowTransfer, changeSet?: ChangeSet | null): ProjectState;
+    hydrateAncestors(): IChangeSet<ProjectState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ProjectState>;
+    addSelfToProject(_changeSet: ChangeSet | null): IChangeSet<ProjectState>;
+    get instancesList(): EntityState[];
+    isOperationDeclaration(entity: ActionDescriptorState): boolean;
+    isGlobalEventActionDescriptor(entity: ActionDescriptorState): boolean;
+    isLoopDeclaration(entity: ActionDescriptorState): boolean;
+    isConditionDeclaration(entity: ActionDescriptorState): boolean;
+    findSubscribedBuiltInInstance(entity: Element_2 | ElementTransfer): EntityState | null;
+    get(entityId: EntityId): EntityState | null;
+    getDeleted(entityId: EntityId): EntityState | null;
+    getManaged(entityId: EntityId): EntityState | null;
+    getBuiltIn(entityId: EntityId): EntityState | null;
+    findSubscribedInstanceFromReference(entity: Reference): EntityState | null;
+    findSubscribedBuiltInInstanceFromReference(entity: Reference): EntityState | null;
+    metaSync(data: Partial<IProject_meta | IProject | IProjectTransfer | IProjectShallowTransfer>, changeSet?: ChangeSet | null): ProjectState;
+    getAllBuiltInIds(): EntityId[];
+    getAllBuiltIn(): EntityState[];
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IProject_meta;
+    toJSON(seenEntities?: Set<EntityId>): IProjectTransfer | IProjectReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IProjectTransfer;
+    toReference(options?: IEntityRecursionOptions): IProjectReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IProjectShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(): IProjectGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): ProjectState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: IProjectTransfer | null;
+    };
+    validateChildren(): void;
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    getDefinitionEntity(id: EntityId): DefinitionEntityState | null;
+    addDefinitionEntity(entity: DefinitionEntityState): DefinitionEntityState;
+    addFunctionDeclaration(func: FunctionDeclarationState): FunctionDeclarationState;
+    addFunctionCall(func: FunctionCallState): FunctionCallState;
+    addVariableDeclaration(variable: VariableDeclarationState): VariableDeclarationState;
+    addVariableInstance(variable: VariableInstanceState): VariableInstanceState;
+    addInstalledProject(project: InstalledProjectState): ProjectState;
+    addGlobalEvent(event: GlobalEventState): ProjectState;
+    addCondition(condition: ConditionState): ProjectState;
+    addOperation(operation: OperationState): ProjectState;
+    addLoop(loop: LoopState): ProjectState;
+    addSearch(search: SearchState): ProjectState;
+    removeDefinitionEntity(entity: IDefinitionEntity): DefinitionEntityState | null;
+    removeCondition(condition: ICondition): ConditionState | null;
+    removeOperation(operation: IOperation): OperationState | null;
+    removeLoop(loop: ILoop): LoopState | null;
+    removeSearch(search: ISearch): SearchState | null;
+    removeFunctionCall(funcCall: IFunctionCall): FunctionCallState | null;
+    removeVariableInstance(variable: IVariableInstance): VariableInstanceState | null;
+    removeVariableDeclaration(variable: IVariableDeclaration): VariableDeclarationState | null;
+    removeFunctionDeclaration(func: IFunctionDeclaration): FunctionDeclarationState | null;
+    removeInstalledProject(project: IInstalledProject): InstalledProjectState | null;
+    removeGlobalEvent(event: IGlobalEvent): GlobalEventState | null;
+    removeTopLevelVariableDeclaration(variable: VariableDeclarationState): VariableDeclarationState | null;
+    getEntryPoints(): EntryPointEntityState[];
+    getTerminationStatements(): TerminationState[];
+    getFunctionDeclaration(id: EntityId): FunctionDeclarationState | null;
+    getConditions(): ConditionState[];
+    getOperations(): OperationState[];
+    getVariables(): VariableState[];
+    getVariableInstances(): VariableInstanceState[];
+    getVariableDeclarations(): VariableDeclarationState[];
+    getLoops(): LoopState[];
+    getSearches(): SearchState[];
+    getBuiltInPersistedEntity(): BuiltInBaseEntityState | null;
+    requestActiveDynamicValue(valueOwner: EntityWithValueState): IDynamicValue | null;
+    undo(): IProjectVersionTransitionConfig;
+    redo(): IProjectVersionTransitionConfig;
+    applyExternalChangeSet(request: PersistChangeSetEntityActionRequestPayload): ChangeSet;
+    toFullProjectTransfer(): {
+        order: EntityId[];
+        size: number;
+        record: Record<EntityId, UserManagedElementShallowTransfer>;
+    };
+}
+
 export declare type ProjectPayloadUnion = ProjectState | ProjectTypesUnion;
 
 export declare const projectPublicationCompletedGlobalEvent: IActionDescriptorTransfer;
 
 export declare class ProjectState extends VersionedState implements IProject, UserManagedEntityStateTemplate, BaseState {
+    readonly parentContext: IProjectInstanceParentContext;
     initialData: IProject | IProjectTransfer;
     readonly id: EntityId;
     type: EntityType.Project;
@@ -12673,17 +12906,14 @@ export declare class ProjectState extends VersionedState implements IProject, Us
     activeVersion: boolean;
     initialized: boolean;
     startedInitialization: boolean;
-    _eventsHub: Events;
     onCloseChangeSetCallback: ((changeSet: ChangeSet) => Promise<{
         success: boolean;
     }>) | null;
     onAddChangeSetCallback: ((changeSet: ChangeSet, undoableStackValueIndex: number) => void) | null;
     onDiscardChangeSetCallback: ((changeSet: ChangeSet) => void) | null;
-    onRequestActiveDynamicValueCallback: ((valueOwner: EntityWithValueState) => IDynamicValue | null) | null;
-    constructor(initialData: IProject | IProjectTransfer);
-    private static _UUIDModule;
+    constructor(initialData: IProject | IProjectTransfer, parentContext?: IProjectInstanceParentContext);
+    static parentContext: IProjectStaticParentContext;
     static get UUID(): UUIDModule;
-    static injectUUIDModule(module: UUIDModule): void;
     static sessionAuthor: string;
     static repository: IEditableEntityPersistanceRepository;
     static type: EntityType.Project;
@@ -12711,7 +12941,6 @@ export declare class ProjectState extends VersionedState implements IProject, Us
     get on(): Events['on'];
     get emit(): Events['emit'];
     closePendingChangeSets(): Promise<void>;
-    onRequestActiveDynamicValue(callback: (valueOwner: EntityWithValueState) => IDynamicValue | null): void;
     onCloseChangeSet(callback: (changeSet: ChangeSet) => Promise<{
         success: boolean;
     }>): Promise<void>;
@@ -12851,6 +13080,7 @@ export declare class ProjectState extends VersionedState implements IProject, Us
     attachOrphanReferences(): ProjectState;
     getBuiltInPersistedEntity(): BuiltInBaseEntityState | null;
     requestActiveDynamicValue(valueOwner: EntityWithValueState): IDynamicValue | null;
+    requestModule<T = any>(moduleId: string): T | null;
     undo(): IProjectVersionTransitionConfig;
     redo(): IProjectVersionTransitionConfig;
     applyExternalChangeSet(request: PersistChangeSetEntityActionRequestPayload): ChangeSet;
@@ -13270,6 +13500,11 @@ export declare function rebaseStack<T = any>(undoableStackValueIndex: number, hi
 
 export declare type Reference = IGenericReference | IFunctionDeclarationReference | IInstalledProjectReference | IDataTypeReference | IVariableDeclarationReference | IVariableInstanceReference | IOperationReference | IDefinitionEntityReference | IPrimitiveEntityReference | IProjectReference | IGlobalEventReference | IFunctionDeclarationReference | IFunctionDeclarationReference | IPropertyReference | IFunctionCallReference | IArgumentDeclarationReference | IInputMapReference | IOutputMapReference | IReturnDeclarationReference | IConditionReference | IReturnStatementReference | IBreakStatementReference | IContinueStatementReference | ILoopReference | IActionDescriptorReference | ISearchReference | ILiteralValueReference | IBuiltInBaseEntityReference | IValueDescriptorReference | IInternalCallReference;
 
+declare interface RegisteredExtension<T extends object = {}> {
+    manifest: ExtensionManifest;
+    module: ExtensionModule<T>;
+}
+
 export declare const relationalDatabaseBuiltInBaseEntity: IBuiltInBaseEntityTransfer;
 
 export declare const relationalDatabaseBuiltInBaseEntityAutoscalingProperty: IPropertyTransfer;
@@ -13738,6 +13973,17 @@ export declare enum SearchDependencyField {
     Parent = "parent"
 }
 
+export declare type SearchImplementationModule = {
+    searchImplementation: (entity: SearchState, inputs: IDynamicValue[]) => Promise<{
+        data: {
+            [columnName: string]: any;
+        } | null | {
+            [columnName: string]: any;
+        }[];
+        error: string | null;
+    }>;
+};
+
 declare enum SearchLiteralValueType {
     String = "string",
     Number = "number",