@ohos-ports/nodejs-polars 0.23.4-beta.0

package/bin/index.d.ts

@@ -0,0 +1,256 @@
+import * as df from "./dataframe";
+import { Field as _field, DataType } from "./datatypes";
+import * as series from "./series";
+export { DataType } from "./datatypes";
+import * as cfg from "./cfg";
+import * as func from "./functions";
+import * as io from "./io";
+import * as ldf from "./lazy/dataframe";
+export * from "./cfg";
+export * from "./dataframe";
+export * from "./functions";
+export * from "./io";
+export * from "./lazy";
+export * from "./lazy/dataframe";
+export * from "./series";
+import * as lazy from "./lazy";
+export * from "./types";
+import * as sql from "./sql";
+export type { GroupBy } from "./groupby";
+export declare namespace pl {
+    export import Expr = lazy.Expr;
+    export import DataFrame = df.DataFrame;
+    export import LazyDataFrame = ldf.LazyDataFrame;
+    export import Series = series.Series;
+    type LazyGroupBy = lazy.LazyGroupBy;
+    type When = lazy.When;
+    type Then = lazy.Then;
+    type ChainedWhen = lazy.ChainedWhen;
+    type ChainedThen = lazy.ChainedThen;
+    export import Config = cfg.Config;
+    export import Field = _field;
+    export import repeat = func.repeat;
+    export import concat = func.concat;
+    export import scanCSV = io.scanCSV;
+    export import scanJson = io.scanJson;
+    export import scanIPC = io.scanIPC;
+    export import scanParquet = io.scanParquet;
+    export import readRecords = io.readRecords;
+    export import readCSV = io.readCSV;
+    export import readIPC = io.readIPC;
+    export import readIPCStream = io.readIPCStream;
+    export import readJSON = io.readJSON;
+    export import readParquet = io.readParquet;
+    export import readAvro = io.readAvro;
+    export import readCSVStream = io.readCSVStream;
+    export import readJSONStream = io.readJSONStream;
+    export import col = lazy.col;
+    export import nth = lazy.nth;
+    export import cols = lazy.cols;
+    export import lit = lazy.lit;
+    export import intRange = lazy.intRange;
+    export import intRanges = lazy.intRanges;
+    export import argSortBy = lazy.argSortBy;
+    export import avg = lazy.avg;
+    export import concatList = lazy.concatList;
+    export import concatString = lazy.concatString;
+    export import count = lazy.count;
+    export import cov = lazy.cov;
+    export import exclude = lazy.exclude;
+    export import element = lazy.element;
+    export import first = lazy.first;
+    export import format = lazy.format;
+    export import groups = lazy.groups;
+    export import head = lazy.head;
+    export import last = lazy.last;
+    export import len = lazy.len;
+    export import mean = lazy.mean;
+    export import median = lazy.median;
+    export import nUnique = lazy.nUnique;
+    export import pearsonCorr = lazy.pearsonCorr;
+    export import quantile = lazy.quantile;
+    export import select = lazy.select;
+    export import struct = lazy.struct;
+    export import allHorizontal = lazy.allHorizontal;
+    export import anyHorizontal = lazy.anyHorizontal;
+    export import minHorizontal = lazy.minHorizontal;
+    export import maxHorizontal = lazy.maxHorizontal;
+    export import sumHorizontal = lazy.sumHorizontal;
+    export import spearmanRankCorr = lazy.spearmanRankCorr;
+    export import tail = lazy.tail;
+    export import list = lazy.list;
+    export import when = lazy.when;
+    const version: any;
+    type Categorical = import("./datatypes").Categorical;
+    type Int8 = import("./datatypes").Int8;
+    type Int16 = import("./datatypes").Int16;
+    type Int32 = import("./datatypes").Int32;
+    type Int64 = import("./datatypes").Int64;
+    type UInt8 = import("./datatypes").UInt8;
+    type UInt16 = import("./datatypes").UInt16;
+    type UInt32 = import("./datatypes").UInt32;
+    type UInt64 = import("./datatypes").UInt64;
+    type Float32 = import("./datatypes").Float32;
+    type Float64 = import("./datatypes").Float64;
+    type Bool = import("./datatypes").Bool;
+    type Utf8 = import("./datatypes").Utf8;
+    type String = import("./datatypes").String;
+    type List = import("./datatypes").List;
+    type FixedSizeList = import("./datatypes").FixedSizeList;
+    type Date = import("./datatypes").Date;
+    type Datetime = import("./datatypes").Datetime;
+    type Time = import("./datatypes").Time;
+    type Duration = import("./datatypes").Duration;
+    type Object = import("./datatypes").Object_;
+    type Null = import("./datatypes").Null;
+    type Struct = import("./datatypes").Struct;
+    type Decimal = import("./datatypes").Decimal;
+    const Categorical: import("./datatypes").Categorical;
+    const Int8: import("./datatypes").Int8;
+    const Int16: import("./datatypes").Int16;
+    const Int32: import("./datatypes").Int32;
+    const Int64: import("./datatypes").Int64;
+    const UInt8: import("./datatypes").UInt8;
+    const UInt16: import("./datatypes").UInt16;
+    const UInt32: import("./datatypes").UInt32;
+    const UInt64: import("./datatypes").UInt64;
+    const Float32: import("./datatypes").Float32;
+    const Float64: import("./datatypes").Float64;
+    const Bool: import("./datatypes").Bool;
+    const Utf8: import("./datatypes").Utf8;
+    const String: import("./datatypes").String;
+    const List: typeof DataType.List;
+    const FixedSizeList: typeof DataType.FixedSizeList;
+    const Date: import("./datatypes").Date;
+    const Datetime: typeof DataType.Datetime;
+    const Duration: typeof DataType.Duration;
+    const Time: import("./datatypes").Time;
+    const Object: import("./datatypes").Object_;
+    const Null: import("./datatypes").Null;
+    const Struct: typeof DataType.Struct;
+    const Decimal: typeof DataType.Decimal;
+    /**
+     * Run SQL queries against DataFrame/LazyFrame data.
+     *
+     * @experimental This functionality is considered **unstable**, although it is close to being
+     * considered stable. It may be changed at any point without it being considered a breaking change.
+     */
+    function SQLContext(frames?: Record<string, DataFrame | LazyDataFrame>): sql.SQLContext;
+}
+export default pl;
+export import Expr = lazy.Expr;
+export import DataFrame = df.DataFrame;
+export import LazyDataFrame = ldf.LazyDataFrame;
+export import Series = series.Series;
+export type LazyGroupBy = lazy.LazyGroupBy;
+export type When = lazy.When;
+export type Then = lazy.Then;
+export type ChainedWhen = lazy.ChainedWhen;
+export type ChainedThen = lazy.ChainedThen;
+export import Config = cfg.Config;
+export import Field = _field;
+export import repeat = func.repeat;
+export import concat = func.concat;
+export import scanCSV = io.scanCSV;
+export import scanJson = io.scanJson;
+export import scanIPC = io.scanIPC;
+export import scanParquet = io.scanParquet;
+export import readRecords = io.readRecords;
+export import readCSV = io.readCSV;
+export import readIPC = io.readIPC;
+export import readIPCStream = io.readIPCStream;
+export import readJSON = io.readJSON;
+export import readParquet = io.readParquet;
+export import readAvro = io.readAvro;
+export import readCSVStream = io.readCSVStream;
+export import readJSONStream = io.readJSONStream;
+export import col = lazy.col;
+export import cols = lazy.cols;
+export import lit = lazy.lit;
+export import intRange = lazy.intRange;
+export import intRanges = lazy.intRanges;
+export import argSortBy = lazy.argSortBy;
+export import avg = lazy.avg;
+export import concatList = lazy.concatList;
+export import concatString = lazy.concatString;
+export import count = lazy.count;
+export import cov = lazy.cov;
+export import exclude = lazy.exclude;
+export import element = lazy.element;
+export import first = lazy.first;
+export import format = lazy.format;
+export import groups = lazy.groups;
+export import head = lazy.head;
+export import last = lazy.last;
+export import mean = lazy.mean;
+export import median = lazy.median;
+export import nUnique = lazy.nUnique;
+export import pearsonCorr = lazy.pearsonCorr;
+export import quantile = lazy.quantile;
+export import select = lazy.select;
+export import struct = lazy.struct;
+export import allHorizontal = lazy.allHorizontal;
+export import anyHorizontal = lazy.anyHorizontal;
+export import minHorizontal = lazy.minHorizontal;
+export import maxHorizontal = lazy.maxHorizontal;
+export import sumHorizontal = lazy.sumHorizontal;
+export import spearmanRankCorr = lazy.spearmanRankCorr;
+export import tail = lazy.tail;
+export import list = lazy.list;
+export import when = lazy.when;
+export declare const version: any;
+export type Categorical = import("./datatypes").Categorical;
+export type Int8 = import("./datatypes").Int8;
+export type Int16 = import("./datatypes").Int16;
+export type Int32 = import("./datatypes").Int32;
+export type Int64 = import("./datatypes").Int64;
+export type UInt8 = import("./datatypes").UInt8;
+export type UInt16 = import("./datatypes").UInt16;
+export type UInt32 = import("./datatypes").UInt32;
+export type UInt64 = import("./datatypes").UInt64;
+export type Float32 = import("./datatypes").Float32;
+export type Float64 = import("./datatypes").Float64;
+export type Bool = import("./datatypes").Bool;
+export type Utf8 = import("./datatypes").Utf8;
+export type String = import("./datatypes").String;
+export type List = import("./datatypes").List;
+export type FixedSizeList = import("./datatypes").FixedSizeList;
+export type Date = import("./datatypes").Date;
+export type Datetime = import("./datatypes").Datetime;
+export type Time = import("./datatypes").Time;
+export type Duration = import("./datatypes").Duration;
+export type Object = import("./datatypes").Object_;
+export type Null = import("./datatypes").Null;
+export type Struct = import("./datatypes").Struct;
+export type Decimal = import("./datatypes").Decimal;
+export declare const Categorical: import("./datatypes").Categorical;
+export declare const Int8: import("./datatypes").Int8;
+export declare const Int16: import("./datatypes").Int16;
+export declare const Int32: import("./datatypes").Int32;
+export declare const Int64: import("./datatypes").Int64;
+export declare const UInt8: import("./datatypes").UInt8;
+export declare const UInt16: import("./datatypes").UInt16;
+export declare const UInt32: import("./datatypes").UInt32;
+export declare const UInt64: import("./datatypes").UInt64;
+export declare const Float32: import("./datatypes").Float32;
+export declare const Float64: import("./datatypes").Float64;
+export declare const Bool: import("./datatypes").Bool;
+export declare const Utf8: import("./datatypes").Utf8;
+export declare const String: import("./datatypes").String;
+export declare const List: typeof DataType.List;
+export declare const FixedSizeList: typeof DataType.FixedSizeList;
+export declare const Date: import("./datatypes").Date;
+export declare const Datetime: typeof DataType.Datetime;
+export declare const Duration: typeof DataType.Duration;
+export declare const Time: import("./datatypes").Time;
+export declare const Object: import("./datatypes").Object_;
+export declare const Null: import("./datatypes").Null;
+export declare const Struct: typeof DataType.Struct;
+export declare const Decimal: typeof DataType.Decimal;
+/**
+ * Run SQL queries against DataFrame/LazyFrame data.
+ *
+ * @experimental This functionality is considered **unstable**, although it is close to being
+ * considered stable. It may be changed at any point without it being considered a breaking change.
+ */
+export declare function SQLContext(frames?: Record<string, DataFrame | LazyDataFrame>): sql.SQLContext;

