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

package/dist/definitions/types/base.d.ts

@@ -0,0 +1,193 @@
+import { Element, EntryPointEntity, EntryPointEntityReference, IBuiltInBaseEntity, IDefinitionEntityReference, IProject, IProjectReference, IReturnStatementReference, PassThroughCallableEntityReference, Reference, ValueReadingEntity, ValueReadingEntityReference, ValueReadingEntityTransfer, ValueWritingEntity, ValueWritingEntityReference, ValueWritingEntityTransfer, IBuiltInBaseEntityReference, IActionDescriptorReference, IPrimitiveEntityReference, IDataType, IDataTypeTransfer, IDefinitionEntity, IPrimitiveEntity, IReturnStatement, IActionInputMapTransfer, IActionInputMap, IActionOutputMap, IActionOutputMapTransfer, CallableEntity, CallableEntityTransfer, EntityWithLogicScope, EntityWithLogicScopeReference, IFunctionDeclarationTransfer, IFunctionDeclarationReference, IFunctionDeclaration, IVariableDeclaration, IVariableInstance, IVariableInstanceReference, IVariableDeclarationReference, PassThroughCallableEntity, IBreakStatement, IBreakStatementReference, IContinueStatement, IContinueStatementReference, ILoop, ILoopReference, IActionDescriptorTransfer, IVariableDeclarationTransfer, IVariableInstanceTransfer, ElementTransfer, IDataTypeReference, IInputMapReference, IOutputMapReference, CallableEntityReference, PassThroughCallableEntityTransfer, EntryPointEntityTransfer, IActionDescriptor, ILiteralValue, ILiteralValueReference, ILiteralValueTransfer } from '.';
+
+export type EntityId = string;
+export type EntityVersion = string;
+export declare enum EntityType {
+    DefinitionEntity = "definition-entity",
+    BuiltInBaseEntity = "built-in-base-entity",
+    Project = "project",
+    InstalledProject = "installed-project",
+    GlobalEvent = "global-event",
+    DataType = "data-type",
+    FunctionCall = "function-call",
+    FunctionDeclaration = "function-declaration",
+    ActionDescriptor = "action-descriptor",
+    ValueDescriptor = "value-descriptor",
+    ArgumentDeclaration = "argument-declaration",
+    InputMap = "input-map",
+    ReturnStatement = "return-statement",
+    BreakStatement = "break-statement",
+    ContinueStatement = "continue-statement",
+    OutputMap = "output-map",
+    PrimitiveEntity = "primitive-entity",
+    LiteralValue = "literal-value",
+    Property = "property",
+    Operation = "operation",
+    Condition = "condition",
+    VariableDeclaration = "variable-declaration",
+    VariableInstance = "variable-instance",
+    Search = "search",
+    Loop = "loop",
+    InternalCall = "internal-call",
+    GenericReference = "generic-reference"
+}
+export interface IVersionMetadata {
+    version: EntityVersion;
+    author: string;
+    createdAt: string;
+    previousVersion: EntityVersion | null;
+    deleted: boolean;
+}
+export interface IGenericBase extends IVersionMetadata {
+    id: EntityId;
+    type: EntityType;
+}
+export interface IUserManagedGenericBase extends IGenericBase {
+    editable: boolean;
+    deletable: boolean;
+}
+export interface IChildEntityTransfer {
+    parent: Element | ElementTransfer | Reference;
+}
+export interface IChildEntityShallowTransfer extends IChildEntityTransfer {
+    parent: Reference;
+}
+export interface IChildEntityGenerationTarget {
+    parent?: EntityId;
+}
+export interface IChildEntity extends IChildEntityTransfer {
+    parent: Element;
+}
+export interface ICalledEntityTransfer {
+    calledBySuccess: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByError: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByEntry: (EntryPointEntity | EntryPointEntityTransfer | EntryPointEntityReference)[];
+}
+export interface ICalledEntityGenerationTarget {
+    calledBySuccess: EntityId[];
+    calledByError: EntityId[];
+    calledByEntry: EntityId[];
+}
+export interface ICalledEntityShallowTransfer extends ICalledEntityTransfer {
+    calledBySuccess: PassThroughCallableEntityReference[];
+    calledByError: PassThroughCallableEntityReference[];
+    calledByEntry: EntryPointEntityReference[];
+}
+export interface ICalledEntity extends ICalledEntityTransfer {
+    calledBySuccess: PassThroughCallableEntity[];
+    calledByError: PassThroughCallableEntity[];
+    calledByEntry: EntryPointEntity[];
+}
+export interface IBaseCanvasDraggable extends IUserManagedGenericBase {
+    x: number;
+    y: number;
+}
+export interface IBaseVariable_meta extends IUserManagedGenericBase {
+    name: string;
+    codeName: string | null;
+    description: string | null;
+    required: boolean;
+    constant: boolean;
+}
+export interface IBaseVariableTransfer extends IUserManagedGenericBase, IChildEntityTransfer, IBaseVariable_meta {
+    defaultValue: ILiteralValue | ILiteralValueTransfer | null;
+    dataType: IDataType | IDataTypeTransfer | null;
+    parent: PassThroughCallableEntity | PassThroughCallableEntityReference | ILoop | ILoopReference | IReturnStatement | IReturnStatementReference | IBreakStatement | IBreakStatementReference | IContinueStatement | IContinueStatementReference | IActionDescriptor | IActionDescriptorReference | IDefinitionEntity | EntryPointEntity | EntryPointEntityReference | IProject | IProjectReference | IDefinitionEntityReference | IBuiltInBaseEntity | IBuiltInBaseEntityReference | IPrimitiveEntity | IPrimitiveEntityReference;
+}
+export interface IBaseVariableGenerationTarget {
+    id: EntityId;
+    type: EntityType;
+    name: string;
+    codeName?: string | null;
+    description?: string | null;
+    required?: boolean;
+    constant?: boolean;
+    parent?: EntityId;
+}
+export interface IBaseVariableShallowTransfer extends IUserManagedGenericBase, IChildEntityShallowTransfer {
+    name: string;
+    codeName: string | null;
+    description: string | null;
+    defaultValue: ILiteralValueReference | null;
+    required: boolean;
+    constant: boolean;
+    dataType: IDataTypeReference | null;
+    parent: PassThroughCallableEntityReference | ILoopReference | IReturnStatementReference | IBreakStatementReference | IContinueStatementReference | IActionDescriptorReference | EntryPointEntityReference | IProjectReference | IDefinitionEntityReference | IBuiltInBaseEntityReference | IPrimitiveEntityReference;
+}
+export interface IBaseVariable extends IBaseVariableTransfer, IChildEntity {
+    defaultValue: ILiteralValue | null;
+    dataType: IDataType | null;
+    parent: PassThroughCallableEntity | ILoop | IReturnStatement | IBreakStatement | IContinueStatement | IActionDescriptor | IDefinitionEntity | EntryPointEntity | IProject | IBuiltInBaseEntity | IPrimitiveEntity;
+}
+export interface IValueReadingEntityTransfer {
+    readsValue: ValueWritingEntity | ValueWritingEntityTransfer | ValueWritingEntityReference | null;
+}
+export interface IValueReadingEntityGenerationTarget {
+    readsValue?: EntityId;
+}
+export interface IValueReadingEntityShallowTransfer extends IValueReadingEntityTransfer {
+    readsValue: ValueWritingEntityReference | null;
+}
+export interface IValueReadingEntity extends IValueReadingEntityTransfer {
+    readsValue: ValueWritingEntity | null;
+}
+export interface IValueWritingEntityTransfer {
+    writesValues: (ValueReadingEntity | ValueReadingEntityTransfer | ValueReadingEntityReference)[];
+}
+export interface IValueWritingEntityGenerationTarget {
+}
+export interface IValueWritingEntityShallowTransfer extends IValueWritingEntityTransfer {
+    writesValues: ValueReadingEntityReference[];
+}
+export interface IValueWritingEntity extends IValueWritingEntityTransfer {
+    writesValues: ValueReadingEntity[];
+}
+export interface IBaseActionCall_meta extends IUserManagedGenericBase {
+    type: EntityType.Operation | EntityType.FunctionCall | EntityType.InternalCall | EntityType.Loop | EntityType.Search;
+}
+export interface IBaseActionCallTransfer extends IBaseActionCall_meta, IChildEntityTransfer, ICalledEntityTransfer, IValueWritingEntityTransfer {
+    declaration: IActionDescriptor | IActionDescriptorTransfer | IFunctionDeclarationTransfer | IFunctionDeclarationReference;
+    inputs: (IActionInputMap | IActionInputMapTransfer)[];
+    outputs: (IActionOutputMap | IActionOutputMapTransfer)[];
+    successCalls: (CallableEntity | CallableEntityTransfer)[];
+    errorCalls: (CallableEntity | CallableEntityTransfer)[];
+    calledBySuccess: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByError: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByEntry: (EntryPointEntity | EntryPointEntityTransfer | EntryPointEntityReference)[];
+    parent: EntityWithLogicScope | EntityWithLogicScopeReference | IProject | IProjectReference | IVariableDeclaration | IVariableDeclarationTransfer | IVariableDeclarationReference | IVariableInstance | IVariableInstanceTransfer | IVariableInstanceReference;
+    error: IActionOutputMap | IActionOutputMapTransfer | null;
+}
+export interface IBaseActionCallGenerationTarget extends IChildEntityGenerationTarget, ICalledEntityGenerationTarget, IValueWritingEntityGenerationTarget {
+    id: EntityId;
+    type: EntityType.Operation | EntityType.FunctionCall | EntityType.InternalCall | EntityType.Loop | EntityType.Search;
+    declaration: EntityId;
+    calledBySuccess: EntityId[];
+    calledByError: EntityId[];
+    calledByEntry: EntityId[];
+    parent?: EntityId;
+}
+export interface IBaseActionCallShallowTransfer extends IBaseActionCall_meta, IChildEntityShallowTransfer, ICalledEntityShallowTransfer, IValueWritingEntityShallowTransfer {
+    declaration: IActionDescriptorReference | IFunctionDeclarationReference;
+    inputs: IInputMapReference[];
+    outputs: IOutputMapReference[];
+    successCalls: CallableEntityReference[];
+    errorCalls: CallableEntityReference[];
+    calledBySuccess: PassThroughCallableEntityReference[];
+    calledByError: PassThroughCallableEntityReference[];
+    calledByEntry: EntryPointEntityReference[];
+    error: IOutputMapReference | null;
+    parent: EntityWithLogicScopeReference | IProjectReference | IVariableDeclarationReference | IVariableInstanceReference;
+}
+export interface IBaseActionCall extends IBaseActionCallTransfer, IChildEntity, ICalledEntity, IValueWritingEntity {
+    writesValues: ValueReadingEntity[];
+    declaration: IActionDescriptor | IFunctionDeclaration;
+    inputs: IActionInputMap[];
+    outputs: IActionOutputMap[];
+    successCalls: CallableEntity[];
+    errorCalls: CallableEntity[];
+    calledBySuccess: PassThroughCallableEntity[];
+    calledByError: PassThroughCallableEntity[];
+    calledByEntry: EntryPointEntity[];
+    parent: EntityWithLogicScope | IProject | IVariableDeclaration | IVariableInstance;
+    error: IActionOutputMap | null;
+}

