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

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

@@ -0,0 +1,167 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,227 @@
+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 {};