@elyx-code/project-logic-tree 0.0.6680 → 0.0.6682

package/dist/index.d.ts

@@ -50,6 +50,7 @@ import { TableFactor } from 'sql-parser-cst';
 import { TablesampleExpr } from 'sql-parser-cst';
 import { UnpivotExpr } from 'sql-parser-cst';
 import { WhereClause } from 'sql-parser-cst';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
 import * as z from 'zod';
 import { z as z_2 } from 'zod';
 
@@ -169,7 +170,11 @@ export declare class ActionDescriptorState extends UserManagedVersionedState imp
     validate(): {
         success: boolean;
     };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
     getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
     getShallowErrors(): EntityError[];
     clone(changeSet?: ChangeSet | null, parent?: DefinitionEntityState | PrimitiveEntityState | BuiltInBaseEntityState | DataTypeState | null, newId?: string | null, subscribe?: boolean): ActionDescriptorState;
     addInput(argument: ValueDescriptorState, changeSet?: ChangeSet | null): ActionDescriptorState;
@@ -186,6 +191,7 @@ export declare type ActionDescriptorTypesUnion = IActionDescriptor | IActionDesc
 
 declare namespace actionDescriptorValidation {
     export {
+        validateAsync_8 as validateAsync,
         validate_8 as validate
     }
 }