package/dist/definitions/types/condition.d.ts

@@ -0,0 +1,62 @@
+import { CallableEntity, CallableEntityTransfer, EntityWithLogicScope, EntityWithLogicScopeReference, IProject, IProjectReference, IActionInputMap, IActionInputMapTransfer, EntityType, ICalledEntity, ICalledEntityTransfer, IChildEntity, IChildEntityTransfer, IUserManagedGenericBase, IBaseCanvasDraggable, IInputMapReference, CallableEntityReference, IChildEntityShallowTransfer, ICalledEntityShallowTransfer, IChildEntityGenerationTarget, EntityId, ICalledEntityGenerationTarget, PassThroughCallableEntity, EntryPointEntity, EntryPointEntityTransfer, EntryPointEntityReference, PassThroughCallableEntityTransfer, PassThroughCallableEntityReference, IActionDescriptor, IActionDescriptorTransfer, IActionDescriptorReference, IConditionReference } from '.';
+
+export declare enum StandaloneOperatorTypes {
+    BooleanIsTrue = "condition-boolean-is-true",
+    BooleanIsFalse = "condition-boolean-is-false"
+}
+export declare enum GroupOperatorTypes {
+    And = "condition-group-and",
+    Or = "condition-group-or"
+}
+export type OperatorTypes = GroupOperatorTypes | StandaloneOperatorTypes;
+export interface IConditionGenerationTarget extends IChildEntityGenerationTarget, ICalledEntityGenerationTarget {
+    id: EntityId;
+    type: EntityType.Condition;
+    declaration: EntityId;
+    calledBySuccess: EntityId[];
+    calledByError: EntityId[];
+    calledByEntry: EntityId[];
+    parent?: EntityId;
+}
+export interface ICondition_meta extends IUserManagedGenericBase, IBaseCanvasDraggable {
+    type: EntityType.Condition;
+    index: number | null;
+}
+export interface IConditionShallowTransfer extends ICondition_meta, IChildEntityShallowTransfer, ICalledEntityShallowTransfer {
+    inputs: IInputMapReference[];
+    declaration: IActionDescriptorReference;
+    successCalls: CallableEntityReference[];
+    errorCalls: CallableEntityReference[];
+    andChildrenGroup: IConditionReference[] | null;
+    orChildrenGroup: IConditionReference[] | null;
+    calledBySuccess: PassThroughCallableEntityReference[];
+    calledByError: PassThroughCallableEntityReference[];
+    calledByEntry: EntryPointEntityReference[];
+    parent: EntityWithLogicScopeReference | IProjectReference | IConditionReference;
+}
+export interface IConditionTransfer extends ICondition_meta, IChildEntityTransfer, ICalledEntityTransfer {
+    type: EntityType.Condition;
+    declaration: IActionDescriptor | IActionDescriptorTransfer;
+    andChildrenGroup: (ICondition | IConditionTransfer)[] | null;
+    orChildrenGroup: (ICondition | IConditionTransfer)[] | null;
+    inputs: (IActionInputMap | IActionInputMapTransfer)[];
+    successCalls: (CallableEntity | CallableEntityTransfer)[];
+    errorCalls: (CallableEntity | CallableEntityTransfer)[];
+    calledBySuccess: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByError: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByEntry: (EntryPointEntity | EntryPointEntityTransfer | EntryPointEntityReference)[];
+    parent: EntityWithLogicScope | EntityWithLogicScopeReference | IProject | IProjectReference | ICondition | IConditionReference;
+}
+export interface ICondition extends IConditionTransfer, IChildEntity, ICalledEntity {
+    inputs: IActionInputMap[];
+    declaration: IActionDescriptor;
+    andChildrenGroup: ICondition[] | null;
+    orChildrenGroup: ICondition[] | null;
+    successCalls: CallableEntity[];
+    errorCalls: CallableEntity[];
+    calledBySuccess: PassThroughCallableEntity[];
+    calledByError: PassThroughCallableEntity[];
+    calledByEntry: EntryPointEntity[];
+    parent: EntityWithLogicScope | IProject | ICondition;
+}
+export type ConditionTypesUnion = ICondition | IConditionTransfer | IConditionShallowTransfer | IConditionGenerationTarget;

