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

package/dist/tree/state/return-statement/validation/validation-schema.d.ts

@@ -1,167 +0,0 @@
-import { EntityType } from '../../../../definitions';
-import { z } from 'zod';
-
-export declare function getReturnStatementTypeSchema(): z.ZodUnion<[z.ZodObject<{
-    type: z.ZodLiteral<EntityType.ReturnStatement>;
-}, "strip", z.ZodTypeAny, {
-    type: EntityType.ReturnStatement;
-}, {
-    type: EntityType.ReturnStatement;
-}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
-export declare function getReturnStatementReferenceSchema(): z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<EntityType.GenericReference>;
-    entityId: z.ZodString;
-    entityType: z.ZodLiteral<EntityType.ReturnStatement>;
-}, "strip", z.ZodTypeAny, {
-    type: EntityType.GenericReference;
-    id: string;
-    entityType: EntityType.ReturnStatement;
-    entityId: string;
-}, {
-    type: EntityType.GenericReference;
-    id: string;
-    entityType: EntityType.ReturnStatement;
-    entityId: string;
-}>;
-export declare function getReturnStatementBaseSchema(): z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<EntityType.ReturnStatement>;
-}, "strip", z.ZodTypeAny, {
-    type: EntityType.ReturnStatement;
-    id: string;
-}, {
-    type: EntityType.ReturnStatement;
-    id: string;
-}>;
-export declare function getReturnStatementMetaSchema(): z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<EntityType.ReturnStatement>;
-} & {
-    version: z.ZodString;
-    x: z.ZodNumber;
-    y: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    type: EntityType.ReturnStatement;
-    id: string;
-    version: string;
-    x: number;
-    y: number;
-}, {
-    type: EntityType.ReturnStatement;
-    id: string;
-    version: string;
-    x: number;
-    y: number;
-}>;
-export declare function getReturnStatementGenerationTargetSchema(): z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<EntityType.ReturnStatement>;
-}, "strip", z.ZodTypeAny, {
-    type: EntityType.ReturnStatement;
-    id: string;
-}, {
-    type: EntityType.ReturnStatement;
-    id: string;
-}>;
-export declare function getReturnStatementNestedEntitiesSchema(): z.ZodObject<{
-    calledBySuccess: z.ZodArray<z.ZodTypeAny, "many">;
-    calledByError: z.ZodArray<z.ZodTypeAny, "many">;
-    calledByEntry: z.ZodArray<z.ZodTypeAny, "many">;
-    outputs: 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">;
-    throws: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
-        type: z.ZodLiteral<EntityType.InputMap>;
-    }, "strip", z.ZodTypeAny, {
-        type: EntityType.InputMap;
-    }, {
-        type: EntityType.InputMap;
-    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
-    parent: z.ZodTypeAny;
-}, "strip", z.ZodTypeAny, {
-    outputs: (Record<string, any> | {
-        type: EntityType.InputMap;
-    })[];
-    calledBySuccess: any[];
-    calledByError: any[];
-    calledByEntry: any[];
-    parent?: any;
-    throws?: Record<string, any> | {
-        type: EntityType.InputMap;
-    } | undefined;
-}, {
-    outputs: (Record<string, any> | {
-        type: EntityType.InputMap;
-    })[];
-    calledBySuccess: any[];
-    calledByError: any[];
-    calledByEntry: any[];
-    parent?: any;
-    throws?: Record<string, any> | {
-        type: EntityType.InputMap;
-    } | undefined;
-}>;
-export declare function getReturnStatementSchema(): z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<EntityType.ReturnStatement>;
-} & {
-    version: z.ZodString;
-    x: z.ZodNumber;
-    y: z.ZodNumber;
-} & {
-    calledBySuccess: z.ZodArray<z.ZodTypeAny, "many">;
-    calledByError: z.ZodArray<z.ZodTypeAny, "many">;
-    calledByEntry: z.ZodArray<z.ZodTypeAny, "many">;
-    outputs: 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">;
-    throws: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
-        type: z.ZodLiteral<EntityType.InputMap>;
-    }, "strip", z.ZodTypeAny, {
-        type: EntityType.InputMap;
-    }, {
-        type: EntityType.InputMap;
-    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
-    parent: z.ZodTypeAny;
-}, "strip", z.ZodTypeAny, {
-    outputs: (Record<string, any> | {
-        type: EntityType.InputMap;
-    })[];
-    calledBySuccess: any[];
-    calledByError: any[];
-    calledByEntry: any[];
-    type: EntityType.ReturnStatement;
-    id: string;
-    version: string;
-    x: number;
-    y: number;
-    parent?: any;
-    throws?: Record<string, any> | {
-        type: EntityType.InputMap;
-    } | undefined;
-}, {
-    outputs: (Record<string, any> | {
-        type: EntityType.InputMap;
-    })[];
-    calledBySuccess: any[];
-    calledByError: any[];
-    calledByEntry: any[];
-    type: EntityType.ReturnStatement;
-    id: string;
-    version: string;
-    x: number;
-    y: number;
-    parent?: any;
-    throws?: Record<string, any> | {
-        type: EntityType.InputMap;
-    } | undefined;
-}>;

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

