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

package/dist/tree/state/value-descriptor/validation/validation-schema.d.ts

@@ -0,0 +1,191 @@
+import { EntityType } from '../../../../definitions';
+import { z } from 'zod';
+
+export declare function getValueDescriptorTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.ValueDescriptor>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.ValueDescriptor;
+}, {
+    type: EntityType.ValueDescriptor;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getValueDescriptorReferenceSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.GenericReference>;
+    entityId: z.ZodString;
+    entityType: z.ZodLiteral<EntityType.ValueDescriptor>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.ValueDescriptor;
+    entityId: string;
+}, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.ValueDescriptor;
+    entityId: string;
+}>;
+export declare function getValueDescriptorBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.ValueDescriptor>;
+    name: z.ZodString;
+    required: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.ValueDescriptor;
+    id: string;
+    name: string;
+    required: boolean;
+}, {
+    type: EntityType.ValueDescriptor;
+    id: string;
+    name: string;
+    required: boolean;
+}>;
+export declare function getValueDescriptorMetaSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.ValueDescriptor>;
+    name: z.ZodString;
+    required: z.ZodBoolean;
+} & {
+    version: z.ZodString;
+    index: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.ValueDescriptor;
+    id: string;
+    version: string;
+    name: string;
+    required: boolean;
+    index: number;
+}, {
+    type: EntityType.ValueDescriptor;
+    id: string;
+    version: string;
+    name: string;
+    required: boolean;
+    index: number;
+}>;
+export declare function getValueDescriptorGenerationTargetSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.ValueDescriptor>;
+    name: z.ZodString;
+    required: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.ValueDescriptor;
+    id: string;
+    name: string;
+    required: boolean;
+}, {
+    type: EntityType.ValueDescriptor;
+    id: string;
+    name: string;
+    required: boolean;
+}>;
+export declare function getValueDescriptorNestedEntitiesSchema(): z.ZodObject<{
+    dataType: z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.DataType>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.DataType;
+    }, {
+        type: EntityType.DataType;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+    parent: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+        entityId: z.ZodString;
+        entityType: z.ZodLiteral<EntityType.ActionDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.ActionDescriptor;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.ActionDescriptor;
+        entityId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.ActionDescriptor;
+        entityId: string;
+    };
+    dataType: Record<string, any> | {
+        type: EntityType.DataType;
+    };
+}, {
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.ActionDescriptor;
+        entityId: string;
+    };
+    dataType: Record<string, any> | {
+        type: EntityType.DataType;
+    };
+}>;
+export declare function getValueDescriptorSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.ValueDescriptor>;
+    name: z.ZodString;
+    required: z.ZodBoolean;
+} & {
+    version: z.ZodString;
+    index: z.ZodNumber;
+} & {
+    dataType: z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.DataType>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.DataType;
+    }, {
+        type: EntityType.DataType;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+    parent: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+        entityId: z.ZodString;
+        entityType: z.ZodLiteral<EntityType.ActionDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.ActionDescriptor;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.ActionDescriptor;
+        entityId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.ActionDescriptor;
+        entityId: string;
+    };
+    type: EntityType.ValueDescriptor;
+    id: string;
+    version: string;
+    name: string;
+    required: boolean;
+    dataType: Record<string, any> | {
+        type: EntityType.DataType;
+    };
+    index: number;
+}, {
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.ActionDescriptor;
+        entityId: string;
+    };
+    type: EntityType.ValueDescriptor;
+    id: string;
+    version: string;
+    name: string;
+    required: boolean;
+    dataType: Record<string, any> | {
+        type: EntityType.DataType;
+    };
+    index: number;
+}>;

package/dist/tree/state/value-descriptor/value-descriptor.d.ts