package/dist/definitions/types/data-type.d.ts

@@ -0,0 +1,75 @@
+import { EntityType, IChildEntity, IUserManagedGenericBase, IProperty, IPropertyReference, IActionDescriptor, IActionDescriptorTransfer, IValueDescriptor, IChildEntityTransfer, IDefinitionEntity, IDefinitionEntityTransfer, IActionDescriptorReference, IValueDescriptorReference, IPrimitiveEntity, IPrimitiveEntityTransfer, ILiteralValue, ILiteralValueTransfer, IBuiltInBaseEntityTransfer, IBuiltInBaseEntity, IDefinitionEntityReference, IDataTypeReference, IChildEntityShallowTransfer, ILiteralValueReference, IPrimitiveEntityReference, IBuiltInBaseEntityReference, IChildEntityGenerationTarget, IVariableDeclaration, IVariableDeclarationReference, IArgumentDeclaration, IArgumentDeclarationReference, IReturnStatement, IReturnStatementReference, EntityId, IInputMap, IOutputMap, IInputMapReference, IOutputMapReference, IBreakStatement, IBreakStatementReference, IContinueStatement, IContinueStatementReference, ILoop, ISearch, ISearchReference, ILoopReference, IFunctionDeclaration, IFunctionDeclarationReference, IPropertyTransfer } from '.';
+
+export type DataTypeEntityOption = IDefinitionEntity | IPrimitiveEntity | IActionDescriptor | IBuiltInBaseEntity | ILiteralValue;
+export type DataTypeEntityTransferOption = DataTypeEntityOption | IDefinitionEntityTransfer | IPrimitiveEntityTransfer | IActionDescriptorTransfer | IBuiltInBaseEntityTransfer | ILiteralValueTransfer;
+export type DataTypeEntityReferenceOption = IDefinitionEntityReference | IPrimitiveEntityReference | IActionDescriptorReference | IBuiltInBaseEntityReference | ILiteralValueReference;
+/**
+ * Entity types that have a 'dataType' field.
+ */
+export declare const ENTITIES_WITH_DATA_TYPES: EntityType[];
+export declare const DATA_TYPE_USER_MANAGED_PARENT_TYPES: EntityType[];
+export declare const DATA_TYPE_PARENT_TYPES: EntityType[];
+/**
+ * Type of entities that can be used/referenced in the 'entity' field of a data type.
+ */
+export declare const DATA_TYPE_ENTITY_OPTION_TYPES: EntityType[];
+export declare enum DataTypeParentChildRelation {
+    OrDataTypeGroup = "or-data-type-group",
+    AndDataTypeGroup = "and-data-type-group"
+}
+export interface IDataType_base {
+    id: EntityId;
+    type: EntityType.DataType;
+    isList: boolean | null;
+    asType: boolean | null;
+    options?: string[];
+    parentRelationType?: DataTypeParentChildRelation;
+    like?: boolean;
+    foreignKeyAllowed?: boolean;
+    implementationChooseOne?: boolean;
+    staticEntities?: boolean;
+    interactiveEntities?: boolean;
+    actionEntities?: boolean;
+}
+export interface IDataType_meta extends IUserManagedGenericBase {
+    type: EntityType.DataType;
+    like: boolean;
+    inferred: boolean;
+    index: number | null;
+    implementationChooseOne: boolean;
+    options: string[] | null;
+    parentRelationType: DataTypeParentChildRelation | null;
+    foreignKeyAllowed: boolean | null;
+    asType: boolean | null;
+    isList: boolean | null;
+    staticEntities: boolean | null;
+    interactiveEntities: boolean | null;
+    actionEntities: boolean | null;
+}
+export interface IDataTypeTransfer extends IDataType_meta, IChildEntityTransfer {
+    entity: IDefinitionEntityReference | DataTypeEntityTransferOption | null;
+    foreignKeyRef: IPropertyReference | IProperty | IPropertyTransfer | null;
+    andChildrenGroup: IDataTypeTransfer[] | null;
+    orChildrenGroup: IDataTypeTransfer[] | null;
+    parent: IVariableDeclaration | IVariableDeclarationReference | IArgumentDeclaration | IArgumentDeclarationReference | IReturnStatement | IReturnStatementReference | IBreakStatement | IBreakStatementReference | IContinueStatement | IContinueStatementReference | IProperty | IPropertyReference | IValueDescriptor | IValueDescriptorReference | IInputMap | IInputMapReference | IOutputMap | IOutputMapReference | IDataType | IDataTypeReference | IFunctionDeclaration | IFunctionDeclarationReference | IActionDescriptor | IActionDescriptorReference | ILoop | ILoopReference | ISearch | ISearchReference | IDefinitionEntity | IDefinitionEntityReference | IBuiltInBaseEntity | IBuiltInBaseEntityReference;
+}
+export interface IDataTypeGenerationTarget extends IDataType_base, IChildEntityGenerationTarget {
+    entity: EntityId | null;
+    foreignKeyRef: EntityId | null;
+    parent: EntityId;
+}
+export interface IDataTypeShallowTransfer extends IDataType_meta, IChildEntityShallowTransfer {
+    entity: DataTypeEntityReferenceOption | null;
+    foreignKeyRef: IPropertyReference | null;
+    andChildrenGroup: IDataTypeReference[] | null;
+    orChildrenGroup: IDataTypeReference[] | null;
+    parent: IVariableDeclarationReference | IArgumentDeclarationReference | IReturnStatementReference | IBreakStatementReference | IContinueStatementReference | IPropertyReference | IValueDescriptorReference | IInputMapReference | IOutputMapReference | IDataTypeReference | IFunctionDeclarationReference | IActionDescriptorReference | ILoopReference | ISearchReference | IDefinitionEntityReference | IBuiltInBaseEntityReference;
+}
+export interface IDataType extends IDataTypeTransfer, IChildEntity {
+    entity: DataTypeEntityOption | null;
+    foreignKeyRef: IProperty | null;
+    andChildrenGroup: IDataType[] | null;
+    orChildrenGroup: IDataType[] | null;
+    parent: IVariableDeclaration | IArgumentDeclaration | IReturnStatement | IBreakStatement | IContinueStatement | IProperty | IValueDescriptor | IInputMap | IOutputMap | IDataType | IFunctionDeclaration | IActionDescriptor | ILoop | ISearch | IDefinitionEntity | IBuiltInBaseEntity;
+}
+export type DataTypeTypesUnion = IDataTypeTransfer | IDataTypeShallowTransfer | IDataType | IDataTypeGenerationTarget;

