@devrev/meerkat-core 0.0.77

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

@@ -0,0 +1,212 @@
+import { Expression, ExpressionType } from './Expression';
+import { Value } from './Misc';
+import { ParsedExpression } from './ParsedExpression';
+import { SelectStatement } from './Statement';
+import { TableFilter } from './TableFilter';
+import { ExtraTypeInfo } from './Types';
+export interface LogicalType {
+    id?: number;
+    type_info?: ExtraTypeInfo;
+}
+export declare enum CTEMaterialize {
+    CTE_MATERIALIZE_DEFAULT = "CTE_MATERIALIZE_DEFAULT",
+    CTE_MATERIALIZE_ALWAYS = "CTE_MATERIALIZE_ALWAYS",
+    CTE_MATERIALIZE_NEVER = "CTE_MATERIALIZE_NEVER"
+}
+export interface CommonTableExpressionInfo {
+    aliases: string[];
+    query: SelectStatement;
+    materialized: CTEMaterialize;
+}
+export interface CommonTableExpressionMap {
+    map: Record<string, CommonTableExpressionInfo> | Array<CommonTableExpressionInfo>;
+}
+export declare enum OrderType {
+    INVALID = "INVALID",
+    ORDER_DEFAULT = "ORDER_DEFAULT",
+    ASCENDING = "ASCENDING",
+    DESCENDING = "DESCENDING"
+}
+export declare enum OrderByNullType {
+    INVALID = "INVALID",
+    ORDER_DEFAULT = "ORDER_DEFAULT",
+    NULLS_FIRST = "NULLS_FIRST",
+    NULLS_LAST = "NULLS_LAST"
+}
+export declare enum DefaultOrderByNullType {
+    INVALID = "INVALID",
+    NULLS_FIRST = "NULLS_FIRST",
+    NULLS_LAST = "NULLS_LAST",
+    NULLS_FIRST_ON_ASC_LAST_ON_DESC = "NULLS_FIRST_ON_ASC_LAST_ON_DESC",
+    NULLS_LAST_ON_ASC_FIRST_ON_DESC = "NULLS_LAST_ON_ASC_FIRST_ON_DESC"
+}
+export interface OrderByNode {
+    type: OrderType;
+    null_order: OrderByNullType;
+    expression: ParsedExpression;
+}
+export interface BoundOrderByNode {
+    type: OrderType;
+    null_order: OrderByNullType;
+    expression: Expression;
+}
+export interface CaseCheck {
+    when_expr: ParsedExpression;
+    then_expr: ParsedExpression;
+}
+export interface BoundCaseCheck {
+    when_expr: Expression;
+    then_expr: Expression;
+}
+export declare enum SampleMethod {
+    SYSTEM_SAMPLE = "SYSTEM_SAMPLE",
+    BERNOULLI_SAMPLE = "BERNOULLI_SAMPLE",
+    RESERVOIR_SAMPLE = "RESERVOIR_SAMPLE"
+}
+export interface SampleOptions {
+    sample_size: Value;
+    is_percentage: boolean;
+    method: SampleMethod;
+    seed: number;
+}
+export interface PivotColumn {
+    pivot_expressions: ParsedExpression[];
+    unpivot_names: string[];
+    entries: PivotColumnEntry[];
+    pivot_enum: string;
+}
+export interface PivotColumnEntry {
+    values: Value[];
+    star_expr?: ParsedExpression;
+    alias: string;
+}
+export interface BoundPivotInfo {
+    group_count: number;
+    types: LogicalType[];
+    pivot_values: string[];
+    aggregates: Expression[];
+}
+export declare enum TableColumnType {
+    STANDARD = "STANDARD",
+    GENERATED = "GENERATED"
+}
+export declare enum CompressionType {
+    COMPRESSION_AUTO = "COMPRESSION_AUTO",
+    COMPRESSION_UNCOMPRESSED = "COMPRESSION_UNCOMPRESSED",
+    COMPRESSION_CONSTANT = "COMPRESSION_CONSTANT",
+    COMPRESSION_RLE = "COMPRESSION_RLE",
+    COMPRESSION_DICTIONARY = "COMPRESSION_DICTIONARY",
+    COMPRESSION_PFOR_DELTA = "COMPRESSION_PFOR_DELTA",
+    COMPRESSION_BITPACKING = "COMPRESSION_BITPACKING",
+    COMPRESSION_FSST = "COMPRESSION_FSST",
+    COMPRESSION_CHIMP = "COMPRESSION_CHIMP",
+    COMPRESSION_PATAS = "COMPRESSION_PATAS",
+    COMPRESSION_COUNT = "COMPRESSION_COUNT"
+}
+export interface ColumnDefinition {
+    name: string;
+    type: LogicalType;
+    expression?: ParsedExpression;
+    category: TableColumnType;
+    compression_type: CompressionType;
+}
+export interface ColumnList {
+    columns: ColumnDefinition[];
+}
+export interface ColumnBinding {
+    table_index: number;
+    column_index: number;
+}
+export interface BoundParameterData {
+    value: Value;
+    return_type: LogicalType;
+}
+export interface JoinCondition {
+    left: Expression;
+    right: Expression;
+    comparison: ExpressionType;
+}
+export interface VacuumOptions {
+    vacuum: boolean;
+    analyze: boolean;
+}
+export interface TableFilterSet {
+    filters: Record<number, TableFilter>;
+}
+export interface MultiFileReaderOptions {
+    filename: boolean;
+    hive_partitioning: boolean;
+    auto_detect_hive_partitioning: boolean;
+    union_by_name: boolean;
+    hive_types_autocast: boolean;
+    hive_types_schema: Record<string, LogicalType>;
+}
+export interface MultiFileReaderBindData {
+    filename_idx: number;
+    hive_partitioning_indexes: HivePartitioningIndex[];
+}
+export interface HivePartitioningIndex {
+    value: string;
+    index: number;
+}
+declare enum FileCompressionType {
+    AUTO_DETECT = "AUTO_DETECT",
+    UNCOMPRESSED = "UNCOMPRESSED",
+    GZIP = "GZIP",
+    ZSTD = "ZSTD"
+}
+export interface CSVReaderOptions {
+    has_delimiter: boolean;
+    has_quote: boolean;
+    has_escape: boolean;
+    has_header: boolean;
+    ignore_errors: boolean;
+    buffer_sample_size: number;
+    null_str: string;
+    compression: FileCompressionType;
+    allow_quoted_nulls: boolean;
+    skip_rows_set: boolean;
+    maximum_line_size: number;
+    normalize_names: boolean;
+    force_not_null: boolean[];
+    all_varchar: boolean;
+    sample_chunk_size: number;
+    sample_chunks: number;
+    auto_detect: boolean;
+    file_path: string;
+    decimal_separator: string;
+    null_padding: boolean;
+    buffer_size: number;
+    file_options: MultiFileReaderOptions;
+    force_quote: boolean[];
+    rejects_table_name: string;
+    rejects_limit: number;
+    rejects_recovery_columns: string[];
+    rejects_recovery_column_ids: number[];
+    dialect_options: any;
+}
+export interface StrpTimeFormat {
+    format_specifier: string;
+}
+export interface ReadCSVData {
+    files: string[];
+    csv_types: LogicalType[];
+    csv_names: string[];
+    return_types: LogicalType[];
+    return_names: string[];
+    filename_col_idx: number;
+    options: any;
+    single_threaded: boolean;
+    reader_bind: MultiFileReaderBindData;
+    column_info: ColumnInfo[];
+}
+export interface ColumnInfo {
+    names: string[];
+    types: LogicalType[];
+}
+export interface IntervalT {
+    months: number;
+    days: number;
+    micros: number;
+}
+export {};

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