@@ -1,9 +0,0 @@
-export * from './search';
-export * from './utils';
-import * as searchValidation from './validation/logic-validation';
-import * as searchStatementDefs from './query/defs';
-import * as searchStatementFunctions from './query/function-registry';
-import * as searchStatementUtils from './query/hydrate';
-import * as searchStatementState from './query/search-statement-state';
-import * as SQLAST from 'sql-parser-cst';
-export { searchValidation, searchStatementDefs, searchStatementFunctions, searchStatementUtils, searchStatementState, SQLAST };

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

@@ -1,76 +0,0 @@
-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",
-    FunctionCall = "function-call"
-}
-export declare enum DataSourceType {
-    Table = "table",
-    Query = "query",
-    Aggregation = "aggregation",
-    Function = "function"
-}
-export declare enum SortStatementDirection {
-    Ascending = "asc",
-    Descending = "desc"
-}
-export declare enum WhereStatementOperator {
-    Like = "like",
-    NotLike = "not-like",
-    In = "in",
-    Equal = "=",
-    Between = "-",
-    BiggerThan = ">",
-    SmallerThan = "<",
-    BiggerThanOrEqualTo = ">=",
-    SmallerThanOrEqualTo = "<=",
-    NotEqual = "!="
-}
-export declare enum SearchLiteralValueType {
-    String = "string",
-    Number = "number",
-    Boolean = "boolean",
-    Null = "null",
-    Date = "date",
-    Array = "array"
-}
-export declare enum AggregationStatementType {
-    Inner = "inner",
-    Left = "left",
-    Right = "right",
-    Full = "full",
-    Cross = "cross",
-    Self = "self",
-    Natural = "natural"
-}
-export declare enum SQLFunctionCategory {
-    Scalar = "SCALAR",
-    Aggregate = "AGGREGATE",
-    TableValued = "TABLE_VALUED"
-}
-export type SQLDataType = 'string' | 'number' | 'boolean' | 'date' | 'table' | 'any' | 'json' | 'array';
-export declare enum FunctionNames {
-    Upper = "UPPER",
-    Lower = "LOWER",
-    Max = "MAX",
-    Min = "MIN",
-    JsonBuildObject = "json_build_object",
-    RowToJson = "row_to_json",
-    JsonAgg = "json_agg",
-    Count = "COUNT",
-    GenerateSeries = "generate_series",
-    Unnest = "unnest",
-    Coalesce = "COALESCE",
-    Concat = "CONCAT",
-    Sum = "SUM",
-    Length = "LENGTH",
-    Round = "ROUND",
-    Now = "NOW"
-}

package/dist/tree/state/search/query/function-registry.d.ts

@@ -1,17 +0,0 @@
-import { FunctionNames, SQLDataType, SQLFunctionCategory } from './defs';
-
-export interface ISQLFunctionArgument {
-    name: string;
-    acceptedTypes: SQLDataType[];
-    isVariadic?: boolean;
-    optional?: boolean;
-}
-export interface ISQLFunctionDefinition {
-    name: FunctionNames;
-    category: SQLFunctionCategory;
-    description: string;
-    returnType: SQLDataType;
-    arguments: ISQLFunctionArgument[];
-}
-export declare const SQL_FUNCTION_REGISTRY: Record<string, ISQLFunctionDefinition>;
-export declare function getFunctionDefinition(name: FunctionNames): ISQLFunctionDefinition | null;

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

