@elyx-code/project-logic-tree 0.0.6281 → 0.0.6283

package/dist/tree/state/search/index.d.ts

@@ -1,5 +0,0 @@
-export * from './search';
-export * as searchValidation from './validation/logic-validation';
-export * as searchStatementUtils from './query/hydrate';
-export * as searchStatementState from './query/search-statement-state';
-export * as SQLAST from 'sql-parser-cst';

package/dist/tree/state/search/query/hydrate.d.ts

@@ -1,113 +0,0 @@
-import { SelectStmt, Program, FromClause, TablesampleExpr, JoinExpr, LimitClause, OrderByClause, Keyword, PivotExpr, UnpivotExpr, ForSystemTimeAsOfExpr, TableFactor, SelectClause, WhereClause, Expr, PostgresqlOperatorExpr, BinaryExpr, Program as SQLAST } from 'sql-parser-cst';
-import { AggregationStatement, AggregationStatementType, ColumnRef, SearchStatementState, SortStatement, WhereStatement, WhereStatementOperator } from './search-statement-state';
-import { ProjectState } from '../../project';
-import { DefinitionEntityState } from '../../definition-entity';
-import { SearchState } from '../search';
-import { PropertyState } from '../../property';
-
-export declare const FORBIDDEN_SQL_KEYWORDS: string[];
-export interface IShallowColumnMapping {
-    from: string;
-    to: string;
-}
-export interface IColumnMapping {
-    as: string;
-    column: {
-        columnName: string;
-        property: PropertyState | null;
-    };
-}
-export interface Table {
-    entity: DefinitionEntityState;
-    columns: {
-        columnName: string;
-        property: PropertyState | null;
-    }[];
-}
-type SupportedOperators = string | PostgresqlOperatorExpr | Keyword<'IS'> | [Keyword<'IS'>, Keyword<'NOT'>] | [Keyword<'IS'>, Keyword<'DISTINCT'>, Keyword<'FROM'>] | [Keyword<'IS'>, Keyword<'NOT'>, Keyword<'DISTINCT'>, Keyword<'FROM'>] | Keyword<'IN'> | [Keyword<'NOT'>, Keyword<'IN'>] | Keyword<'LIKE' | 'RLIKE' | 'ILIKE' | 'GLOB' | 'MATCH'> | [Keyword<'NOT'>, Keyword<'LIKE' | 'RLIKE' | 'ILIKE' | 'GLOB' | 'MATCH'>];
-export declare function loadProjectDatasources(project: ProjectState): DefinitionEntityState[];
-export declare function getSelectStatementFromProgram(program: Program): SelectStmt | null;
-export declare function getFromClauseFromSelectStatement(selectStatement: SelectStmt): FromClause | null;
-export declare function getNestedFromSubqueryFromSelectStatement(selectStatement: SelectStmt): {
-    selectStatement: SelectStmt;
-    as: string;
-} | null;
-export declare function getMainSourceNameFromFromClauseExpr(fromExpr: JoinExpr | PivotExpr | UnpivotExpr | TablesampleExpr | ForSystemTimeAsOfExpr | TableFactor, parentExpr?: JoinExpr): {
-    type: 'table';
-    name: string;
-    as: string;
-} | null;
-export declare function getMainSourceNameFromSelectStatement(selectStatement: SelectStmt): {
-    type: 'table';
-    name: string;
-    as: string;
-} | null;
-export declare function getMainSourceFromSelectStatement(selectStatement: SelectStmt): {
-    type: 'table';
-    name: string;
-    as: string;
-} | {
-    type: 'query';
-    subquery: SelectStmt;
-    as: string;
-} | null;
-export declare function getSelectClauseFromSelectStatement(selectStatement: SelectStmt): SelectClause;
-export declare function fromSelectClauseColumnsToColumnMappings(selectClause: SelectClause, objectName?: string): IShallowColumnMapping[];
-export declare function getSelectionsConfigFromSelectClause(selectClause: SelectClause): {
-    columns: {
-        name: string;
-        source: string | null;
-    }[];
-    globalSelectAll: boolean;
-    scopedSelectAll: string[];
-} | null;
-export declare function getJoinTypeFromJoinClause(joinClause: JoinExpr): AggregationStatementType;
-export declare function getJoinTableFromJoinClause(joinClause: JoinExpr): string;
-export declare function fromSqlOperatorsExprToComparisonOperator(operator: SupportedOperators): WhereStatementOperator | 'not' | null;
-export declare function fromWhereBinaryExprToComparisonOperator(binaryExpr: BinaryExpr): WhereStatementOperator | null;
-export declare function fromWhereBinaryExprToAndOrOperatorValue(whereExpr: BinaryExpr): 'AND' | 'OR' | null;
-export declare function flattenBinaryExprComparisonsToWhereStatements(whereExpr: BinaryExpr, parent: WhereStatement, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState, debug?: boolean): {
-    ands: WhereStatement[];
-    ors: WhereStatement[];
-};
-export declare function fromWhereExprToWhereStatement(whereExpr: Expr, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState, debug?: boolean): WhereStatement | null;
-export declare function getJoinOnSpecificationAsWhereStatementFromJoinExpr(joinClause: JoinExpr, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState, debug?: boolean): WhereStatement | null;
-export declare function flattenJoinExprIntoAggregationStatementsSync(joinExpr: JoinExpr, parentQuery: SelectStmt, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState, helpers?: {
-    onDescribeTable?: (tableName: string) => Table | null;
-}, debug?: boolean): {
-    aggregations: AggregationStatement[];
-    columnMappings: IColumnMapping[];
-    errors: {
-        entity: 'column' | 'table';
-        code: 'not-found';
-        name: string;
-    }[];
-};
-export declare function getAggregationStatementsFromSelectStatementSync(selectStatement: SelectStmt, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState, helpers?: {
-    onDescribeTable?: (tableName: string) => Table | null;
-}): {
-    aggregations: AggregationStatement[];
-    columnMappings: IColumnMapping[];
-    errors: {
-        entity: 'column' | 'table';
-        code: 'not-found';
-        name: string;
-    }[];
-};
-export declare function fromSelectClauseToLiteralValueSelections(selectClause: SelectClause, state: SearchStatementState, _debug?: boolean): ColumnRef[];
-export declare function getWhereClauseFromSelectStatement(selectStatement: SelectStmt): WhereClause | null;
-export declare function getWhereStatementsFromSelectStatement(selectStatement: SelectStmt, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState): WhereStatement | null;
-export declare function getLimitClauseFromSelectStatement(selectStatement: SelectStmt): LimitClause | null;
-export declare function getRawOffetFromLimitClause(limitClause: LimitClause | null): number;
-export declare function getRawLimitFromLimitClause(limitClause: LimitClause | null): number | null;
-export declare function getOrderByClauseFromSelectStatement(selectStatement: SelectStmt): OrderByClause | null;
-export declare function fromOrderByClauseToSortStatements(orderByClause: OrderByClause, _selectStatement: SelectStmt, _allColumns: IColumnMapping[], state: SearchStatementState): SortStatement[];
-export declare function hydrateSearchStatementState(ast: SQLAST | SelectStmt, project: ProjectState, entity?: SearchState | null, debug?: boolean): {
-    state: SearchStatementState | null;
-    errors: {
-        entity: 'column' | 'table';
-        code: 'not-found';
-        name: string;
-    }[];
-};
-export {};