package/dist/definitions/types/definition-entity.d.ts

@@ -0,0 +1,46 @@
+import { IFunctionDeclaration, IFunctionDeclarationTransfer, IProject, IProjectReference, IProperty, IBaseEntityTransfer, IBuiltInBaseEntity, EntityType, IBaseCanvasDraggable, IChildEntity, IChildEntityTransfer, IBuiltInBaseEntityTransfer, IDataType, IDataTypeReference, IDefinitionEntityReference, IBuiltInBaseEntityReference, IFunctionDeclarationReference, IChildEntityShallowTransfer, IBaseEntityShallowTransfer, IChildEntityGenerationTarget, IBaseEntityGenerationTarget, EntityId, IBaseEntity_meta, IPropertyReference, IDataTypeTransfer, IPropertyTransfer } from '.';
+
+export interface IDefinitionEntity_meta extends IBaseEntity_meta, IBaseCanvasDraggable {
+    codeName: string | null;
+    type: EntityType.DefinitionEntity;
+    additionalProperties: boolean;
+}
+export interface IDefinitionEntityShallowTransfer extends IBaseCanvasDraggable, IChildEntityShallowTransfer, IBaseEntityShallowTransfer, IDefinitionEntity_meta {
+    type: EntityType.DefinitionEntity;
+    codeName: string | null;
+    additionalPropertiesDataType: IDataTypeReference | null;
+    allPropertiesImplement: IPropertyReference | null;
+    extends: IDefinitionEntityReference | IBuiltInBaseEntityReference | null;
+    implements: (IDefinitionEntityReference | IBuiltInBaseEntityReference)[];
+    parent: IProjectReference | IDataTypeReference;
+    methods: IFunctionDeclarationReference[];
+}
+export interface IDefinitionEntityGenerationTarget extends IChildEntityGenerationTarget, IBaseEntityGenerationTarget {
+    id: EntityId;
+    type: EntityType.DefinitionEntity;
+    codeName?: string | null;
+    extends?: EntityId;
+    implements: EntityId[];
+    parent?: EntityId;
+    additionalProperties?: boolean;
+}
+export interface IDefinitionEntityTransfer extends IBaseCanvasDraggable, IChildEntityTransfer, IBaseEntityTransfer, IDefinitionEntity_meta {
+    type: EntityType.DefinitionEntity;
+    codeName: string | null;
+    additionalPropertiesDataType: IDataType | IDataTypeTransfer | null;
+    allPropertiesImplement: IProperty | IPropertyTransfer | null;
+    extends: IDefinitionEntity | IDefinitionEntityTransfer | IBuiltInBaseEntity | IBuiltInBaseEntityTransfer | null;
+    implements: (IDefinitionEntity | IDefinitionEntityTransfer | IBuiltInBaseEntity | IBuiltInBaseEntityTransfer)[];
+    parent: IProject | IProjectReference | IDataType | IDataTypeReference;
+    methods: (IFunctionDeclaration | IFunctionDeclarationTransfer)[];
+}
+export interface IDefinitionEntity extends IDefinitionEntityTransfer, IChildEntity {
+    parent: IProject | IDataType;
+    additionalPropertiesDataType: IDataType | null;
+    allPropertiesImplement: IProperty | null;
+    extends: IDefinitionEntity | IBuiltInBaseEntity | null;
+    implements: (IDefinitionEntity | IBuiltInBaseEntity)[];
+    properties: IProperty[];
+    methods: IFunctionDeclaration[];
+}
+export type DefinitionEntityTypesUnion = IDefinitionEntity | IDefinitionEntityTransfer | IDefinitionEntityShallowTransfer | IDefinitionEntityGenerationTarget;