@@ -0,0 +1,159 @@
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, ValueDescriptorParentChildRelation, IValueDescriptor, IValueDescriptorGenerationTarget, IValueDescriptorReference, IValueDescriptorShallowTransfer, IValueDescriptorTransfer, ValueDescriptorTypesUnion, EntityVersion, IValueDescriptor_meta } from '../../../definitions';
+import { UserManagedBaseState, ChildEntityBaseClass, EntityWithDefaultValueClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate, ValueValidationCallback } from '../base';
+import { DataTypeState } from '../data-type';
+import { ProjectState } from '../project/project';
+import { ActionDescriptorState } from '../action-descriptor';
+import { EntityError, EntityGenerationError } from '../error';
+import { EntityState, EntryPointEntityState, PassThroughCallableEntityState, TerminationEntityState, UserManagedEntityState } from '../types';
+import { GenerationExplanationIds } from '../validate';
+import { LiteralValueState } from '../literal-value';
+import { SearchState } from '../search';
+import { UserManagedVersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
+import { ArgumentDeclarationState } from '../argument-declaration';
+import { InputMapState } from '../input-map';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare enum ValueDescriptorDependencyField {
+    DataTypeEntity = "data-type-entity"
+}
+export declare class ValueDescriptorState extends UserManagedVersionedState implements IValueDescriptor, UserManagedEntityStateTemplate, UserManagedBaseState, ChildEntityBaseClass, EntityWithDefaultValueClass {
+    initialData: IValueDescriptor | IValueDescriptorTransfer;
+    readonly id: EntityId;
+    name: string;
+    codeName: string | null;
+    description: string | null;
+    index: number;
+    required: boolean;
+    parentRelationType?: ValueDescriptorParentChildRelation;
+    readonly type: EntityType.ValueDescriptor;
+    defaultValue: LiteralValueState | null;
+    dataType: DataTypeState | null;
+    project: ProjectState;
+    errors: EntityError[];
+    parent: ActionDescriptorState | SearchState | null;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
+    knownVersions: Map<string, UserManagedEntityState> | null;
+    activeVersion: boolean;
+    initialized: boolean;
+    startedInitialization: boolean;
+    readonly _codeNativeValueValidation: ValueValidationCallback | null;
+    constructor(initialData: IValueDescriptor | IValueDescriptorTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.ValueDescriptor;
+    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): IValueDescriptorTransfer;
+    static fromGenerationTarget(data: IValueDescriptorGenerationTarget, parentProjectState: ProjectState, _changeSet?: ChangeSet | null): ValueDescriptorState;
+    static validateGenerationTarget(data: IValueDescriptorGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: IValueDescriptorGenerationTarget;
+    };
+    get codeNativeValueValidation(): ValueValidationCallback | null;
+    validateGeneratedUpdate(data: Partial<IValueDescriptorGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<IValueDescriptorGenerationTarget>;
+    };
+    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(): ValueDescriptorState;
+    snapshot(): ValueDescriptorState;
+    /**
+     * 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 {ValueDescriptorState} snapshotInstance
+     * @returns {ValueDescriptorState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: ValueDescriptorState): ValueDescriptorState;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ValueDescriptorState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<ValueDescriptorState>>;
+    updateWithShallowTransfer(transfer: IValueDescriptorShallowTransfer, changeSet?: ChangeSet | null): ValueDescriptorState;
+    updateWithGenerationTarget(transfer: Partial<IValueDescriptorGenerationTarget>, changeSet?: ChangeSet | null): ValueDescriptorState;
+    hydrateAncestors(): IChangeSet<ValueDescriptorState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ValueDescriptorState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<ValueDescriptorState>;
+    setParent(parent: ActionDescriptorState | SearchState, changeSet?: ChangeSet | null): ValueDescriptorState;
+    initChildren(changeSet?: ChangeSet | null): ValueDescriptorState;
+    subscribe(): ValueDescriptorState;
+    unsubscribe(): ValueDescriptorState;
+    metaSync(changedData: Partial<IValueDescriptor_meta | IValueDescriptor | IValueDescriptorTransfer | IValueDescriptorShallowTransfer>, changeSet?: ChangeSet | null): ValueDescriptorState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ValueDescriptorState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ValueDescriptorState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ValueDescriptorState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ValueDescriptorState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ValueDescriptorState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IValueDescriptorShallowTransfer | null>;
+    removeFromParent(changeSet?: ChangeSet | null): IChangeSet;
+    remove({ ignoreUpstream }?: {
+        ignoreUpstream: boolean;
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<EntityState>;
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IValueDescriptor_meta;
+    toJSON(seenEntities?: Set<EntityId>): IValueDescriptorTransfer | IValueDescriptorReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IValueDescriptorTransfer | IValueDescriptorReference;
+    toReference(options?: IEntityRecursionOptions): IValueDescriptorReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IValueDescriptorShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(options?: IEntityRecursionOptions): IValueDescriptorGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): ValueDescriptorState;
+    validate(): {
+        success: boolean;
+    };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
+    getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
+    getShallowErrors(): EntityError[];
+    clone(changeSet?: ChangeSet | null, parent?: ActionDescriptorState | SearchState | null, newId?: string | null, subscribe?: boolean): ValueDescriptorState;
+    getDataType(changeSet?: ChangeSet | null): DataTypeState | null;
+    setDataType(dataType: DataTypeState | null, changeSet?: ChangeSet | null): ValueDescriptorState;
+    getDefaultValue(): LiteralValueState | null;
+    setDefaultValue(value: LiteralValueState | null, changeSet?: ChangeSet | null): ValueDescriptorState;
+    removeDataType(changeSet?: ChangeSet | null): ValueDescriptorState;
+    implementAsInputMap(changeSet: (ChangeSet | null) | undefined, newParent: PassThroughCallableEntityState | TerminationEntityState, newId?: string): InputMapState;
+    implementAsArgumentDeclaration(changeSet: (ChangeSet | null) | undefined, newParent: EntryPointEntityState, newId?: string): ArgumentDeclarationState;
+}
+export type ValueDescriptorPayloadUnion = ValueDescriptorState | ValueDescriptorTypesUnion;

package/dist/tree/state/variable-declaration/index.d.ts

@@ -0,0 +1,3 @@
+export * from './variable-declaration';
+import * as variableDeclarationValidation from './validation/logic-validation';
+export { variableDeclarationValidation };

package/dist/tree/state/variable-declaration/validation/logic-validation.d.ts

@@ -0,0 +1,17 @@
+import { VariableDeclarationState } from '..';
+import { EntityError } from '../../error';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare function validateAsync(self: VariableDeclarationState, options?: YieldOptions): Promise<EntityError[]>;
+export declare function validate(self: VariableDeclarationState): EntityError[];
+export declare function validateVariableDeclarationName(self: VariableDeclarationState, newName?: string): EntityError[];
+/**
+ * Check if it is global, if so, it cannot:
+ * 	- Catch an error
+ * 	- Be called
+ * 	- Or call on the error branch (because that is equivalent to an explicit error catch)
+ *
+ * @param self - The variable declaration state to validate
+ * @returns An array of EntityError objects representing validation errors
+ */
+export declare function validateGlobalVariableDeclaration(self: VariableDeclarationState): EntityError[];

package/dist/tree/state/variable-declaration/validation/validation-schema.d.ts

@@ -0,0 +1,297 @@
+import { EntityType } from '../../../../definitions';
+import { z } from 'zod';
+
+export declare function getVariableDeclarationTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.VariableDeclaration>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.VariableDeclaration;
+}, {
+    type: EntityType.VariableDeclaration;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getVariableDeclarationReferenceSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.GenericReference>;
+    entityId: z.ZodString;
+    entityType: z.ZodLiteral<EntityType.VariableDeclaration>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.VariableDeclaration;
+    entityId: string;
+}, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.VariableDeclaration;
+    entityId: string;
+}>;
+export declare function getVariableDeclarationBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.VariableDeclaration>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.VariableDeclaration;
+    id: string;
+    name: string;
+    description: string | null;
+}, {
+    type: EntityType.VariableDeclaration;
+    id: string;
+    name: string;
+    description: string | null;
+}>;
+export declare function getVariableDeclarationMetaSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.VariableDeclaration>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+} & {
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.VariableDeclaration;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+    x: number;
+    y: number;
+}, {
+    type: EntityType.VariableDeclaration;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+    x: number;
+    y: number;
+}>;
+export declare function getVariableDeclarationGenerationTargetSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.VariableDeclaration>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.VariableDeclaration;
+    id: string;
+    name: string;
+    description: string | null;
+}, {
+    type: EntityType.VariableDeclaration;
+    id: string;
+    name: string;
+    description: string | null;
+}>;
+export declare function getVariableDeclarationNestedEntitiesSchema(): z.ZodObject<{
+    dataType: z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.DataType>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.DataType;
+    }, {
+        type: EntityType.DataType;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+    readsValue: z.ZodNullable<z.ZodTypeAny>;
+    writesValues: z.ZodArray<z.ZodTypeAny, "many">;
+    inputs: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.InputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.InputMap;
+    }, {
+        type: EntityType.InputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    outputs: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.OutputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.OutputMap;
+    }, {
+        type: EntityType.OutputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    successCalls: z.ZodArray<z.ZodTypeAny, "many">;
+    errorCalls: z.ZodArray<z.ZodTypeAny, "many">;
+    internalCalls: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.InternalCall>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.InternalCall;
+    }, {
+        type: EntityType.InternalCall;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    calledBySuccess: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByError: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByEntry: z.ZodArray<z.ZodTypeAny, "many">;
+    parent: z.ZodUnion<[z.ZodTypeAny, z.ZodObject<{
+        entityType: z.ZodLiteral<EntityType.Project>;
+        entityId: z.ZodString;
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    writesValues: any[];
+    dataType: Record<string, any> | {
+        type: EntityType.DataType;
+    } | null;
+    internalCalls: (Record<string, any> | {
+        type: EntityType.InternalCall;
+    })[];
+    parent?: any;
+    readsValue?: any;
+}, {
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    writesValues: any[];
+    dataType: Record<string, any> | {
+        type: EntityType.DataType;
+    } | null;
+    internalCalls: (Record<string, any> | {
+        type: EntityType.InternalCall;
+    })[];
+    parent?: any;
+    readsValue?: any;
+}>;
+export declare function getVariableDeclarationSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.VariableDeclaration>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+} & {
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+} & {
+    dataType: z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.DataType>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.DataType;
+    }, {
+        type: EntityType.DataType;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+    readsValue: z.ZodNullable<z.ZodTypeAny>;
+    writesValues: z.ZodArray<z.ZodTypeAny, "many">;
+    inputs: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.InputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.InputMap;
+    }, {
+        type: EntityType.InputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    outputs: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.OutputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.OutputMap;
+    }, {
+        type: EntityType.OutputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    successCalls: z.ZodArray<z.ZodTypeAny, "many">;
+    errorCalls: z.ZodArray<z.ZodTypeAny, "many">;
+    internalCalls: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.InternalCall>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.InternalCall;
+    }, {
+        type: EntityType.InternalCall;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    calledBySuccess: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByError: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByEntry: z.ZodArray<z.ZodTypeAny, "many">;
+    parent: z.ZodUnion<[z.ZodTypeAny, z.ZodObject<{
+        entityType: z.ZodLiteral<EntityType.Project>;
+        entityId: z.ZodString;
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    type: EntityType.VariableDeclaration;
+    id: string;
+    version: string;
+    writesValues: any[];
+    name: string;
+    description: string | null;
+    x: number;
+    y: number;
+    dataType: Record<string, any> | {
+        type: EntityType.DataType;
+    } | null;
+    internalCalls: (Record<string, any> | {
+        type: EntityType.InternalCall;
+    })[];
+    parent?: any;
+    readsValue?: any;
+}, {
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    type: EntityType.VariableDeclaration;
+    id: string;
+    version: string;
+    writesValues: any[];
+    name: string;
+    description: string | null;
+    x: number;
+    y: number;
+    dataType: Record<string, any> | {
+        type: EntityType.DataType;
+    } | null;
+    internalCalls: (Record<string, any> | {
+        type: EntityType.InternalCall;
+    })[];
+    parent?: any;
+    readsValue?: any;
+}>;