@@ -0,0 +1,92 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    CTEMaterialize: function() {
+        return CTEMaterialize;
+    },
+    OrderType: function() {
+        return OrderType;
+    },
+    OrderByNullType: function() {
+        return OrderByNullType;
+    },
+    DefaultOrderByNullType: function() {
+        return DefaultOrderByNullType;
+    },
+    SampleMethod: function() {
+        return SampleMethod;
+    },
+    TableColumnType: function() {
+        return TableColumnType;
+    },
+    CompressionType: function() {
+        return CompressionType;
+    }
+});
+var CTEMaterialize;
+(function(CTEMaterialize) {
+    CTEMaterialize["CTE_MATERIALIZE_DEFAULT"] = "CTE_MATERIALIZE_DEFAULT";
+    CTEMaterialize["CTE_MATERIALIZE_ALWAYS"] = "CTE_MATERIALIZE_ALWAYS";
+    CTEMaterialize["CTE_MATERIALIZE_NEVER"] = "CTE_MATERIALIZE_NEVER";
+})(CTEMaterialize || (CTEMaterialize = {}));
+var OrderType;
+(function(OrderType) {
+    OrderType["INVALID"] = "INVALID";
+    OrderType["ORDER_DEFAULT"] = "ORDER_DEFAULT";
+    OrderType["ASCENDING"] = "ASCENDING";
+    OrderType["DESCENDING"] = "DESCENDING";
+})(OrderType || (OrderType = {}));
+var OrderByNullType;
+(function(OrderByNullType) {
+    OrderByNullType["INVALID"] = "INVALID";
+    OrderByNullType["ORDER_DEFAULT"] = "ORDER_DEFAULT";
+    OrderByNullType["NULLS_FIRST"] = "NULLS_FIRST";
+    OrderByNullType["NULLS_LAST"] = "NULLS_LAST";
+})(OrderByNullType || (OrderByNullType = {}));
+var DefaultOrderByNullType;
+(function(DefaultOrderByNullType) {
+    DefaultOrderByNullType["INVALID"] = "INVALID";
+    DefaultOrderByNullType["NULLS_FIRST"] = "NULLS_FIRST";
+    DefaultOrderByNullType["NULLS_LAST"] = "NULLS_LAST";
+    DefaultOrderByNullType["NULLS_FIRST_ON_ASC_LAST_ON_DESC"] = "NULLS_FIRST_ON_ASC_LAST_ON_DESC";
+    DefaultOrderByNullType["NULLS_LAST_ON_ASC_FIRST_ON_DESC"] = "NULLS_LAST_ON_ASC_FIRST_ON_DESC";
+})(DefaultOrderByNullType || (DefaultOrderByNullType = {}));
+var SampleMethod;
+(function(SampleMethod) {
+    SampleMethod["SYSTEM_SAMPLE"] = "SYSTEM_SAMPLE";
+    SampleMethod["BERNOULLI_SAMPLE"] = "BERNOULLI_SAMPLE";
+    SampleMethod["RESERVOIR_SAMPLE"] = "RESERVOIR_SAMPLE";
+})(SampleMethod || (SampleMethod = {}));
+var TableColumnType;
+(function(TableColumnType) {
+    TableColumnType["STANDARD"] = "STANDARD";
+    TableColumnType["GENERATED"] = "GENERATED";
+})(TableColumnType || (TableColumnType = {}));
+var CompressionType;
+(function(CompressionType) {
+    CompressionType["COMPRESSION_AUTO"] = "COMPRESSION_AUTO";
+    CompressionType["COMPRESSION_UNCOMPRESSED"] = "COMPRESSION_UNCOMPRESSED";
+    CompressionType["COMPRESSION_CONSTANT"] = "COMPRESSION_CONSTANT";
+    CompressionType["COMPRESSION_RLE"] = "COMPRESSION_RLE";
+    CompressionType["COMPRESSION_DICTIONARY"] = "COMPRESSION_DICTIONARY";
+    CompressionType["COMPRESSION_PFOR_DELTA"] = "COMPRESSION_PFOR_DELTA";
+    CompressionType["COMPRESSION_BITPACKING"] = "COMPRESSION_BITPACKING";
+    CompressionType["COMPRESSION_FSST"] = "COMPRESSION_FSST";
+    CompressionType["COMPRESSION_CHIMP"] = "COMPRESSION_CHIMP";
+    CompressionType["COMPRESSION_PATAS"] = "COMPRESSION_PATAS";
+    CompressionType["COMPRESSION_COUNT"] = "COMPRESSION_COUNT";
+})(CompressionType || (CompressionType = {}));
+var FileCompressionType;
+(function(FileCompressionType) {
+    FileCompressionType["AUTO_DETECT"] = "AUTO_DETECT";
+    FileCompressionType["UNCOMPRESSED"] = "UNCOMPRESSED";
+    FileCompressionType["GZIP"] = "GZIP";
+    FileCompressionType["ZSTD"] = "ZSTD";
+})(FileCompressionType || (FileCompressionType = {}));
+
+//# sourceMappingURL=Nodes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Nodes.ts"],"sourcesContent":["import { Expression, ExpressionType } from './Expression';\nimport { Value } from './Misc';\nimport { ParsedExpression } from './ParsedExpression';\nimport { SelectStatement } from './Statement';\nimport { TableFilter } from './TableFilter';\nimport { ExtraTypeInfo } from './Types';\n\nexport interface LogicalType {\n  id?: number;\n  type_info?: ExtraTypeInfo;\n}\n\nexport enum CTEMaterialize {\n  CTE_MATERIALIZE_DEFAULT = 'CTE_MATERIALIZE_DEFAULT',\n  CTE_MATERIALIZE_ALWAYS = 'CTE_MATERIALIZE_ALWAYS',\n  CTE_MATERIALIZE_NEVER = 'CTE_MATERIALIZE_NEVER',\n}\n\nexport interface CommonTableExpressionInfo {\n  aliases: string[];\n  query: SelectStatement;\n  materialized: CTEMaterialize;\n}\n\nexport interface CommonTableExpressionMap {\n  map:\n    | Record<string, CommonTableExpressionInfo>\n    | Array<CommonTableExpressionInfo>;\n}\n\nexport enum OrderType {\n  INVALID = 'INVALID',\n  ORDER_DEFAULT = 'ORDER_DEFAULT',\n  ASCENDING = 'ASCENDING',\n  DESCENDING = 'DESCENDING',\n}\n\nexport enum OrderByNullType {\n  INVALID = 'INVALID',\n  ORDER_DEFAULT = 'ORDER_DEFAULT',\n  NULLS_FIRST = 'NULLS_FIRST',\n  NULLS_LAST = 'NULLS_LAST',\n}\n\nexport enum DefaultOrderByNullType {\n  INVALID = 'INVALID',\n  NULLS_FIRST = 'NULLS_FIRST',\n  NULLS_LAST = 'NULLS_LAST',\n  NULLS_FIRST_ON_ASC_LAST_ON_DESC = 'NULLS_FIRST_ON_ASC_LAST_ON_DESC',\n  NULLS_LAST_ON_ASC_FIRST_ON_DESC = 'NULLS_LAST_ON_ASC_FIRST_ON_DESC',\n}\n\nexport interface OrderByNode {\n  type: OrderType;\n  null_order: OrderByNullType;\n  expression: ParsedExpression;\n}\n\nexport interface BoundOrderByNode {\n  type: OrderType;\n  null_order: OrderByNullType;\n  expression: Expression;\n}\n\nexport interface CaseCheck {\n  when_expr: ParsedExpression;\n  then_expr: ParsedExpression;\n}\n\nexport interface BoundCaseCheck {\n  when_expr: Expression;\n  then_expr: Expression;\n}\n\nexport enum SampleMethod {\n  SYSTEM_SAMPLE = 'SYSTEM_SAMPLE',\n  BERNOULLI_SAMPLE = 'BERNOULLI_SAMPLE',\n  RESERVOIR_SAMPLE = 'RESERVOIR_SAMPLE',\n}\n\nexport interface SampleOptions {\n  sample_size: Value;\n  is_percentage: boolean;\n  method: SampleMethod;\n  seed: number;\n}\n\nexport interface PivotColumn {\n  pivot_expressions: ParsedExpression[];\n  unpivot_names: string[];\n  entries: PivotColumnEntry[];\n  pivot_enum: string;\n}\n\nexport interface PivotColumnEntry {\n  values: Value[];\n  star_expr?: ParsedExpression;\n  alias: string;\n}\n\nexport interface BoundPivotInfo {\n  group_count: number;\n  types: LogicalType[];\n  pivot_values: string[];\n  aggregates: Expression[];\n}\n\nexport enum TableColumnType {\n  STANDARD = 'STANDARD',\n  GENERATED = 'GENERATED',\n}\n\nexport enum CompressionType {\n  COMPRESSION_AUTO = 'COMPRESSION_AUTO',\n  COMPRESSION_UNCOMPRESSED = 'COMPRESSION_UNCOMPRESSED',\n  COMPRESSION_CONSTANT = 'COMPRESSION_CONSTANT',\n  COMPRESSION_RLE = 'COMPRESSION_RLE',\n  COMPRESSION_DICTIONARY = 'COMPRESSION_DICTIONARY',\n  COMPRESSION_PFOR_DELTA = 'COMPRESSION_PFOR_DELTA',\n  COMPRESSION_BITPACKING = 'COMPRESSION_BITPACKING',\n  COMPRESSION_FSST = 'COMPRESSION_FSST',\n  COMPRESSION_CHIMP = 'COMPRESSION_CHIMP',\n  COMPRESSION_PATAS = 'COMPRESSION_PATAS',\n  COMPRESSION_COUNT = 'COMPRESSION_COUNT',\n}\n\nexport interface ColumnDefinition {\n  name: string;\n  type: LogicalType;\n  expression?: ParsedExpression;\n  category: TableColumnType;\n  compression_type: CompressionType;\n}\n\nexport interface ColumnList {\n  columns: ColumnDefinition[];\n}\n\nexport interface ColumnBinding {\n  table_index: number;\n  column_index: number;\n}\n\nexport interface BoundParameterData {\n  value: Value;\n  return_type: LogicalType;\n}\n\nexport interface JoinCondition {\n  left: Expression;\n  right: Expression;\n  comparison: ExpressionType;\n}\n\nexport interface VacuumOptions {\n  vacuum: boolean;\n  analyze: boolean;\n}\n\nexport interface TableFilterSet {\n  filters: Record<number, TableFilter>;\n}\n\nexport interface MultiFileReaderOptions {\n  filename: boolean;\n  hive_partitioning: boolean;\n  auto_detect_hive_partitioning: boolean;\n  union_by_name: boolean;\n  hive_types_autocast: boolean;\n  hive_types_schema: Record<string, LogicalType>;\n}\n\nexport interface MultiFileReaderBindData {\n  filename_idx: number;\n  hive_partitioning_indexes: HivePartitioningIndex[];\n}\n\nexport interface HivePartitioningIndex {\n  value: string;\n  index: number;\n}\n\nenum FileCompressionType {\n  AUTO_DETECT = 'AUTO_DETECT',\n  UNCOMPRESSED = 'UNCOMPRESSED',\n  GZIP = 'GZIP',\n  ZSTD = 'ZSTD',\n}\n\nexport interface CSVReaderOptions {\n  has_delimiter: boolean;\n  has_quote: boolean;\n  has_escape: boolean;\n  has_header: boolean;\n  ignore_errors: boolean;\n  buffer_sample_size: number;\n  null_str: string;\n  compression: FileCompressionType;\n  allow_quoted_nulls: boolean;\n  skip_rows_set: boolean;\n  maximum_line_size: number;\n  normalize_names: boolean;\n  force_not_null: boolean[];\n  all_varchar: boolean;\n  sample_chunk_size: number;\n  sample_chunks: number;\n  auto_detect: boolean;\n  file_path: string;\n  decimal_separator: string;\n  null_padding: boolean;\n  buffer_size: number;\n  file_options: MultiFileReaderOptions;\n  force_quote: boolean[];\n  rejects_table_name: string;\n  rejects_limit: number;\n  rejects_recovery_columns: string[];\n  rejects_recovery_column_ids: number[];\n  dialect_options: any;\n}\n\nexport interface StrpTimeFormat {\n  format_specifier: string;\n}\n\nexport interface ReadCSVData {\n  files: string[];\n  csv_types: LogicalType[];\n  csv_names: string[];\n  return_types: LogicalType[];\n  return_names: string[];\n  filename_col_idx: number;\n  options: any;\n  single_threaded: boolean;\n  reader_bind: MultiFileReaderBindData;\n  column_info: ColumnInfo[];\n}\n\nexport interface ColumnInfo {\n  names: string[];\n  types: LogicalType[];\n}\n\nexport interface IntervalT {\n  months: number;\n  days: number;\n  micros: number;\n}\n"],"names":["CTEMaterialize","CTE_MATERIALIZE_DEFAULT","CTE_MATERIALIZE_ALWAYS","CTE_MATERIALIZE_NEVER","OrderType","INVALID","ORDER_DEFAULT","ASCENDING","DESCENDING","OrderByNullType","NULLS_FIRST","NULLS_LAST","DefaultOrderByNullType","NULLS_FIRST_ON_ASC_LAST_ON_DESC","NULLS_LAST_ON_ASC_FIRST_ON_DESC","SampleMethod","SYSTEM_SAMPLE","BERNOULLI_SAMPLE","RESERVOIR_SAMPLE","TableColumnType","STANDARD","GENERATED","CompressionType","COMPRESSION_AUTO","COMPRESSION_UNCOMPRESSED","COMPRESSION_CONSTANT","COMPRESSION_RLE","COMPRESSION_DICTIONARY","COMPRESSION_PFOR_DELTA","COMPRESSION_BITPACKING","COMPRESSION_FSST","COMPRESSION_CHIMP","COMPRESSION_PATAS","COMPRESSION_COUNT","FileCompressionType","AUTO_DETECT","UNCOMPRESSED","GZIP","ZSTD"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYO;UAAKA,cAAc;IAAdA,eACVC,6BAAAA;IADUD,eAEVE,4BAAAA;IAFUF,eAGVG,2BAAAA;GAHUH,mBAAAA;IAkBL;UAAKI,SAAS;IAATA,UACVC,aAAAA;IADUD,UAEVE,mBAAAA;IAFUF,UAGVG,eAAAA;IAHUH,UAIVI,gBAAAA;GAJUJ,cAAAA;IAOL;UAAKK,eAAe;IAAfA,gBACVJ,aAAAA;IADUI,gBAEVH,mBAAAA;IAFUG,gBAGVC,iBAAAA;IAHUD,gBAIVE,gBAAAA;GAJUF,oBAAAA;IAOL;UAAKG,sBAAsB;IAAtBA,uBACVP,aAAAA;IADUO,uBAEVF,iBAAAA;IAFUE,uBAGVD,gBAAAA;IAHUC,uBAIVC,qCAAAA;IAJUD,uBAKVE,qCAAAA;GALUF,2BAAAA;IA8BL;UAAKG,YAAY;IAAZA,aACVC,mBAAAA;IADUD,aAEVE,sBAAAA;IAFUF,aAGVG,sBAAAA;GAHUH,iBAAAA;IAiCL;UAAKI,eAAe;IAAfA,gBACVC,cAAAA;IADUD,gBAEVE,eAAAA;GAFUF,oBAAAA;IAKL;UAAKG,eAAe;IAAfA,gBACVC,sBAAAA;IADUD,gBAEVE,8BAAAA;IAFUF,gBAGVG,0BAAAA;IAHUH,gBAIVI,qBAAAA;IAJUJ,gBAKVK,4BAAAA;IALUL,gBAMVM,4BAAAA;IANUN,gBAOVO,4BAAAA;IAPUP,gBAQVQ,sBAAAA;IARUR,gBASVS,uBAAAA;IATUT,gBAUVU,uBAAAA;IAVUV,gBAWVW,uBAAAA;GAXUX,oBAAAA;IAsEZ;UAAKY,mBAAmB;IAAnBA,oBACHC,iBAAAA;IADGD,oBAEHE,kBAAAA;IAFGF,oBAGHG,UAAAA;IAHGH,oBAIHI,UAAAA;GAJGJ,wBAAAA"}

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