@@ -403,7 +409,7 @@ export declare function applyNewScope(self: CallableEntityState, changeSet: Chan
 export declare function applyQueuedToCached(opts: {
     projectId: EntityId;
     projectRecord: Record<EntityId, UserManagedElementShallowTransfer>;
-    chain: IRecordChangeSet<UserManagedElementShallowTransfer, UserManagedElementShallowTransfer>[];
+    chain: IRecordChangeSet<UserManagedElementShallowTransfer | null, UserManagedElementShallowTransfer>[];
     sort?: boolean;
     order?: boolean;
 }): {
@@ -599,7 +605,11 @@ export declare class ArgumentDeclarationState extends UserManagedVersionedState
     validate(): {
         success: boolean;
     };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
     getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
     getShallowErrors(): EntityError[];
     getDefaultValue(): LiteralValueState | null;
     setDefaultValue(value: LiteralValueState | null, changeSet?: ChangeSet | null): ArgumentDeclarationState;
@@ -614,6 +624,7 @@ export declare type ArgumentDeclarationTypesUnion = IArgumentDeclaration | IArgu
 
 declare namespace argumentDeclarationValidation {
     export {
+        validateAsync_7 as validateAsync,
         validate_7 as validate
     }
 }
@@ -864,7 +875,11 @@ export declare class BreakStatementState extends UserManagedVersionedState imple
     validate(): {
         success: boolean;
     };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
     getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
     getShallowErrors(): EntityError[];
     getDefaultValue(): LiteralValueState | null;
     setDefaultValue(value: LiteralValueState | null, changeSet?: ChangeSet | null): BreakStatementState;
@@ -880,6 +895,7 @@ export declare type BreakStatementTypesUnion = IBreakStatement | IBreakStatement
 
 declare namespace breakStatementValidation {
     export {
+        validateAsync_15 as validateAsync,
         validate_15 as validate
     }
 }
@@ -9229,7 +9245,11 @@ export declare class BuiltInBaseEntityState extends VersionedState implements Ba
     validate(): {
         success: boolean;
     };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
     getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
     getShallowErrors(): EntityError[];
     implement(newEntityName: string, changeSet?: ChangeSet | null, newId?: string): DefinitionEntityState;
     getAllPropertiesImplements(): PropertyState[];
@@ -9501,22 +9521,27 @@ export declare class ChangeSet extends Events {
     get affectedIds(): EntityId[];
     event(payload: IChangeSetEventCreationPayload): void;
     discardOrphans(): void;
+    discardOrphansAsync(options?: YieldOptions): Promise<void>;
     captureAllChangesInVersionInstances(): void;
+    captureAllChangesInVersionInstancesAsync(options?: YieldOptions): Promise<void>;
     attemptAutocloseAsync(knownAutoCloseActionName: string, closingEntityId: EntityId): Promise<ChangeSet>;
     closeAsync(options?: {
         awaitBeforeClose?: boolean;
         awaitExternalPersist?: boolean;
         persistType?: 'sequential' | 'parallel';
-    }): Promise<ChangeSet>;
+    } & YieldOptions): Promise<ChangeSet>;
     attemptAutoclose(knownAutoCloseActionName: string, closingEntityId: EntityId): ChangeSet;
     recursiveCaptureUpstreamVersions(): void;
+    recursiveCaptureUpstreamVersionsAsync(options?: YieldOptions): Promise<void>;
     sanitize(): void;
+    sanitizeAsync(options?: YieldOptions): Promise<void>;
     syncDependents(): ChangeSet;
-    beforeCloseAsync(): Promise<void>;
+    syncDependentsAsync(options?: YieldOptions): Promise<ChangeSet>;
+    beforeCloseAsync(options?: YieldOptions): Promise<void>;
     beforeClose(): void;
     teardown(): void;
     emitProjectSideEffects(): ChangeSet;
-    emitAsyncProjectSideEffects(): Promise<ChangeSet>;
+    emitAsyncProjectSideEffects(options?: YieldOptions): Promise<ChangeSet>;
     close(options?: {
         persistType?: 'sequential' | 'parallel';
     }): ChangeSet;
@@ -9990,7 +10015,11 @@ export declare class ConditionState extends UserManagedVersionedState implements
     validate(): {
         success: boolean;
     };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
     getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
     getShallowErrors(): EntityError[];
     clone(changeSet?: ChangeSet | null, parent?: EntryPointEntityState | ProjectState | ConditionState | null, newId?: string | null, subscribe?: boolean): ConditionState;
     addToAndGroup(child: ConditionState, changeSet?: ChangeSet | null): ConditionState;
@@ -10008,6 +10037,7 @@ export declare type ConditionTypesUnion = ICondition | IConditionTransfer | ICon
 
 declare namespace conditionValidation {
     export {
+        validateAsync_12 as validateAsync,
         validate_12 as validate
     }
 }
@@ -10143,7 +10173,11 @@ export declare class ContinueStatementState extends UserManagedVersionedState im
     validate(): {
         success: boolean;
     };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
     getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
     getShallowErrors(): EntityError[];
     getDefaultValue(): LiteralValueState | null;
     setDefaultValue(value: LiteralValueState | null, changeSet?: ChangeSet | null): ContinueStatementState;
@@ -10159,6 +10193,7 @@ export declare type ContinueStatementTypesUnion = IContinueStatement | IContinue
 
 declare namespace continueStatementValidation {
     export {
+        validateAsync_14 as validateAsync,
         validate_14 as validate
     }
 }
@@ -10728,7 +10763,11 @@ export declare class DataTypeState extends UserManagedVersionedState implements
     validate(): {
         success: boolean;
     };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
     getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
     getShallowErrors(): EntityError[];
     clone(changeSet?: ChangeSet | null, parent?: DataTypeParentEntityState | null, newId?: string | null, subscribe?: boolean): DataTypeState;
     merge(sourceEntity: DataTypeState | null, changeSet?: ChangeSet | null): IChangeSet<DataTypeState>;
@@ -10791,6 +10830,7 @@ export declare type DataTypeTypesUnion = IDataTypeTransfer | IDataTypeShallowTra
 
 declare namespace dataTypeValidation {
     export {
+        validateAsync_3 as validateAsync,
         validate_3 as validate
     }
 }
@@ -11690,7 +11730,11 @@ export declare class DefinitionEntityState extends UserManagedVersionedState imp
     validate(): {
         success: boolean;
     };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
     getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
     getShallowErrors(): EntityError[];
     clone(changeSet?: ChangeSet | null, parent?: ProjectState | DataTypeState | null, newId?: string | null, subscribe?: boolean): DefinitionEntityState;
     getFunctionDeclaration(id: EntityId): FunctionDeclarationState | undefined;
@@ -11716,6 +11760,7 @@ export declare type DefinitionEntityTypesUnion = IDefinitionEntity | IDefinition
 
 declare namespace definitionEntityValidation {
     export {
+        validateAsync_2 as validateAsync,
         validate_2 as validate,
         getBasePropertiesNotImplemented,
         getBaseMethodsNotImplemented,
@@ -11966,7 +12011,7 @@ export declare type ElementTransfer = IProjectTransfer | IInstalledProjectTransf
 
 export declare type ElementTypesUnion = ProjectTypesUnion | InstalledProjectTypesUnion | DefinitionEntityTypesUnion | GlobalEventTypesUnion | FunctionDeclarationTypesUnion | FunctionCallTypesUnion | PropertyTypesUnion | VariableDeclarationTypesUnion | VariableInstanceTypesUnion | OperationTypesUnion | ConditionTypesUnion | ArgumentDeclarationTypesUnion | InputMapTypesUnion | OutputMapTypesUnion | DataTypeTypesUnion | ReturnStatementTypesUnion | BreakStatementTypesUnion | ContinueStatementTypesUnion | LoopTypesUnion | ActionDescriptorTypesUnion | SearchTypesUnion | PrimitiveEntityTypesUnion | LiteralValueTypesUnion | ValueDescriptorTypesUnion | BuiltInBaseEntityTypesUnion | InternalCallTypesUnion;
 
-export declare function emitAsyncProjectSideEffects(changeSet: ChangeSet): Promise<ChangeSet>;
+export declare function emitAsyncProjectSideEffects(changeSet: ChangeSet, options?: YieldOptions): Promise<ChangeSet>;
 
 export declare function emitProjectSideEffects(changeSet: ChangeSet): ChangeSet;
 
@@ -13767,6 +13812,8 @@ export declare function filterOutDependentCallers(callers: CallerEntityState[]):
 
 export declare function filterOutDuplicateEntities(entities: (EntityState | Element_2 | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget)[]): (Element_2 | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget | EntityState)[];
 
+export declare function filterOutDuplicateEntitiesAsync(entities: (EntityState | Element_2 | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget)[], options?: YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget | EntityState)[]>;
+
 export declare function filterOutDuplicateErrors(errors: (EntityGenerationError | EntityError)[]): EntityGenerationError[] | EntityError[];
 
 export declare function findEntityFromKeys(keys: string[], project: ProjectState): DefinitionEntityState | null;
@@ -13791,10 +13838,18 @@ export declare function flattenActionDescriptor(entity: IActionDescriptor | IAct
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenActionDescriptorAsync(entity: IActionDescriptor | IActionDescriptorTransfer | IActionDescriptorShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenArgumentDeclaration(entity: IArgumentDeclaration | IArgumentDeclarationTransfer | IArgumentDeclarationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenArgumentDeclarationAsync(entity: IArgumentDeclaration | IArgumentDeclarationTransfer | IArgumentDeclarationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 declare function flattenBinaryExprComparisonsToWhereStatements(whereExpr: BinaryExpr, parent: WhereStatement, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState, debug?: boolean): {
     ands: WhereStatement[];
     ors: WhereStatement[];
@@ -13804,10 +13859,18 @@ export declare function flattenBreakStatement(entity: IBreakStatement | IBreakSt
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenBreakStatementAsync(entity: IBreakStatement | IBreakStatementTransfer | IBreakStatementShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenBuiltInBaseEntity(entity: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer | IBuiltInBaseEntityShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenBuiltInBaseEntityAsync(entity: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer | IBuiltInBaseEntityShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 /**
  * Returns a flat list of caller entities that are ancestors in the call chain of the given entity
  * Recursively checks until we have found the 'until' entity, as an ancestor or reached the root project entity
@@ -13835,18 +13898,34 @@ export declare function flattenCondition(entity: ICondition | IConditionTransfer
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenConditionAsync(entity: ICondition | IConditionTransfer | IConditionShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenContinueStatement(entity: IContinueStatement | IContinueStatementTransfer | IContinueStatementShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenContinueStatementAsync(entity: IContinueStatement | IContinueStatementTransfer | IContinueStatementShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenDataType(entity: IDataType | IDataTypeTransfer | IDataTypeShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenDataTypeAsync(entity: IDataType | IDataTypeTransfer | IDataTypeShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenDefinitionEntity(entity: IDefinitionEntity | IDefinitionEntityTransfer | IDefinitionEntityShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenDefinitionEntityAsync(entity: IDefinitionEntity | IDefinitionEntityTransfer | IDefinitionEntityShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenDefinitionEntityExtensionAndImplementationTypes(entity: DefinitionEntityState): (BaseEntityNames | EntityType.DefinitionEntity)[];
 
 export declare function flattenDefinitionEntityExtensions(entity: DefinitionEntityState | BuiltInBaseEntityState): (BuiltInBaseEntityState | DefinitionEntityState)[];
@@ -13868,6 +13947,17 @@ export declare function flattenDefinitionEntityImplementionTypes(entity: Definit
  */
 export declare function flattenDerivedCanvasEntities(entity: CanvasEntityState, seenEntities?: Set<EntityId>): CanvasEntityState[];
 
+/**
+ * Given an entity from the canvas, it returns a flat list of entities
+ * representing the chain of entities on the right of the given one, that are related to it
+ * Including relations of its relations, recursively
+ *
+ * @param entity The entity to flatten
+ * @param seenEntities A set of already seen entities to avoid infinite loops
+ * @returns {CanvasEntityState[]} A flat list of derived canvas entities
+ */
+export declare function flattenDerivedCanvasEntitiesAsync(entity: CanvasEntityState, seenEntities?: Set<EntityId>, options?: YieldOptions): Promise<CanvasEntityState[]>;
+
 export declare function flattenDetachedBranch(entity: CanvasEntityState): CanvasEntityState[];
 
 export declare function flattenElementCalls(element: CallerEntityState): CallableEntityState[];
@@ -13881,37 +13971,62 @@ export declare function flattenElementCallsWithCallType(element: CallerEntitySta
 
 export declare function flattenEntity(entity: Element_2 | ElementTransfer | ElementShallowTransfer | Reference, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
+    diggestedBuiltInBaseEntitiesIds?: Set<EntityId>;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
 export declare function flattenEntityAsync(entity: Element_2 | ElementTransfer | ElementShallowTransfer | Reference, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
-    yieldEvery?: number;
-}): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+    diggestedBuiltInBaseEntitiesIds?: Set<EntityId>;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
 
 export declare function flattenFunctionCall(entity: IFunctionCall | IFunctionCallTransfer | IFunctionCallShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenFunctionCallAsync(entity: IFunctionCall | IFunctionCallTransfer | IFunctionCallShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenFunctionDeclaration(entity: IFunctionDeclaration | IFunctionDeclarationTransfer | IFunctionDeclarationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenFunctionDeclarationAsync(entity: IFunctionDeclaration | IFunctionDeclarationTransfer | IFunctionDeclarationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenGlobalEvent(entity: IGlobalEvent | IGlobalEventTransfer | IGlobalEventShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenGlobalEventAsync(entity: IGlobalEvent | IGlobalEventTransfer | IGlobalEventShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenInputMap(entity: IInputMap | IInputMapTransfer | IInputMapShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenInputMapAsync(entity: IInputMap | IInputMapTransfer | IInputMapShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenInstalledProject(entity: IInstalledProject | IInstalledProjectTransfer | IInstalledProjectShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenInstalledProjectAsync(entity: IInstalledProject | IInstalledProjectTransfer | IInstalledProjectShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenInternalCall(entity: IInternalCall | IInternalCallTransfer | IInternalCallShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenInternalCallAsync(entity: IInternalCall | IInternalCallTransfer | IInternalCallShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 declare function flattenJoinExprIntoAggregationStatementsSync(joinExpr: JoinExpr, parentQuery: SelectStmt, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState, helpers?: {
     onDescribeTable?: (tableName: string) => ITable | null;
 }, debug?: boolean): {
@@ -13928,34 +14043,62 @@ export declare function flattenLiteralValue(entity: ILiteralValue | ILiteralValu
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenLiteralValueAsync(entity: ILiteralValue | ILiteralValueTransfer | ILiteralValueShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenLoop(entity: ILoop | ILoopTransfer | ILoopShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenLoopAsync(entity: ILoop | ILoopTransfer | ILoopShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenOneLevel(list: unknown): any[];
 
 export declare function flattenOperation(entity: IOperation | IOperationTransfer | IOperationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenOperationAsync(entity: IOperation | IOperationTransfer | IOperationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenOutputMap(entity: IOutputMap | IOutputMapTransfer | IOutputMapShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenOutputMapAsync(entity: IOutputMap | IOutputMapTransfer | IOutputMapShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenPrimitiveEntity(entity: IPrimitiveEntity | IPrimitiveEntityTransfer | IPrimitiveEntityShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenPrimitiveEntityAsync(entity: IPrimitiveEntity | IPrimitiveEntityTransfer | IPrimitiveEntityShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenProject(entity: IProject | IProjectTransfer | IProjectShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenProjectAsync(entity: IProject | IProjectTransfer | IProjectShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenProjectElements(project: ProjectState): EntityState[];
 
 export declare function flattenProperty(entity: IProperty | IPropertyTransfer | IPropertyShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenPropertyAsync(entity: IProperty | IPropertyTransfer | IPropertyShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenRelatedCallableElementsOnTheRight(entity: CanvasEntityState | ProjectState | InternalCallState, respectCollapse?: boolean): CallableEntityState[];
 
 export declare function flattenRelatedCanvasElementsOnTheLeft(entity: CanvasEntityState): CanvasEntityState[];
@@ -13966,22 +14109,42 @@ export declare function flattenReturnStatement(entity: IReturnStatement | IRetur
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenReturnStatementAsync(entity: IReturnStatement | IReturnStatementTransfer | IReturnStatementShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenSearch(entity: ISearch | ISearchTransfer | ISearchShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenSearchAsync(entity: ISearch | ISearchTransfer | ISearchShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenValueDescriptor(entity: IValueDescriptor | IValueDescriptorTransfer | IValueDescriptorShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenValueDescriptorAsync(entity: IValueDescriptor | IValueDescriptorTransfer | IValueDescriptorShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenVariableDeclaration(entity: IVariableDeclaration | IVariableDeclarationTransfer | IVariableDeclarationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenVariableDeclarationAsync(entity: IVariableDeclaration | IVariableDeclarationTransfer | IVariableDeclarationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenVariableInstance(entity: IVariableInstance | IVariableInstanceTransfer | IVariableInstanceShallowTransfer, seenEntities?: Set<EntityId>, options?: {
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+export declare function flattenVariableInstanceAsync(entity: IVariableInstance | IVariableInstanceTransfer | IVariableInstanceShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+} & YieldOptions): Promise<(Element_2 | ElementTransfer | ElementShallowTransfer)[]>;
+
 export declare function flattenVariableReads(variable: VariableState, seenVariables?: Set<string>): VariableState[];
 
 export declare function flattenVariables(element: CanvasEntityState, seenVariables?: Set<string>): VariableState[];
@@ -14015,7 +14178,7 @@ export declare const formatDateOperation: IActionDescriptorTransfer;
 
 export declare const formatDateResponseDT: IDataTypeTransfer;
 
-export declare function freezeDownstreamEntitiesFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet, seenEntities?: Set<string>, allBuiltInEntityIds?: string[]): void;
+export declare function freezeDownstreamEntitiesFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet, seenEntities?: Set<string>): void;
 
 /** Converts bytes into string using the given encoding. */
 export declare function fromBytes(bytes: Bytes, encoding?: AnyEncoding): string;
@@ -14217,7 +14380,11 @@ export declare class FunctionCallState extends UserManagedVersionedState impleme
     validate(): {
         success: boolean;
     };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
     getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
     getShallowErrors(): EntityError[];
     clone(changeSet?: ChangeSet | null, parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): FunctionCallState;
     removeUnrecognizedInputs(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
@@ -14235,6 +14402,7 @@ export declare type FunctionCallTypesUnion = IFunctionCall | IFunctionCallTransf
 
 declare namespace functionCallValidation {
     export {
+        validateAsync_11 as validateAsync,
         validate_11 as validate
     }
 }
@@ -14369,7 +14537,11 @@ export declare class FunctionDeclarationState extends UserManagedVersionedState
     validate(): {
         success: boolean;
     };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
     getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
     getShallowErrors(): EntityError[];
     clone(changeSet?: ChangeSet | null, parent?: InstalledProjectState | ProjectState | DefinitionEntityState | LoopState | null, newId?: string | null, subscribe?: boolean, cloneBody?: boolean): FunctionDeclarationState;
     getVariableInstances(): VariableInstanceState[];
@@ -14393,6 +14565,7 @@ export declare type FunctionDeclarationTypesUnion = IFunctionDeclaration | IFunc
 
 declare namespace functionDeclarationValidation {
     export {
+        validateAsync_9 as validateAsync,
         validate_9 as validate,
         validateFunctionDeclarationName_2 as validateFunctionDeclarationName
     }
@@ -14615,7 +14788,9 @@ export declare function getAllActionDescriptorsForLoops(project: ProjectState):
 
 export declare function getAllActionDescriptorsForOperations(project: ProjectState): string;
 
-export declare function getAllBuiltInEntityIds(): EntityId[];
+export declare function getAllBuiltInEntityIds(): Set<EntityId>;
+
+export declare function getAllBuiltInEntityIdsAsync(options?: YieldOptions): Promise<Set<EntityId>>;
 
 export declare function getAllGloballyDeclaredFunctionDeclarationsExplanation(project: ProjectState): string;
 
@@ -18385,7 +18560,13 @@ declare function getRawLimitFromLimitClause(limitClause: LimitClause | null): nu
 
 declare function getRawOffetFromLimitClause(limitClause: LimitClause | null): number;
 
-export declare function getRecordOrderForTraversal(entities: Record<EntityId, Element_2 | ElementTransfer | EntityState | ElementShallowTransfer>): EntityId[];
+export declare function getRecordOrderForTraversal(entities: Record<EntityId, Element_2 | ElementTransfer | EntityState | ElementShallowTransfer>, options: {
+    allBuiltInEntityIds?: Set<EntityId>;
+}): EntityId[];
+
+export declare function getRecordOrderForTraversalAsync(entities: Record<EntityId, Element_2 | ElementTransfer | EntityState | ElementShallowTransfer>, options: {
+    allBuiltInEntityIds?: Set<EntityId>;
+} & YieldOptions): Promise<EntityId[]>;
 
 export declare function getRecusriveParentsIds(entity: Element_2 | ElementTransfer | ElementShallowTransfer | EntityState, allKnownEntities?: Record<EntityId, Element_2 | ElementTransfer | ElementShallowTransfer | EntityState>): EntityId[];
 
@@ -18417,7 +18598,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      */
  export declare function getReferencedIds(entity: ElementTransfer | Element_2 | ElementShallowTransfer | EntityState, allKnownEntities?: Record<EntityId, Element_2 | ElementTransfer | ElementShallowTransfer>, options?: {
      ignoreBuiltInBaseEntities?: boolean;
-     allBuiltInEntityIds?: EntityId[];
+     allBuiltInEntityIds?: Set<EntityId>;
      entityMaps?: Map<string, string>;
  }): {
      upstream: Record<EntityId, EntityVersion>;
@@ -18432,8 +18613,24 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  export declare function getRelatedCanvasElementsOnTheLeftFromTransfer(entity: DraggableElement | DraggableElementTransfer | DraggableElementShallowTransfer, allKnownEntities: Record<EntityId, Element_2 | ElementTransfer | ElementShallowTransfer>): (DraggableElement | DraggableElementTransfer | DraggableElementShallowTransfer)[];
 
+ /**
+  * Get all the entities that are related to the given entity on the right
+  * This includes:
+  *	- entities called by the given entity
+  *	- entities that read from the given entity,
+  *		both variables and other canvas entities that are the parent of the value reading entity
+  */
  export declare function getRelatedCanvasElementsOnTheRight(entity: CanvasEntityState | ProjectState | InternalCallState, respectCollapse?: boolean): CanvasEntityState[];
 
+ /**
+  * (ASYNC) Get all the entities that are related to the given entity on the right
+  * This includes:
+  *	- entities called by the given entity
+  *	- entities that read from the given entity,
+  *		both variables and other canvas entities that are the parent of the value reading entity
+  */
+ export declare function getRelatedCanvasElementsOnTheRightAsync(entity: CanvasEntityState | ProjectState | InternalCallState, respectCollapse?: boolean, options?: YieldOptions): Promise<CanvasEntityState[]>;
+
  export declare function getRelationalDBInstanceNameFromEntityId(entityId: string): string;
 
  export declare function getRootEntryPointScopeOwner(entity: EntityState | Element_2 | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, project: ProjectState): EntityWithLogicScopeState | null;
@@ -19081,7 +19278,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      clone(changeSet?: ChangeSet | null, parent?: InstalledProjectState | ProjectState | null, newId?: string | null, subscribe?: boolean, cloneBody?: boolean): GlobalEventState;
      getVariableInstances(): VariableInstanceState[];
@@ -19095,6 +19296,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace globalEventValidation {
      export {
+         validateAsync_16 as validateAsync,
          validate_16 as validate
      }
  }
@@ -21294,11 +21496,13 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  export declare function initBaseProjectEntity(data: IProjectTransfer, options?: {
      shallowErrors?: boolean;
+     allBuiltInIds?: Set<EntityId>;
  }, parentContext?: IProjectInstanceParentContext): ProjectState;
 
  export declare function initBaseProjectEntityAsync(data: IProjectTransfer, options?: {
      shallowErrors?: boolean;
      yieldEvery?: number;
+     allBuiltInIds?: Set<EntityId>;
  }, parentContext?: IProjectInstanceParentContext): Promise<ProjectState>;
 
  export declare function initProject(data: IProjectTransfer, { enrich, shallowErrors, }?: {
@@ -21445,7 +21649,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      getDefaultValue(): LiteralValueState | null;
      setDefaultValue(value: LiteralValueState | null, changeSet?: ChangeSet | null): InputMapState;
@@ -21458,6 +21666,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace inputMapValidation {
      export {
+         validateAsync_17 as validateAsync,
          validate_17 as validate
      }
  }
@@ -21573,7 +21782,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      clone(changeSet?: ChangeSet | null, parent?: ProjectState | null, newId?: string | null, subscribe?: boolean): InstalledProjectState;
  }
@@ -21582,6 +21795,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace installedProjectValidation {
      export {
+         validateAsync_18 as validateAsync,
          validate_18 as validate
      }
  }
@@ -21716,7 +21930,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      clone(changeSet?: ChangeSet | null, parent?: VariableState | null, newId?: string | null, subscribe?: boolean): InternalCallState;
      removeUnrecognizedInputs(changeSet?: ChangeSet | null): IChangeSet<InternalCallState>;
@@ -21734,6 +21952,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace internalCallValidation {
      export {
+         validateAsync_19 as validateAsync,
          validate_19 as validate,
          validateParentRelation
      }
@@ -24020,7 +24239,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      clone(changeSet?: ChangeSet | null, parent?: DataTypeState | InputMapState | PropertyState | ArgumentDeclarationState | ReturnStatementState | BreakStatementState | ContinueStatementState | VariableDeclarationState | VariableInstanceState | ValueDescriptorState | null, newId?: string | null, subscribe?: boolean): LiteralValueState;
      merge(sourceEntity: LiteralValueState, changeSet?: ChangeSet | null): IChangeSet<LiteralValueState>;
@@ -24032,6 +24255,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace literalValueValidation {
      export {
+         validateAsync_23 as validateAsync,
          validate_23 as validate
      }
  }
@@ -24184,7 +24408,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      clone(changeSet?: ChangeSet | null, parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): LoopState;
      getVariableInstances(): VariableInstanceState[];
@@ -24237,6 +24465,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace loopValidation {
      export {
+         validateAsync_21 as validateAsync,
          validate_21 as validate,
          validateListLoop
      }
@@ -24473,7 +24702,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  export declare const mockClientProject: IProjectTransfer;
 
- export declare function modifyEditableAndDeletableDownstreamEntitiesFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet, newValue: boolean, seenEntities?: Set<string>, allBuiltInEntityIds?: string[]): void;
+ export declare function modifyEditableAndDeletableDownstreamEntitiesFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet, newValue: boolean, seenEntities?: Set<string>): void;
 
  export declare const NESTED_PROPERTY_HEIGHT = 26;
 
@@ -28439,7 +28668,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      clone(changeSet?: ChangeSet | null, parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): OperationState;
      removeUnrecognizedInputs(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
@@ -28459,6 +28692,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace operationValidation {
      export {
+         validateAsync_10 as validateAsync,
          validate_10 as validate
      }
  }
@@ -28474,7 +28708,13 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  export declare const orConditionResultVoidDataTypeParentRef: IActionDescriptorReference;
 
- export declare function orderEntitiesForTraversal(entities: (Element_2 | ElementTransfer | EntityState | ElementShallowTransfer)[]): (Element_2 | ElementTransfer | EntityState | ElementShallowTransfer)[];
+ export declare function orderEntitiesForTraversal(entities: (Element_2 | ElementTransfer | EntityState | ElementShallowTransfer)[], options: {
+     allBuiltInEntityIds?: Set<EntityId>;
+ }): (Element_2 | ElementTransfer | EntityState | ElementShallowTransfer)[];
+
+ export declare function orderEntitiesForTraversalAsync(entities: (Element_2 | ElementTransfer | EntityState | ElementShallowTransfer)[], options: {
+     allBuiltInEntityIds?: Set<EntityId>;
+ } & YieldOptions): Promise<(Element_2 | ElementTransfer | EntityState | ElementShallowTransfer)[]>;
 
  export declare const outEncDefault: ILiteralValueTransfer;
 
@@ -28599,7 +28839,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      clone(changeSet?: ChangeSet | null, parent?: PassThroughCallableEntityWithOutputsState | null, newId?: string | null, subscribe?: boolean): OutputMapState;
      getDataType(changeSet?: ChangeSet | null): DataTypeState | null;
@@ -28609,6 +28853,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace outputMapValidation {
      export {
+         validateAsync,
          validate
      }
  }
@@ -28781,7 +29026,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  export declare function percentageChange(oldRaw: unknown, newRaw: unknown): number;
 
- export declare type PersistChangeSetEntityActionPayload = IRecordChangeSet<UserManagedElementShallowTransfer, UserManagedElementShallowTransfer> & {
+ export declare type PersistChangeSetEntityActionPayload = IRecordChangeSet<UserManagedElementShallowTransfer | null, UserManagedElementShallowTransfer> & {
      isNewBranchHead: boolean;
      branch: string;
  };
@@ -28954,7 +29199,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      getAllInteractiveMethods(): ActionDescriptorState[];
  }
@@ -29043,6 +29292,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      activeVersion: boolean;
      initialized: boolean;
      startedInitialization: boolean;
+     diggestedBuiltInBaseEntitiesIds: Set<EntityId>;
      onPersistChangeSetSequentiallyCallback: ((changeSet: ChangeSet) => Promise<{
          success: boolean;
      }>) | null;
@@ -29189,8 +29439,13 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      validateChildren(): void;
+     validateChildrenAsync(options?: YieldOptions): Promise<void>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      clone(): ProjectState;
      getDefinitionEntity(id: EntityId): DefinitionEntityState | null;
@@ -29410,7 +29665,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      implement(parent: DefinitionEntityState, changeSet?: ChangeSet | null, newId?: string | null): PropertyState;
      clone(changeSet?: ChangeSet | null, parent?: DefinitionEntityState | null, newId?: string | null, subscribe?: boolean): PropertyState;
@@ -29429,6 +29688,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace propertyValidation {
      export {
+         validateAsync_4 as validateAsync,
          validate_4 as validate,
          validateImplementation,
          validatePropertyEntityName
@@ -30146,7 +30406,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      getDefaultValue(): LiteralValueState | null;
      setDefaultValue(value: LiteralValueState | null, changeSet?: ChangeSet | null): ReturnStatementState;
@@ -30161,6 +30425,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace returnStatementValidation {
      export {
+         validateAsync_13 as validateAsync,
          validate_13 as validate
      }
  }
@@ -30381,7 +30646,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      clone(changeSet?: ChangeSet | null, parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): SearchState;
      syncInputMaps(changeSet?: ChangeSet | null): IChangeSet<SearchState>;
@@ -30550,6 +30819,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace searchValidation {
      export {
+         validateAsync_20 as validateAsync,
          validate_20 as validate
      }
  }
@@ -32389,41 +32659,38 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
  export declare class Traverser {
      order: EntityId[];
      flatRecord: Record<EntityId, Element_2 | ElementTransfer | EntityState | ElementShallowTransfer>;
-     allBuiltInEntityIds: string[];
+     allBuiltInEntityIds: Set<EntityId>;
      private onGoingVisits;
+     cachedReferences: Record<EntityId, {
+         upstream: Record<EntityId, true>;
+         downstream: Record<EntityId, true>;
+     }>;
      constructor(root?: Element_2 | ElementTransfer | EntityState | ElementShallowTransfer, options?: {
          asyncInitial?: boolean;
-         yieldEvery?: number;
          onOrdered?: () => void;
-     });
+         allBuiltInEntityIds?: Set<EntityId>;
+     } & YieldOptions);
      flatten(entity: Element_2 | ElementTransfer | EntityState | ElementShallowTransfer): void;
-     flattenAsync(entity: Element_2 | ElementTransfer | EntityState | ElementShallowTransfer, options?: {
-         yieldEvery?: number;
-     }): Promise<void>;
+     flattenAsync(entity: Element_2 | ElementTransfer | EntityState | ElementShallowTransfer, options?: YieldOptions): Promise<void>;
      private moveEntityAfterDependencies;
      orderEntities(): void;
-     orderEntitiesAsync(options?: {
-         yieldEvery?: number;
-         recursiveIndex?: number;
-     }): Promise<void>;
+     orderEntitiesAsync(options?: YieldOptions): Promise<void>;
      getUpstreamOngoingDependenciesVisits(entityId: EntityId, taskId: string): Record<EntityId, Promise<any>>;
      getDownstreamOngoingDependenciesVisits(entityId: EntityId, taskId: string): Record<EntityId, Promise<any>>;
      settlePromises(promises: Record<EntityId, Promise<any>>, taskId: string): Promise<void>;
      visit(callback: (entity: Element_2 | ElementTransfer | EntityState | ElementShallowTransfer, knownEntitiesRecord: Record<EntityId, Element_2 | ElementTransfer | EntityState | ElementShallowTransfer>) => any): Traverser;
      reverseVisit(callback: (entity: Element_2 | ElementTransfer | EntityState | ElementShallowTransfer, knownEntitiesRecord: Record<EntityId, Element_2 | ElementTransfer | EntityState | ElementShallowTransfer>) => any): Traverser;
      visitAsync(callback: (entity: Element_2 | ElementTransfer | EntityState | ElementShallowTransfer, knownEntitiesRecord: Record<EntityId, Element_2 | ElementTransfer | EntityState | ElementShallowTransfer>) => any, options?: {
-         yieldEvery?: number;
          parallelise?: boolean;
-     }): Promise<Traverser>;
+     } & YieldOptions): Promise<Traverser>;
      reverseVisitAsync(callback: (entity: Element_2 | ElementTransfer | EntityState | ElementShallowTransfer, knownEntitiesRecord: Record<EntityId, Element_2 | ElementTransfer | EntityState | ElementShallowTransfer>) => any, options?: {
-         yieldEvery?: number;
          parallelise?: boolean;
-     }): Promise<Traverser>;
+     } & YieldOptions): Promise<Traverser>;
  }
 
  declare type TypedArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | BigUint64Array | BigInt64Array | Float32Array | Float64Array;
 
- export declare function unfreezeDownstreamEntitiesFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet, seenEntities?: Set<string>, allBuiltInEntityIds?: string[]): void;
+ export declare function unfreezeDownstreamEntitiesFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet, seenEntities?: Set<string>): void;
 
  export declare function uniqueList(list: unknown): any[];
 
@@ -32719,6 +32986,52 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  export declare function validateArgumentDeclarationName(entity: ArgumentDeclarationState | IArgumentDeclarationGenerationTarget | IArgumentDeclarationShallowTransfer | IArgumentDeclarationTransfer, project: ProjectState): EntityGenerationError[];
 
+ declare function validateAsync(self: OutputMapState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_10(self: OperationState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_11(self: FunctionCallState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_12(self: ConditionState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_13(self: ReturnStatementState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_14(self: ContinueStatementState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_15(self: BreakStatementState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_16(self: GlobalEventState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_17(self: InputMapState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_18(self: InstalledProjectState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_19(self: InternalCallState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_2(self: DefinitionEntityState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_20(self: SearchState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_21(self: LoopState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_22(self: ValueDescriptorState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_23(self: LiteralValueState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_3(self: DataTypeState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_4(self: PropertyState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_5(self: VariableDeclarationState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_6(self: VariableInstanceState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_7(self: ArgumentDeclarationState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_8(self: ActionDescriptorState, options?: YieldOptions): Promise<EntityError[]>;
+
+ declare function validateAsync_9(self: FunctionDeclarationState, options?: YieldOptions): Promise<EntityError[]>;
+
  export declare function validateCallableEntityShouldCallReturnStatement(self: CallableEntityState): EntityError[];
 
  export declare function validateCalledByErrorIdInAction(calledByErrorId: EntityId, project: ProjectState, propertyName?: string): EntityGenerationError[];
@@ -33426,7 +33739,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      clone(changeSet?: ChangeSet | null, parent?: ActionDescriptorState | SearchState | null, newId?: string | null, subscribe?: boolean): ValueDescriptorState;
      getDataType(changeSet?: ChangeSet | null): DataTypeState | null;
@@ -33442,6 +33759,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace valueDescriptorValidation {
      export {
+         validateAsync_22 as validateAsync,
          validate_22 as validate
      }
  }
@@ -33663,7 +33981,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      getDefaultValue(): LiteralValueState | null;
      setDefaultValue(value: LiteralValueState | null, changeSet?: ChangeSet | null): VariableDeclarationState;
@@ -33689,6 +34011,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace variableDeclarationValidation {
      export {
+         validateAsync_5 as validateAsync,
          validate_5 as validate,
          validateVariableDeclarationName_2 as validateVariableDeclarationName,
          validateGlobalVariableDeclaration
@@ -33865,7 +34188,11 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
      validate(): {
          success: boolean;
      };
+     validateAsync(options?: YieldOptions): Promise<{
+         success: boolean;
+     }>;
      getErrors(): EntityError[];
+     getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
      getShallowErrors(): EntityError[];
      getDefaultValue(): LiteralValueState | null;
      setDefaultValue(value: LiteralValueState | null, changeSet?: ChangeSet | null): VariableInstanceState;
@@ -33889,6 +34216,7 @@ export declare function getReferencedEntityStateOrErrors(data: ElementGeneration
 
  declare namespace variableInstanceValidation {
      export {
+         validateAsync_6 as validateAsync,
          validate_6 as validate
      }
  }