package/bin/index.js

@@ -0,0 +1,267 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anyHorizontal = exports.allHorizontal = exports.struct = exports.select = exports.quantile = exports.pearsonCorr = exports.nUnique = exports.median = exports.mean = exports.last = exports.head = exports.groups = exports.format = exports.first = exports.element = exports.exclude = exports.cov = exports.count = exports.concatString = exports.concatList = exports.avg = exports.argSortBy = exports.intRanges = exports.intRange = exports.lit = exports.cols = exports.col = exports.readJSONStream = exports.readCSVStream = exports.readAvro = exports.readParquet = exports.readJSON = exports.readIPCStream = exports.readIPC = exports.readCSV = exports.readRecords = exports.scanParquet = exports.scanIPC = exports.scanJson = exports.scanCSV = exports.concat = exports.repeat = exports.Field = exports.Config = exports.Series = exports.LazyDataFrame = exports.DataFrame = exports.Expr = exports.pl = exports.DataType = void 0;
+exports.Decimal = exports.Struct = exports.Null = exports.Object = exports.Time = exports.Duration = exports.Datetime = exports.Date = exports.FixedSizeList = exports.List = exports.String = exports.Utf8 = exports.Bool = exports.Float64 = exports.Float32 = exports.UInt64 = exports.UInt32 = exports.UInt16 = exports.UInt8 = exports.Int64 = exports.Int32 = exports.Int16 = exports.Int8 = exports.Categorical = exports.version = exports.when = exports.list = exports.tail = exports.spearmanRankCorr = exports.sumHorizontal = exports.maxHorizontal = exports.minHorizontal = void 0;
+exports.SQLContext = SQLContext;
+const df = __importStar(require("./dataframe"));
+const datatypes_1 = require("./datatypes");
+const series = __importStar(require("./series"));
+var datatypes_2 = require("./datatypes");
+Object.defineProperty(exports, "DataType", { enumerable: true, get: function () { return datatypes_2.DataType; } });
+const cfg = __importStar(require("./cfg"));
+const func = __importStar(require("./functions"));
+const polars_internal_1 = __importDefault(require("./internals/polars_internal"));
+const io = __importStar(require("./io"));
+const ldf = __importStar(require("./lazy/dataframe"));
+__exportStar(require("./cfg"), exports);
+__exportStar(require("./dataframe"), exports);
+__exportStar(require("./functions"), exports);
+__exportStar(require("./io"), exports);
+__exportStar(require("./lazy"), exports);
+__exportStar(require("./lazy/dataframe"), exports);
+__exportStar(require("./series"), exports);
+const lazy = __importStar(require("./lazy"));
+__exportStar(require("./types"), exports);
+const sql = __importStar(require("./sql"));
+var pl;
+(function (pl) {
+    pl.Expr = lazy.Expr;
+    pl.DataFrame = df.DataFrame;
+    pl.LazyDataFrame = ldf.LazyDataFrame;
+    pl.Series = series.Series;
+    pl.Config = cfg.Config;
+    pl.Field = datatypes_1.Field;
+    pl.repeat = func.repeat;
+    pl.concat = func.concat;
+    // IO
+    pl.scanCSV = io.scanCSV;
+    pl.scanJson = io.scanJson;
+    pl.scanIPC = io.scanIPC;
+    pl.scanParquet = io.scanParquet;
+    pl.readRecords = io.readRecords;
+    pl.readCSV = io.readCSV;
+    pl.readIPC = io.readIPC;
+    pl.readIPCStream = io.readIPCStream;
+    pl.readJSON = io.readJSON;
+    pl.readParquet = io.readParquet;
+    pl.readAvro = io.readAvro;
+    pl.readCSVStream = io.readCSVStream;
+    pl.readJSONStream = io.readJSONStream;
+    // lazy
+    pl.col = lazy.col;
+    pl.nth = lazy.nth;
+    pl.cols = lazy.cols;
+    pl.lit = lazy.lit;
+    pl.intRange = lazy.intRange;
+    pl.intRanges = lazy.intRanges;
+    pl.argSortBy = lazy.argSortBy;
+    pl.avg = lazy.avg;
+    pl.concatList = lazy.concatList;
+    pl.concatString = lazy.concatString;
+    pl.count = lazy.count;
+    pl.cov = lazy.cov;
+    pl.exclude = lazy.exclude;
+    pl.element = lazy.element;
+    pl.first = lazy.first;
+    pl.format = lazy.format;
+    pl.groups = lazy.groups;
+    pl.head = lazy.head;
+    pl.last = lazy.last;
+    pl.len = lazy.len;
+    pl.mean = lazy.mean;
+    pl.median = lazy.median;
+    pl.nUnique = lazy.nUnique;
+    pl.pearsonCorr = lazy.pearsonCorr;
+    pl.quantile = lazy.quantile;
+    pl.select = lazy.select;
+    pl.struct = lazy.struct;
+    pl.allHorizontal = lazy.allHorizontal;
+    pl.anyHorizontal = lazy.anyHorizontal;
+    pl.minHorizontal = lazy.minHorizontal;
+    pl.maxHorizontal = lazy.maxHorizontal;
+    pl.sumHorizontal = lazy.sumHorizontal;
+    pl.spearmanRankCorr = lazy.spearmanRankCorr;
+    pl.tail = lazy.tail;
+    pl.list = lazy.list;
+    pl.when = lazy.when;
+    pl.version = polars_internal_1.default.version();
+    pl.Categorical = datatypes_1.DataType.Categorical;
+    pl.Int8 = datatypes_1.DataType.Int8;
+    pl.Int16 = datatypes_1.DataType.Int16;
+    pl.Int32 = datatypes_1.DataType.Int32;
+    pl.Int64 = datatypes_1.DataType.Int64;
+    pl.UInt8 = datatypes_1.DataType.UInt8;
+    pl.UInt16 = datatypes_1.DataType.UInt16;
+    pl.UInt32 = datatypes_1.DataType.UInt32;
+    pl.UInt64 = datatypes_1.DataType.UInt64;
+    pl.Float32 = datatypes_1.DataType.Float32;
+    pl.Float64 = datatypes_1.DataType.Float64;
+    pl.Bool = datatypes_1.DataType.Bool;
+    pl.Utf8 = datatypes_1.DataType.Utf8;
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: pl.String
+    pl.String = datatypes_1.DataType.String;
+    pl.List = datatypes_1.DataType.List;
+    pl.FixedSizeList = datatypes_1.DataType.FixedSizeList;
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: pl.Date
+    pl.Date = datatypes_1.DataType.Date;
+    pl.Datetime = datatypes_1.DataType.Datetime;
+    pl.Duration = datatypes_1.DataType.Duration;
+    pl.Time = datatypes_1.DataType.Time;
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: pl.Object
+    pl.Object = datatypes_1.DataType.Object;
+    pl.Null = datatypes_1.DataType.Null;
+    pl.Struct = datatypes_1.DataType.Struct;
+    pl.Decimal = datatypes_1.DataType.Decimal;
+    /**
+     * Run SQL queries against DataFrame/LazyFrame data.
+     *
+     * @experimental This functionality is considered **unstable**, although it is close to being
+     * considered stable. It may be changed at any point without it being considered a breaking change.
+     */
+    function SQLContext(frames) {
+        return new sql.SQLContext(frames);
+    }
+    pl.SQLContext = SQLContext;
+})(pl || (exports.pl = pl = {}));
+exports.default = pl;
+// ------
+// CommonJS compatibility.
+// This allows the user to use any of the following
+// `import * as pl from "nodejs-polars"`
+// `import pl from "nodejs-polars"`.
+// `const pl = require("nodejs-polars")`.
+// `const { DataFrame, Series, } = require("nodejs-polars")`.
+// ------
+exports.Expr = lazy.Expr;
+exports.DataFrame = df.DataFrame;
+exports.LazyDataFrame = ldf.LazyDataFrame;
+exports.Series = series.Series;
+exports.Config = cfg.Config;
+exports.Field = datatypes_1.Field;
+exports.repeat = func.repeat;
+exports.concat = func.concat;
+// IO
+exports.scanCSV = io.scanCSV;
+exports.scanJson = io.scanJson;
+exports.scanIPC = io.scanIPC;
+exports.scanParquet = io.scanParquet;
+exports.readRecords = io.readRecords;
+exports.readCSV = io.readCSV;
+exports.readIPC = io.readIPC;
+exports.readIPCStream = io.readIPCStream;
+exports.readJSON = io.readJSON;
+exports.readParquet = io.readParquet;
+exports.readAvro = io.readAvro;
+exports.readCSVStream = io.readCSVStream;
+exports.readJSONStream = io.readJSONStream;
+// lazy
+exports.col = lazy.col;
+exports.cols = lazy.cols;
+exports.lit = lazy.lit;
+exports.intRange = lazy.intRange;
+exports.intRanges = lazy.intRanges;
+exports.argSortBy = lazy.argSortBy;
+exports.avg = lazy.avg;
+exports.concatList = lazy.concatList;
+exports.concatString = lazy.concatString;
+exports.count = lazy.count;
+exports.cov = lazy.cov;
+exports.exclude = lazy.exclude;
+exports.element = lazy.element;
+exports.first = lazy.first;
+exports.format = lazy.format;
+exports.groups = lazy.groups;
+exports.head = lazy.head;
+exports.last = lazy.last;
+exports.mean = lazy.mean;
+exports.median = lazy.median;
+exports.nUnique = lazy.nUnique;
+exports.pearsonCorr = lazy.pearsonCorr;
+exports.quantile = lazy.quantile;
+exports.select = lazy.select;
+exports.struct = lazy.struct;
+exports.allHorizontal = lazy.allHorizontal;
+exports.anyHorizontal = lazy.anyHorizontal;
+exports.minHorizontal = lazy.minHorizontal;
+exports.maxHorizontal = lazy.maxHorizontal;
+exports.sumHorizontal = lazy.sumHorizontal;
+exports.spearmanRankCorr = lazy.spearmanRankCorr;
+exports.tail = lazy.tail;
+exports.list = lazy.list;
+exports.when = lazy.when;
+exports.version = polars_internal_1.default.version();
+exports.Categorical = datatypes_1.DataType.Categorical;
+exports.Int8 = datatypes_1.DataType.Int8;
+exports.Int16 = datatypes_1.DataType.Int16;
+exports.Int32 = datatypes_1.DataType.Int32;
+exports.Int64 = datatypes_1.DataType.Int64;
+exports.UInt8 = datatypes_1.DataType.UInt8;
+exports.UInt16 = datatypes_1.DataType.UInt16;
+exports.UInt32 = datatypes_1.DataType.UInt32;
+exports.UInt64 = datatypes_1.DataType.UInt64;
+exports.Float32 = datatypes_1.DataType.Float32;
+exports.Float64 = datatypes_1.DataType.Float64;
+exports.Bool = datatypes_1.DataType.Bool;
+exports.Utf8 = datatypes_1.DataType.Utf8;
+// biome-ignore lint/suspicious/noShadowRestrictedNames: pl.String
+exports.String = datatypes_1.DataType.String;
+exports.List = datatypes_1.DataType.List;
+exports.FixedSizeList = datatypes_1.DataType.FixedSizeList;
+// biome-ignore lint/suspicious/noShadowRestrictedNames: pl.Date
+exports.Date = datatypes_1.DataType.Date;
+exports.Datetime = datatypes_1.DataType.Datetime;
+exports.Duration = datatypes_1.DataType.Duration;
+exports.Time = datatypes_1.DataType.Time;
+// biome-ignore lint/suspicious/noShadowRestrictedNames: pl.Object
+exports.Object = datatypes_1.DataType.Object;
+exports.Null = datatypes_1.DataType.Null;
+exports.Struct = datatypes_1.DataType.Struct;
+exports.Decimal = datatypes_1.DataType.Decimal;
+/**
+ * Run SQL queries against DataFrame/LazyFrame data.
+ *
+ * @experimental This functionality is considered **unstable**, although it is close to being
+ * considered stable. It may be changed at any point without it being considered a breaking change.
+ */
+function SQLContext(frames) {
+    return new sql.SQLContext(frames);
+}

package/bin/internals/construction.d.ts

@@ -0,0 +1,7 @@
+import { DataType } from "../datatypes";
+export declare const jsTypeToPolarsType: (value: unknown) => DataType;
+/**
+ * Construct an internal `JsSeries` from an array
+ */
+export declare function arrayToJsSeries(name?: string, values?: any[], dtype?: DataType): any;
+export declare function arrayToJsDataFrame(data: any[], options?: any): any;