dsl-to-sql 1.0.0-fabric-1p-development.1

package/dist/index.d.ts

@@ -0,0 +1,927 @@
+import * as acorn from "acorn";
+
+//#region src/js-lib/ParseContext.d.ts
+declare enum MDM_COLUMN_TYPE {
+  TEXT = 1,
+  SINGLE_SELECT = 2,
+  MULTI_SELECT = 3,
+  DATE = 4,
+  COMMENTS = 5,
+  NUMBER = 6,
+  PERSON = 7,
+  TIME = 8,
+  LAST_UPDATED_BY = 9,
+  LAST_UPDATED_AT = 10,
+  CHECKBOX = 11,
+  DATETIME = 12,
+  DECIMAL = 13,
+  IMAGE = 14,
+  URL = 15,
+  EMAIL = 16,
+  FORMULA = 17,
+}
+declare enum ResolvedExpressionType {
+  COLUMN = "columnExpr",
+  CTE = "cteExpr",
+}
+type CteExpression = {
+  type: ResolvedExpressionType.CTE;
+  cteName: string;
+  value: string[];
+};
+type ColumnExpression = {
+  type: ResolvedExpressionType.COLUMN;
+  value: string[];
+};
+type SqlQueryProps = {
+  resolvedExpression: ColumnExpression | CteExpression;
+};
+type ColumnMeta = {
+  sqlQueryProps?: SqlQueryProps;
+  computationOrder?: number;
+  deps?: string[];
+  [key: string]: any;
+};
+interface IMDMColumnConfigWithParsedMeta {
+  columnName: string;
+  columnType: MDM_COLUMN_TYPE;
+  columnMeta: ColumnMeta;
+}
+type TColumnConfigMap = Record<string, IMDMColumnConfigWithParsedMeta>;
+type ParseContextProps = {
+  columnConfigMap: TColumnConfigMap;
+  currentColumnId: string;
+  primaryKeyColumns: string[];
+  tableName: string;
+};
+declare class ParseContext {
+  private lastEvaluatedValue;
+  private _cteCount;
+  formulaIdColumnMap: Record<string, string>;
+  deprecatedFormulaColumnMap: Record<string, string>;
+  ifCondition: boolean;
+  private readonly columnDeps;
+  readonly state: Map<string, any>;
+  readonly columnConfigMap: TColumnConfigMap;
+  readonly currentColumnId: string;
+  readonly primaryKeyColumns: string[];
+  readonly tableName: string;
+  readonly entityNameFormatter: (name: string) => string;
+  returnType: string | undefined;
+  isValid: boolean;
+  error: string | undefined;
+  constructor(props: ParseContextProps);
+  /**
+   * Reset the parse context
+   */
+  reset(): ParseContext;
+  get(node: acorn.Node): any;
+  set(node: acorn.Node, value: any): void;
+  getId(node: acorn.Node): string;
+  getLastEvaluatedValue(): any;
+  getColumnCount(): number;
+  addColumnDep(columnName: string): void;
+  getColumnDeps(): Set<string>;
+  get cteCount(): number;
+  incrementCTECount(): void;
+}
+//#endregion
+//#region src/query-builder/SuperFilterBuilder.d.ts
+declare enum EDateRangeRelativeFilterCondition {
+  IS_IN_THE_LAST = "IS_IN_THE_LAST",
+  IS_IN_THIS = "IS_IN_THIS",
+  IS_IN_THE_NEXT = "IS_IN_THE_NEXT",
+}
+declare enum EDateRangeRelativePeriodFilterCondition {
+  DAYS = "DAYS",
+  WEEKS = "WEEKS",
+  CALENDER_WEEKS = "CALENDER_WEEKS",
+  MONTHS = "MONTHS",
+  CALENDER_MONTHS = "CALENDER_MONTHS",
+  YEARS = "YEARS",
+  CALENDER_YEARS = "CALENDER_YEARS",
+  HOURS = "HOURS",
+  MINUTES = "MINUTES",
+  CALENDER_QUARTERS = "CALENDER_QUARTERS",
+  FISCAL_QUARTER = "FISCAL_QUARTER",
+  FISCAL_YEAR = "FISCAL_YEAR",
+  QUARTERS = "QUARTERS",
+}
+declare const negativeCharacterOperators: RangeOperator[];
+declare const startsWithCharacterOperators: RangeOperator[];
+declare const containsCharacterOperators: RangeOperator[];
+declare enum EFilterDataType {
+  BOOLEAN = "boolean",
+  DATE = "date",
+  NUMBER = "number",
+  STRING = "string",
+}
+declare class SuperFilterBuilder {
+  private superFilter;
+  private databaseDetails;
+  private skipCountForRankingFilter;
+  private joinClauses;
+  private manualFilterOptions;
+  private lastRankingFilter;
+  constructor(superFilter: ISuperFilterConfig, databaseDetails: any, skipCountForRankingFilter?: boolean, joinClauses?: JoinExpressions, manualFilterOptions?: IManualFilterConfig[]);
+  /**
+   * Entry point: build SQL condition string
+   */
+  build(): string;
+  /**
+   * Recursively process group and children
+   * - skips all ranking filters during this pass
+   * - preserves order of all other filters
+   */
+  private processGroup;
+  /**
+   * Find the last ranking filter in the whole superFilter (depth-first, left-to-right traversal)
+   */
+  private findLastRankingFilter;
+  /**
+   * Decide which filter type to handle
+   */
+  private processFilter;
+  /**
+   * Handle VALUES filter => column IN/NOT IN (...)
+   */
+  private processValuesFilter;
+  /**
+   * Handle RANGE filter => column op value AND/OR column op value
+   */
+  private processRangeFilter;
+  /**
+   * Handle RANKING filter (top/bottom/both)
+   */
+  private processRankingFilter;
+  /**
+   * Resolve column name (table.column or column only)
+   */
+  private getColumnName;
+  /**
+   * Get filter data type
+   */
+  private getFilterDataType;
+  /**
+   * Format value depending on datatype/db
+   */
+  private formatValue;
+  /**
+   * Format relative character filter
+   */
+  private formatRelativeCharacterFilter;
+  /**
+   * Process search filter
+   */
+  processSearchFilter(filter: IGroupFilter, isSearch?: boolean): string;
+  private getManualFilterMatch;
+  private getOperatorFlags;
+}
+//#endregion
+//#region src/filters/filter-types.d.ts
+type LogicalCombinator = 'and' | 'or';
+type Rule = {
+  operator: string;
+  value: string | number | boolean | (string | number)[];
+  column: string;
+  isCategoryFilter?: boolean;
+  topNDataTarget?: string;
+};
+type RuleGroup = {
+  rules: Array<Rule>;
+  combinator: LogicalCombinator;
+};
+type FilterConfig = {
+  rules: Array<Rule | RuleGroup>;
+  combinator: LogicalCombinator;
+  not: boolean;
+};
+type FilterType = 'VALUES' | 'RANGE' | 'DATE' | 'RANKING';
+interface IValueFilter {
+  id: string[];
+  label: string[];
+}
+interface IRangeFilter {
+  from?: string;
+  to?: string;
+  logicalOperator?: 'AND' | 'OR';
+  fromCondition?: string;
+  toCondition?: string;
+}
+interface IRankingFilter {
+  type: 'TOP' | 'BOTTOM' | 'BOTH';
+  rankByColumnId: string;
+  rankByColumnName: string;
+  rankByColumnType: string;
+  rankByTableName: string;
+  rankByAggregationType: string;
+  value: number;
+  isPercentage: boolean;
+}
+type IDateTimeFilter = {
+  relativeDateFilter?: EDateRangeRelativeFilterCondition;
+  period?: EDateRangeRelativePeriodFilterCondition;
+  duration?: number;
+  includeToday?: boolean;
+  fiscalYearStartMonth?: number;
+};
+interface IGroupFilter {
+  columnIds: string[];
+  tableNames: string[];
+  columnNames: string[];
+  dataType: string[];
+  filterType: FilterType;
+  sourceType?: string[];
+  columnType?: string[];
+  columnDataType?: string[];
+  valuesFilterApplicationType?: 'exclude' | 'include';
+  valuesFilter?: IValueFilter[];
+  logicalOperator?: 'AND' | 'OR';
+  aggregationType?: string[];
+  rangeFilter?: IRangeFilter[];
+  dateTimeFilter?: IDateTimeFilter;
+  rankingFilter?: IRankingFilter[];
+  searchConfig?: {
+    matchCase: boolean;
+    searchString: string;
+  };
+}
+interface ISuperFilterConfig {
+  groupId: string;
+  groupLabel: string;
+  condition: 'AND' | 'OR';
+  children: ({
+    filters: IGroupFilter;
+  } | ISuperFilterConfig)[];
+}
+type RelationshipMapping = {
+  joinType: string;
+  id: string;
+  schema: string;
+  table: string;
+  joinId: string;
+  label: string;
+  alias: string;
+};
+type JoinExpressions = {
+  alias: string;
+  joinRelation: RelationshipMapping[];
+};
+type RangeOperator = 'IS' | 'IS_NOT' | 'IS_BLANK' | 'IS_NOT_BLANK' | 'IS_AFTER' | 'IS_BEFORE' | 'IS_ON_OR_AFTER' | 'IS_ON_OR_BEFORE' | 'IS_LESS_THAN' | 'IS_LESS_THAN_OR_EQUAL_TO' | 'IS_GREATER_THAN' | 'IS_GREATER_THAN_OR_EQUAL_TO' | 'CONTAINS' | 'DOES_NOT_CONTAIN' | 'STARTS_WITH' | 'DOES_NOT_START_WITH';
+interface IManualFilterOption {
+  displayName?: string;
+  value: string | number | boolean;
+  id: string;
+}
+interface IManualFilterConfig {
+  column: string;
+  options: IManualFilterOption[];
+}
+//#endregion
+//#region src/query-builder/PaginationBuilder.d.ts
+interface PaginationBuilder {
+  generateQuery(offset: number, limit: number): string;
+}
+//#endregion
+//#region src/query-builder/QueryBuilder.d.ts
+type SortConfig = {
+  column: string;
+  order: 'ASC' | 'DESC';
+}[];
+type PaginationConfig = {
+  skip: number;
+  take: number;
+};
+type FilterResolverParams = {
+  filterConfig: FilterConfig;
+  schema?: IColumnSchemaItem[];
+};
+interface QueryResolver {
+  filterResolver(params: FilterResolverParams): string;
+}
+type RuntimeVariables = {
+  $RUNTIME_LOGGEDIN_NAME: string;
+  $RUNTIME_LOGGEDIN_EMAIL: string;
+  $RUNTIME_CURRENT_DATE?: string;
+  $RUNTIME_CURRENT_DATETIME?: string;
+};
+type QueryBuilderOptions = {
+  selectedColumns: string[];
+  databaseDetails: Record<string, any>;
+  primaryKeyColumns: string[];
+  filterConfig?: FilterConfig;
+  pagination?: PaginationConfig;
+  sortConfig?: SortConfig;
+  searchExpression?: string;
+  distinct?: boolean;
+  columnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta>;
+  queryResolver: QueryResolver;
+  runtimeVariables: RuntimeVariables;
+  schema?: IColumnSchemaItem[];
+  includeFinalCTESelectQuery?: boolean;
+  finalResponseAsObject?: boolean;
+  superFilters?: ISuperFilterConfig;
+  skipCountForRankingFilter?: boolean;
+  joinClauses?: JoinExpressions;
+  manualFilterOptions?: IManualFilterConfig[];
+  enableLastSelectCTEWrap?: boolean;
+};
+type BuildOptions = Partial<Omit<QueryBuilderOptions, 'tableName' | 'queryResolver' | 'schema'>>;
+type FinalQueryResult = {
+  finalQuery: string;
+  finalCteName?: string;
+};
+type CalculationOrderResult = {
+  nativeColumns: Set<string>;
+  formulaColumnsByDependencyLevel: IMDMColumnConfigWithParsedMeta[][];
+};
+declare enum DEFAULT_VALUE_TYPE {
+  MANUAL = "MANUAL",
+  DERIVED = "DERIVED",
+  NONE = "NONE",
+}
+type IColumnSchemaItem = {
+  name: string;
+  type: string;
+  defaultValue?: string | number;
+  isNullable?: boolean;
+  isIdentity?: boolean;
+};
+declare const MAX_STRING_TYPE = "nvarchar(max)";
+/**
+ * Steps:
+ * 1. Separate out filters for native columns and formula columns
+ * 2. Apply filters for native columns in the main CTE. If Native columns have sorting config then -
+ *      - If SortConfig exists for Formula columns with cte, do not apply sorting
+ *      - If SortConfig exists for Formula columns without cte, apply sorting
+ *      - If SortConfig does not exist for Formula columns, apply sorting
+ * 3. Apply filters for formula columns in the CTE followed by the column specific CTEs due to alias not supported in where clause
+ * 4. Apply SortConfig and pagination in the CTE with last filter
+ * 5. Perform final projection and apply SortConfig and Pagination, if still exists
+ */
+declare class QueryBuilder {
+  private readonly paginationBuilder;
+  private readonly options;
+  constructor(options: QueryBuilderOptions);
+  build(options?: BuildOptions): FinalQueryResult;
+  buildCountQuery(options?: BuildOptions): FinalQueryResult;
+}
+/**
+ * Implementation class for QueryBuilder
+ *
+ * @private exposed for testing
+ */
+declare class QueryBuilderImpl {
+  private readonly paginationBuilder;
+  private readonly options;
+  private buildState;
+  private readonly entityNameFormatter;
+  constructor(options: QueryBuilderOptions, paginationBuilder: PaginationBuilder);
+  build(isCountQuery?: boolean): FinalQueryResult;
+  /**
+   * Returns the sort config with only the columns that are part of the requested columns
+   */
+  private getRelevantSortConfig;
+  /**
+   * Adds columns used in the filter config to the set of all columns
+   */
+  private addColumnsFromFilterConfig;
+  private retrieveColumnExprsInFront;
+  private buildMainCTE;
+  /**
+   * Returns the filter expression for the selected columns. If column type is formula,
+   * stores the rules in pending filter config and process it in the next call to getFilterExpression
+   * else processes immediately.
+   *
+   *  Note - Pass empty set to process any pending filter config
+   */
+  private getFilterExpression;
+  /**
+   * Returns the sort expression if each column in the sort config is part of selected columns
+   */
+  private getSortExpression;
+  /**
+   * Returns the pagination expression if the pagination config is set and sort is not pending.
+   * It must be called after getSortExpression.
+   */
+  private getPaginationExpression;
+  /**
+   * Builds the intermediate CTEs for the formula columns
+   * 1. Replace table name with previous cte name
+   * 2. Apply filter condition
+   * 3. Apply sort expression, if applicable
+   * 4. Apply pagination, if applicable
+   * 5. Return CTEs/Column expressions
+   */
+  private buildIntermediateCTE;
+  private addStagingCTE;
+  private buildFinalProjection;
+  private applyDistinctExpressionToMainCTE;
+  private applyCountExpressionToMainCTE;
+  private getDistinctCountCte;
+  private buildSqlQueryParts;
+  /**
+   * Returns the calculation order for the given columns
+   * @private exposed for testing
+   */
+  getCalculationOrder(columns: Set<string>): CalculationOrderResult;
+  private dfs;
+  /**
+   * Applies the join positions from the query builder to the given Select AST.
+   * The join positions are added to the FROM list of the AST.
+   *
+   * @param {Select} ast - The Select AST to apply the join positions to.
+   * @returns {string[]} - An empty array, for consistency with other methods.
+   */
+  private applyJoinExpressionToMainCTE;
+  /**
+   * Gets the super filter expression.
+   * If super filters are present and the pending filter config is not empty,
+   * it will process the super filter condition and return the result.
+   * If the super filter expression is empty, it will return an empty string.
+   * @returns {string} - The super filter expression.
+   */
+  private getSuperFilterExpression;
+  private buildFinalQueryComponents;
+  private filterRequiredColumns;
+}
+//#endregion
+//#region src/js-lib/db/base/VisitorInterface.d.ts
+type Node = acorn.Node;
+interface VisitorInterface<T extends Node> {
+  visitor: (node: T, context: ParseContext) => void;
+}
+//#endregion
+//#region src/js-lib/JsToSqlParser.d.ts
+type ResolvedFormulaProps = {
+  returnType: string | undefined;
+  isValid: boolean;
+  error: string | undefined;
+  sqlQueryProps: SqlQueryProps;
+  deps: string[];
+};
+/**
+ * Factory function to create database specific parser
+ */
+declare function createJsToSqlParser(context: ParseContext): JsToSqlParser;
+type VisitorConfig = {
+  callExpression?: VisitorInterface<acorn.CallExpression>;
+  identifier?: VisitorInterface<acorn.Identifier>;
+  literal?: VisitorInterface<acorn.Literal>;
+  binaryExpression?: VisitorInterface<acorn.BinaryExpression>;
+  arrayExpression?: VisitorInterface<acorn.ArrayExpression>;
+  unaryExpression?: VisitorInterface<acorn.UnaryExpression>;
+  program?: VisitorInterface<acorn.Program>;
+  memberExpression?: VisitorInterface<acorn.MemberExpression>;
+  assignmentExpression?: VisitorInterface<acorn.AssignmentExpression>;
+};
+/**
+ * Parses a JavaScript formula and returns the corresponding SQL AST.
+ * - For Database specific overrides, implement the corresponding visitor in `db` directory and
+ *   pass it to the constructor as part of the `config` parameter.
+ * - Use Factory function to compose parser for specific database
+ */
+declare class JsToSqlParser {
+  private context;
+  private callExpression;
+  private identifier;
+  private literal;
+  private binaryExpression;
+  private arrayExpression;
+  private unaryExpression;
+  private program;
+  private memberExpression;
+  private assignmentExpression;
+  constructor(context: ParseContext, config?: VisitorConfig);
+  parse(formula: string): any;
+  /**
+   * Converts the SQL AST to a SQL query string
+   */
+  toSql(sqlAst: any): string;
+  /**
+   * Creates appropriate SQL query props based on the SQL AST
+   */
+  toSqlProps(sqlAst: any): SqlQueryProps;
+  /**
+   * Returns the resolved formula props for current column along with the dependencies
+   */
+  getResolvedFormulaProps(sqlAst: any): ResolvedFormulaProps;
+  /**
+   * Pre walk and detect if the jsAst has 'if'
+   */
+  private detectIfCondition;
+  /**
+   *  Extracts and normalizes formula by adding parentheses to reserved function names
+   */
+  private processFormulaText;
+  private removeForeach;
+}
+//#endregion
+//#region src/sql-types.d.ts
+interface OrderBy {
+  type: 'ASC' | 'DESC';
+  expr: any;
+  loc?: LocationRange;
+}
+type RawSqlExpression = {
+  type: 'sql_expr';
+  value: string;
+  meta?: Record<string, any>;
+};
+interface ValueExpr<T = string | number | boolean> {
+  type: 'backticks_quote_string' | 'string' | 'regex_string' | 'hex_string' | 'full_hex_string' | 'natural_string' | 'bit_string' | 'double_quote_string' | 'single_quote_string' | 'boolean' | 'bool' | 'null' | 'star' | 'param' | 'origin' | 'date' | 'datetime' | 'default' | 'time' | 'timestamp' | 'var_string';
+  value: T;
+}
+interface ColumnRefItem {
+  type: 'column_ref';
+  table: string | null;
+  column: string | {
+    expr: ValueExpr;
+  };
+  options?: ExprList;
+  loc?: LocationRange;
+  collate?: {
+    collate: CollateExpr;
+  };
+}
+interface ColumnRefExpr {
+  type: 'expr';
+  expr: ColumnRefItem;
+  as: string | null;
+}
+type ColumnRef = ColumnRefItem | ColumnRefExpr;
+interface Case {
+  type: 'case';
+  expr: null;
+  args: Array<{
+    cond: Binary;
+    result: ExpressionValue;
+    type: 'when';
+  } | {
+    result: ExpressionValue;
+    type: 'else';
+  }>;
+}
+interface Cast {
+  type: 'cast';
+  keyword: 'cast';
+  expr: ExpressionValue;
+  symbol: 'as';
+  target: {
+    dataType: string;
+    suffix: unknown[];
+  };
+}
+interface AggrFunc {
+  type: 'aggr_func';
+  name: string;
+  args: {
+    expr: ExpressionValue;
+    distinct: 'DISTINCT' | null;
+    orderby: OrderBy[] | null;
+    parentheses?: boolean;
+  };
+  loc?: LocationRange;
+}
+type FunctionName = {
+  schema?: {
+    value: string;
+    type: string;
+  };
+  name: ValueExpr<string>[];
+};
+interface SqlFunction {
+  type: 'function';
+  name: FunctionName;
+  args?: ExprList;
+  suffix?: any;
+  loc?: LocationRange;
+}
+interface Column {
+  type: 'column';
+  expr: ExpressionValue;
+  as: ValueExpr<string> | string | null;
+  type?: string;
+  loc?: LocationRange;
+}
+interface Interval {
+  type: 'interval';
+  unit: string;
+  expr: ValueExpr & {
+    loc?: LocationRange;
+  };
+}
+type Param = {
+  type: 'param';
+  value: string;
+  loc?: LocationRange;
+};
+type Value = {
+  type: string;
+  value: any;
+  loc?: LocationRange;
+};
+type Binary = {
+  type: 'binary_expr';
+  operator: string;
+  left: ExpressionValue | ExprList;
+  right: ExpressionValue | ExprList;
+  loc?: LocationRange;
+  parentheses?: boolean;
+};
+type UnaryExpression = {
+  type: 'unary_expr';
+  operator: string;
+  expr: ExpressionValue;
+};
+type ExpressionValue = ColumnRef | Column | Param | SqlFunction | Case | AggrFunc | Value | UnaryExpression | Binary | Cast | Interval | RawSqlExpression;
+type ExprList = {
+  type: 'expr_list';
+  value: ExpressionValue[];
+  loc?: LocationRange;
+  parentheses?: boolean;
+  separator?: string;
+};
+type CollateExpr = {
+  type: 'collate';
+  symbol?: '=';
+  value: string;
+};
+//#endregion
+//#region src/constants.d.ts
+declare enum EDataType {
+  STRING = "string",
+  NUMBER = "number",
+  DATE = "date",
+  BOOLEAN = "boolean",
+  NULL = "null",
+}
+type NullableValueType = EDataType | null;
+//#endregion
+//#region src/utils.d.ts
+declare function formatDBEntityName(name: string): string;
+declare function getEntityNameFormatter(): (name: string, type?: string) => string;
+declare function resolveRuntimeVariables(expr: string, runtimeVariables: RuntimeVariables): string;
+declare function getDeprecatedFormulaId(columnName: string): string;
+declare function getFormulaId(columnName: string): string;
+declare function getDeprecatedFormulaIdColumnMap(columnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta>): Record<string, string>;
+declare function getFormulaIdColumnMap(columnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta>): Record<string, string>;
+declare function getFormattedTableName(databaseDetails: Record<string, any>): string;
+declare function getCurrentDate(): string;
+declare function getCurrentDateTime(): string;
+/**
+ * Gets the join expressions from the join config
+ * @returns An array of join expressions in SQL format
+ */
+declare function getJoinExpressions(joinClauses: JoinExpressions, databaseDetails: Record<string, string>): string[];
+/**
+ * Strips the 'WHERE' clause from the SQL query.
+ *  - If where clause is not present, returns the original query.
+ *  - If where clause is present, returns the part of the query after the 'WHERE' clause.
+ */
+declare function stripWhereClause(sqlQuery: string): string;
+/**
+ * Extracts the target type of a CAST expression from a given Binary expression.
+ * The target type is the right-hand side of the AS operator, e.g. 'INT' in 'CAST(x AS INT)'.
+ * If the given expression does not represent a CAST expression, returns null.
+ * @param {Binary} arg - The Binary expression to extract the target type from.
+ * @returns {string | null} - The target type of the CAST expression, or null if it is not a CAST expression.
+ */
+declare function extractCastTargetType(arg: Binary): string | null;
+/**
+ * Maps a SQL cast type  to a Fabric data type
+ * @param {string} type - The SQL cast type to map.
+ * @returns {NullableValueType} - The corresponding Fabric data type.
+ */
+declare function mapSqlTypeToDataType(type: string): NullableValueType;
+declare function isValidDate(value: string): boolean;
+declare function getArgType(arg: ExpressionValue, context: ParseContext): NullableValueType;
+//#endregion
+//#region src/epm-query-builder/types/query-builder-types.d.ts
+interface Relationship {
+  fromTable: string;
+  fromColumn: string;
+  toTable: string;
+  toColumn: string;
+  isActive?: boolean;
+  crossFilterDirection?: 'SINGLE' | 'BOTH' | null;
+  fromColumnMultiplicity: '*' | '0..1';
+  toColumnMultiplicity: '*' | '0..1';
+}
+interface EpmQueryBuilderOptions {
+  config: {
+    source: string;
+  };
+  selectedColumns?: string[];
+  databaseDetails: Record<string, unknown>;
+  primaryKeyColumns?: string[];
+  pagination?: PaginationConfig$1;
+  searchExpression?: string;
+  distinct?: boolean;
+  superFilters?: SuperFilterConfig;
+  rows: RowColumnConfig[];
+  columns: RowColumnConfig[];
+  values: MeasureConfig[];
+  orderBy: OrderByConfig[];
+  skipRollup?: boolean;
+  isCrossHighlightEnabled?: boolean;
+  measureFilters?: MeasureFilterConfig[];
+  dimensionIdMappings?: Record<string, DimensionIdMapping[]>;
+  customMeasures?: string[];
+  staticFormatStrings?: Record<string, string>;
+  isRankingFilterIncluded?: boolean;
+  relationships?: Relationship[];
+}
+interface RowColumnConfig {
+  id: string;
+  label: string;
+  type: string;
+  columnName: string;
+  tableName?: string;
+  aggregationType?: string;
+  dataType?: string;
+  orderByRef?: string;
+  formatString?: string;
+  expansionConfig?: ExpansionConfig;
+}
+interface MeasureConfig {
+  id: string;
+  label: string;
+  columnName: string;
+  tableName: string;
+  type: string;
+  aggregationType?: string;
+  dataType?: string;
+  formatString?: string;
+  isGetRangeEnabled?: boolean;
+}
+interface OrderByConfig {
+  id: string;
+  columnName: string;
+  tableName?: string;
+  type: 'ASC' | 'DESC';
+  aggregationType?: string;
+  isColumnPresentInOutput?: boolean;
+}
+interface RangeFilter {
+  operator?: string;
+  value?: string | number;
+  from?: string | number;
+  fromCondition?: string;
+  to?: string | number;
+  toCondition?: string;
+  logicalOperator?: string;
+}
+interface DateRangeFilter {
+  startDate: string;
+  endDate: string;
+  operator?: string;
+}
+interface SearchCondition {
+  operator: string;
+  value: string;
+  logicalOperator?: string;
+}
+interface RankingConfig {
+  type: RankingFilterType;
+  rankByColumnId: string;
+  rankByAggregationType: AggregationType;
+  rankByColumnName?: string;
+  rankByTableName?: string;
+  rankByColumnType?: string;
+  value: number;
+  isPercentage?: boolean;
+  operator?: string;
+  measureId?: string;
+}
+interface FilterConfig$1 {
+  filterType: string;
+  columnIds: string[];
+  columnNames: string[];
+  tableNames: string[];
+  columnDataType?: string[];
+  sourceType?: string[];
+  dataType?: string[];
+  valuesFilterApplicationType?: ValuesFilterApplicationType;
+  valuesFilter?: {
+    id: string | string[];
+    label: string | string[];
+  }[];
+  isCrossHighlight?: boolean;
+  rangeFilter?: RangeFilter[];
+  dateRangeFilter?: DateRangeFilter[];
+  relativePeriodFilter?: RelativePeriodFilterConfig;
+  aggregationType?: string[];
+  columnType?: string[];
+  logicalOperator?: string;
+  isTupleFilter?: boolean;
+  searchConditions?: SearchCondition[];
+  isRankingFilter?: boolean;
+  rankingConfig?: RankingConfig;
+  rankingFilter?: RankingConfig[];
+  blankFilterConfig?: BlankFilterConfig;
+  dateHierarchyConfig?: DateHierarchyConfig;
+  compositeColumnConfig?: CompositeColumnConfig;
+  fieldParameterMapping?: FieldParameterMapping;
+  distinctRowsCount?: number;
+  isRelativePeriodFilter?: boolean;
+  isDateHierarchyFilter?: boolean;
+  isFieldParameterFilter?: boolean;
+  isCompositeFilter?: boolean;
+}
+interface SuperFilterChild {
+  filters?: FilterConfig$1;
+  isGroup?: boolean;
+  isFilter?: boolean;
+  groupId?: string;
+  groupLabel?: string;
+  condition?: string;
+  children?: SuperFilterChild[];
+}
+interface SuperFilterConfig {
+  groupId: string;
+  groupLabel: string;
+  condition: string;
+  children: SuperFilterChild[];
+}
+interface MeasureFilterConfig {
+  id: string;
+  tableName: string;
+  columnName: string;
+  aggregationType?: string;
+  dataType: string;
+  operator: string;
+  value: string | number;
+  logicalOperator?: string;
+}
+interface PaginationConfig$1 {
+  limit?: number;
+  skip?: number;
+  take?: number;
+  reference?: PaginationReference;
+}
+interface PaginationReference {
+  dimensions?: string[];
+  instances?: string[];
+  command?: PaginationCommand;
+  nextToken?: string[];
+}
+interface ExpansionConfig {
+  expansionType: string;
+  items?: string[];
+  start?: string;
+  end?: string;
+  step?: number;
+  interval?: string;
+  hierarchies?: string[];
+  hierarchyTable?: string[][];
+}
+type AggregationType = 'SUM' | 'COUNT' | 'COUNT_DISTINCT' | 'DISTINCT_COUNT' | 'AVG' | 'MIN' | 'MAX' | 'FIRST' | 'LAST' | 'STANDARD_DEVIATION' | 'VARIANCE' | 'MEDIAN' | 'MODE' | 'CONCATENATED' | 'CONCATENATED_IDS';
+type RankingFilterType = 'TOP' | 'BOTTOM' | 'BOTH';
+type ValuesFilterApplicationType = 'INCLUDE' | 'EXCLUDE';
+type PaginationCommand = 'NEXT_HEIR' | 'SIBLING' | 'CHILDREN';
+type RelativePeriodFilter = 'DAYS' | 'WEEKS' | 'MONTHS' | 'YEARS' | 'CALENDER_WEEKS' | 'CALENDER_MONTHS' | 'CALENDER_YEARS' | 'CALENDER_QUARTERS' | 'FISCAL_YEAR' | 'FISCAL_QUARTER' | 'HOURS' | 'MINUTES';
+type DateRelativeFilter = 'IS_IN_THE_LAST' | 'IS_IN_THE_NEXT' | 'IS_IN_THIS' | 'IS_BEFORE' | 'IS_AFTER';
+interface DimensionIdMapping {
+  sourceField: string;
+  targetTable: string;
+  targetField: string;
+}
+interface FieldParameterMapping {
+  sourceField: string;
+  targetTable: string;
+  targetField: string;
+  filterValues?: string[];
+}
+interface RelativePeriodFilterConfig {
+  duration: number;
+  period: RelativePeriodFilter;
+  relativeDateFilter: DateRelativeFilter;
+  includeToday?: boolean;
+  fiscalYearStartMonth?: number;
+}
+interface DateHierarchyConfig {
+  level: 'YEAR' | 'QUARTER' | 'MONTH' | 'DAY' | 'WEEK' | 'DAYOFWEEK';
+  values: number[];
+  format?: string;
+  fiscalYearStartMonth?: number;
+}
+interface BlankFilterConfig {
+  operator: 'IS_BLANK' | 'IS_NOT_BLANK';
+  treatEmptyStringAsBlank?: boolean;
+}
+interface CompositeColumnConfig {
+  columnIds: string[];
+  operator: 'CONCATENATE' | 'COMBINE';
+  separator?: string;
+}
+//#endregion
+//#region src/epm-query-builder/EpmQueryBuilder.d.ts
+declare class EpmQueryBuilder {
+  private readonly impl;
+  constructor(options: EpmQueryBuilderOptions);
+  build(): string;
+}
+//#endregion
+export { ColumnExpression, ColumnMeta, CteExpression, DEFAULT_VALUE_TYPE, EDateRangeRelativeFilterCondition, EDateRangeRelativePeriodFilterCondition, EFilterDataType, EpmQueryBuilder, type EpmQueryBuilderOptions, FilterConfig, FilterResolverParams, FilterType, FinalQueryResult, IDateTimeFilter, IGroupFilter, IMDMColumnConfigWithParsedMeta, IManualFilterConfig, IManualFilterOption, IRangeFilter, IRankingFilter, ISuperFilterConfig, IValueFilter, JoinExpressions, JsToSqlParser, LogicalCombinator, MAX_STRING_TYPE, MDM_COLUMN_TYPE, PaginationConfig, ParseContext, ParseContextProps, QueryBuilder, QueryBuilderImpl, QueryBuilderOptions, QueryResolver, RangeOperator, RelationshipMapping, ResolvedExpressionType, ResolvedFormulaProps, Rule, RuleGroup, RuntimeVariables, SortConfig, SqlQueryProps, SuperFilterBuilder, TColumnConfigMap, VisitorConfig, containsCharacterOperators, createJsToSqlParser, extractCastTargetType, formatDBEntityName, getArgType, getCurrentDate, getCurrentDateTime, getDeprecatedFormulaId, getDeprecatedFormulaIdColumnMap, getEntityNameFormatter, getFormattedTableName, getFormulaId, getFormulaIdColumnMap, getJoinExpressions, isValidDate, mapSqlTypeToDataType, negativeCharacterOperators, resolveRuntimeVariables, startsWithCharacterOperators, stripWhereClause };
+//# sourceMappingURL=index.d.ts.map