package/dist/definitions/types/event.d.ts

@@ -0,0 +1,50 @@
+import { CallableEntity, CallableEntityTransfer, IInstalledProject, IProject, IProjectReference, EntityType, IBaseCanvasDraggable, IChildEntity, IChildEntityTransfer, IArgumentDeclaration, IArgumentDeclarationTransfer, IInstalledProjectReference, IChildEntityShallowTransfer, IArgumentDeclarationReference, CallableEntityReference, IChildEntityGenerationTarget, IUserManagedGenericBase, IActionDescriptorReference, IActionDescriptor, IActionDescriptorTransfer, EntityId } from '.';
+
+export interface IBaseEvent_meta extends IBaseCanvasDraggable {
+    type: EntityType.GlobalEvent;
+    description: string | null;
+    collapsed: boolean;
+}
+export interface IBaseEventTransfer extends IBaseEvent_meta {
+    inputs: (IArgumentDeclaration | IArgumentDeclarationTransfer)[];
+    calls: (CallableEntity | CallableEntityTransfer)[];
+}
+export interface IBaseEventGenerationTarget extends IUserManagedGenericBase {
+    type: EntityType.GlobalEvent;
+}
+export interface IBaseEventShallowTransfer extends IBaseEvent_meta {
+    type: EntityType.GlobalEvent;
+    description: string | null;
+    inputs: IArgumentDeclarationReference[];
+    calls: CallableEntityReference[];
+    implements: IActionDescriptorReference;
+}
+export declare enum GlobalEventNames {
+    PROJECT_PUBLICATION_COMPLETED = "GLOBAL_EVENT_PROJECT_PUBLICATION_COMPLETED"
+}
+export interface IGlobalEvent_meta extends IBaseEvent_meta {
+    type: EntityType.GlobalEvent;
+    name: GlobalEventNames;
+}
+export interface IGlobalEventTransfer extends IGlobalEvent_meta, IBaseEventTransfer, IChildEntityTransfer {
+    implements: IActionDescriptor | IActionDescriptorTransfer;
+    parent: IProject | IProjectReference | IInstalledProject | IInstalledProjectReference;
+}
+export interface IGlobalEventGenerationTarget extends IChildEntityGenerationTarget {
+    id: EntityId;
+    type: EntityType.GlobalEvent;
+    name: GlobalEventNames;
+    description?: string;
+    implements: EntityId;
+    parent?: EntityId;
+}
+export interface IGlobalEventShallowTransfer extends IGlobalEvent_meta, IBaseEventShallowTransfer, IChildEntityShallowTransfer {
+    parent: IProjectReference | IInstalledProjectReference;
+}
+export interface IGlobalEvent extends IGlobalEventTransfer, IChildEntity {
+    parent: IProject | IInstalledProject;
+    inputs: IArgumentDeclaration[];
+    implements: IActionDescriptor;
+    calls: CallableEntity[];
+}
+export type GlobalEventTypesUnion = IGlobalEvent | IGlobalEventTransfer | IGlobalEventShallowTransfer | IGlobalEventGenerationTarget;

