@elyx-code/project-logic-tree 0.0.6999 → 0.0.7000

package/dist/tree/state/variable-instance/variable-instance.d.ts

@@ -0,0 +1,203 @@
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IVariableInstance, IVariableInstanceGenerationTarget, IVariableInstanceReference, IVariableInstanceShallowTransfer, IVariableInstanceTransfer, IVariableInstance_meta, VariableInstanceTypesUnion } from '../../../definitions';
+import { BaseCanvasDraggableState, UserManagedBaseState, CallableEntityClass, ChildEntityBaseClass, EntityWithDefaultValueClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateTemplate, ValueReadingEntityClass, ValueValidationCallback, ValueWritingEntityClass } from '../base';
+import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState, ValueReadingEntityState, ValueWritingEntityState } from '../types';
+import { ProjectState } from '../project';
+import { VariableInputMapState } from '../input-map';
+import { ActionOutputMapState, VariableOutputMapState } from '../output-map';
+import { InternalCallState } from '../internal-call';
+import { VariableDeclarationState } from '../variable-declaration';
+import { EntityError, EntityGenerationError } from '../error';
+import { LiteralValueState } from '../literal-value';
+import { GenerationExplanationIds } from '../validate';
+import { DataTypeState } from '../data-type';
+import { UserManagedVersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare enum VariableInstanceDependencyField {
+    Parent = "parent",
+    DataTypeEntity = "data-type-entity",
+    VarDeclaration = "var-declaration"
+}
+export declare class VariableInstanceState extends UserManagedVersionedState implements IVariableInstance, UserManagedBaseState, UserManagedEntityStateTemplate, ValueWritingEntityClass, ValueReadingEntityClass, BaseCanvasDraggableState, ChildEntityBaseClass, EntityWithDefaultValueClass, PassThroughCallableEntityClass, CallableEntityClass {
+    initialData: IVariableInstance | IVariableInstanceTransfer;
+    readonly id: EntityId;
+    x: number;
+    y: number;
+    readonly type: EntityType.VariableInstance;
+    catchesError: boolean;
+    defaultValue: LiteralValueState | null;
+    writesValues: ValueReadingEntityState[];
+    readsValue: ValueWritingEntityState | null;
+    declaration: VariableDeclarationState;
+    inputs: VariableInputMapState[];
+    outputs: VariableOutputMapState[];
+    error: ActionOutputMapState | null;
+    calledBySuccess: PassThroughCallableEntityState[];
+    calledByError: PassThroughCallableEntityState[];
+    calledByEntry: EntryPointEntityState[];
+    successCalls: CallableEntityState[];
+    errorCalls: CallableEntityState[];
+    internalCalls: InternalCallState[];
+    project: ProjectState;
+    errors: EntityError[];
+    parent: EntityWithLogicScopeState | ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
+    knownVersions: Map<string, UserManagedEntityState> | null;
+    activeVersion: boolean;
+    initialized: boolean;
+    startedInitialization: boolean;
+    suggestion: boolean;
+    readonly _codeNativeValueValidation: ValueValidationCallback | null;
+    constructor(initialData: IVariableInstance | IVariableInstanceTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.VariableInstance;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
+    static MUTABLE_BASE_PROPERTIES: string[];
+    static INMUTABLE_BASE_PROPERTIES: string[];
+    static BASE_PROPERTIES: string[];
+    static MUTABLE_META_PROPERTIES: string[];
+    static INMUTABLE_META_PROPERTIES: string[];
+    static META_PROPERTIES: string[];
+    static MUTABLE_UPSTREAM_PROPERTIES: string[];
+    static INMUTABLE_UPSTREAM_PROPERTIES: string[];
+    static UPSTREAM_PROPERTIES: string[];
+    static MUTABLE_DOWNSTREAM_PROPERTIES: string[];
+    static INMUTABLE_DOWNSTREAM_PROPERTIES: string[];
+    static DOWNSTREAM_PROPERTIES: string[];
+    static PROPERTIES: string[];
+    static new(changeSet?: ChangeSet | null): IVariableInstanceTransfer;
+    static fromGenerationTarget(data: IVariableInstanceGenerationTarget, parentProjectState: ProjectState, _changeSet?: ChangeSet | null): VariableInstanceState;
+    static validateGenerationTarget(data: IVariableInstanceGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: IVariableInstanceGenerationTarget;
+    };
+    get codeName(): string | null;
+    get codeNativeValueValidation(): ValueValidationCallback | null;
+    validateGeneratedUpdate(data: Partial<IVariableInstanceGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<IVariableInstanceGenerationTarget>;
+    };
+    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>;
+    unsubscribeFromDependencies(): UserManagedEntityState;
+    subscribeToDependencies(): UserManagedEntityState;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
+    captureVersion(): VariableInstanceState;
+    snapshot(): VariableInstanceState;
+    /**
+     * Given an instance of the same entity class type,
+     * it applies the current entity state to it by copying all of its data and entity references
+     *
+     * @param {VariableInstanceState} snapshotInstance
+     * @returns {VariableInstanceState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: VariableInstanceState): VariableInstanceState;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<VariableInstanceState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<VariableInstanceState>>;
+    updateWithShallowTransfer(transfer: IVariableInstanceShallowTransfer, changeSet?: ChangeSet | null): VariableInstanceState;
+    updateWithGenerationTarget(transfer: Partial<IVariableInstanceGenerationTarget>, changeSet?: ChangeSet | null): VariableInstanceState;
+    hydrateAncestors(): IChangeSet<VariableInstanceState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<VariableInstanceState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<VariableInstanceState>;
+    get calledBy(): CallerEntityState[];
+    get usedInputs(): VariableInputMapState[];
+    get unusedInputs(): VariableInputMapState[];
+    get usedOutputs(): VariableOutputMapState[];
+    get unusedOutputs(): VariableOutputMapState[];
+    get usedInternalCalls(): InternalCallState[];
+    get unusedInternalCalls(): InternalCallState[];
+    removeInternalCall(internalCall: InternalCallState, changeSet?: ChangeSet | null): VariableInstanceState;
+    removeInput(input: VariableInputMapState, changeSet?: ChangeSet | null): VariableInstanceState;
+    addInput(input: VariableInputMapState, changeSet?: ChangeSet | null): VariableInstanceState;
+    addOutput(output: VariableOutputMapState, changeSet?: ChangeSet | null): VariableInstanceState;
+    removeOutput(output: VariableOutputMapState, changeSet?: ChangeSet | null): VariableInstanceState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): VariableInstanceState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): VariableInstanceState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): VariableInstanceState;
+    addErrorCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): VariableInstanceState;
+    addSuccessCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): VariableInstanceState;
+    removeCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): VariableInstanceState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): VariableInstanceState;
+    addValueReader(entity: ValueReadingEntityState, changeSet?: ChangeSet | null): VariableInstanceState;
+    setError(error: ActionOutputMapState | null, changeSet?: ChangeSet | null): VariableInstanceState;
+    setParent(parent: EntityWithLogicScopeState | ProjectState, changeSet?: ChangeSet | null): VariableInstanceState;
+    initChildren(changeSet?: ChangeSet | null): VariableInstanceState;
+    setValueWriter(valueWriter: ValueWritingEntityState | null, changeSet?: ChangeSet | null): VariableInstanceState;
+    removeValueWriter(changeSet?: ChangeSet | null): VariableInstanceState;
+    removeValueReader(valueReader: ValueReadingEntityState, changeSet?: ChangeSet | null): VariableInstanceState;
+    subscribe(): VariableInstanceState;
+    unsubscribe(): VariableInstanceState;
+    metaSync(changedData: Partial<IVariableInstance_meta | IVariableInstance | IVariableInstanceTransfer | IVariableInstanceShallowTransfer>, changeSet?: ChangeSet | null): VariableInstanceState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<VariableInstanceState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<VariableInstanceState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<VariableInstanceState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<VariableInstanceState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<VariableInstanceState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IVariableInstanceShallowTransfer | null>;
+    removeFromParent(changeSet?: ChangeSet | null): IChangeSet;
+    remove({ ignoreUpstream }?: {
+        ignoreUpstream: boolean;
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<VariableInstanceState>;
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IVariableInstance_meta;
+    toJSON(seenEntities?: Set<EntityId>): IVariableInstanceTransfer | IVariableInstanceReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IVariableInstanceTransfer | IVariableInstanceReference;
+    toReference(options?: IEntityRecursionOptions): IVariableInstanceReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IVariableInstanceShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(options?: IEntityRecursionOptions): IVariableInstanceGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): VariableInstanceState;
+    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;
+    clone(changeSet?: ChangeSet | null, parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): VariableInstanceState;
+    addInternalCall(internalCall: InternalCallState): VariableInstanceState;
+    setDeclaration(declaration: VariableDeclarationState): VariableInstanceState;
+    removeUnrecognizedInputs(changeSet?: ChangeSet | null): IChangeSet<VariableInstanceState>;
+    removeUnrecognizedOutputs(changeSet?: ChangeSet | null): IChangeSet<VariableInstanceState>;
+    removeUnrecognizedInternalCalls(changeSet?: ChangeSet | null): IChangeSet<VariableInstanceState>;
+    syncInputs(changeSet?: ChangeSet | null): IChangeSet<VariableInstanceState>;
+    syncOutputs(changeSet?: ChangeSet | null): IChangeSet<VariableInstanceState>;
+    generateUnusedInternalCalls(changeSet?: ChangeSet | null): IChangeSet<VariableInstanceState>;
+    getDataType(changeSet?: ChangeSet | null): DataTypeState | null;
+    getUnusedInputs(): VariableInputMapState[];
+    getUnusedOutputs(): VariableOutputMapState[];
+    getUsedInputs(): VariableInputMapState[];
+    getUsedOutputs(): VariableOutputMapState[];
+}
+export type VariableInstancePayloadUnion = VariableInstanceTypesUnion | VariableInstanceState;

package/dist/tree/state/version.d.ts

@@ -0,0 +1,26 @@
+import { EntityVersion, IUserManagedGenericBase, IVersionMetadata } from '../../definitions';
+import { UserManagedEntityState, ValueReadingEntityState, ValueWritingEntityState } from './types';
+import { ChangeSet, StateMutationAction } from './change-set';
+import { BuiltInBaseEntityState } from './built-in-base-entity';
+import { PrimitiveEntityState } from './primitive-entity';
+
+export declare class VersionedState implements IVersionMetadata {
+    version: EntityVersion;
+    previousVersion: EntityVersion | null;
+    createdAt: string;
+    deleted: boolean;
+    author: string;
+    constructor(data: IVersionMetadata);
+    baseMetaSync(data: Partial<IVersionMetadata>, _self: UserManagedEntityState, _changeSet: ChangeSet | null): void;
+}
+export declare class UserManagedVersionedState extends VersionedState implements Omit<IUserManagedGenericBase, 'type' | 'id'> {
+    deletable: boolean;
+    editable: boolean;
+    constructor(data: IUserManagedGenericBase);
+    checkCanEditWithCounterpartAndSideEffects(self: UserManagedEntityState, counterpart: UserManagedEntityState | PrimitiveEntityState | BuiltInBaseEntityState, stateMutationAction: StateMutationAction, changeSet: ChangeSet | null): boolean;
+    checkCanEditFromScopeOwner(self: ValueWritingEntityState | ValueReadingEntityState, changeSet: ChangeSet | null): boolean;
+    checkCanEditFromScopeOwnerWithSideEffects(self: ValueWritingEntityState | ValueReadingEntityState, stateMutationAction: StateMutationAction, changeSet: ChangeSet | null): boolean;
+    checkCanEdit(self: UserManagedEntityState | PrimitiveEntityState | BuiltInBaseEntityState, changeSet: ChangeSet | null): boolean;
+    checkCanDelete(self: UserManagedEntityState, changeSet: ChangeSet | null): boolean;
+    baseMetaSync(data: Partial<IUserManagedGenericBase>, self: UserManagedEntityState, changeSet: ChangeSet | null): void;
+}

package/dist/tree/utils/data-type.d.ts

@@ -0,0 +1,166 @@
+import { PrimitiveTypes } from '../../definitions';
+import { ArgumentDeclarationState, DefinitionEntityState, DataTypeState, EntityWithValueState, InputMapState, OutputMapState, PropertyState, VariableDeclarationState, VariableInstanceState, ChangeSet, ReturnStatementState, BreakStatementState, ContinueStatementState, TerminationEntityState, SearchState, FunctionCallState, InternalCallState, LoopState, OperationState, FunctionDeclarationState, GlobalEventState } from '../state';
+import { ValueDescriptorState } from '../state/value-descriptor';
+
+export declare function checkArePropertiesCompatibleAsDataType(sourceProperty: PropertyState, targetProperty: PropertyState, options?: {
+    exactDataType?: boolean;
+}): boolean;
+/**
+ * Merges two property entities by aligning their attributes.
+ * Always returns the first entity (self) with its attributes modified to match the second entity (sourceProperty).
+ *
+ * @param {PropertyState} self - The property entity to be modified.
+ * @param {PropertyState} sourceProperty - The property entity to merge from.
+ * @param {ChangeSet | null} changeSet - The change set to apply the changes.
+ *
+ * @return {PropertyState} The modified property entity (self).
+ */
+export declare function mergeProperties(self: PropertyState, sourceProperty: PropertyState, changeSet?: ChangeSet | null, options?: {
+    exactDataType?: boolean;
+}): PropertyState;
+/**
+ * Merges two definition entities by aligning their properties.
+ * Always returns the first entity (self) with its properties modified to match the second entity (sourceDefinitionEntity).
+ *
+ * @param {DefinitionEntityState} self - The definition entity to be modified.
+ * @param {DefinitionEntityState} sourceDefinitionEntity - The definition entity to merge from.
+ * @param {ChangeSet | null} changeSet - The change set to apply the changes.
+ * @returns {DefinitionEntityState} The modified definition entity (self).
+ */
+export declare function mergeDefinitionEntities(self: DefinitionEntityState, sourceDefinitionEntity: DefinitionEntityState, changeSet?: ChangeSet | null, options?: {
+    exactDataType?: boolean;
+}): DefinitionEntityState;
+export declare function checkAreDefinitionEntitiesCompatibleAsDataType(sourceDefinitionEntity: DefinitionEntityState, targetDefinitionEntity: DefinitionEntityState): boolean;
+export declare enum DataTypeCompatibilityTypes {
+    BothUnconstrained = "both-unconstrained",
+    AConstraintBUnconstrained = "a-constraint-b-unconstrained",
+    BConstraintAUnconstrained = "b-constraint-a-unconstrained",
+    Same = "same",
+    AIsListBIsNot = "a-is-list-b-is-not",
+    BIsListAIsNot = "b-is-list-a-is-not",
+    AIsNullableBIsNot = "a-is-nullable-b-is-not",
+    BIsNullableAIsNot = "b-is-nullable-a-is-not",
+    AIsTemplateBIsNot = "a-is-template-b-is-not",
+    BIsTemplateAIsNot = "b-is-template-a-is-not",
+    BothUntyped = "both-untyped",
+    AIsUntypedBIsNot = "a-is-untyped-b-is-not",
+    BIsUntypedAIsNot = "b-is-untyped-a-is-not",
+    TypeEntityMismatch = "type-entity-mismatch",
+    SameDefinitionEntities = "same-definition-entities",
+    CompatibleDefinitionEntities = "compatible-definition-entities",
+    IncompatibleDefinitionEntities = "incompatible-definition-entities",
+    SamePrimitiveEntities = "same-primitive-entities",
+    APrimitiveExtendsBPrimitive = "a-primitive-extends-b-primitive",
+    BPrimitiveExtendsAPrimitive = "b-primitive-extends-a-primitive",
+    IncompatiblePrimitiveEntities = "incompatible-primitive-entities",
+    SameBuiltInBaseEntities = "same-built-in-base-entities",
+    IncompatibleBuiltInBaseEntities = "incompatible-built-in-base-entities",
+    CheckUnknown = "check-unknown",
+    AIsObjectBIsNot = "a-is-object-b-is-not",
+    BIsObjectAIsNot = "b-is-object-a-is-not",
+    BIsExactObjectAIsNot = "b-is-exact-object-a-is-not",
+    BothAreFreeFormObjects = "both-are-free-form-objects",
+    AIsFreeFormObjectBIsDefEnt = "a-is-free-form-object-b-is-def-ent",
+    BIsFreeFormObjectAIsDefEnt = "b-is-free-form-object-a-is-def-ent",
+    ANoMatchWithBOrOptions = "a-no-match-with-b-or-options",
+    BNoMatchWithAOrOptions = "b-no-match-with-a-or-options",
+    BNoMatchWithAANDOptions = "b-no-match-with-a-and-options",
+    AIsRefBIsNot = "a-is-ref-b-is-not",
+    AIsRefBAllowsIt = "a-is-ref-b-allows-it",
+    BIsRefAIsNot = "b-is-ref-a-is-not",
+    BIsRefAAllowsIt = "b-is-ref-a-allows-it",
+    BIsRefAIsNotButHasCompatibleType = "b-is-ref-a-is-not-but-has-compatible-type",
+    AIsRefBIsNotButHasCompatibleType = "a-is-ref-b-is-not-but-has-compatible-type",
+    BothAreForeignRefButIncompatible = "both-are-foreign-ref-but-incompatible",
+    BothAreSameForeignRef = "both-are-same-foreign-ref",
+    BothAreForeignRefDifferentButCompatibleDataTypes = "both-are-foreign-ref-different-but-compatible-data-types"
+}
+export interface IDataTypeCompatibility {
+    compatible: boolean;
+    exact: boolean;
+    type: DataTypeCompatibilityTypes;
+}
+export interface IDataTypeCompatible extends IDataTypeCompatibility {
+    compatible: true;
+    exact: boolean;
+    type: DataTypeCompatibilityTypes.BothUnconstrained | DataTypeCompatibilityTypes.AConstraintBUnconstrained | DataTypeCompatibilityTypes.BConstraintAUnconstrained | DataTypeCompatibilityTypes.Same | DataTypeCompatibilityTypes.BothUntyped | DataTypeCompatibilityTypes.AIsUntypedBIsNot | DataTypeCompatibilityTypes.BIsUntypedAIsNot | DataTypeCompatibilityTypes.SameDefinitionEntities | DataTypeCompatibilityTypes.CompatibleDefinitionEntities | DataTypeCompatibilityTypes.SamePrimitiveEntities | DataTypeCompatibilityTypes.APrimitiveExtendsBPrimitive | DataTypeCompatibilityTypes.BPrimitiveExtendsAPrimitive | DataTypeCompatibilityTypes.SameBuiltInBaseEntities | DataTypeCompatibilityTypes.BothAreFreeFormObjects | DataTypeCompatibilityTypes.AIsFreeFormObjectBIsDefEnt | DataTypeCompatibilityTypes.BIsFreeFormObjectAIsDefEnt | DataTypeCompatibilityTypes.AIsRefBAllowsIt | DataTypeCompatibilityTypes.BIsRefAAllowsIt | DataTypeCompatibilityTypes.BIsRefAIsNotButHasCompatibleType | DataTypeCompatibilityTypes.AIsRefBIsNotButHasCompatibleType | DataTypeCompatibilityTypes.BothAreSameForeignRef | DataTypeCompatibilityTypes.BothAreForeignRefDifferentButCompatibleDataTypes;
+}
+export interface IDataTypeIncompatibile extends IDataTypeCompatibility {
+    compatible: false;
+    exact: false;
+    type: DataTypeCompatibilityTypes.AIsListBIsNot | DataTypeCompatibilityTypes.BIsListAIsNot | DataTypeCompatibilityTypes.AIsNullableBIsNot | DataTypeCompatibilityTypes.BIsNullableAIsNot | DataTypeCompatibilityTypes.AIsTemplateBIsNot | DataTypeCompatibilityTypes.BIsTemplateAIsNot | DataTypeCompatibilityTypes.TypeEntityMismatch | DataTypeCompatibilityTypes.IncompatibleDefinitionEntities | DataTypeCompatibilityTypes.IncompatiblePrimitiveEntities | DataTypeCompatibilityTypes.IncompatibleBuiltInBaseEntities | DataTypeCompatibilityTypes.CheckUnknown | DataTypeCompatibilityTypes.AIsObjectBIsNot | DataTypeCompatibilityTypes.BIsObjectAIsNot | DataTypeCompatibilityTypes.BIsExactObjectAIsNot | DataTypeCompatibilityTypes.ANoMatchWithBOrOptions | DataTypeCompatibilityTypes.BNoMatchWithAOrOptions | DataTypeCompatibilityTypes.BNoMatchWithAANDOptions | DataTypeCompatibilityTypes.AIsRefBIsNot | DataTypeCompatibilityTypes.BIsRefAIsNot | DataTypeCompatibilityTypes.BothAreForeignRefButIncompatible;
+}
+/**
+ * Checks whether two data-type entities are compatible.
+ *
+ * Order matters. `dataTypeA` is treated as the value writer (source) and
+ * `dataTypeB` as the value reader (target). `compatible: true` means every
+ * possible value of A is acceptable to B (i.e. A ⊆ B). `exact: true`
+ * additionally means A and B describe the same value set (A ≡ B).
+ *
+ * Notable behaviour:
+ *   - `null` represents an unconstrained data-type. An unconstrained side is
+ *     considered compatible with anything (lenient codebase convention).
+ *   - Degenerate single-child or/and-group wrappers (e.g. `[string]`,
+ *     `and[string]`) are transparently collapsed to their child as long as
+ *     the wrapper hasn't overridden `isList`/`asType`. So `string` and
+ *     `[string]` compare exactly equivalent.
+ *   - For or-groups, A is compatible with B iff every option of A fits in B
+ *     (any option of B if B itself is an or-group). The function does NOT
+ *     return `compatible: true` just because some single pair overlaps.
+ *
+ * @param dataTypeA
+ * @param dataTypeB
+ * @returns
+ */
+export declare function checkAreDataTypesCompatible(dataTypeA: DataTypeState | null, dataTypeB: DataTypeState | null, options?: {
+    ignoreTopListDif?: boolean;
+    ignoreNestedListDif?: boolean;
+}): IDataTypeCompatible | IDataTypeIncompatibile;
+export declare function inferArgumentDeclarationDataType(entity: ArgumentDeclarationState, _changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferInputMapDataType(entity: InputMapState, changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferVariableInstanceDataType(entity: VariableInstanceState, changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferVariableDeclarationDataType(entity: VariableDeclarationState, changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferOutputMapDataType(entity: OutputMapState, _changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferPropertyDataType(entity: PropertyState, _changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferValueDescriptorDataType(entity: ValueDescriptorState, _changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferReturnStatementDataType(entity: ReturnStatementState, _changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferBreakStatementDataType(entity: BreakStatementState, _changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferContinueStatementDataType(entity: ContinueStatementState, _changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferSearchDataType(entity: SearchState, _changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferFunctionCallDataType(entity: FunctionCallState, _changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferInternalCallDataType(entity: InternalCallState, _changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferOperationDataType(entity: OperationState, _changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferLoopDataType(entity: LoopState, _changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function inferDataType(entity: EntityWithValueState | PropertyState | ValueDescriptorState | TerminationEntityState | FunctionDeclarationState | GlobalEventState, changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function resolveDataType(entity: EntityWithValueState | PropertyState | ValueDescriptorState | TerminationEntityState | FunctionDeclarationState | GlobalEventState, changeSet?: ChangeSet | null): DataTypeState | null;
+export declare function getLiteralValueNameFromDataType(dataType: DataTypeState | null): PrimitiveTypes;
+/**
+ * Checks whether the given data-type is either explicitly set to null, or is an or-group where all options are explicitly set to null. In other words, whether the data-type allows only for a null value and nothing else.
+ *
+ * @param {DataTypeState | null} dataType the data-type to check
+ * @returns {boolean} whether the given data-type is either explicitly set to null
+ */
+export declare function checkIsOnlyNull(dataType: DataTypeState | null): boolean;
+/**
+ * Checks whether the given data-type ALLOWS for a null value.
+ * This is either because the 'entity' field is the primitive null-prototype
+ * Or because it has a literal-value, with its value set to `null`
+ * Or because the data-type is an or-group where at least one of its children meets the above requirements
+ *
+ * @param dataType
+ */
+export declare function checkIsNullable(dataType: DataTypeState | null): boolean;
+export declare function flattenDataTypeAndGroup(dataType: DataTypeState | null, shouldThrow?: boolean, errorMessage?: string): DataTypeState | null;
+export declare function flattenDataTypesInOrGroup(dataType: DataTypeState | null, options?: {
+    removeDuplicates?: boolean;
+    removeNulls?: boolean;
+}): DataTypeState[];
+/**
+ * Given a data-type, recursively selects an option, which isn't a group
+ * And optionally that doesn't match (meaning, is incompatible with) a provided data-types to avoid
+ */
+export declare function recursivelySelectDataTypeOption(selectionSource: DataTypeState, avoidDataTypes?: DataTypeState[]): {
+    selectedDataType: DataTypeState | null;
+};
+export declare function selectFinalSingleNotNullDataTypeFromOrGroup(dataType: DataTypeState | null, shouldThrow?: boolean, errorMessage?: string): DataTypeState | null;

package/dist/tree/utils/definition-entity-to-zod-schema.d.ts

@@ -0,0 +1,4 @@
+import { DefinitionEntityState, PropertyState } from '..';
+import * as z from 'zod';
+export declare function propertyToZodSchema(property: PropertyState): z.ZodType<any>;
+export declare function definitionEntityToZodSchema(entity: DefinitionEntityState, asCodeNameKeys?: boolean): z.ZodObject<any>;

package/dist/tree/utils/flatten/async.d.ts

@@ -0,0 +1,113 @@
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+import { ElementShallowTransfer, ElementTransfer, Element, EntityId, IActionDescriptor, IActionDescriptorTransfer, IArgumentDeclaration, IArgumentDeclarationTransfer, Reference, IBreakStatement, IBreakStatementTransfer, IBuiltInBaseEntity, IBuiltInBaseEntityTransfer, ICondition, IConditionTransfer, IContinueStatement, IContinueStatementTransfer, IDefinitionEntity, IDefinitionEntityTransfer, IDataType, IDataTypeTransfer, IFunctionCall, IFunctionCallTransfer, IFunctionDeclaration, IFunctionDeclarationTransfer, IGlobalEvent, IGlobalEventTransfer, IInputMap, IInputMapTransfer, IInstalledProject, IInstalledProjectTransfer, IInternalCall, IInternalCallTransfer, ILiteralValue, ILiteralValueTransfer, ILoop, ILoopTransfer, IOperation, IOperationTransfer, IOutputMap, IOutputMapTransfer, IPrimitiveEntity, IPrimitiveEntityTransfer, IProject, IProjectTransfer, IProperty, IPropertyTransfer, IReturnStatement, IReturnStatementTransfer, ISearch, ISearchTransfer, IValueDescriptor, IValueDescriptorTransfer, IVariableDeclarationTransfer, IVariableDeclaration, IVariableInstance, IVariableInstanceTransfer, IActionDescriptorShallowTransfer, IDataTypeShallowTransfer, IDefinitionEntityShallowTransfer, IFunctionDeclarationShallowTransfer, IInstalledProjectShallowTransfer, ILoopShallowTransfer, IOperationShallowTransfer, ILiteralValueShallowTransfer, IPrimitiveEntityShallowTransfer, IProjectShallowTransfer, IPropertyShallowTransfer, IReturnStatementShallowTransfer, ISearchShallowTransfer, IValueDescriptorShallowTransfer, IVariableDeclarationShallowTransfer, IVariableInstanceShallowTransfer, IFunctionCallShallowTransfer, IGlobalEventShallowTransfer, IInputMapShallowTransfer, IInternalCallShallowTransfer, IOutputMapShallowTransfer, IConditionShallowTransfer, IContinueStatementShallowTransfer, IBreakStatementShallowTransfer, IArgumentDeclarationShallowTransfer, IBuiltInBaseEntityShallowTransfer } from '../../../definitions';
+
+export declare function getAllBuiltInEntityIdsAsync(options?: YieldOptions): Promise<Set<EntityId>>;
+export declare function flattenActionDescriptorAsync(entity: IActionDescriptor | IActionDescriptorTransfer | IActionDescriptorShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenArgumentDeclarationAsync(entity: IArgumentDeclaration | IArgumentDeclarationTransfer | IArgumentDeclarationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenBreakStatementAsync(entity: IBreakStatement | IBreakStatementTransfer | IBreakStatementShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenBuiltInBaseEntityAsync(entity: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer | IBuiltInBaseEntityShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenConditionAsync(entity: ICondition | IConditionTransfer | IConditionShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenContinueStatementAsync(entity: IContinueStatement | IContinueStatementTransfer | IContinueStatementShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenDefinitionEntityAsync(entity: IDefinitionEntity | IDefinitionEntityTransfer | IDefinitionEntityShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenDataTypeAsync(entity: IDataType | IDataTypeTransfer | IDataTypeShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenFunctionCallAsync(entity: IFunctionCall | IFunctionCallTransfer | IFunctionCallShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenFunctionDeclarationAsync(entity: IFunctionDeclaration | IFunctionDeclarationTransfer | IFunctionDeclarationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenGlobalEventAsync(entity: IGlobalEvent | IGlobalEventTransfer | IGlobalEventShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenInputMapAsync(entity: IInputMap | IInputMapTransfer | IInputMapShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenInstalledProjectAsync(entity: IInstalledProject | IInstalledProjectTransfer | IInstalledProjectShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenInternalCallAsync(entity: IInternalCall | IInternalCallTransfer | IInternalCallShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenLiteralValueAsync(entity: ILiteralValue | ILiteralValueTransfer | ILiteralValueShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenLoopAsync(entity: ILoop | ILoopTransfer | ILoopShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenOperationAsync(entity: IOperation | IOperationTransfer | IOperationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenOutputMapAsync(entity: IOutputMap | IOutputMapTransfer | IOutputMapShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenPrimitiveEntityAsync(entity: IPrimitiveEntity | IPrimitiveEntityTransfer | IPrimitiveEntityShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenProjectAsync(entity: IProject | IProjectTransfer | IProjectShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenPropertyAsync(entity: IProperty | IPropertyTransfer | IPropertyShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenReturnStatementAsync(entity: IReturnStatement | IReturnStatementTransfer | IReturnStatementShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenSearchAsync(entity: ISearch | ISearchTransfer | ISearchShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenValueDescriptorAsync(entity: IValueDescriptor | IValueDescriptorTransfer | IValueDescriptorShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenVariableDeclarationAsync(entity: IVariableDeclaration | IVariableDeclarationTransfer | IVariableDeclarationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenVariableInstanceAsync(entity: IVariableInstance | IVariableInstanceTransfer | IVariableInstanceShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;
+export declare function flattenEntityAsync(entity: Element | ElementTransfer | ElementShallowTransfer | Reference, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    diggestedBuiltInBaseEntitiesIds?: Set<EntityId>;
+    allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+} & YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer)[]>;

package/dist/tree/utils/flatten/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sync';
+export * from './async';

package/dist/tree/utils/flatten/sync.d.ts

@@ -0,0 +1,85 @@
+import { ElementShallowTransfer, ElementTransfer, Element, EntityId, IActionDescriptor, IActionDescriptorTransfer, IArgumentDeclaration, IArgumentDeclarationTransfer, Reference, IBreakStatement, IBreakStatementTransfer, IBuiltInBaseEntity, IBuiltInBaseEntityTransfer, ICondition, IConditionTransfer, IContinueStatement, IContinueStatementTransfer, IDefinitionEntity, IDefinitionEntityTransfer, IDataType, IDataTypeTransfer, IFunctionCall, IFunctionCallTransfer, IFunctionDeclaration, IFunctionDeclarationTransfer, IGlobalEvent, IGlobalEventTransfer, IInputMap, IInputMapTransfer, IInstalledProject, IInstalledProjectTransfer, IInternalCall, IInternalCallTransfer, ILiteralValue, ILiteralValueTransfer, ILoop, ILoopTransfer, IOperation, IOperationTransfer, IOutputMap, IOutputMapTransfer, IPrimitiveEntity, IPrimitiveEntityTransfer, IProject, IProjectTransfer, IProperty, IPropertyTransfer, IReturnStatement, IReturnStatementTransfer, ISearch, ISearchTransfer, IValueDescriptor, IValueDescriptorTransfer, IVariableDeclarationTransfer, IVariableDeclaration, IVariableInstance, IVariableInstanceTransfer, IActionDescriptorShallowTransfer, IDataTypeShallowTransfer, IDefinitionEntityShallowTransfer, IFunctionDeclarationShallowTransfer, IInstalledProjectShallowTransfer, ILoopShallowTransfer, IOperationShallowTransfer, ILiteralValueShallowTransfer, IPrimitiveEntityShallowTransfer, IProjectShallowTransfer, IPropertyShallowTransfer, IReturnStatementShallowTransfer, ISearchShallowTransfer, IValueDescriptorShallowTransfer, IVariableDeclarationShallowTransfer, IVariableInstanceShallowTransfer, IFunctionCallShallowTransfer, IGlobalEventShallowTransfer, IInputMapShallowTransfer, IInternalCallShallowTransfer, IOutputMapShallowTransfer, IConditionShallowTransfer, IContinueStatementShallowTransfer, IBreakStatementShallowTransfer, IArgumentDeclarationShallowTransfer, IBuiltInBaseEntityShallowTransfer } from '../../../definitions';
+
+export declare function getAllBuiltInEntityIds(): Set<EntityId>;
+export declare function flattenActionDescriptor(entity: IActionDescriptor | IActionDescriptorTransfer | IActionDescriptorShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenArgumentDeclaration(entity: IArgumentDeclaration | IArgumentDeclarationTransfer | IArgumentDeclarationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenBreakStatement(entity: IBreakStatement | IBreakStatementTransfer | IBreakStatementShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenBuiltInBaseEntity(entity: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer | IBuiltInBaseEntityShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenCondition(entity: ICondition | IConditionTransfer | IConditionShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenContinueStatement(entity: IContinueStatement | IContinueStatementTransfer | IContinueStatementShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenDefinitionEntity(entity: IDefinitionEntity | IDefinitionEntityTransfer | IDefinitionEntityShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenDataType(entity: IDataType | IDataTypeTransfer | IDataTypeShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenFunctionCall(entity: IFunctionCall | IFunctionCallTransfer | IFunctionCallShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenFunctionDeclaration(entity: IFunctionDeclaration | IFunctionDeclarationTransfer | IFunctionDeclarationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenGlobalEvent(entity: IGlobalEvent | IGlobalEventTransfer | IGlobalEventShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenInputMap(entity: IInputMap | IInputMapTransfer | IInputMapShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenInstalledProject(entity: IInstalledProject | IInstalledProjectTransfer | IInstalledProjectShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenInternalCall(entity: IInternalCall | IInternalCallTransfer | IInternalCallShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenLiteralValue(entity: ILiteralValue | ILiteralValueTransfer | ILiteralValueShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenLoop(entity: ILoop | ILoopTransfer | ILoopShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenOperation(entity: IOperation | IOperationTransfer | IOperationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenOutputMap(entity: IOutputMap | IOutputMapTransfer | IOutputMapShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenPrimitiveEntity(entity: IPrimitiveEntity | IPrimitiveEntityTransfer | IPrimitiveEntityShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenProject(entity: IProject | IProjectTransfer | IProjectShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenProperty(entity: IProperty | IPropertyTransfer | IPropertyShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenReturnStatement(entity: IReturnStatement | IReturnStatementTransfer | IReturnStatementShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenSearch(entity: ISearch | ISearchTransfer | ISearchShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenValueDescriptor(entity: IValueDescriptor | IValueDescriptorTransfer | IValueDescriptorShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenVariableDeclaration(entity: IVariableDeclaration | IVariableDeclarationTransfer | IVariableDeclarationShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenVariableInstance(entity: IVariableInstance | IVariableInstanceTransfer | IVariableInstanceShallowTransfer, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];
+export declare function flattenEntity(entity: Element | ElementTransfer | ElementShallowTransfer | Reference, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    diggestedBuiltInBaseEntitiesIds?: Set<EntityId>;
+}): (Element | ElementTransfer | ElementShallowTransfer)[];