@elyx-code/project-logic-tree 0.0.6340 → 0.0.6343

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { BinaryExpr } from 'sql-parser-cst';
+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';
@@ -171,6 +172,11 @@ export declare class ActionOutputMapState extends OutputMapState implements IAct
     toJSON(seenEntities?: Set<EntityId>): IActionOutputMap | IOutputMapReference;
 }
 
+export declare function addDisabledReasons(existingDisbledResons: CanvasEntityDisabledReason[], newReasons: CanvasEntityDisabledReason[]): {
+    hasChanged: boolean;
+    reasons: CanvasEntityDisabledReason[];
+};
+
 export declare function afterLiteralValueAsTypeChangeSideEffects(newValue: ValueAsTypeState | ValueAsTypeState[] | null, entity: EntityWithValueState, project: ProjectState, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
 
 export declare function afterLiteralValueAsTypeDeleteSideEffects(entity: EntityWithValueState, project: ProjectState, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
@@ -233,6 +239,12 @@ export declare const ALL_BUILT_IN_TOP_LEVEL_ENTITIES: ElementTransfer[];
 
 export declare const ALL_BUILT_IN_VALUE_DESCRIPTORS: IValueDescriptorTransfer[];
 
+export declare const ALL_CONNECTION_DISABLED_REASONS: CanvasEntityConnectionDisabledReason[];
+
+export declare const ALL_OTHER_DISABLED_REASONS: CanvasEntityOtherDisabledReason[];
+
+export declare const ALL_TESTING_DISABLED_REASONS: CanvasEntityTestingDisabledReason[];
+
 declare class AllColumnsSelector implements ISearchNode {
     owner: SearchStatementState;
     parent: DataSource | null;
@@ -286,6 +298,74 @@ export declare const appendToListOperationSecondListDataType: IDataTypeTransfer;
 
 export declare function applyNewScope(self: CallableEntityState, changeSet: ChangeSet | null): void;
 
+export declare class Area {
+    ids: string[];
+    entity: CanvasEntityState | ProjectState;
+    entityCardHeight: number;
+    entityCardWidth: number;
+    index: number;
+    childEntities: CanvasEntityState[];
+    children: Area[];
+    parents: Area[];
+    calculationEntryPoint: Area;
+    _onlyEntities: CanvasEntityState[] | null;
+    private _changeSet;
+    constructor(entity: CanvasEntityState | ProjectState, index: number, calculationEntryPoint?: Area | null, changeSet?: ChangeSet);
+    static autoGenerateLayout(entryPointEntity: CanvasEntityState | ProjectState, changeSet: ChangeSet | null, onlyEntities?: CanvasEntityState[]): CanvasEntityState[];
+    static recursivelyAssembleChildrenAreas(renderedParents: Area[]): void;
+    get onlyEntities(): CanvasEntityState[] | null;
+    get changeSet(): ChangeSet | null;
+    set changeSet(changeSet: ChangeSet | null);
+    findAreaInChildrenFromEntity(entity: CanvasEntityState): Area | null;
+    findAreaFromEntity(entity: CanvasEntityState): Area | null;
+    addParent(parent: Area): void;
+    static resolveIds(parent: Area, index: number): string[];
+    getSortedChildren(): void;
+    calculateCardSize(): void;
+    static getBoundriesOfTwoAreas(area1: ICoordinates, area2: ICoordinates): ICoordinates;
+    static getBoundriedOfCombinedAreas(areas: Area[], until: Area[]): ICoordinates;
+    getFullAreaUntilAny(areas: Area[]): ICoordinates;
+    getFullAreaUntilAreaOrAnyChildren(childArea: Area): ICoordinates;
+    getFullAreaUntil(childArea: Area): ICoordinates;
+    get fullBranchArea(): ICoordinates;
+    get ownEntityArea(): ICoordinates;
+    get ownEntityPlusBufferArea(): ICoordinates;
+    static filterOutRepeatedAreas(areas: Area[]): Area[];
+    getEarliestId(idA: string, idB: string): string;
+    getEarliestLevel(): number;
+    countColumns(): number;
+    getLatestId(idA: string, idB: string): string;
+    getLatestLevel(): number;
+    smoothPosition(): void;
+    shiftDownUntilAny(areas: Area[], amount: number): Area[];
+    shiftRightUntilAny(areas: Area[], amount: number): void;
+    shiftRight(amount: number): void;
+    shiftDownAlone(amount: number): void;
+    centerHeaderVerticallyOverCombinedAllParentsHeaderHeight(): void;
+    centerHeaderVerticallyOverCombinedAllChildrenHeaderHeight(): number;
+    resolveChildrenOverlaps(): void;
+    static getEarliestParentInChain(area: Area): Area;
+    flattenEarlierSiblings(seenSiblings?: Set<string>): Area[];
+    flattenSiblings(seenSiblings?: Set<string>): Area[];
+    flattenChildren(seenChildren?: Set<string>): Area[];
+    flattenParents(seenParents?: Set<string>): Area[];
+    getAreaIfRendered(entity: CanvasEntityState): Area | null;
+    getLowerSiblings(): Area[];
+    getLowerAreas(): Area[];
+    adjustVerticallyToAvoidOverlaps(alreadyShiftedAreas?: Area[]): Area[];
+    move(entity: CanvasEntityState, coordinates: {
+        x: number;
+        y: number;
+    } | {
+        y: number;
+    } | {
+        x: number;
+    }): void;
+    addChild(index: number): Area | null;
+    flattenChildEntities(seenEntities?: Set<string>): CanvasEntityState[];
+    next(onLevelComplete: (renderedLevel: Area[]) => void): void;
+}
+
 export declare enum ArgumentDeclarationDependencyField {
     DataTypeEntity = "data-type-entity",
     Implements = "implements"
@@ -1165,6 +1245,16 @@ export declare const CACHED_PROJECTS_BY_ID: {
     [id: string]: ProjectState;
 };
 
+export declare function calculateCardSize(entity: CanvasEntityState): {
+    height: number;
+    width: number;
+};
+
+export declare function calculateMethodCardSize(entity: FunctionDeclarationState): {
+    height: number;
+    width: number;
+};
+
 export declare function calculateNewParentBasedOnCallers(self: CallableEntityState): EntityWithLogicScopeState | ProjectState;
 
 export declare const CALLABLE_ENTITIES_EXPLANATION: string;
@@ -1198,8 +1288,6 @@ export declare type CallableEntityTransfer = PassThroughCallableEntityTransfer |
 
 export declare type CallableEntityTypesUnion = CallableEntity | CallableEntityTransfer | CallableEntityShallowTransfer | CallableEntityGenerationTarget;
 
-declare type CallbackArguments<Arguments extends any[] = any[]> = [...args: Arguments];
-
 export declare const CALLER_ENTITIES_EXPLANATION: string;
 
 export declare const CALLER_TYPES: EntityType[];
@@ -1226,10 +1314,68 @@ export declare type CallerEntityTypesUnion = CallerEntity | CallerEntityTransfer
 
 export declare const CALLS_UPDATE_EXPLANATION = "Caller to callee relationships can be updated with the 'add_caller' and 'remove_caller' generation action with the properties: 'callerEntityId', a 'calleeEntityId'. For adding a caller, you can optionally add a boolean property 'fromError' (if the caller calls when an error occured in its execution).\nEither of these two actions will only affect the one relationship between the given caller and callee and ignore any others present in either entity.";
 
+export declare const CANVAS_BASE_X: number;
+
+export declare const CANVAS_BASE_Y: number;
+
+export declare const CANVAS_CARD_HEADER_CENTER_HEIGHT = 32;
+
+export declare const CANVAS_CARD_WIDTH = 280;
+
+export declare const CANVAS_COMPLEX_CARD_HEIGHT = 300;
+
+export declare const CANVAS_HORIZONTAL_BUFFER_BETWEEN_CARDS = 270;
+
+export declare const CANVAS_SIMPLE_CARD_HEIGHT = 65;
+
+export declare const CANVAS_SIZE = 40000;
+
+export declare const CANVAS_VERTICAL_BUFFER_BETWEEN_CARDS = 90;
+
+export declare enum CanvasEntityConnectionDisabledReason {
+    ValuesAlreadyConnected = "values-already-connected",
+    CannotReadMoreThanOneValue = "cannot-read-more-than-one-value",
+    CannotReadValueFromChildren = "cannot-read-value-from-children",
+    CannotWriteValueToChildren = "cannot-write-value-to-children",
+    CannotBeCalledByChildren = "cannot-be-called-by-children",
+    ExecutionsAlreadyConnected = "executions-already-connected",
+    DataTypesNotCompatible = "data-types-not-compatible",
+    CannotCallAncestor = "cannot-call-ancestor",
+    CannotWriteValueToAncestor = "cannot-write-value-to-ancestor",
+    NotInScope = "not-in-scope",
+    IsNotValueWrittingEntity = "is-not-value-writting-entity",
+    IsNotValueReadingEntity = "is-not-value-reading-entity",
+    ContinueOrBreakStatementCalledFromOutsideLoop = "continue-or-break-statement-called-from-outside-loop",
+    ElementInLoopBodyCallingOutsideLoop = "element-in-loop-body-calling-outside-loop",
+    CallerIsInHigherScope = "caller-is-in-higher-scope",
+    CallerIsInLowerScope = "caller-is-in-lower-scope",
+    CallIsInHigherScope = "call-is-in-higher-scope",
+    CallIsInLowerScope = "call-is-in-lower-scope",
+    OtherIncompatibleScopeReason = "other-incompatible-scope-reason"
+}
+
+export declare type CanvasEntityDisabledReason = CanvasEntityConnectionDisabledReason | CanvasEntityTestingDisabledReason | CanvasEntityOtherDisabledReason;
+
+export declare enum CanvasEntityOtherDisabledReason {
+    Suggestion = "suggestion",
+    CanvasGloballyDisabled = "canvas-globally-disabled"
+}
+
 export declare type CanvasEntityState = InstalledProjectState | DefinitionEntityState | FunctionDeclarationState | GlobalEventState | VariableState | ConditionState | OperationState | FunctionCallState | ReturnStatementState | ContinueStatementState | BreakStatementState | LoopState | SearchState;
 
+export declare enum CanvasEntityTestingDisabledReason {
+    NotPartOfOngoingTest = "not-part-of-ongoing-test",
+    CannotBeAddedToTest = "cannot-be-added-to-test"
+}
+
 export declare function capitalizeFirstLetter(value: string): string;
 
+export declare const CARD_FOOTER_HEIGHT = 38;
+
+export declare const CARD_PROPERTIES_SECTION_PADDING: number;
+
+export declare const CARD_PROPERTIES_SECTION_SINGLE_PADDING = 10;
+
 export declare class ChangeSet {
     id: string;
     seenEntities: EntityId[];
@@ -1414,10 +1560,6 @@ declare class ColumnRef implements ISearchNode {
     get isValid(): boolean;
 }
 
-declare class CombinedVersionedEvents extends VersionedState {
-    constructor(...args: ConstructorParameters<typeof VersionedState>);
-}
-
 export declare enum CommonStringValidationErrorCodes {
     StringValueMustNotHaveSpaces = "string-value-must-not-have-spaces",
     StringValueMustNotHaveDashes = "string-value-must-not-have-dashes"
@@ -2505,6 +2647,8 @@ export declare type ElementTransfer = IProjectTransfer | IInstalledProjectTransf
 
 export declare type ElementTypesUnion = ProjectTypesUnion | InstalledProjectTypesUnion | DefinitionEntityTypesUnion | GlobalEventTypesUnion | FunctionDeclarationTypesUnion | FunctionCallTypesUnion | PropertyTypesUnion | VariableDeclarationTypesUnion | VariableInstanceTypesUnion | OperationTypesUnion | ConditionTypesUnion | ArgumentDeclarationTypesUnion | InputMapTypesUnion | ReturnDeclarationTypesUnion | OutputMapTypesUnion | DataTypeTypesUnion | ReturnStatementTypesUnion | BreakStatementTypesUnion | ContinueStatementTypesUnion | LoopTypesUnion | ActionDescriptorTypesUnion | SearchTypesUnion | PrimitiveEntityTypesUnion | LiteralValueTypesUnion | ValueDescriptorTypesUnion | BuiltInBaseEntityTypesUnion | InternalCallTypesUnion;
 
+export declare function emitSideEffects(changeSet: ChangeSet): ChangeSet;
+
 export declare const endpointBuiltInBaseEntity: IBuiltInBaseEntityTransfer;
 
 export declare const endpointBuiltInBaseEntityRef: IBuiltInBaseEntityReference;
@@ -2925,9 +3069,11 @@ export declare const enumPrototype: IPrimitiveEntityTransfer;
 
 export declare const enumPrototypeRef: IPrimitiveEntityReference;
 
-export declare const EVENT_TYPES: EntityType[];
+export declare const ERROR_PROPERTY_HEIGHT = 52;
 
-declare type EventCallback<Arguments extends any[]> = (...args: CallbackArguments<Arguments>) => any;
+export declare function errorCodeToMessage(errorCode: string): string;
+
+export declare const EVENT_TYPES: EntityType[];
 
 export declare type EventEntity = IGlobalEvent;
 
@@ -2945,19 +3091,6 @@ export declare type EventEntityTransfer = IGlobalEventTransfer;
 
 export declare type EventEntityTypesUnion = EventEntity | EventEntityTransfer | EventEntityShallowTransfer | EventEntityGenerationTarget;
 
-export declare class Events {
-    private subscribedEvents;
-    private getEvent;
-    _on<Arguments extends any[]>(eventName: string, callback: EventCallback<Arguments>): void;
-    on: <Arguments extends any[]>(eventName: string, callback: EventCallback<Arguments>) => void;
-    _emit<Arguments extends any[]>(eventName: string, ...args: Arguments): void;
-    emit: <Arguments extends any[]>(eventName: string, ...args: Arguments) => void;
-    _off<Arguments extends any[]>(eventName: string, callback?: EventCallback<Arguments>): void;
-    off: <Arguments extends any[]>(eventName: string, callback?: EventCallback<Arguments>) => void;
-    _destroy(): void;
-    destroy: () => void;
-}
-
 export declare const EXECUTABLE_TYPES: EntityType[];
 
 export declare type ExecutableEntity = CallableEntity | EntryPointEntity;
@@ -3604,6 +3737,8 @@ export declare function generateIdFromStrategy(entity: EntityState, project: Pro
 
 export declare function generateMutablePropertiesExplanation(entityToUpdate: EntityState): string;
 
+export declare function generatePlaceholderValueStore(id: string, project: ProjectState): IValueStoreClient;
+
 export declare function generateRandomBoolean(_: IAutogenerationRandomBoolean): boolean;
 
 export declare function generateRandomDate(options: IAutogenerationRandomDate): Date;
@@ -8507,6 +8642,13 @@ export declare interface IContinueStatementTransfer extends ITerminationStatemen
     parent: ILoop | ILoopReference;
 }
 
+export declare interface ICoordinates {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+
 declare interface IDataSource {
     entity: DefinitionEntityState | null;
     query: NestedSearchStatement | null;
@@ -8647,7 +8789,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<Options extends object = {}> extends IUndoableInterface, IValueResolutionContext {
     ready: boolean;
     hasLoadedLogic: boolean;
     destroyed: boolean;
@@ -8667,26 +8809,29 @@ export declare interface IEditor extends IUndoableInterface, IValueResolutionCon
     onLogicLoadingCompleteCallback: null | ((chunk: any) => void);
     onRenderedCallback: null | (() => void);
     onProjectSetupErrorCallback: null | ((error: any) => void);
-    constructor(projectId: EntityId, socket?: IWebsocketsClient | null, events?: Events): IEditor;
+    constructor(projectId: EntityId, socket: IWebsocketsClient | null, events: Events | null, options?: Options): IEditor;
     get execution(): Execution | null;
     get project(): ProjectState;
     get lastExecutionResults(): EfimeralValueStore;
     get undoableStackValueIndex(): number;
     set undoableStackValueIndex(value: number);
     get PROJECT_NOTIFICATIONS_CHANNEL(): string;
+    getAccessToken(): Promise<string | null>;
     onProjectHeadLoaded(callback: (projectState: ProjectState) => void): void;
     onLogicLoadingComplete(callback: (chunk: any) => void): void;
-    onRendered(callback: () => void): void;
     onProjectSetupError(callback: (error: any) => void): void;
     removeValueByOwnerId(entityId: EntityId): void;
     removeValue(dynamicValue: IDynamicValue): void;
-    handleNotificationChannelsMessage(message: IOutgoingWSMessage<string, {
+    handleIncommingWebsocketMessage(message: {
+        [key: string]: any;
+    }): Promise<void>;
+    handleNotificationChannelsMessage(message: {
         data: {
             channels: IChannelConnections[];
             sessionId: string;
         };
-    }>): void;
-    handlePersistChangeSetMessage(message: IOutgoingWSMessage<string, PersistChangeSetEntityActionRequestPayload>): void;
+    }): void;
+    handlePersistChangeSetMessage(message: PersistChangeSetEntityActionRequestPayload): void;
     getLogic(options?: {
         mockLogic?: ProjectState;
     }): Promise<void>;
@@ -8767,8 +8912,8 @@ export declare interface IExecutionCallbackContext {
 }
 
 export declare interface IExecutionClient {
-    onBeforeEntityExecution?: (entity: EntityState, inputs: IDynamicValue[], context: IExecutionCallbackContext) => Promise<any>;
-    onEntityExecuted?: (entity: EntityState, result: IExecutionResult, context: IExecutionCallbackContext) => Promise<any>;
+    onBeforeEntityExecution?: (entity: TestableEntityState, inputs: IDynamicValue[], context: IExecutionCallbackContext) => Promise<any>;
+    onEntityExecuted?: (entity: TestableEntityState, result: IExecutionResult, context: IExecutionCallbackContext) => Promise<any>;
 }
 
 export declare interface IExecutionResult {
@@ -9906,7 +10051,7 @@ export declare interface IProjectTransfer extends IProject_meta {
     searches: (ISearch | ISearchTransfer)[];
 }
 
-declare interface IProjectVersionTransitionConfig {
+export declare interface IProjectVersionTransitionConfig {
     transitionalChangeSet: ChangeSet;
     transitionTime: string;
     timeOfOriginalTargetChanges: string;
@@ -11176,6 +11321,10 @@ export { loopValidation }
 
 export declare function lowercaseFirstLetter(value: string): string;
 
+export declare const MAIN_VALUE_PROPERTY_HEADER_HEIGHT = 44;
+
+export declare const MAIN_VALUE_SUB_PROPERTY_HEIGHT = 35;
+
 export declare const manualFlowActionDescriptorDeclarationArgumentDeclaration: IValueDescriptorTransfer;
 
 export declare const manualFlowActionDescriptorDeclarationArgumentDeclarationDataType: IDataTypeTransfer;
@@ -11204,6 +11353,8 @@ export declare function mapActionDescriptorToTypeItRepresents(entity: EntityStat
 
 export declare function mapRecord(record: Record<EntityId, Element_2 | ElementTransfer | ElementShallowTransfer> | undefined, entityIdMaps: Map<EntityId, EntityId>): Record<EntityId, Element_2 | ElementTransfer | ElementShallowTransfer>;
 
+export declare function mergeArraysOfStringsWithoutDuplicates(arr1: string[], arr2: string[]): string[];
+
 export declare function mergeEntityErrorsList(oldErrors: EntityError[], newErrors: EntityError[]): EntityError[];
 
 export declare function mergeListOfEntities(oldErrors: EntityState[], newErrors: EntityState[]): EntityState[];
@@ -11230,6 +11381,8 @@ export declare const moreThanOrEqualConditionRightHandArgumentDataTypeParentRef:
 
 export declare const moreThanOrEqualConditionRightHandArgumentParentRef: IActionDescriptorReference;
 
+export declare const NESTED_PROPERTY_HEIGHT = 26;
+
 declare class NestedSearchStatement implements ISearchNode {
     owner: SearchStatementState;
     statement: SearchStatementState | null;
@@ -11976,10 +12129,7 @@ export declare type ProjectPayloadUnion = ProjectState | ProjectTypesUnion;
 
 export declare const projectPublicationCompletedGlobalEvent: IActionDescriptorTransfer;
 
-export declare interface ProjectState extends Events {
-}
-
-export declare class ProjectState extends CombinedVersionedEvents implements IProject, UserManagedEntityStateTemplate, BaseState {
+export declare class ProjectState extends VersionedState implements IProject, UserManagedEntityStateTemplate, BaseState {
     initialData: IProject | IProjectTransfer;
     readonly id: EntityId;
     type: EntityType.Project;
@@ -12029,6 +12179,7 @@ export declare class ProjectState extends CombinedVersionedEvents implements IPr
     activeVersion: boolean;
     initialized: boolean;
     startedInitialization: boolean;
+    _eventsHub: Events;
     onCloseChangeSetCallback: ((changeSet: ChangeSet) => Promise<{
         success: boolean;
     }>) | null;
@@ -12061,6 +12212,9 @@ export declare class ProjectState extends CombinedVersionedEvents implements IPr
         errors: EntityGenerationError[];
         modifiedData: IProjectGenerationTarget;
     };
+    get off(): Events['off'];
+    get on(): Events['on'];
+    get emit(): Events['emit'];
     closePendingChangeSets(): Promise<void>;
     onRequestActiveValue(callback: (valueOwner: EntityWithValueState) => LiteralValueState | null): void;
     onCloseChangeSet(callback: (changeSet: ChangeSet) => Promise<{
@@ -12236,6 +12390,8 @@ export declare function propagateNewStaticPropertyValueAsTypeToVariables(entity:
 
 export declare function propagateNewStaticPropertyValueToVariables(entity: PropertyState, project: ProjectState, newValue: LiteralValueType, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
 
+export declare const PROPERTY_HEIGHT = 39;
+
 export declare const PROPERTY_NOT_VALUE_READER_WRITTER_EXPLANATION = "A property entity, is neither a value reading, or a value writting entity, but they are often confused with one.\nA 'property' can have a default value through its nested 'data-type' entity.\nThe 'property' entity only represents the data field in the declaration, and it can't write or read values.\nWhen a 'definition-entity' is instantiated as a variable, any writes or reads to its properties are done through 'input-map's and 'output-map's.";
 
 export declare enum PropertyDependencyField {
@@ -12388,8 +12544,163 @@ export { propertyValidation }
 
 export declare const READ_ONLY_ENTITY_PERSISTANCE_REPOSITORY: IReadOnlyEntityPersistanceRepository;
 
+export declare const READABLE_ENTITY_TYPES: {
+    "primitive-entity": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "definition-entity": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "built-in-base-entity": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    property: {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "function-declaration": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "function-call": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "global-event": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    project: {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "variable-declaration": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "variable-instance": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    condition: {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    operation: {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "return-statement": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "installed-project": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    search: {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    loop: {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "action-descriptor": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "internal-call": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "break-statement": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "continue-statement": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "argument-declaration": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "input-map": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "output-map": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "return-declaration": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+    "value-descriptor": {
+        singular: string;
+        plural: string;
+        shortSingular: string;
+        shortPlural: string;
+    };
+};
+
 export declare function readValueFromWritter(entity: ValueReadingEntityState, context: IValueResolutionContext): IDynamicValue | null;
 
+export declare function rebaseStack<T = any>(undoableStackValueIndex: number, history: T[], newItem: T): number;
+
 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;
 
 export declare const relationalDatabaseBuiltInBaseEntity: IBuiltInBaseEntityTransfer;
@@ -12448,6 +12759,11 @@ export declare const relationalDatabaseBuiltInBaseEntityUsernamePropertyDataType
 
 export declare const relationalDatabaseBuiltInBaseEntityUsernamePropertyRef: IPropertyReference;
 
+export declare function removeDisabledReasons(existingDisbledResons: CanvasEntityDisabledReason[], reasonsToRemove: CanvasEntityDisabledReason[]): {
+    hasChanged: boolean;
+    reasons: CanvasEntityDisabledReason[];
+};
+
 export declare function resolveActionDescriptorName(actionDescriptor: ActionDescriptorState): string;
 
 declare function resolveAreThereConflictingColumnsInSelectAll(allColumnsSelector: AllColumnsSelector | null): boolean;
@@ -12458,6 +12774,8 @@ export declare function resolveBaseEntityName(baseEntities: BaseEntityNames[]):
 
 export declare function resolveBuiltInBaseEntityDataTypeLabel(entity: BuiltInBaseEntityState): string;
 
+export declare function resolveCardSubheader(entity: CanvasEntityState): string;
+
 export declare function resolveClonedEntityProject(newParent: EntityState | null, self: EntityState): ProjectState;
 
 export declare function resolveConditionOperatorLabel(condition: ConditionState): "and" | "or" | "is equal to" | "is not equal to" | "is greater than" | "is greater than or equal to" | "is less than" | "is less than or equal to" | "is empty" | "is not empty" | undefined;
@@ -12472,18 +12790,26 @@ export declare function resolveDataTypeEntityOrNestedChildrenFromLiteralValue(va
     abstract?: boolean;
 }, changeSet: ChangeSet | null, rootEntityCreated: DefinitionEntityState): IChangeSet<DataTypeState>;
 
+export declare function resolveDatatypeIconName(dataType: DataTypeState): "definition-entity" | "number" | "boolean" | "uuid" | "list" | "text" | "date-time";
+
 export declare function resolveDataTypeLabel(dataType: DataTypeState | null): string;
 
 export declare function resolveDefinitionEntityDataTypeLabel(entity: DefinitionEntityState): string;
 
+export declare function resolveDefinitionEntitySubheader(entity: DefinitionEntityState): string;
+
 export declare function resolveEntityDataTypeLabel(entity: PropertyState | EntityWithValueState | ValueDescriptorState): string;
 
 export declare function resolveEntityName(entity: EntityPayloadUnion, project: ProjectState): string;
 
+export declare function resolveEntitySubheader(entity: VariableState | DefinitionEntityState | LoopState | SearchState | FunctionDeclarationState | GlobalEventState | ReturnStatementState | BreakStatementState | ContinueStatementState | BuiltInBaseEntityState): string;
+
 export declare function resolveFirstCallsSecond(first: DraggableExecutableEntityState, second: DraggableCallableEntityState): boolean;
 
 export declare function resolveFirstWritesSecond(first: ValueWritingEntityState, second: ValueReadingEntityState): boolean;
 
+export declare function resolveFunctionDeclarationCardSubheader(entity: FunctionDeclarationState): string;
+
 export declare function resolveInputMapNextStandaloneValue(entity: InputMapState, context: IValueResolutionContext): IDynamicValue | null;
 
 export declare function resolveInputMapNextValue(entity: InputMapState, context: IValueResolutionContext): IDynamicValue | null;
@@ -12496,6 +12822,8 @@ export declare function resolveInputMapValue(entity: InputMapState, context: IVa
 
 export declare function resolveInputMapValueAsPropertyOfAnObject(entity: InputMapState, context: IValueResolutionContext): IDynamicValue | null;
 
+export declare function resolveMethodCardSubheader(entity: FunctionDeclarationState): string;
+
 export declare function resolveNextValue(entity: ValueReadingEntityState, context: IValueResolutionContext): IDynamicValue | null;
 
 export declare function resolveOutputMapValue(entity: OutputMapState, context: IValueResolutionContext): IDynamicValue | null;
@@ -13374,6 +13702,8 @@ export declare enum StandaloneOperatorTypes {
     NotEmpty = "not-empty"
 }
 
+export declare const STATIC_PROPERTY_HEIGHT = 49;
+
 export declare const STRING_OPERATIONS: {
     [key: string]: IActionDescriptorTransfer;
 };
@@ -13507,6 +13837,18 @@ export declare function toLowerCaseKebabCase(str: string): string;
 
 export declare function toPascalCase(str: string): string;
 
+export declare function transitionProjectVersion(from: ChangeSet | 'initial', to: ChangeSet | 'initial', project: ProjectState): IProjectVersionTransitionConfig;
+
+export declare function translateLogicErrorCode(error: EntityError): string;
+
+export declare function translateLogicErrorCodeShort(error: EntityError): string;
+
+export declare function translateLogicErrorCodeShortWithEntityName(error: EntityError): string;
+
+export declare function translateLogicErrorCodeWithEntityName(error: EntityError): string;
+
+export declare function traverseChangeSet(changeSet: ChangeSet, onAdded: (entity: UserManagedEntityState) => void, onUpdated: (entity: UserManagedEntityState) => void, onRemoved: (entity: UserManagedEntityState) => void): void;
+
 export declare class Traverser {
     order: EntityId[];
     flatRecord: Record<EntityId, Element_2 | ElementTransfer | EntityState | ElementShallowTransfer>;