package/dist/definitions/types/function.d.ts

@@ -0,0 +1,124 @@
+import { CallableEntity, CallableEntityTransfer, EntityWithLogicScope, EntryPointEntity, EntryPointEntityReference, IInstalledProject, IProject, EntityType, IBaseCanvasDraggable, IBaseVariable, IBaseVariableTransfer, ICalledEntity, IChildEntity, IChildEntityTransfer, IUserManagedGenericBase, IValueWritingEntity, IValueWritingEntityTransfer, IFunctionDeclarationReference, IProjectReference, IActionInputMap, IActionOutputMap, IBaseActionCallTransfer, IDefinitionEntity, IDefinitionEntityReference, ILoop, ILoopReference, IInstalledProjectReference, IActionDescriptorReference, IChildEntityShallowTransfer, IArgumentDeclarationReference, CallableEntityReference, IBaseVariableShallowTransfer, IValueWritingEntityShallowTransfer, IBaseActionCallShallowTransfer, IValueDescriptorReference, IBaseActionCallGenerationTarget, IValueWritingEntityGenerationTarget, IChildEntityGenerationTarget, IBaseVariableGenerationTarget, EntityId, PassThroughCallableEntity, IBaseActionCall_meta, IBaseVariable_meta, IDataType, IDataTypeReference, IDataTypeTransfer, IProperty, IPropertyTransfer, IPropertyReference, ICalledEntityGenerationTarget } from '.';
+import { IActionDescriptor, IActionDescriptorTransfer, IValueDescriptor, IValueDescriptorTransfer } from './action-descriptor';
+
+export declare enum BuiltInFunctionIds {
+    DeletePersistedEntity = "base-delete-persisted-entity",
+    CreatePersistedEntity = "base-create-persisted-entity",
+    UpdatePersistedEntity = "base-update-persisted-entity",
+    UpSQLRowTransformer = "base-up-sql-row-transformer",
+    DownSQLRowTransformer = "base-down-sql-row-transformer",
+    AbortExecution = "base-abort-execution"
+}
+export interface IFunctionCallGenerationTarget extends IBaseActionCallGenerationTarget, IChildEntityGenerationTarget, ICalledEntityGenerationTarget {
+    type: EntityType.FunctionCall;
+    declaration: EntityId;
+    catchesError?: boolean;
+}
+export interface IFunctionCall_meta extends IBaseActionCall_meta, IBaseCanvasDraggable {
+    type: EntityType.FunctionCall;
+    catchesError: boolean;
+}
+export interface IFunctionCallTransfer extends IFunctionCall_meta, IBaseActionCallTransfer, IBaseCanvasDraggable {
+    type: EntityType.FunctionCall;
+    declaration: IFunctionDeclaration | IFunctionDeclarationTransfer | IFunctionDeclarationReference;
+}
+export interface IFunctionCallShallowTransfer extends IFunctionCall_meta, IBaseActionCallShallowTransfer, IBaseCanvasDraggable {
+    type: EntityType.FunctionCall;
+    declaration: IFunctionDeclarationReference;
+}
+export interface IFunctionCall extends IFunctionCallTransfer, IChildEntity, ICalledEntity {
+    successCalls: CallableEntity[];
+    errorCalls: CallableEntity[];
+    inputs: IActionInputMap[];
+    outputs: IActionOutputMap[];
+    declaration: IFunctionDeclaration;
+    calledBySuccess: PassThroughCallableEntity[];
+    calledByError: PassThroughCallableEntity[];
+    calledByEntry: EntryPointEntity[];
+    parent: EntityWithLogicScope | IProject;
+    error: IActionOutputMap | null;
+}
+export interface IArgumentDeclaration_base {
+    id: EntityId;
+    type: EntityType.ArgumentDeclaration;
+    required: boolean;
+    constant: true;
+}
+export interface IArgumentDeclaration_meta extends IUserManagedGenericBase, IArgumentDeclaration_base, IBaseVariable_meta {
+    type: EntityType.ArgumentDeclaration;
+    index: number;
+    constant: true;
+}
+export interface IArgumentDeclarationTransfer extends IArgumentDeclaration_meta, IChildEntityTransfer, IBaseVariableTransfer, IValueWritingEntityTransfer {
+    type: EntityType.ArgumentDeclaration;
+    implements: (IValueDescriptor | IValueDescriptorTransfer | IProperty | IPropertyTransfer)[];
+    constant: true;
+    parent: EntryPointEntity | EntryPointEntityReference;
+}
+export interface IArgumentDeclarationGenerationTarget extends IArgumentDeclaration_base, IChildEntityGenerationTarget, IBaseVariableGenerationTarget, IValueWritingEntityGenerationTarget {
+    id: EntityId;
+    type: EntityType.ArgumentDeclaration;
+    required: boolean;
+    constant: true;
+    implements?: EntityId[];
+    parent: EntityId;
+}
+export interface IArgumentDeclarationShallowTransfer extends IArgumentDeclaration_meta, IChildEntityShallowTransfer, IBaseVariableShallowTransfer, IValueWritingEntityShallowTransfer {
+    type: EntityType.ArgumentDeclaration;
+    constant: true;
+    implements: (IValueDescriptorReference | IPropertyReference)[];
+    parent: EntryPointEntityReference;
+}
+export interface IArgumentDeclaration extends IArgumentDeclaration_meta, IBaseVariable, IChildEntity, IValueWritingEntity {
+    type: EntityType.ArgumentDeclaration;
+    constant: true;
+    implements: (IValueDescriptor | IProperty)[];
+    parent: EntryPointEntity;
+}
+export interface IFunctionDeclaration_meta extends IBaseCanvasDraggable {
+    type: EntityType.FunctionDeclaration;
+    name: string;
+    codeName: string | null;
+    description: string | null;
+    collapsed: boolean;
+    private: boolean;
+    index: number | null;
+}
+export interface IFunctionDeclarationTransfer extends IFunctionDeclaration_meta, IChildEntityTransfer {
+    inputs: (IArgumentDeclaration | IArgumentDeclarationTransfer)[];
+    calls: (CallableEntity | CallableEntityTransfer)[];
+    dataType: IDataType | IDataTypeTransfer | null;
+    implements: IActionDescriptor | IActionDescriptorTransfer | null;
+    extends: IFunctionDeclaration | IFunctionDeclarationTransfer | null;
+    parent: IProject | IProjectReference | IInstalledProject | IInstalledProjectReference | IDefinitionEntity | IDefinitionEntityReference | ILoop | ILoopReference;
+}
+export interface IFunctionDeclarationGenerationTarget extends IChildEntityGenerationTarget {
+    id: EntityId;
+    type: EntityType.FunctionDeclaration;
+    name: string;
+    codeName?: string | null;
+    description?: string | null;
+    private?: boolean;
+    implements?: EntityId;
+    extends?: EntityId;
+    parent?: EntityId;
+}
+export interface IFunctionDeclarationShallowTransfer extends IFunctionDeclaration_meta, IChildEntityShallowTransfer {
+    inputs: IArgumentDeclarationReference[];
+    calls: CallableEntityReference[];
+    dataType: IDataTypeReference | null;
+    implements: IActionDescriptorReference | null;
+    extends: IFunctionDeclarationReference | null;
+    parent: IProjectReference | IInstalledProjectReference | IDefinitionEntityReference | ILoopReference;
+}
+export interface IFunctionDeclaration extends IFunctionDeclarationTransfer, IChildEntity {
+    inputs: IArgumentDeclaration[];
+    calls: CallableEntity[];
+    dataType: IDataType | null;
+    implements: IActionDescriptor | null;
+    extends: IFunctionDeclaration | null;
+    parent: IProject | IInstalledProject | IDefinitionEntity | ILoop;
+}
+export type FunctionCallTypesUnion = IFunctionCall | IFunctionCallTransfer | IFunctionCallShallowTransfer | IFunctionCallGenerationTarget;
+export type ArgumentDeclarationTypesUnion = IArgumentDeclaration | IArgumentDeclarationTransfer | IArgumentDeclarationShallowTransfer | IArgumentDeclarationGenerationTarget;
+export type FunctionDeclarationTypesUnion = IFunctionDeclaration | IFunctionDeclarationTransfer | IFunctionDeclarationShallowTransfer | IFunctionDeclarationGenerationTarget;

