@devrev/meerkat-core 0.0.77

package/src/types/duckdb-serialization-types/serialization/Types.d.ts

@@ -0,0 +1,53 @@
+import { LogicalType } from './Nodes';
+export declare enum ExtraTypeInfoType {
+    INVALID_TYPE_INFO = "INVALID_TYPE_INFO",
+    GENERIC_TYPE_INFO = "GENERIC_TYPE_INFO",
+    DECIMAL_TYPE_INFO = "DECIMAL_TYPE_INFO",
+    STRING_TYPE_INFO = "STRING_TYPE_INFO",
+    LIST_TYPE_INFO = "LIST_TYPE_INFO",
+    STRUCT_TYPE_INFO = "STRUCT_TYPE_INFO",
+    ENUM_TYPE_INFO = "ENUM_TYPE_INFO",
+    USER_TYPE_INFO = "USER_TYPE_INFO",
+    AGGREGATE_STATE_TYPE_INFO = "AGGREGATE_STATE_TYPE_INFO"
+}
+export interface BaseExtraTypeInfo {
+    type: ExtraTypeInfoType;
+    alias: string;
+}
+export type ExtraTypeInfo = DecimalTypeInfo | StringTypeInfo | ListTypeInfo | StructTypeInfo | AggregateStateTypeInfo | UserTypeInfo | EnumTypeInfo | InvalidTypeInfo | GenericTypeInfo;
+export interface DecimalTypeInfo extends BaseExtraTypeInfo {
+    enum: 'DECIMAL_TYPE_INFO';
+    width: number;
+    scale: number;
+}
+export interface StringTypeInfo extends BaseExtraTypeInfo {
+    enum: 'STRING_TYPE_INFO';
+    collation: string;
+}
+export interface ListTypeInfo extends BaseExtraTypeInfo {
+    enum: 'LIST_TYPE_INFO';
+    child_type: LogicalType;
+}
+export interface StructTypeInfo extends BaseExtraTypeInfo {
+    enum: 'STRUCT_TYPE_INFO';
+    child_types: LogicalType[];
+}
+export interface AggregateStateTypeInfo extends BaseExtraTypeInfo {
+    enum: 'AGGREGATE_STATE_TYPE_INFO';
+    function_name: string;
+    return_type: LogicalType;
+    bound_argument_types: LogicalType[];
+}
+export interface UserTypeInfo extends BaseExtraTypeInfo {
+    enum: 'USER_TYPE_INFO';
+    user_type_name: string;
+}
+export interface EnumTypeInfo extends BaseExtraTypeInfo {
+    enum: 'ENUM_TYPE_INFO';
+}
+export interface InvalidTypeInfo extends BaseExtraTypeInfo {
+    enum: 'INVALID_TYPE_INFO';
+}
+export interface GenericTypeInfo extends BaseExtraTypeInfo {
+    enum: 'GENERIC_TYPE_INFO';
+}

package/src/types/duckdb-serialization-types/serialization/Types.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "ExtraTypeInfoType", {
+    enumerable: true,
+    get: function() {
+        return ExtraTypeInfoType;
+    }
+});
+var ExtraTypeInfoType;
+(function(ExtraTypeInfoType) {
+    ExtraTypeInfoType["INVALID_TYPE_INFO"] = "INVALID_TYPE_INFO";
+    ExtraTypeInfoType["GENERIC_TYPE_INFO"] = "GENERIC_TYPE_INFO";
+    ExtraTypeInfoType["DECIMAL_TYPE_INFO"] = "DECIMAL_TYPE_INFO";
+    ExtraTypeInfoType["STRING_TYPE_INFO"] = "STRING_TYPE_INFO";
+    ExtraTypeInfoType["LIST_TYPE_INFO"] = "LIST_TYPE_INFO";
+    ExtraTypeInfoType["STRUCT_TYPE_INFO"] = "STRUCT_TYPE_INFO";
+    ExtraTypeInfoType["ENUM_TYPE_INFO"] = "ENUM_TYPE_INFO";
+    ExtraTypeInfoType["USER_TYPE_INFO"] = "USER_TYPE_INFO";
+    ExtraTypeInfoType["AGGREGATE_STATE_TYPE_INFO"] = "AGGREGATE_STATE_TYPE_INFO";
+})(ExtraTypeInfoType || (ExtraTypeInfoType = {}));
+
+//# sourceMappingURL=Types.js.map