@@ -1,132 +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, ColumnRef, SearchStatementLiteralValue, SearchStatementState, SortStatement, WhereStatement, FunctionCall, FunctionArgument } from './search-statement-state';
-import { ProjectState } from '../../project';
-import { DefinitionEntityState } from '../../definition-entity';
-import { SearchState } from '../search';
-import { PropertyState } from '../../property';
-import { AggregationStatementType, FunctionNames, WhereStatementOperator } from './defs';
-
-export declare function sanitizeSQLIdentifierText(text: string): FunctionNames;
-export declare function tryHydrateJsonArrayString(state: SearchStatementState, rawValue: string): SearchStatementLiteralValue | null;
-export declare function sanitizeQuery(query: string): string;
-export declare function fromNameToTableDescription(tableName: string, project: ProjectState): ITable | null;
-export declare const FORBIDDEN_SQL_KEYWORDS: string[];
-export interface IShallowColumnMapping {
-    from: string;
-    to: string;
-}
-export interface IColumn {
-    columnName: string;
-    property: PropertyState | null;
-    primaryKey?: boolean;
-    table?: ITable;
-}
-export interface IColumnMapping {
-    as: string;
-    column: IColumn;
-}
-export interface ITable {
-    entity: DefinitionEntityState;
-    tableName: string;
-    columns: IColumn[];
-}
-export 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;
-} | {
-    type: 'function';
-    functionCall: Expr;
-    as: string;
-} | null;
-export declare function getMainSourceNameFromSelectStatement(selectStatement: SelectStmt): {
-    type: 'table';
-    name: string;
-    as: string;
-} | {
-    type: 'function';
-    functionCall: Expr;
-    as: string;
-} | null;
-export declare function getMainSourceFromSelectStatement(selectStatement: SelectStmt): {
-    type: 'table';
-    name: string;
-    as: string;
-} | {
-    type: 'query';
-    subquery: SelectStmt;
-    as: string;
-} | {
-    type: 'function';
-    functionCall: Expr;
-    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 fromCallExprToFunctionCall(callExpr: Expr, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState): FunctionCall | null;
-export declare function resolveExprToFunctionArgument(expr: Expr | any, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState): FunctionArgument | 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) => ITable | 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) => ITable | null;
-}): {
-    aggregations: AggregationStatement[];
-    columnMappings: IColumnMapping[];
-    errors: {
-        entity: 'column' | 'table';
-        code: 'not-found';
-        name: string;
-    }[];
-};
-export declare function fromSelectClauseToLiteralValueSelections(selectClause: SelectClause, state: SearchStatementState, project: ProjectState, _debug?: boolean): (ColumnRef | FunctionCall)[];
-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 | string;
-export declare function getRawLimitFromLimitClause(limitClause: LimitClause | null): number | string | null;
-export declare function getOrderByClauseFromSelectStatement(selectStatement: SelectStmt): OrderByClause | null;
-export declare function fromOrderByClauseToSortStatements(orderByClause: OrderByClause, _selectStatement: SelectStmt, _allColumns: IColumnMapping[], state: SearchStatementState, project: ProjectState): 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;
-    }[];
-};

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