package/dist/definitions/types/generic-reference.d.ts

@@ -0,0 +1,93 @@
+import { EntityId, EntityType, EntityVersion } from '.';
+
+export interface IGenericReference {
+    id: EntityId;
+    type: EntityType.GenericReference;
+    entityType: EntityType;
+    version: EntityVersion;
+    entityId: EntityId;
+}
+export interface IFunctionDeclarationReference extends IGenericReference {
+    entityType: EntityType.FunctionDeclaration;
+}
+export interface IFunctionCallReference extends IGenericReference {
+    entityType: EntityType.FunctionCall;
+}
+export interface IVariableDeclarationReference extends IGenericReference {
+    entityType: EntityType.VariableDeclaration;
+}
+export interface IVariableInstanceReference extends IGenericReference {
+    entityType: EntityType.VariableInstance;
+}
+export interface IPropertyReference extends IGenericReference {
+    entityType: EntityType.Property;
+}
+export interface IDataTypeReference extends IGenericReference {
+    entityType: EntityType.DataType;
+}
+export interface IDefinitionEntityReference extends IGenericReference {
+    entityType: EntityType.DefinitionEntity;
+}
+export interface IPrimitiveEntityReference extends IGenericReference {
+    entityType: EntityType.PrimitiveEntity;
+}
+export interface IProjectReference extends IGenericReference {
+    entityType: EntityType.Project;
+}
+export interface ILoopReference extends IGenericReference {
+    entityType: EntityType.Loop;
+}
+export interface ISearchReference extends IGenericReference {
+    entityType: EntityType.Search;
+}
+export interface IGlobalEventReference extends IGenericReference {
+    entityType: EntityType.GlobalEvent;
+}
+export interface IFunctionDeclarationReference extends IGenericReference {
+    entityType: EntityType.FunctionDeclaration;
+}
+export interface IFunctionDeclarationReference extends IGenericReference {
+    entityType: EntityType.FunctionDeclaration;
+}
+export interface IOperationReference extends IGenericReference {
+    entityType: EntityType.Operation;
+}
+export interface IConditionReference extends IGenericReference {
+    entityType: EntityType.Condition;
+}
+export interface IReturnStatementReference extends IGenericReference {
+    entityType: EntityType.ReturnStatement;
+}
+export interface IBreakStatementReference extends IGenericReference {
+    entityType: EntityType.BreakStatement;
+}
+export interface IContinueStatementReference extends IGenericReference {
+    entityType: EntityType.ContinueStatement;
+}
+export interface IOutputMapReference extends IGenericReference {
+    entityType: EntityType.OutputMap;
+}
+export interface IArgumentDeclarationReference extends IGenericReference {
+    entityType: EntityType.ArgumentDeclaration;
+}
+export interface IInputMapReference extends IGenericReference {
+    entityType: EntityType.InputMap;
+}
+export interface ILiteralValueReference extends IGenericReference {
+    entityType: EntityType.LiteralValue;
+}
+export interface IActionDescriptorReference extends IGenericReference {
+    entityType: EntityType.ActionDescriptor;
+}
+export interface IValueDescriptorReference extends IGenericReference {
+    entityType: EntityType.ValueDescriptor;
+}
+export interface IInstalledProjectReference extends IGenericReference {
+    entityType: EntityType.InstalledProject;
+}
+export interface IBuiltInBaseEntityReference extends IGenericReference {
+    entityType: EntityType.BuiltInBaseEntity;
+}
+export interface IInternalCallReference extends IGenericReference {
+    entityType: EntityType.InternalCall;
+}