@@ -0,0 +1,192 @@
+import { PhysicalIndex } from './Constraint';
+import { Value } from './Misc';
+import { ColumnDefinition, LogicalType } from './Nodes';
+import { ParsedExpression } from './ParsedExpression';
+export declare enum ParseInfoType {
+    ALTER_INFO = "ALTER_INFO",
+    ATTACH_INFO = "ATTACH_INFO",
+    COPY_INFO = "COPY_INFO",
+    CREATE_INFO = "CREATE_INFO",
+    DETACH_INFO = "DETACH_INFO",
+    DROP_INFO = "DROP_INFO",
+    BOUND_EXPORT_DATA = "BOUND_EXPORT_DATA",
+    LOAD_INFO = "LOAD_INFO",
+    PRAGMA_INFO = "PRAGMA_INFO",
+    SHOW_SELECT_INFO = "SHOW_SELECT_INFO",
+    TRANSACTION_INFO = "TRANSACTION_INFO",
+    VACUUM_INFO = "VACUUM_INFO"
+}
+export interface ParseInfo {
+    info_type: ParseInfoType;
+}
+export declare enum AlterType {
+    INVALID = "INVALID",
+    ALTER_TABLE = "ALTER_TABLE",
+    ALTER_VIEW = "ALTER_VIEW",
+    ALTER_SEQUENCE = "ALTER_SEQUENCE",
+    CHANGE_OWNERSHIP = "CHANGE_OWNERSHIP",
+    ALTER_SCALAR_FUNCTION = "ALTER_SCALAR_FUNCTION",
+    ALTER_TABLE_FUNCTION = "ALTER_TABLE_FUNCTION"
+}
+export declare enum OnEntryNotFound {
+    THROW_EXCEPTION = "THROW_EXCEPTION",
+    RETURN_NULL = "RETURN_NULL"
+}
+export interface AlterInfo extends ParseInfo {
+    type: AlterType;
+    catalog: string;
+    schema: string;
+    name: string;
+    if_not_found: OnEntryNotFound;
+    allow_internal: boolean;
+}
+export declare enum AlterTableType {
+    INVALID = "INVALID",
+    RENAME_COLUMN = "RENAME_COLUMN",
+    RENAME_TABLE = "RENAME_TABLE",
+    ADD_COLUMN = "ADD_COLUMN",
+    REMOVE_COLUMN = "REMOVE_COLUMN",
+    ALTER_COLUMN_TYPE = "ALTER_COLUMN_TYPE",
+    SET_DEFAULT = "SET_DEFAULT",
+    FOREIGN_KEY_CONSTRAINT = "FOREIGN_KEY_CONSTRAINT",
+    SET_NOT_NULL = "SET_NOT_NULL",
+    DROP_NOT_NULL = "DROP_NOT_NULL"
+}
+export interface AlterTableInfo extends AlterInfo {
+    alter_table_type: AlterTableType;
+}
+export interface RenameColumnInfo extends AlterTableInfo {
+    old_name: string;
+    new_name: string;
+}
+export interface RenameTableInfo extends AlterTableInfo {
+    new_table_name: string;
+}
+export interface AddColumnInfo extends AlterTableInfo {
+    new_column: ColumnDefinition;
+    if_column_not_exists: boolean;
+}
+export interface RemoveColumnInfo extends AlterTableInfo {
+    removed_column: string;
+    if_column_exists: boolean;
+    cascade: boolean;
+}
+export interface ChangeColumnTypeInfo extends AlterTableInfo {
+    column_name: string;
+    target_type: LogicalType;
+    expression: ParsedExpression;
+}
+export interface SetDefaultInfo extends AlterTableInfo {
+    column_name: string;
+    expression?: ParsedExpression;
+}
+export declare enum AlterForeignKeyType {
+    AFT_ADD = "AFT_ADD",
+    AFT_DELETE = "AFT_DELETE"
+}
+export interface AlterForeignKeyInfo extends AlterTableInfo {
+    fk_table: string;
+    pk_columns: string[];
+    fk_columns: string[];
+    pk_keys: PhysicalIndex[];
+    fk_keys: PhysicalIndex[];
+    alter_fk_type: AlterForeignKeyType;
+}
+export interface SetNotNullInfo extends AlterTableInfo {
+    column_name: string;
+}
+export interface DropNotNullInfo extends AlterTableInfo {
+    column_name: string;
+}
+export declare enum AlterViewType {
+    INVALID = "INVALID",
+    RENAME_VIEW = "RENAME_VIEW"
+}
+export interface AlterViewInfo extends AlterInfo {
+    alter_view_type: AlterViewType;
+}
+export interface RenameViewInfo extends AlterViewInfo {
+    new_view_name: string;
+}
+export interface AttachInfo extends ParseInfo {
+    name: string;
+    path: string;
+    options: {
+        [key: string]: Value;
+    };
+}
+export interface CopyInfo extends ParseInfo {
+    catalog: string;
+    schema: string;
+    table: string;
+    select_list: string[];
+    is_from: boolean;
+    format: string;
+    file_path: string;
+    options: {
+        [key: string]: Value[];
+    };
+}
+export interface DetachInfo extends ParseInfo {
+    name: string;
+    if_not_found: OnEntryNotFound;
+}
+export declare enum CatalogType {
+    INVALID = "INVALID",
+    TABLE_ENTRY = "TABLE_ENTRY",
+    SCHEMA_ENTRY = "SCHEMA_ENTRY",
+    VIEW_ENTRY = "VIEW_ENTRY",
+    INDEX_ENTRY = "INDEX_ENTRY",
+    PREPARED_STATEMENT = "PREPARED_STATEMENT",
+    SEQUENCE_ENTRY = "SEQUENCE_ENTRY",
+    COLLATION_ENTRY = "COLLATION_ENTRY",
+    TYPE_ENTRY = "TYPE_ENTRY",
+    DATABASE_ENTRY = "DATABASE_ENTRY",
+    TABLE_FUNCTION_ENTRY = "TABLE_FUNCTION_ENTRY",
+    SCALAR_FUNCTION_ENTRY = "SCALAR_FUNCTION_ENTRY",
+    AGGREGATE_FUNCTION_ENTRY = "AGGREGATE_FUNCTION_ENTRY",
+    PRAGMA_FUNCTION_ENTRY = "PRAGMA_FUNCTION_ENTRY",
+    COPY_FUNCTION_ENTRY = "COPY_FUNCTION_ENTRY",
+    MACRO_ENTRY = "MACRO_ENTRY",
+    TABLE_MACRO_ENTRY = "TABLE_MACRO_ENTRY",
+    UPDATED_ENTRY = "UPDATED_ENTRY",
+    DELETED_ENTRY = "DELETED_ENTRY"
+}
+export interface DropInfo extends ParseInfo {
+    type: CatalogType;
+    catalog: string;
+    schema: string;
+    name: string;
+    if_not_found: OnEntryNotFound;
+    cascade: boolean;
+    allow_drop_internal: boolean;
+}
+export declare enum LoadType {
+    LOAD = "LOAD",
+    INSTALL = "INSTALL",
+    FORCE_INSTALL = "FORCE_INSTALL"
+}
+export interface LoadInfo extends ParseInfo {
+    filename: string;
+    load_type: LoadType;
+    repository: string;
+}
+export interface PragmaInfo extends ParseInfo {
+    name: string;
+    parameters: Value[];
+    named_parameters: {
+        [key: string]: Value;
+    };
+}
+export declare enum TransactionType {
+    INVALID = "INVALID",
+    BEGIN_TRANSACTION = "BEGIN_TRANSACTION",
+    COMMIT = "COMMIT",
+    ROLLBACK = "ROLLBACK"
+}
+export interface TransactionInfo extends ParseInfo {
+    type: TransactionType;
+}
+export interface VacuumInfo extends ParseInfo {
+    options: any;
+}

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