@@ -1,227 +0,0 @@
-import { Program as SQLAST } from 'sql-parser-cst';
-import { AggregationStatementType, DataSourceType, FunctionNames, SearchLiteralValueType, SearchStatementNodeType, SortStatementDirection, SQLFunctionCategory, WhereStatementOperator } from './defs';
-import { DefinitionEntityState, InputMapState, PropertyState } from '../..';
-
-export declare function resolveAreThereConflictingColumnsInSelectAll(allColumnsSelector: AllColumnsSelector | null): boolean;
-export interface ISearchNode {
-    type: SearchStatementNodeType;
-}
-interface IDataSource {
-    entity: DefinitionEntityState | null;
-    query: NestedSearchStatement | null;
-    aggregation: AggregationStatement | null;
-    sourceType: DataSourceType | null;
-    as: string;
-}
-export type FunctionArgument = ColumnRef | ValueRef | SearchStatementLiteralValue | FunctionCall | AllColumnsSelector;
-export declare class FunctionCall implements ISearchNode {
-    owner: SearchStatementState;
-    private _functionName;
-    category: SQLFunctionCategory;
-    arguments: FunctionArgument[];
-    parent: DataSource | null;
-    _id: string;
-    _as: string | null;
-    constructor(owner: SearchStatementState);
-    set functionName(name: FunctionNames | string);
-    get functionName(): FunctionNames | '';
-    set as(as: string);
-    get as(): string;
-    get type(): SearchStatementNodeType.FunctionCall;
-    get property(): null;
-    get literalValue(): null;
-    get id(): string;
-    get isValid(): boolean;
-    toQuery(): string;
-    hasFunctionOfCategory(category: SQLFunctionCategory): boolean;
-}
-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 | FunctionCall)[];
-    get selectedColumns(): (ColumnRef | FunctionCall)[];
-    get primaryKeys(): ColumnRef[];
-    get primaryKey(): ColumnRef | null;
-    setDataSource(dataSource: DataSource): void;
-    removeDataSource(): void;
-    editDataSource(dataSource: DataSource): void;
-}
-export declare class ValueRef implements ISearchNode {
-    owner: SearchStatementState;
-    inputMap: InputMapState | null;
-    _id: string;
-    constructor(owner: SearchStatementState);
-    get id(): string;
-    get type(): SearchStatementNodeType.ValueRef;
-    toQuery(): string;
-}
-type SearchStatementPrimitiveLiteralRawValue = string | number | boolean | null | Date;
-type SearchStatementRecursiveLiteralRawValue = SearchStatementPrimitiveLiteralRawValue | SearchStatementPrimitiveLiteralRawValue[] | SearchStatementRecursiveLiteralRawValue[];
-export declare class SearchStatementLiteralValue implements ISearchNode {
-    owner: SearchStatementState;
-    valueType: SearchLiteralValueType;
-    value: string | number | boolean | null | Date | SearchStatementLiteralValue[];
-    _id: string;
-    constructor(owner: SearchStatementState);
-    get type(): SearchStatementNodeType.LiteralValue;
-    get id(): string;
-    get isValid(): boolean;
-    flattenRawValue(): SearchStatementRecursiveLiteralRawValue;
-    private arrayItemsToJson;
-    toQuery(): string;
-}
-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 | ValueRef | SearchStatementLiteralValue | FunctionCall | null;
-    operator: WhereStatementOperator | null;
-    right: ColumnRef | ValueRef | SearchStatementLiteralValue | FunctionCall | 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;
-    hasFunctionOfCategory(category: SQLFunctionCategory): boolean;
-}
-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 | FunctionCall)[];
-    get selectedColumns(): ColumnRef[];
-    get primaryKeys(): ColumnRef[];
-    get primaryKey(): ColumnRef | null;
-    toQuery(): string;
-}
-export declare class DataSource implements IDataSource, ISearchNode {
-    owner: SearchStatementState;
-    entity: DefinitionEntityState | null;
-    query: NestedSearchStatement | null;
-    aggregation: AggregationStatement | null;
-    functionCall: FunctionCall | null;
-    sourceType: DataSourceType | null;
-    private _asFallback;
-    constructor(owner: SearchStatementState);
-    get id(): string;
-    get type(): SearchStatementNodeType.DataSource;
-    get isValid(): boolean;
-    get source(): DefinitionEntityState | NestedSearchStatement | AggregationStatement | FunctionCall | null;
-    set as(as: string);
-    get as(): string;
-    get columns(): ColumnRef[];
-    get selections(): (ColumnRef | AllColumnsSelector | FunctionCall)[];
-    get mainPersistedEntity(): DefinitionEntityState | null;
-    get selectedColumns(): (ColumnRef | FunctionCall)[];
-    get primaryKeys(): ColumnRef[];
-    get primaryKey(): ColumnRef | null;
-}
-export declare class ColumnRef implements ISearchNode {
-    owner: SearchStatementState;
-    source: ColumnRef | PropertyState | ValueRef | SearchStatementLiteralValue | FunctionCall | 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 class SortStatement implements ISearchNode {
-    owner: SearchStatementState;
-    column: ColumnRef | FunctionCall | 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 | FunctionCall)[];
-    from: DataSource | null;
-    aggregations: AggregationStatement[];
-    where: WhereStatement | null;
-    offset: ValueRef | SearchStatementLiteralValue | null;
-    limit: ValueRef | SearchStatementLiteralValue | null;
-    asList: boolean;
-    sorting: SortStatement[];
-    dataSources: DataSource[];
-    constructor(id: string);
-    get validationErrors(): 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 | FunctionCall)[];
-    get validSelections(): (ColumnRef | AllColumnsSelector | FunctionCall)[];
-    get validSelectedColumns(): (ColumnRef | FunctionCall)[];
-    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;
-    sanitizeSelectionsForAggregation(): void;
-    addSelection(selection: ColumnRef | AllColumnsSelector | FunctionCall): void;
-    removeSelection(selection: ColumnRef | AllColumnsSelector | FunctionCall): void;
-    editSelection(selection: ColumnRef | AllColumnsSelector | FunctionCall): void;
-    setFrom(from: DataSource): void;
-    setWhere(where: WhereStatement): void;
-    setLimit(limit: SearchStatementLiteralValue | ValueRef): void;
-    setOffset(offset: SearchStatementLiteralValue | ValueRef): void;
-    setAsList(asList: boolean): void;
-}
-export type SearchNode = SearchStatementState | SortStatement | AllColumnsSelector | ColumnRef | DataSource | NestedSearchStatement | WhereStatement | SearchStatementLiteralValue | ValueRef | AggregationStatement | FunctionCall;
-export {};