package/dist/tree/state/search/query/search-statement-state.d.ts

@@ -1,233 +0,0 @@
-import { Program as SQLAST } from 'sql-parser-cst';
-import { DefinitionEntityState, InputMapState, PropertyState } from '../..';
-
-export declare function resolveAreThereConflictingColumnsInSelectAll(allColumnsSelector: AllColumnsSelector | null): boolean;
-export declare enum SearchStatementNodeType {
-    SearchStatement = "search-statement",
-    NestedSearchStatement = "nested-search-statement",
-    DataSource = "data-source",
-    ColumnRef = "column-ref",
-    ValueRef = "value-ref",
-    LiteralValue = "search-statement-literal-value",
-    WhereStatement = "where-statement",
-    AggregationStatement = "aggregation-statement",
-    SortStatement = "sort-statement",
-    AllColumnsSelector = "all-columns-selector"
-}
-export interface ISearchNode {
-    type: SearchStatementNodeType;
-}
-export declare enum AggregationStatementType {
-    Inner = "inner",
-    Left = "left",
-    Right = "right",
-    Full = "full",
-    Cross = "cross",
-    Self = "self",
-    Natural = "natural"
-}
-interface IDataSource {
-    entity: DefinitionEntityState | null;
-    query: NestedSearchStatement | null;
-    aggregation: AggregationStatement | null;
-    sourceType: DataSourceType | null;
-    as: string;
-}
-export declare class AggregationStatement implements ISearchNode {
-    owner: SearchStatementState;
-    dataSource: DataSource | null;
-    joinType: AggregationStatementType;
-    on: WhereStatement | null;
-    as: string | null;
-    constructor(owner: SearchStatementState);
-    get type(): SearchStatementNodeType.AggregationStatement;
-    get id(): string;
-    get columns(): ColumnRef[];
-    get isValid(): boolean;
-    get selections(): (ColumnRef | AllColumnsSelector)[];
-    get selectedColumns(): ColumnRef[];
-    get primaryKeys(): ColumnRef[];
-    get primaryKey(): ColumnRef | null;
-    setDataSource(dataSource: DataSource): void;
-    removeDataSource(): void;
-    editDataSource(dataSource: DataSource): void;
-}
-export declare enum SearchLiteralValueType {
-    String = "string",
-    Number = "number",
-    Boolean = "boolean",
-    Null = "null",
-    Date = "date"
-}
-export declare class SearchStatementLiteralValue implements ISearchNode {
-    owner: SearchStatementState;
-    valueType: SearchLiteralValueType;
-    value: string | number | boolean | null | Date;
-    _id: string;
-    constructor(owner: SearchStatementState);
-    get type(): SearchStatementNodeType.LiteralValue;
-    get id(): string;
-    toQuery(): string;
-}
-export declare enum WhereStatementOperator {
-    Like = "like",
-    NotLike = "not-like",
-    In = "in",
-    Equal = "=",
-    Between = "-",
-    BiggerThan = ">",
-    SmallerThan = "<",
-    BiggerThanOrEqualTo = ">=",
-    SmallerThanOrEqualTo = "<=",
-    NotEqual = "!="
-}
-export declare function whereStatementOperatorToSQL(operator: WhereStatementOperator): 'LIKE' | 'NOT LIKE' | 'IS NOT' | 'BETWEEN' | 'IN' | WhereStatementOperator.BiggerThan | WhereStatementOperator.SmallerThan | WhereStatementOperator.BiggerThanOrEqualTo | WhereStatementOperator.SmallerThanOrEqualTo;
-export declare class WhereStatement implements ISearchNode {
-    owner: SearchStatementState;
-    parent: WhereStatement | null;
-    and: WhereStatement[];
-    or: WhereStatement[];
-    left: ColumnRef | InputMapState | SearchStatementLiteralValue | null;
-    operator: WhereStatementOperator | null;
-    right: ColumnRef | InputMapState | SearchStatementLiteralValue | null;
-    _id: string;
-    constructor(owner: SearchStatementState, parent?: WhereStatement);
-    get type(): SearchStatementNodeType.WhereStatement;
-    get isValid(): boolean;
-    get id(): string;
-    removeDataSource(dataSource: DataSource): void;
-    toQuery(): string;
-    sanitize(): void;
-    removeFromParent(): void;
-    remove(): void;
-}
-export declare class NestedSearchStatement implements ISearchNode {
-    owner: SearchStatementState;
-    statement: SearchStatementState | null;
-    as: string | null;
-    constructor(owner: SearchStatementState);
-    get type(): SearchStatementNodeType.NestedSearchStatement;
-    get id(): string;
-    get isValid(): boolean;
-    get columns(): ColumnRef[];
-    get mainPersistedEntity(): DefinitionEntityState | null;
-    get selections(): (ColumnRef | AllColumnsSelector)[];
-    get selectedColumns(): ColumnRef[];
-    get primaryKeys(): ColumnRef[];
-    get primaryKey(): ColumnRef | null;
-    toQuery(): string;
-}
-export declare enum DataSourceType {
-    Table = "table",
-    Query = "query",
-    Aggregation = "aggregation"
-}
-export declare class DataSource implements IDataSource, ISearchNode {
-    owner: SearchStatementState;
-    entity: DefinitionEntityState | null;
-    query: NestedSearchStatement | null;
-    aggregation: AggregationStatement | null;
-    sourceType: DataSourceType | null;
-    constructor(owner: SearchStatementState);
-    get id(): string;
-    get type(): SearchStatementNodeType.DataSource;
-    get isValid(): boolean;
-    get source(): DefinitionEntityState | NestedSearchStatement | AggregationStatement | null;
-    set as(as: string);
-    get as(): string;
-    get columns(): ColumnRef[];
-    get selections(): (ColumnRef | AllColumnsSelector)[];
-    get mainPersistedEntity(): DefinitionEntityState | null;
-    get selectedColumns(): ColumnRef[];
-    get primaryKeys(): ColumnRef[];
-    get primaryKey(): ColumnRef | null;
-}
-export declare class ColumnRef implements ISearchNode {
-    owner: SearchStatementState;
-    source: ColumnRef | PropertyState | SearchStatementLiteralValue | null;
-    parent: DataSource | null;
-    _id: string;
-    _as: string | null;
-    constructor(owner: SearchStatementState);
-    set as(as: string);
-    get as(): string;
-    get property(): PropertyState | null;
-    get literalValue(): SearchStatementLiteralValue | null;
-    get type(): SearchStatementNodeType.ColumnRef;
-    get id(): string;
-    get isValid(): boolean;
-}
-export declare class AllColumnsSelector implements ISearchNode {
-    owner: SearchStatementState;
-    parent: DataSource | null;
-    constructor(owner: SearchStatementState);
-    get type(): SearchStatementNodeType.AllColumnsSelector;
-    get id(): string;
-    get isValid(): boolean;
-    get columns(): ColumnRef[];
-    get selectedColumns(): ColumnRef[];
-}
-export declare enum SortStatementDirection {
-    Ascending = "asc",
-    Descending = "desc"
-}
-export declare class SortStatement implements ISearchNode {
-    owner: SearchStatementState;
-    column: ColumnRef | null;
-    direction: SortStatementDirection;
-    index: number;
-    constructor(owner: SearchStatementState);
-    get type(): SearchStatementNodeType.SortStatement;
-    get isValid(): boolean;
-}
-export declare class SearchStatementState implements ISearchNode {
-    id: string;
-    selections: (ColumnRef | AllColumnsSelector)[];
-    from: DataSource | null;
-    aggregations: AggregationStatement[];
-    where: WhereStatement | null;
-    offset: InputMapState | SearchStatementLiteralValue | null;
-    limit: InputMapState | SearchStatementLiteralValue | null;
-    asList: boolean;
-    sorting: SortStatement[];
-    dataSources: DataSource[];
-    constructor(id: string);
-    get isUntouchedEntity(): boolean;
-    get usedDataSources(): DataSource[];
-    get type(): SearchStatementNodeType.SearchStatement;
-    get mainPersistedEntity(): DefinitionEntityState | null;
-    get mainDatabaseEntity(): DefinitionEntityState | null;
-    get validSortings(): SortStatement[];
-    get selectedColumns(): ColumnRef[];
-    get validSelections(): (ColumnRef | AllColumnsSelector)[];
-    get validSelectedColumns(): ColumnRef[];
-    get columns(): ColumnRef[];
-    get isValid(): boolean;
-    get primaryKeys(): ColumnRef[];
-    get primaryKey(): ColumnRef | null;
-    get duplicateColumnNames(): string[];
-    get isOnlyAllFromSelected(): boolean;
-    addDataSource(dataSource: DataSource): DataSource;
-    getDataSource(id: string): DataSource | null;
-    editDataSource(dataSource: DataSource): DataSource | null;
-    toQuery(): string;
-    calculateAst(): {
-        ast: SQLAST | null;
-        query: string | null;
-    };
-    addAggregation(aggregation: AggregationStatement): void;
-    removeAggregation(aggregation: AggregationStatement): void;
-    editAggregation(aggregation: AggregationStatement): void;
-    addSort(sort: SortStatement): void;
-    removeSort(sort: SortStatement): void;
-    editSort(sort: SortStatement): void;
-    addSelection(selection: ColumnRef | AllColumnsSelector): void;
-    removeSelection(selection: ColumnRef | AllColumnsSelector): void;
-    editSelection(selection: ColumnRef | AllColumnsSelector): void;
-    setFrom(from: DataSource): void;
-    setWhere(where: WhereStatement): void;
-    setLimit(limit: SearchStatementLiteralValue | InputMapState): void;
-    setOffset(offset: SearchStatementLiteralValue | InputMapState): void;
-    setAsList(asList: boolean): void;
-}
-export {};

