@elyx-code/project-logic-tree 0.0.6110 → 0.0.6111

package/dist/tree/state/literal-value/index.d.ts

@@ -0,0 +1 @@
+export * from './literal-value';

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

@@ -0,0 +1,103 @@
+import { ILiteralValue, ILiteralValueTransfer, EntityId, EntityType, EntityVersion, PrimitiveTypes, ILiteralValueReference, ValueAutogenerationOptions, LiteralValueType, ILiteralValueShallowTransfer, ElementShallowTransfer, ILiteralValueGenerationTarget, ElementGenerationTarget, LiteralValueTypesUnion } from '../../../definitions';
+import { ProjectState } from '../project';
+import { CustomEntityState } from '../custom-entity';
+import { DataTypeState } from '../data-type';
+import { InputMapState } from '../input-map';
+import { ZodError } from 'zod';
+import { BaseState, ChildEntityState, UserManagedEntityStateFunctionality } from '../base';
+import { FunctionDeclarationState } from '../function-declaration';
+import { EntityError, EntityGenerationError } from '../error';
+import { OperationState } from '../operation';
+import { EntityState, EntityWithValueState, IChangeSet } from '../types';
+import { PropertyState } from '../property';
+import { ArgumentDeclarationState } from '../argument-declaration';
+import { ReturnDeclarationState } from '../return-declaration';
+import { VariableDeclarationState } from '../variable-declaration';
+import { ValueDescriptorState } from '../value-descriptor';
+import { OutputMapState } from '../output-map';
+import { VariableInstanceState } from '../variable-instance';
+
+export type ValueAsTypeState = CustomEntityState | FunctionDeclarationState | OperationState;
+export declare class LiteralValueState implements BaseState, UserManagedEntityStateFunctionality, ChildEntityState, ILiteralValue {
+    initialData: ILiteralValue | ILiteralValueTransfer;
+    readonly type: EntityType.LiteralValue;
+    id: EntityId;
+    version: EntityVersion;
+    name: PrimitiveTypes;
+    autogeneration: ValueAutogenerationOptions | null;
+    value: LiteralValueType;
+    valueAsType: ValueAsTypeState | ValueAsTypeState[] | null;
+    errors: EntityError[];
+    parent: DataTypeState | InputMapState | PropertyState | ArgumentDeclarationState | ReturnDeclarationState | VariableDeclarationState | VariableInstanceState | ValueDescriptorState | OutputMapState;
+    standaloneParent: EntityWithValueState;
+    project: ProjectState;
+    initialized: boolean;
+    standalone: boolean;
+    constructor(initialEntityData: ILiteralValue | ILiteralValueTransfer, parentProjectState: ProjectState);
+    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 fromGenerationTarget(data: ILiteralValueGenerationTarget, parentProjectState: ProjectState): LiteralValueState;
+    static validateGenerationTarget(data: ILiteralValueGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        modifiedData: ILiteralValueGenerationTarget;
+    };
+    validateGeneratedUpdate(data: Partial<ILiteralValueGenerationTarget>): {
+        errors: EntityGenerationError[];
+        modifiedData: Partial<ILiteralValueGenerationTarget>;
+    };
+    addSelfToProject(): IChangeSet<LiteralValueState>;
+    setParent(parent: DataTypeState | InputMapState | PropertyState | ArgumentDeclarationState | ReturnDeclarationState | VariableDeclarationState | VariableInstanceState | ValueDescriptorState | OutputMapState): LiteralValueState;
+    setStandaloneParent(parent: EntityWithValueState): LiteralValueState;
+    setValueAsType(valueAsType: ValueAsTypeState | ValueAsTypeState[] | null): LiteralValueState;
+    initChildren(): LiteralValueState;
+    subscribe(): LiteralValueState;
+    unsubscribe(): LiteralValueState;
+    sync(data: Partial<ILiteralValue>): LiteralValueState;
+    load(): Promise<LiteralValueState>;
+    create(): Promise<LiteralValueState>;
+    update(_: Partial<LiteralValueTypesUnion>): Promise<LiteralValueState>;
+    delete(): Promise<LiteralValueState>;
+    remove({ ignoreUpstream: _, seenEntities, }?: {
+        ignoreUpstream: boolean;
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        removed: EntityState[];
+    };
+    restore({ seenEntities }?: {
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        self: LiteralValueState;
+    };
+    toFlat(seenEntities?: Set<string>): EntityState[];
+    toFlatIds(seenEntities?: Set<string>): EntityId[];
+    toJSON(): ILiteralValueTransfer;
+    toReference(): ILiteralValueReference;
+    toShallowJSON(): ILiteralValueShallowTransfer;
+    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toGenerationTarget(): ILiteralValueGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    clearErrors(): LiteralValueState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: ILiteralValueTransfer | null;
+    };
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    clone(parent?: DataTypeState | InputMapState | PropertyState | ArgumentDeclarationState | ReturnDeclarationState | VariableDeclarationState | VariableInstanceState | ValueDescriptorState | OutputMapState | null, newId?: string | null, subscribe?: boolean): LiteralValueState;
+    merge(sourceEntity: LiteralValueState): IChangeSet<LiteralValueState>;
+}
+export type LiteralValuePayloadUnion = LiteralValueState | LiteralValueTypesUnion;

package/dist/tree/state/literal-value/validation/logic-validation.d.ts

@@ -0,0 +1,4 @@
+import { EntityError } from '../../error';
+import { LiteralValueState } from '../literal-value';
+
+export declare function validate(self: LiteralValueState): EntityError[];

package/dist/tree/state/literal-value/validation/references.d.ts

@@ -0,0 +1,5 @@
+import { ILiteralValueGenerationTarget } from '../../../../definitions';
+import { EntityGenerationError } from '../../error';
+import { ProjectState } from '../../project';
+
+export declare function validateReferenceTypes(data: ILiteralValueGenerationTarget, project: ProjectState): EntityGenerationError[];