@@ -0,0 +1,128 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ParseInfoType: function() {
+        return ParseInfoType;
+    },
+    AlterType: function() {
+        return AlterType;
+    },
+    OnEntryNotFound: function() {
+        return OnEntryNotFound;
+    },
+    AlterTableType: function() {
+        return AlterTableType;
+    },
+    AlterForeignKeyType: function() {
+        return AlterForeignKeyType;
+    },
+    AlterViewType: function() {
+        return AlterViewType;
+    },
+    CatalogType: function() {
+        return CatalogType;
+    },
+    LoadType: function() {
+        return LoadType;
+    },
+    TransactionType: function() {
+        return TransactionType;
+    }
+});
+var ParseInfoType;
+(function(ParseInfoType) {
+    ParseInfoType["ALTER_INFO"] = "ALTER_INFO";
+    ParseInfoType["ATTACH_INFO"] = "ATTACH_INFO";
+    ParseInfoType["COPY_INFO"] = "COPY_INFO";
+    ParseInfoType["CREATE_INFO"] = "CREATE_INFO";
+    ParseInfoType["DETACH_INFO"] = "DETACH_INFO";
+    ParseInfoType["DROP_INFO"] = "DROP_INFO";
+    ParseInfoType["BOUND_EXPORT_DATA"] = "BOUND_EXPORT_DATA";
+    ParseInfoType["LOAD_INFO"] = "LOAD_INFO";
+    ParseInfoType["PRAGMA_INFO"] = "PRAGMA_INFO";
+    ParseInfoType["SHOW_SELECT_INFO"] = "SHOW_SELECT_INFO";
+    ParseInfoType["TRANSACTION_INFO"] = "TRANSACTION_INFO";
+    ParseInfoType["VACUUM_INFO"] = "VACUUM_INFO";
+})(ParseInfoType || (ParseInfoType = {}));
+var AlterType;
+(function(AlterType) {
+    AlterType["INVALID"] = "INVALID";
+    AlterType["ALTER_TABLE"] = "ALTER_TABLE";
+    AlterType["ALTER_VIEW"] = "ALTER_VIEW";
+    AlterType["ALTER_SEQUENCE"] = "ALTER_SEQUENCE";
+    AlterType["CHANGE_OWNERSHIP"] = "CHANGE_OWNERSHIP";
+    AlterType["ALTER_SCALAR_FUNCTION"] = "ALTER_SCALAR_FUNCTION";
+    AlterType["ALTER_TABLE_FUNCTION"] = "ALTER_TABLE_FUNCTION";
+})(AlterType || (AlterType = {}));
+var OnEntryNotFound;
+(function(OnEntryNotFound) {
+    OnEntryNotFound["THROW_EXCEPTION"] = "THROW_EXCEPTION";
+    OnEntryNotFound["RETURN_NULL"] = "RETURN_NULL";
+})(OnEntryNotFound || (OnEntryNotFound = {}));
+var AlterTableType;
+(function(AlterTableType) {
+    AlterTableType["INVALID"] = "INVALID";
+    AlterTableType["RENAME_COLUMN"] = "RENAME_COLUMN";
+    AlterTableType["RENAME_TABLE"] = "RENAME_TABLE";
+    AlterTableType["ADD_COLUMN"] = "ADD_COLUMN";
+    AlterTableType["REMOVE_COLUMN"] = "REMOVE_COLUMN";
+    AlterTableType["ALTER_COLUMN_TYPE"] = "ALTER_COLUMN_TYPE";
+    AlterTableType["SET_DEFAULT"] = "SET_DEFAULT";
+    AlterTableType["FOREIGN_KEY_CONSTRAINT"] = "FOREIGN_KEY_CONSTRAINT";
+    AlterTableType["SET_NOT_NULL"] = "SET_NOT_NULL";
+    AlterTableType["DROP_NOT_NULL"] = "DROP_NOT_NULL";
+})(AlterTableType || (AlterTableType = {}));
+var AlterForeignKeyType;
+(function(AlterForeignKeyType) {
+    AlterForeignKeyType["AFT_ADD"] = "AFT_ADD";
+    AlterForeignKeyType["AFT_DELETE"] = "AFT_DELETE";
+})(AlterForeignKeyType || (AlterForeignKeyType = {}));
+var AlterViewType;
+(function(AlterViewType) {
+    AlterViewType["INVALID"] = "INVALID";
+    AlterViewType["RENAME_VIEW"] = "RENAME_VIEW";
+})(AlterViewType || (AlterViewType = {}));
+var CatalogType;
+(function(CatalogType) {
+    CatalogType["INVALID"] = "INVALID";
+    CatalogType["TABLE_ENTRY"] = "TABLE_ENTRY";
+    CatalogType["SCHEMA_ENTRY"] = "SCHEMA_ENTRY";
+    CatalogType["VIEW_ENTRY"] = "VIEW_ENTRY";
+    CatalogType["INDEX_ENTRY"] = "INDEX_ENTRY";
+    CatalogType["PREPARED_STATEMENT"] = "PREPARED_STATEMENT";
+    CatalogType["SEQUENCE_ENTRY"] = "SEQUENCE_ENTRY";
+    CatalogType["COLLATION_ENTRY"] = "COLLATION_ENTRY";
+    CatalogType["TYPE_ENTRY"] = "TYPE_ENTRY";
+    CatalogType["DATABASE_ENTRY"] = "DATABASE_ENTRY";
+    CatalogType[// functions
+    "TABLE_FUNCTION_ENTRY"] = "TABLE_FUNCTION_ENTRY";
+    CatalogType["SCALAR_FUNCTION_ENTRY"] = "SCALAR_FUNCTION_ENTRY";
+    CatalogType["AGGREGATE_FUNCTION_ENTRY"] = "AGGREGATE_FUNCTION_ENTRY";
+    CatalogType["PRAGMA_FUNCTION_ENTRY"] = "PRAGMA_FUNCTION_ENTRY";
+    CatalogType["COPY_FUNCTION_ENTRY"] = "COPY_FUNCTION_ENTRY";
+    CatalogType["MACRO_ENTRY"] = "MACRO_ENTRY";
+    CatalogType["TABLE_MACRO_ENTRY"] = "TABLE_MACRO_ENTRY";
+    CatalogType[// version info
+    "UPDATED_ENTRY"] = "UPDATED_ENTRY";
+    CatalogType["DELETED_ENTRY"] = "DELETED_ENTRY";
+})(CatalogType || (CatalogType = {}));
+var LoadType;
+(function(LoadType) {
+    LoadType["LOAD"] = "LOAD";
+    LoadType["INSTALL"] = "INSTALL";
+    LoadType["FORCE_INSTALL"] = "FORCE_INSTALL";
+})(LoadType || (LoadType = {}));
+var TransactionType;
+(function(TransactionType) {
+    TransactionType["INVALID"] = "INVALID";
+    TransactionType["BEGIN_TRANSACTION"] = "BEGIN_TRANSACTION";
+    TransactionType["COMMIT"] = "COMMIT";
+    TransactionType["ROLLBACK"] = "ROLLBACK";
+})(TransactionType || (TransactionType = {}));
+
+//# sourceMappingURL=ParseInfo.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/ParseInfo.ts"],"sourcesContent":["import { PhysicalIndex } from './Constraint';\nimport { Value } from './Misc';\nimport { ColumnDefinition, LogicalType } from './Nodes';\nimport { ParsedExpression } from './ParsedExpression';\n\nexport enum ParseInfoType {\n  ALTER_INFO = 'ALTER_INFO',\n  ATTACH_INFO = 'ATTACH_INFO',\n  COPY_INFO = 'COPY_INFO',\n  CREATE_INFO = 'CREATE_INFO',\n  DETACH_INFO = 'DETACH_INFO',\n  DROP_INFO = 'DROP_INFO',\n  BOUND_EXPORT_DATA = 'BOUND_EXPORT_DATA',\n  LOAD_INFO = 'LOAD_INFO',\n  PRAGMA_INFO = 'PRAGMA_INFO',\n  SHOW_SELECT_INFO = 'SHOW_SELECT_INFO',\n  TRANSACTION_INFO = 'TRANSACTION_INFO',\n  VACUUM_INFO = 'VACUUM_INFO',\n}\n\nexport interface ParseInfo {\n  info_type: ParseInfoType;\n}\n\nexport enum AlterType {\n  INVALID = 'INVALID',\n  ALTER_TABLE = 'ALTER_TABLE',\n  ALTER_VIEW = 'ALTER_VIEW',\n  ALTER_SEQUENCE = 'ALTER_SEQUENCE',\n  CHANGE_OWNERSHIP = 'CHANGE_OWNERSHIP',\n  ALTER_SCALAR_FUNCTION = 'ALTER_SCALAR_FUNCTION',\n  ALTER_TABLE_FUNCTION = 'ALTER_TABLE_FUNCTION',\n}\n\nexport enum OnEntryNotFound {\n  THROW_EXCEPTION = 'THROW_EXCEPTION',\n  RETURN_NULL = 'RETURN_NULL',\n}\n\nexport interface AlterInfo extends ParseInfo {\n  type: AlterType;\n  catalog: string;\n  schema: string;\n  name: string;\n  if_not_found: OnEntryNotFound;\n  allow_internal: boolean;\n}\n\nexport enum AlterTableType {\n  INVALID = 'INVALID',\n  RENAME_COLUMN = 'RENAME_COLUMN',\n  RENAME_TABLE = 'RENAME_TABLE',\n  ADD_COLUMN = 'ADD_COLUMN',\n  REMOVE_COLUMN = 'REMOVE_COLUMN',\n  ALTER_COLUMN_TYPE = 'ALTER_COLUMN_TYPE',\n  SET_DEFAULT = 'SET_DEFAULT',\n  FOREIGN_KEY_CONSTRAINT = 'FOREIGN_KEY_CONSTRAINT',\n  SET_NOT_NULL = 'SET_NOT_NULL',\n  DROP_NOT_NULL = 'DROP_NOT_NULL',\n}\n\nexport interface AlterTableInfo extends AlterInfo {\n  alter_table_type: AlterTableType;\n}\n\nexport interface RenameColumnInfo extends AlterTableInfo {\n  old_name: string;\n  new_name: string;\n}\n\nexport interface RenameTableInfo extends AlterTableInfo {\n  new_table_name: string;\n}\n\nexport interface AddColumnInfo extends AlterTableInfo {\n  new_column: ColumnDefinition;\n  if_column_not_exists: boolean;\n}\n\nexport interface RemoveColumnInfo extends AlterTableInfo {\n  removed_column: string;\n  if_column_exists: boolean;\n  cascade: boolean;\n}\n\nexport interface ChangeColumnTypeInfo extends AlterTableInfo {\n  column_name: string;\n  target_type: LogicalType;\n  expression: ParsedExpression;\n}\n\nexport interface SetDefaultInfo extends AlterTableInfo {\n  column_name: string;\n  expression?: ParsedExpression;\n}\n\nexport enum AlterForeignKeyType {\n  AFT_ADD = 'AFT_ADD',\n  AFT_DELETE = 'AFT_DELETE',\n}\n\nexport interface AlterForeignKeyInfo extends AlterTableInfo {\n  fk_table: string;\n  pk_columns: string[];\n  fk_columns: string[];\n  pk_keys: PhysicalIndex[];\n  fk_keys: PhysicalIndex[];\n  alter_fk_type: AlterForeignKeyType;\n}\n\nexport interface SetNotNullInfo extends AlterTableInfo {\n  column_name: string;\n}\n\nexport interface DropNotNullInfo extends AlterTableInfo {\n  column_name: string;\n}\n\nexport enum AlterViewType {\n  INVALID = 'INVALID',\n  RENAME_VIEW = 'RENAME_VIEW',\n}\n\nexport interface AlterViewInfo extends AlterInfo {\n  alter_view_type: AlterViewType;\n}\n\nexport interface RenameViewInfo extends AlterViewInfo {\n  new_view_name: string;\n}\n\nexport interface AttachInfo extends ParseInfo {\n  name: string;\n  path: string;\n  options: { [key: string]: Value };\n}\n\nexport interface CopyInfo extends ParseInfo {\n  catalog: string;\n  schema: string;\n  table: string;\n  select_list: string[];\n  is_from: boolean;\n  format: string;\n  file_path: string;\n  options: { [key: string]: Value[] };\n}\n\nexport interface DetachInfo extends ParseInfo {\n  name: string;\n  if_not_found: OnEntryNotFound;\n}\n\nexport enum CatalogType {\n  INVALID = 'INVALID',\n  TABLE_ENTRY = 'TABLE_ENTRY',\n  SCHEMA_ENTRY = 'SCHEMA_ENTRY',\n  VIEW_ENTRY = 'VIEW_ENTRY',\n  INDEX_ENTRY = 'INDEX_ENTRY',\n  PREPARED_STATEMENT = 'PREPARED_STATEMENT',\n  SEQUENCE_ENTRY = 'SEQUENCE_ENTRY',\n  COLLATION_ENTRY = 'COLLATION_ENTRY',\n  TYPE_ENTRY = 'TYPE_ENTRY',\n  DATABASE_ENTRY = 'DATABASE_ENTRY',\n\n  // functions\n  TABLE_FUNCTION_ENTRY = 'TABLE_FUNCTION_ENTRY',\n  SCALAR_FUNCTION_ENTRY = 'SCALAR_FUNCTION_ENTRY',\n  AGGREGATE_FUNCTION_ENTRY = 'AGGREGATE_FUNCTION_ENTRY',\n  PRAGMA_FUNCTION_ENTRY = 'PRAGMA_FUNCTION_ENTRY',\n  COPY_FUNCTION_ENTRY = 'COPY_FUNCTION_ENTRY',\n  MACRO_ENTRY = 'MACRO_ENTRY',\n  TABLE_MACRO_ENTRY = 'TABLE_MACRO_ENTRY',\n\n  // version info\n  UPDATED_ENTRY = 'UPDATED_ENTRY',\n  DELETED_ENTRY = 'DELETED_ENTRY',\n}\n\nexport interface DropInfo extends ParseInfo {\n  type: CatalogType;\n  catalog: string;\n  schema: string;\n  name: string;\n  if_not_found: OnEntryNotFound;\n  cascade: boolean;\n  allow_drop_internal: boolean;\n}\n\nexport enum LoadType {\n  LOAD = 'LOAD',\n  INSTALL = 'INSTALL',\n  FORCE_INSTALL = 'FORCE_INSTALL',\n}\n\nexport interface LoadInfo extends ParseInfo {\n  filename: string;\n  load_type: LoadType;\n  repository: string;\n}\n\nexport interface PragmaInfo extends ParseInfo {\n  name: string;\n  parameters: Value[];\n  named_parameters: { [key: string]: Value };\n}\n\nexport enum TransactionType {\n  INVALID = 'INVALID',\n  BEGIN_TRANSACTION = 'BEGIN_TRANSACTION',\n  COMMIT = 'COMMIT',\n  ROLLBACK = 'ROLLBACK',\n}\n\nexport interface TransactionInfo extends ParseInfo {\n  type: TransactionType;\n}\n\nexport interface VacuumInfo extends ParseInfo {\n  options: any;\n}\n"],"names":["ParseInfoType","ALTER_INFO","ATTACH_INFO","COPY_INFO","CREATE_INFO","DETACH_INFO","DROP_INFO","BOUND_EXPORT_DATA","LOAD_INFO","PRAGMA_INFO","SHOW_SELECT_INFO","TRANSACTION_INFO","VACUUM_INFO","AlterType","INVALID","ALTER_TABLE","ALTER_VIEW","ALTER_SEQUENCE","CHANGE_OWNERSHIP","ALTER_SCALAR_FUNCTION","ALTER_TABLE_FUNCTION","OnEntryNotFound","THROW_EXCEPTION","RETURN_NULL","AlterTableType","RENAME_COLUMN","RENAME_TABLE","ADD_COLUMN","REMOVE_COLUMN","ALTER_COLUMN_TYPE","SET_DEFAULT","FOREIGN_KEY_CONSTRAINT","SET_NOT_NULL","DROP_NOT_NULL","AlterForeignKeyType","AFT_ADD","AFT_DELETE","AlterViewType","RENAME_VIEW","CatalogType","TABLE_ENTRY","SCHEMA_ENTRY","VIEW_ENTRY","INDEX_ENTRY","PREPARED_STATEMENT","SEQUENCE_ENTRY","COLLATION_ENTRY","TYPE_ENTRY","DATABASE_ENTRY","TABLE_FUNCTION_ENTRY","SCALAR_FUNCTION_ENTRY","AGGREGATE_FUNCTION_ENTRY","PRAGMA_FUNCTION_ENTRY","COPY_FUNCTION_ENTRY","MACRO_ENTRY","TABLE_MACRO_ENTRY","UPDATED_ENTRY","DELETED_ENTRY","LoadType","LOAD","INSTALL","FORCE_INSTALL","TransactionType","BEGIN_TRANSACTION","COMMIT","ROLLBACK"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKO;UAAKA,aAAa;IAAbA,cACVC,gBAAAA;IADUD,cAEVE,iBAAAA;IAFUF,cAGVG,eAAAA;IAHUH,cAIVI,iBAAAA;IAJUJ,cAKVK,iBAAAA;IALUL,cAMVM,eAAAA;IANUN,cAOVO,uBAAAA;IAPUP,cAQVQ,eAAAA;IARUR,cASVS,iBAAAA;IATUT,cAUVU,sBAAAA;IAVUV,cAWVW,sBAAAA;IAXUX,cAYVY,iBAAAA;GAZUZ,kBAAAA;IAmBL;UAAKa,SAAS;IAATA,UACVC,aAAAA;IADUD,UAEVE,iBAAAA;IAFUF,UAGVG,gBAAAA;IAHUH,UAIVI,oBAAAA;IAJUJ,UAKVK,sBAAAA;IALUL,UAMVM,2BAAAA;IANUN,UAOVO,0BAAAA;GAPUP,cAAAA;IAUL;UAAKQ,eAAe;IAAfA,gBACVC,qBAAAA;IADUD,gBAEVE,iBAAAA;GAFUF,oBAAAA;IAcL;UAAKG,cAAc;IAAdA,eACVV,aAAAA;IADUU,eAEVC,mBAAAA;IAFUD,eAGVE,kBAAAA;IAHUF,eAIVG,gBAAAA;IAJUH,eAKVI,mBAAAA;IALUJ,eAMVK,uBAAAA;IANUL,eAOVM,iBAAAA;IAPUN,eAQVO,4BAAAA;IARUP,eASVQ,kBAAAA;IATUR,eAUVS,mBAAAA;GAVUT,mBAAAA;IAgDL;UAAKU,mBAAmB;IAAnBA,oBACVC,aAAAA;IADUD,oBAEVE,gBAAAA;GAFUF,wBAAAA;IAsBL;UAAKG,aAAa;IAAbA,cACVvB,aAAAA;IADUuB,cAEVC,iBAAAA;GAFUD,kBAAAA;IAmCL;UAAKE,WAAW;IAAXA,YACVzB,aAAAA;IADUyB,YAEVC,iBAAAA;IAFUD,YAGVE,kBAAAA;IAHUF,YAIVG,gBAAAA;IAJUH,YAKVI,iBAAAA;IALUJ,YAMVK,wBAAAA;IANUL,YAOVM,oBAAAA;IAPUN,YAQVO,qBAAAA;IARUP,YASVQ,gBAAAA;IATUR,YAUVS,oBAAAA;IAVUT,YAYV,YAAY;IACZU,0BAAAA;IAbUV,YAcVW,2BAAAA;IAdUX,YAeVY,8BAAAA;IAfUZ,YAgBVa,2BAAAA;IAhBUb,YAiBVc,yBAAAA;IAjBUd,YAkBVe,iBAAAA;IAlBUf,YAmBVgB,uBAAAA;IAnBUhB,YAqBV,eAAe;IACfiB,mBAAAA;IAtBUjB,YAuBVkB,mBAAAA;GAvBUlB,gBAAAA;IAoCL;UAAKmB,QAAQ;IAARA,SACVC,UAAAA;IADUD,SAEVE,aAAAA;IAFUF,SAGVG,mBAAAA;GAHUH,aAAAA;IAkBL;UAAKI,eAAe;IAAfA,gBACVhD,aAAAA;IADUgD,gBAEVC,uBAAAA;IAFUD,gBAGVE,YAAAA;IAHUF,gBAIVG,cAAAA;GAJUH,oBAAAA"}

package/src/types/duckdb-serialization-types/serialization/ParsedExpression.d.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=ParsedExpression.d.js.map

package/src/types/duckdb-serialization-types/serialization/ParsedExpression.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/ParsedExpression.d.ts"],"names":[],"mappings":""}