package/dist/tree/state/search/query/search-statement-state.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,160 +0,0 @@
-import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, ISearch, ISearchGenerationTarget, ISearchReference, ISearchShallowTransfer, ISearchTransfer, ISearch_meta, SearchTypesUnion } from '../../../definitions';
-import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateTemplate } from '../base';
-import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState } from '../types';
-import { ActionInputMapState } from '../input-map';
-import { ActionOutputMapState } from '../output-map';
-import { ProjectState } from '../project/project';
-import { EntityError, EntityGenerationError } from '../../state/error';
-import { ValueDescriptorState } from '../value-descriptor';
-import { VersionedState } from '../version';
-import { ChangeSet, IChangeSet } from '../change-set';
-import { DefinitionEntityState } from '../definition-entity';
-import { SearchStatementState } from './query/search-statement-state';
-
-export declare enum SearchDependencyField {
-    Parent = "parent"
-}
-export declare class SearchState extends VersionedState implements ISearch, BaseState, UserManagedEntityStateTemplate, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
-    initialData: ISearch | ISearchTransfer;
-    readonly id: EntityId;
-    name: string;
-    description: string | null;
-    x: number;
-    y: number;
-    query: string;
-    readonly type: EntityType.Search;
-    successCalls: CallableEntityState[];
-    errorCalls: CallableEntityState[];
-    inputsDeclarations: ValueDescriptorState[];
-    inputs: ActionInputMapState[];
-    outputsDeclarations: ValueDescriptorState[];
-    outputs: ActionOutputMapState[];
-    calledBySuccess: PassThroughCallableEntityState[];
-    calledByError: PassThroughCallableEntityState[];
-    calledByEntry: EntryPointEntityState[];
-    error: ActionOutputMapState | null;
-    parent: EntityWithLogicScopeState | ProjectState;
-    errors: EntityError[];
-    project: ProjectState;
-    state: SearchStatementState | null;
-    detachedDependents: Record<EntityId, {
-        entity: UserManagedEntityState;
-        field: string;
-    }>;
-    knownVersions: Map<string, EntityState> | null;
-    activeVersion: boolean;
-    initialized: boolean;
-    startedInitialization: boolean;
-    constructor(initialData: ISearch | ISearchTransfer, parentProjectState: ProjectState);
-    static repository: IEditableEntityPersistanceRepository;
-    static type: EntityType.Search;
-    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): ISearchTransfer;
-    static fromGenerationTarget(data: ISearchGenerationTarget, parentProjectState: ProjectState): SearchState;
-    static validateGenerationTarget(data: ISearchGenerationTarget, project: ProjectState): {
-        errors: EntityGenerationError[];
-        modifiedData: ISearchGenerationTarget;
-    };
-    get resultsAsList(): boolean;
-    queryToState(): SearchStatementState;
-    stateToQuery(): string;
-    rehydrateQuery(): string;
-    onProjectInitialized(_project: ProjectState, changeSet?: ChangeSet | null): SearchState;
-    onPersistedEntityUpdated(_updatedEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
-    onPersistedEntityAdded(_newEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
-    onPersistedEntityRemoved(_removedEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
-    onRelationalDatabaseEntityUpdated(_updatedEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
-    onRelationalDatabaseEntityAdded(_newEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
-    onRelationalDatabaseEntityRemoved(_removedEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
-    validateGeneratedUpdate(data: Partial<ISearchGenerationTarget>): {
-        errors: EntityGenerationError[];
-        modifiedData: Partial<ISearchGenerationTarget>;
-    };
-    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(): SearchState;
-    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<SearchState>;
-    restoreVersion(versionId: EntityVersion): Promise<IChangeSet<SearchState>>;
-    hydrateAncestors(): IChangeSet<SearchState>;
-    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<SearchState>;
-    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<SearchState>;
-    get calledBy(): CallerEntityState[];
-    removeInput(input: ActionInputMapState, changeSet?: ChangeSet | null): SearchState;
-    addInput(input: ActionInputMapState, changeSet?: ChangeSet | null): SearchState;
-    addInputDeclaration(inputDeclaration: ValueDescriptorState, changeSet?: ChangeSet | null): SearchState;
-    removeInputDeclaration(inputDeclaration: ValueDescriptorState, changeSet?: ChangeSet | null): SearchState;
-    addOutputDeclaration(outputDeclaration: ValueDescriptorState, changeSet?: ChangeSet | null): SearchState;
-    removeOutputDeclaration(outputDeclaration: ValueDescriptorState, changeSet?: ChangeSet | null): SearchState;
-    addOutput(output: ActionOutputMapState, changeSet?: ChangeSet | null): SearchState;
-    removeOutput(output: ActionOutputMapState, changeSet?: ChangeSet | null): SearchState;
-    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
-    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
-    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
-    addErrorCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
-    addSuccessCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
-    removeCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
-    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
-    setParent(parent: EntityWithLogicScopeState | ProjectState, changeSet?: ChangeSet | null): SearchState;
-    initChildren(changeSet?: ChangeSet | null): SearchState;
-    subscribe(): SearchState;
-    unsubscribe(): SearchState;
-    metaSync(data: Partial<ISearch_meta | ISearch | ISearchTransfer | ISearchShallowTransfer>, changeSet?: ChangeSet | null): SearchState;
-    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
-    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
-    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
-    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
-    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
-    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<ISearchShallowTransfer | null>;
-    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(): ISearch_meta;
-    toJSON(seenEntities?: Set<EntityId>): ISearchTransfer | ISearchReference;
-    toJSONClone(options?: IEntityJSONCloneOptions): ISearchTransfer | ISearchReference;
-    toReference(options?: IEntityRecursionOptions): ISearchReference;
-    toShallowJSON(options?: IEntityRecursionOptions): ISearchShallowTransfer;
-    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
-    toGenerationTarget(): ISearchGenerationTarget;
-    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
-    clearErrors(): SearchState;
-    validate(): {
-        success: boolean;
-        error: ZodError | null;
-        data: ISearchTransfer | null;
-    };
-    getErrors(): EntityError[];
-    getShallowErrors(): EntityError[];
-    clone(changeSet?: ChangeSet | null, parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): SearchState;
-    syncInputMaps(changeSet?: ChangeSet | null): IChangeSet<SearchState>;
-}
-export type SearchPayloadUnion = SearchState | SearchTypesUnion;

package/dist/tree/state/search/search.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tree/state/search/validation/logic-validation.d.ts

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