package/src/types/duckdb-serialization-types/serialization/Types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Types.ts"],"sourcesContent":["import { LogicalType } from './Nodes';\n\nexport enum ExtraTypeInfoType {\n  INVALID_TYPE_INFO = 'INVALID_TYPE_INFO',\n  GENERIC_TYPE_INFO = 'GENERIC_TYPE_INFO',\n  DECIMAL_TYPE_INFO = 'DECIMAL_TYPE_INFO',\n  STRING_TYPE_INFO = 'STRING_TYPE_INFO',\n  LIST_TYPE_INFO = 'LIST_TYPE_INFO',\n  STRUCT_TYPE_INFO = 'STRUCT_TYPE_INFO',\n  ENUM_TYPE_INFO = 'ENUM_TYPE_INFO',\n  USER_TYPE_INFO = 'USER_TYPE_INFO',\n  AGGREGATE_STATE_TYPE_INFO = 'AGGREGATE_STATE_TYPE_INFO',\n}\n\nexport interface BaseExtraTypeInfo {\n  type: ExtraTypeInfoType;\n  alias: string;\n}\n\nexport type ExtraTypeInfo =\n  | DecimalTypeInfo\n  | StringTypeInfo\n  | ListTypeInfo\n  | StructTypeInfo\n  | AggregateStateTypeInfo\n  | UserTypeInfo\n  | EnumTypeInfo\n  | InvalidTypeInfo\n  | GenericTypeInfo;\n\nexport interface DecimalTypeInfo extends BaseExtraTypeInfo {\n  enum: 'DECIMAL_TYPE_INFO';\n  width: number;\n  scale: number;\n}\n\nexport interface StringTypeInfo extends BaseExtraTypeInfo {\n  enum: 'STRING_TYPE_INFO';\n  collation: string;\n}\n\nexport interface ListTypeInfo extends BaseExtraTypeInfo {\n  enum: 'LIST_TYPE_INFO';\n  child_type: LogicalType;\n}\n\nexport interface StructTypeInfo extends BaseExtraTypeInfo {\n  enum: 'STRUCT_TYPE_INFO';\n  child_types: LogicalType[];\n}\n\nexport interface AggregateStateTypeInfo extends BaseExtraTypeInfo {\n  enum: 'AGGREGATE_STATE_TYPE_INFO';\n  function_name: string;\n  return_type: LogicalType;\n  bound_argument_types: LogicalType[];\n}\n\nexport interface UserTypeInfo extends BaseExtraTypeInfo {\n  enum: 'USER_TYPE_INFO';\n  user_type_name: string;\n}\n\nexport interface EnumTypeInfo extends BaseExtraTypeInfo {\n  enum: 'ENUM_TYPE_INFO';\n  // custom_implementation: true; // Not sure how this translates to TypeScript\n}\n\nexport interface InvalidTypeInfo extends BaseExtraTypeInfo {\n  enum: 'INVALID_TYPE_INFO';\n  // custom_switch_code: 'return nullptr;'; // Not sure how this translates to TypeScript\n}\n\nexport interface GenericTypeInfo extends BaseExtraTypeInfo {\n  enum: 'GENERIC_TYPE_INFO';\n  // custom_switch_code: 'result = make_shared<ExtraTypeInfo>(type);\\nbreak;'; // Not sure how this translates to TypeScript\n}\n"],"names":["ExtraTypeInfoType","INVALID_TYPE_INFO","GENERIC_TYPE_INFO","DECIMAL_TYPE_INFO","STRING_TYPE_INFO","LIST_TYPE_INFO","STRUCT_TYPE_INFO","ENUM_TYPE_INFO","USER_TYPE_INFO","AGGREGATE_STATE_TYPE_INFO"],"mappings":";;;;;;;IAEO;UAAKA,iBAAiB;IAAjBA,kBACVC,uBAAAA;IADUD,kBAEVE,uBAAAA;IAFUF,kBAGVG,uBAAAA;IAHUH,kBAIVI,sBAAAA;IAJUJ,kBAKVK,oBAAAA;IALUL,kBAMVM,sBAAAA;IANUN,kBAOVO,oBAAAA;IAPUP,kBAQVQ,oBAAAA;IARUR,kBASVS,+BAAAA;GATUT,sBAAAA"}

package/src/types/duckdb-serialization-types/serialization/example.d.ts

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

package/src/types/duckdb-serialization-types/serialization/example.js

@@ -0,0 +1,131 @@
+"use strict";
+const _Expression = require("./Expression");
+const _QueryNode = require("./QueryNode");
+const _ResultModifier = require("./ResultModifier");
+const _TableRef = require("./TableRef");
+const dummy = {
+    node: {
+        type: _QueryNode.QueryNodeType.SELECT_NODE,
+        modifiers: [],
+        cte_map: {
+            map: {}
+        },
+        select_list: [
+            {
+                class: _Expression.ExpressionClass.COLUMN_REF,
+                type: _Expression.ExpressionType.COLUMN_REF,
+                alias: '',
+                column_names: [
+                    'rev_org',
+                    'id'
+                ]
+            },
+            {
+                class: _Expression.ExpressionClass.FUNCTION,
+                type: _Expression.ExpressionType.FUNCTION,
+                alias: '',
+                function_name: 'count_star',
+                schema: '',
+                children: [],
+                filter: null,
+                order_bys: {
+                    type: _ResultModifier.ResultModifierType.ORDER_MODIFIER,
+                    orders: []
+                },
+                distinct: false,
+                is_operator: false,
+                export_state: false,
+                catalog: ''
+            }
+        ],
+        from_table: {
+            type: _TableRef.TableReferenceType.JOIN,
+            alias: '',
+            sample: null,
+            left: {
+                type: _TableRef.TableReferenceType.BASE_TABLE,
+                alias: '',
+                sample: null,
+                schema_name: '',
+                table_name: 'rev_org',
+                column_name_alias: [],
+                catalog_name: ''
+            },
+            right: {
+                type: _TableRef.TableReferenceType.BASE_TABLE,
+                alias: '',
+                sample: null,
+                schema_name: '',
+                table_name: 'tickets',
+                column_name_alias: [],
+                catalog_name: ''
+            },
+            condition: {
+                class: _Expression.ExpressionClass.COMPARISON,
+                type: _Expression.ExpressionType.COMPARE_EQUAL,
+                alias: '',
+                left: {
+                    class: _Expression.ExpressionClass.COLUMN_REF,
+                    type: _Expression.ExpressionType.COLUMN_REF,
+                    alias: '',
+                    column_names: [
+                        'rev_org',
+                        'id'
+                    ]
+                },
+                right: {
+                    class: _Expression.ExpressionClass.COLUMN_REF,
+                    type: _Expression.ExpressionType.COLUMN_REF,
+                    alias: '',
+                    column_names: [
+                        'tickets',
+                        'rev_oid'
+                    ]
+                }
+            },
+            join_type: _TableRef.JoinType.INNER,
+            ref_type: _TableRef.JoinRefType.REGULAR,
+            using_columns: []
+        },
+        where_clause: {
+            class: _Expression.ExpressionClass.COMPARISON,
+            type: _Expression.ExpressionType.COMPARE_EQUAL,
+            alias: '',
+            left: {
+                class: _Expression.ExpressionClass.COLUMN_REF,
+                type: _Expression.ExpressionType.COLUMN_REF,
+                alias: '',
+                column_names: [
+                    'rev_org',
+                    'tier'
+                ]
+            },
+            right: {
+                class: _Expression.ExpressionClass.COLUMN_REF,
+                type: _Expression.ExpressionType.COLUMN_REF,
+                alias: '',
+                column_names: [
+                    'tier_1'
+                ]
+            }
+        },
+        group_expressions: [
+            {
+                class: _Expression.ExpressionClass.COLUMN_REF,
+                type: _Expression.ExpressionType.COLUMN_REF,
+                alias: '',
+                column_names: [
+                    'rev_org',
+                    'id'
+                ]
+            }
+        ],
+        group_sets: new Set(),
+        aggregate_handling: _QueryNode.AggregateHandling.STANDARD_HANDLING,
+        having: null,
+        sample: null,
+        qualify: null
+    }
+};
+
+//# sourceMappingURL=example.js.map

package/src/types/duckdb-serialization-types/serialization/example.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/example.ts"],"sourcesContent":["import { ExpressionClass, ExpressionType } from './Expression';\nimport { AggregateHandling, QueryNodeType } from './QueryNode';\nimport { ResultModifierType } from './ResultModifier';\nimport { SelectStatement } from './Statement';\nimport { JoinRefType, JoinType, TableReferenceType } from './TableRef';\n\nconst dummy: SelectStatement = {\n  node: {\n    type: QueryNodeType.SELECT_NODE,\n    modifiers: [],\n    cte_map: { map: {} },\n    select_list: [\n      {\n        class: ExpressionClass.COLUMN_REF,\n        type: ExpressionType.COLUMN_REF,\n        alias: '',\n        column_names: ['rev_org', 'id'],\n      },\n      {\n        class: ExpressionClass.FUNCTION,\n        type: ExpressionType.FUNCTION,\n        alias: '',\n        function_name: 'count_star',\n        schema: '',\n        children: [],\n        filter: null,\n        order_bys: { type: ResultModifierType.ORDER_MODIFIER, orders: [] },\n        distinct: false,\n        is_operator: false,\n        export_state: false,\n        catalog: '',\n      },\n    ],\n    from_table: {\n      type: TableReferenceType.JOIN,\n      alias: '',\n      sample: null,\n      left: {\n        type: TableReferenceType.BASE_TABLE,\n        alias: '',\n        sample: null,\n        schema_name: '',\n        table_name: 'rev_org',\n        column_name_alias: [],\n        catalog_name: '',\n      },\n      right: {\n        type: TableReferenceType.BASE_TABLE,\n        alias: '',\n        sample: null,\n        schema_name: '',\n        table_name: 'tickets',\n        column_name_alias: [],\n        catalog_name: '',\n      },\n      condition: {\n        class: ExpressionClass.COMPARISON,\n        type: ExpressionType.COMPARE_EQUAL,\n        alias: '',\n        left: {\n          class: ExpressionClass.COLUMN_REF,\n          type: ExpressionType.COLUMN_REF,\n          alias: '',\n          column_names: ['rev_org', 'id'],\n        },\n        right: {\n          class: ExpressionClass.COLUMN_REF,\n          type: ExpressionType.COLUMN_REF,\n          alias: '',\n          column_names: ['tickets', 'rev_oid'],\n        },\n      },\n      join_type: JoinType.INNER,\n      ref_type: JoinRefType.REGULAR,\n      using_columns: [],\n    },\n    where_clause: {\n      class: ExpressionClass.COMPARISON,\n      type: ExpressionType.COMPARE_EQUAL,\n      alias: '',\n      left: {\n        class: ExpressionClass.COLUMN_REF,\n        type: ExpressionType.COLUMN_REF,\n        alias: '',\n        column_names: ['rev_org', 'tier'],\n      },\n      right: {\n        class: ExpressionClass.COLUMN_REF,\n        type: ExpressionType.COLUMN_REF,\n        alias: '',\n        column_names: ['tier_1'],\n      },\n    },\n    group_expressions: [\n      {\n        class: ExpressionClass.COLUMN_REF,\n        type: ExpressionType.COLUMN_REF,\n        alias: '',\n        column_names: ['rev_org', 'id'],\n      },\n    ],\n    group_sets: new Set(),\n    aggregate_handling: AggregateHandling.STANDARD_HANDLING,\n    having: null,\n    sample: null,\n    qualify: null,\n  },\n};\n"],"names":["dummy","node","type","QueryNodeType","SELECT_NODE","modifiers","cte_map","map","select_list","class","ExpressionClass","COLUMN_REF","ExpressionType","alias","column_names","FUNCTION","function_name","schema","children","filter","order_bys","ResultModifierType","ORDER_MODIFIER","orders","distinct","is_operator","export_state","catalog","from_table","TableReferenceType","JOIN","sample","left","BASE_TABLE","schema_name","table_name","column_name_alias","catalog_name","right","condition","COMPARISON","COMPARE_EQUAL","join_type","JoinType","INNER","ref_type","JoinRefType","REGULAR","using_columns","where_clause","group_expressions","group_sets","Set","aggregate_handling","AggregateHandling","STANDARD_HANDLING","having","qualify"],"mappings":";4BAAgD;2BACC;gCACd;0BAEuB;AAE1D,MAAMA,QAAyB;IAC7BC,MAAM;QACJC,MAAMC,wBAAa,CAACC,WAAW;QAC/BC,WAAW,EAAE;QACbC,SAAS;YAAEC,KAAK,CAAC;QAAE;QACnBC,aAAa;YACX;gBACEC,OAAOC,2BAAe,CAACC,UAAU;gBACjCT,MAAMU,0BAAc,CAACD,UAAU;gBAC/BE,OAAO;gBACPC,cAAc;oBAAC;oBAAW;iBAAK;YACjC;YACA;gBACEL,OAAOC,2BAAe,CAACK,QAAQ;gBAC/Bb,MAAMU,0BAAc,CAACG,QAAQ;gBAC7BF,OAAO;gBACPG,eAAe;gBACfC,QAAQ;gBACRC,UAAU,EAAE;gBACZC,QAAQ;gBACRC,WAAW;oBAAElB,MAAMmB,kCAAkB,CAACC,cAAc;oBAAEC,QAAQ,EAAE;gBAAC;gBACjEC,UAAU;gBACVC,aAAa;gBACbC,cAAc;gBACdC,SAAS;YACX;SACD;QACDC,YAAY;YACV1B,MAAM2B,4BAAkB,CAACC,IAAI;YAC7BjB,OAAO;YACPkB,QAAQ;YACRC,MAAM;gBACJ9B,MAAM2B,4BAAkB,CAACI,UAAU;gBACnCpB,OAAO;gBACPkB,QAAQ;gBACRG,aAAa;gBACbC,YAAY;gBACZC,mBAAmB,EAAE;gBACrBC,cAAc;YAChB;YACAC,OAAO;gBACLpC,MAAM2B,4BAAkB,CAACI,UAAU;gBACnCpB,OAAO;gBACPkB,QAAQ;gBACRG,aAAa;gBACbC,YAAY;gBACZC,mBAAmB,EAAE;gBACrBC,cAAc;YAChB;YACAE,WAAW;gBACT9B,OAAOC,2BAAe,CAAC8B,UAAU;gBACjCtC,MAAMU,0BAAc,CAAC6B,aAAa;gBAClC5B,OAAO;gBACPmB,MAAM;oBACJvB,OAAOC,2BAAe,CAACC,UAAU;oBACjCT,MAAMU,0BAAc,CAACD,UAAU;oBAC/BE,OAAO;oBACPC,cAAc;wBAAC;wBAAW;qBAAK;gBACjC;gBACAwB,OAAO;oBACL7B,OAAOC,2BAAe,CAACC,UAAU;oBACjCT,MAAMU,0BAAc,CAACD,UAAU;oBAC/BE,OAAO;oBACPC,cAAc;wBAAC;wBAAW;qBAAU;gBACtC;YACF;YACA4B,WAAWC,kBAAQ,CAACC,KAAK;YACzBC,UAAUC,qBAAW,CAACC,OAAO;YAC7BC,eAAe,EAAE;QACnB;QACAC,cAAc;YACZxC,OAAOC,2BAAe,CAAC8B,UAAU;YACjCtC,MAAMU,0BAAc,CAAC6B,aAAa;YAClC5B,OAAO;YACPmB,MAAM;gBACJvB,OAAOC,2BAAe,CAACC,UAAU;gBACjCT,MAAMU,0BAAc,CAACD,UAAU;gBAC/BE,OAAO;gBACPC,cAAc;oBAAC;oBAAW;iBAAO;YACnC;YACAwB,OAAO;gBACL7B,OAAOC,2BAAe,CAACC,UAAU;gBACjCT,MAAMU,0BAAc,CAACD,UAAU;gBAC/BE,OAAO;gBACPC,cAAc;oBAAC;iBAAS;YAC1B;QACF;QACAoC,mBAAmB;YACjB;gBACEzC,OAAOC,2BAAe,CAACC,UAAU;gBACjCT,MAAMU,0BAAc,CAACD,UAAU;gBAC/BE,OAAO;gBACPC,cAAc;oBAAC;oBAAW;iBAAK;YACjC;SACD;QACDqC,YAAY,IAAIC;QAChBC,oBAAoBC,4BAAiB,CAACC,iBAAiB;QACvDC,QAAQ;QACRzB,QAAQ;QACR0B,SAAS;IACX;AACF"}

package/src/utils/__fixtures__/joins.fixtures.d.ts

@@ -0,0 +1,211 @@
+export declare const CIRCULAR_TABLE_SCHEMA: {
+    name: string;
+    dimensions: {
+        name: string;
+        sql: string;
+    }[];
+    measures: never[];
+    sql: string;
+    joins: {
+        sql: string;
+    }[];
+}[];
+export declare const LINEAR_TABLE_SCHEMA: {
+    name: string;
+    dimensions: {
+        name: string;
+        sql: string;
+    }[];
+    measures: never[];
+    sql: string;
+    joins: {
+        sql: string;
+    }[];
+}[];
+export declare const BASIC_JOIN_PATH: {
+    left: string;
+    right: string;
+    on: string;
+}[][];
+export declare const SINGLE_NODE_JOIN_PATH: {
+    left: string;
+}[][];
+export declare const INTERMEDIATE_JOIN_PATH: {
+    left: string;
+    right: string;
+    on: string;
+}[][];
+export declare const CIRCULAR_JOIN_PATH: {
+    left: string;
+    right: string;
+    on: string;
+}[][];
+export declare const COMPLEX_JOIN_PATH: {
+    left: string;
+    right: string;
+    on: string;
+}[][];
+export declare const EXPECTED_OUTPUT_WITH_ONE_DEPTH: {
+    name: string;
+    measures: never[];
+    dimensions: {
+        schema: {
+            name: string;
+            sql: string;
+        };
+        children: {
+            name: string;
+            measures: never[];
+            dimensions: {
+                schema: {
+                    name: string;
+                    sql: string;
+                };
+                children: {
+                    name: string;
+                    measures: never[];
+                    dimensions: {
+                        schema: {
+                            name: string;
+                            sql: string;
+                        };
+                        children: {
+                            name: string;
+                            measures: never[];
+                            dimensions: {
+                                schema: {
+                                    name: string;
+                                    sql: string;
+                                };
+                                children: {
+                                    name: string;
+                                    measures: never[];
+                                    dimensions: {
+                                        schema: {
+                                            name: string;
+                                            sql: string;
+                                        };
+                                        children: never[];
+                                    }[];
+                                }[];
+                            }[];
+                        }[];
+                    }[];
+                }[];
+            }[];
+        }[];
+    }[];
+};
+export declare const EXPECTED_OUTPUT_WITH_TWO_DEPTH: {
+    name: string;
+    measures: never[];
+    dimensions: {
+        schema: {
+            name: string;
+            sql: string;
+        };
+        children: {
+            name: string;
+            measures: never[];
+            dimensions: {
+                schema: {
+                    name: string;
+                    sql: string;
+                };
+                children: {
+                    name: string;
+                    measures: never[];
+                    dimensions: {
+                        schema: {
+                            name: string;
+                            sql: string;
+                        };
+                        children: {
+                            name: string;
+                            measures: never[];
+                            dimensions: {
+                                schema: {
+                                    name: string;
+                                    sql: string;
+                                };
+                                children: {
+                                    name: string;
+                                    measures: never[];
+                                    dimensions: {
+                                        schema: {
+                                            name: string;
+                                            sql: string;
+                                        };
+                                        children: never[];
+                                    }[];
+                                }[];
+                            }[];
+                        }[];
+                    }[];
+                }[];
+            }[];
+        }[];
+    }[];
+};
+export declare const CIRCULAR_TABLE_SCHEMA_SINGLE_JOIN_PATH: {
+    name: string;
+    measures: never[];
+    dimensions: {
+        schema: {
+            name: string;
+            sql: string;
+        };
+        children: {
+            name: string;
+            measures: never[];
+            dimensions: {
+                schema: {
+                    name: string;
+                    sql: string;
+                };
+                children: {
+                    name: string;
+                    measures: never[];
+                    dimensions: {
+                        schema: {
+                            name: string;
+                            sql: string;
+                        };
+                        children: never[];
+                    }[];
+                }[];
+            }[];
+        }[];
+    }[];
+};
+export declare const EXPECTED_CIRCULAR_TABLE_SCHEMA_INTERMEDIATE_JOIN_PATH: {
+    name: string;
+    measures: never[];
+    dimensions: {
+        schema: {
+            name: string;
+            sql: string;
+        };
+        children: {
+            name: string;
+            measures: never[];
+            dimensions: {
+                schema: {
+                    name: string;
+                    sql: string;
+                };
+                children: {
+                    name: string;
+                    measures: never[];
+                    dimensions: {
+                        schema: {
+                            name: string;
+                            sql: string;
+                        };
+                        children: never[];
+                    }[];
+                }[];
+            }[];
+        }[];
+    }[];
+};