@duckdb/node-api 1.1.2-alpha.1

package/lib/DuckDBVector.d.ts

@@ -0,0 +1,491 @@
+import duckdb from '@duckdb/node-bindings';
+import { DuckDBArrayType, DuckDBBigIntType, DuckDBBitType, DuckDBBlobType, DuckDBBooleanType, DuckDBDateType, DuckDBDecimalType, DuckDBDoubleType, DuckDBEnumType, DuckDBFloatType, DuckDBHugeIntType, DuckDBIntegerType, DuckDBListType, DuckDBMapType, DuckDBSmallIntType, DuckDBStructType, DuckDBTimeTZType, DuckDBTimeType, DuckDBTimestampMillisecondsType, DuckDBTimestampNanosecondsType, DuckDBTimestampSecondsType, DuckDBTimestampType, DuckDBTinyIntType, DuckDBType, DuckDBUBigIntType, DuckDBUHugeIntType, DuckDBUIntegerType, DuckDBUSmallIntType, DuckDBUTinyIntType, DuckDBUUIDType, DuckDBUnionType, DuckDBVarCharType, DuckDBVarIntType } from './DuckDBType';
+export declare class DuckDBSmallDecimal {
+    readonly scaledValue: number;
+    readonly type: DuckDBDecimalType;
+    constructor(scaledValue: number, type: DuckDBDecimalType);
+}
+export declare class DuckDBLargeDecimal {
+    readonly scaledValue: bigint;
+    readonly type: DuckDBDecimalType;
+    constructor(scaledValue: bigint, type: DuckDBDecimalType);
+}
+declare class DuckDBValidity {
+    private readonly data;
+    private readonly offset;
+    private constructor();
+    static fromVector(vector: duckdb.Vector, itemCount: number): DuckDBValidity;
+    itemValid(itemIndex: number): boolean;
+    slice(offset: number): DuckDBValidity;
+}
+export declare abstract class DuckDBVector<T> {
+    static standardSize(): number;
+    static create(vector: duckdb.Vector, itemCount: number, knownType?: DuckDBType): DuckDBVector<any>;
+    abstract get type(): DuckDBType;
+    abstract get itemCount(): number;
+    abstract getItem(itemIndex: number): T | null;
+    abstract slice(offset: number, length: number): DuckDBVector<T>;
+}
+export declare class DuckDBBooleanVector extends DuckDBVector<boolean> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBBooleanVector;
+    get type(): DuckDBBooleanType;
+    get itemCount(): number;
+    getItem(itemIndex: number): boolean | null;
+    slice(offset: number, length: number): DuckDBBooleanVector;
+}
+export declare class DuckDBTinyIntVector extends DuckDBVector<number> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: Int8Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTinyIntVector;
+    get type(): DuckDBTinyIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): number | null;
+    slice(offset: number, length: number): DuckDBTinyIntVector;
+}
+export declare class DuckDBSmallIntVector extends DuckDBVector<number> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: Int16Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBSmallIntVector;
+    get type(): DuckDBSmallIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): number | null;
+    slice(offset: number, length: number): DuckDBSmallIntVector;
+}
+export declare class DuckDBIntegerVector extends DuckDBVector<number> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: Int32Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBIntegerVector;
+    get type(): DuckDBIntegerType;
+    get itemCount(): number;
+    getItem(itemIndex: number): number | null;
+    slice(offset: number, length: number): DuckDBIntegerVector;
+}
+export declare class DuckDBBigIntVector extends DuckDBVector<bigint> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: BigInt64Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBBigIntVector;
+    get type(): DuckDBBigIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBBigIntVector;
+}
+export declare class DuckDBUTinyIntVector extends DuckDBVector<number> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: Uint8Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBUTinyIntVector;
+    get type(): DuckDBUTinyIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): number | null;
+    slice(offset: number, length: number): DuckDBUTinyIntVector;
+}
+export declare class DuckDBUSmallIntVector extends DuckDBVector<number> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: Uint16Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBUSmallIntVector;
+    get type(): DuckDBUSmallIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): number | null;
+    slice(offset: number, length: number): DuckDBUSmallIntVector;
+}
+export declare class DuckDBUIntegerVector extends DuckDBVector<number> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: Uint32Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBUIntegerVector;
+    get type(): DuckDBUIntegerType;
+    get itemCount(): number;
+    getItem(itemIndex: number): number | null;
+    slice(offset: number, length: number): DuckDBUIntegerVector;
+}
+export declare class DuckDBUBigIntVector extends DuckDBVector<bigint> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: BigUint64Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBUBigIntVector;
+    get type(): DuckDBUBigIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBUBigIntVector;
+}
+export declare class DuckDBFloatVector extends DuckDBVector<number> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: Float32Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBFloatVector;
+    get type(): DuckDBFloatType;
+    get itemCount(): number;
+    getItem(itemIndex: number): number | null;
+    slice(offset: number, length: number): DuckDBFloatVector;
+}
+export declare class DuckDBDoubleVector extends DuckDBVector<number> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: Float64Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBDoubleVector;
+    get type(): DuckDBDoubleType;
+    get itemCount(): number;
+    getItem(itemIndex: number): number | null;
+    slice(offset: number, length: number): DuckDBDoubleVector;
+}
+export declare class DuckDBTimestampVector extends DuckDBVector<bigint> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: BigInt64Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimestampVector;
+    get type(): DuckDBTimestampType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBTimestampVector;
+}
+export declare class DuckDBDateVector extends DuckDBVector<number> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: Int32Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBDateVector;
+    get type(): DuckDBDateType;
+    get itemCount(): number;
+    getItem(itemIndex: number): number | null;
+    slice(offset: number, length: number): DuckDBDateVector;
+}
+export declare class DuckDBTimeVector extends DuckDBVector<bigint> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: BigInt64Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimeVector;
+    get type(): DuckDBTimeType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBTimeVector;
+}
+export declare class DuckDBInterval {
+    readonly months: number;
+    readonly days: number;
+    readonly micros: bigint;
+    constructor(months: number, days: number, micros: bigint);
+}
+export declare class DuckDBIntervalVector extends DuckDBVector<DuckDBInterval> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBIntervalVector;
+    get type(): DuckDBHugeIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBInterval | null;
+    slice(offset: number, length: number): DuckDBIntervalVector;
+}
+export declare class DuckDBHugeIntVector extends DuckDBVector<bigint> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBHugeIntVector;
+    get type(): DuckDBHugeIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBHugeIntVector;
+}
+export declare class DuckDBUHugeIntVector extends DuckDBVector<bigint> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBUHugeIntVector;
+    get type(): DuckDBUHugeIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBUHugeIntVector;
+}
+export declare class DuckDBVarCharVector extends DuckDBVector<string> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBVarCharVector;
+    get type(): DuckDBVarCharType;
+    get itemCount(): number;
+    getItem(itemIndex: number): string | null;
+    slice(offset: number, length: number): DuckDBVarCharVector;
+}
+export declare class DuckDBBlobVector extends DuckDBVector<Uint8Array> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBBlobVector;
+    get type(): DuckDBBlobType;
+    get itemCount(): number;
+    getItem(itemIndex: number): Uint8Array | null;
+    slice(offset: number, length: number): DuckDBBlobVector;
+}
+export declare class DuckDBDecimal2Vector extends DuckDBVector<DuckDBSmallDecimal> {
+    private readonly decimalType;
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(decimalType: DuckDBDecimalType, dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(decimalType: DuckDBDecimalType, vector: duckdb.Vector, itemCount: number): DuckDBDecimal2Vector;
+    get type(): DuckDBDecimalType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBSmallDecimal | null;
+    getScaledValue(itemIndex: number): number | null;
+    slice(offset: number, length: number): DuckDBDecimal2Vector;
+}
+export declare class DuckDBDecimal4Vector extends DuckDBVector<DuckDBSmallDecimal> {
+    private readonly decimalType;
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(decimalType: DuckDBDecimalType, dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(decimalType: DuckDBDecimalType, vector: duckdb.Vector, itemCount: number): DuckDBDecimal4Vector;
+    get type(): DuckDBDecimalType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBSmallDecimal | null;
+    getScaledValue(itemIndex: number): number | null;
+    slice(offset: number, length: number): DuckDBDecimal4Vector;
+}
+export declare class DuckDBDecimal8Vector extends DuckDBVector<DuckDBLargeDecimal> {
+    private readonly decimalType;
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(decimalType: DuckDBDecimalType, dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(decimalType: DuckDBDecimalType, vector: duckdb.Vector, itemCount: number): DuckDBDecimal8Vector;
+    get type(): DuckDBDecimalType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBLargeDecimal | null;
+    getScaledValue(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBDecimal8Vector;
+}
+export declare class DuckDBDecimal16Vector extends DuckDBVector<DuckDBLargeDecimal> {
+    private readonly decimalType;
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(decimalType: DuckDBDecimalType, dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(decimalType: DuckDBDecimalType, vector: duckdb.Vector, itemCount: number): DuckDBDecimal16Vector;
+    get type(): DuckDBDecimalType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBLargeDecimal | null;
+    getScaledValue(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBDecimal16Vector;
+}
+export declare class DuckDBTimestampSecondsVector extends DuckDBVector<bigint> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: BigInt64Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimestampSecondsVector;
+    get type(): DuckDBTimestampSecondsType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBTimestampSecondsVector;
+}
+export declare class DuckDBTimestampMillisecondsVector extends DuckDBVector<bigint> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: BigInt64Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimestampMillisecondsVector;
+    get type(): DuckDBTimestampMillisecondsType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBTimestampMillisecondsVector;
+}
+export declare class DuckDBTimestampNanosecondsVector extends DuckDBVector<bigint> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: BigInt64Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimestampNanosecondsVector;
+    get type(): DuckDBTimestampNanosecondsType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBTimestampNanosecondsVector;
+}
+export declare class DuckDBEnum1Vector extends DuckDBVector<string> {
+    private readonly enumType;
+    private readonly items;
+    private readonly validity;
+    constructor(enumType: DuckDBEnumType, items: Uint8Array, validity: DuckDBValidity);
+    static fromRawVector(enumType: DuckDBEnumType, vector: duckdb.Vector, itemCount: number): DuckDBEnum1Vector;
+    get type(): DuckDBEnumType;
+    get itemCount(): number;
+    getItem(itemIndex: number): string | null;
+    slice(offset: number, length: number): DuckDBEnum1Vector;
+}
+export declare class DuckDBEnum2Vector extends DuckDBVector<string> {
+    private readonly enumType;
+    private readonly items;
+    private readonly validity;
+    constructor(enumType: DuckDBEnumType, items: Uint16Array, validity: DuckDBValidity);
+    static fromRawVector(enumType: DuckDBEnumType, vector: duckdb.Vector, itemCount: number): DuckDBEnum2Vector;
+    get type(): DuckDBEnumType;
+    get itemCount(): number;
+    getItem(itemIndex: number): string | null;
+    slice(offset: number, length: number): DuckDBEnum2Vector;
+}
+export declare class DuckDBEnum4Vector extends DuckDBVector<string> {
+    private readonly enumType;
+    private readonly items;
+    private readonly validity;
+    constructor(enumType: DuckDBEnumType, items: Uint32Array, validity: DuckDBValidity);
+    static fromRawVector(enumType: DuckDBEnumType, vector: duckdb.Vector, itemCount: number): DuckDBEnum4Vector;
+    get type(): DuckDBEnumType;
+    get itemCount(): number;
+    getItem(itemIndex: number): string | null;
+    slice(offset: number, length: number): DuckDBEnum4Vector;
+}
+export declare class DuckDBListVector<TValue = any> extends DuckDBVector<DuckDBVector<TValue>> {
+    private readonly listType;
+    private readonly entryData;
+    private readonly validity;
+    private readonly childData;
+    private readonly _itemCount;
+    constructor(listType: DuckDBListType, entryData: BigUint64Array, validity: DuckDBValidity, childData: DuckDBVector<TValue>, itemCount: number);
+    static fromRawVector(listType: DuckDBListType, vector: duckdb.Vector, itemCount: number): DuckDBListVector;
+    get type(): DuckDBListType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBVector<TValue> | null;
+    slice(offset: number, length: number): DuckDBListVector<TValue>;
+}
+export interface DuckDBStructEntry {
+    readonly name: string;
+    readonly value: any;
+}
+export declare class DuckDBStructVector extends DuckDBVector<readonly DuckDBStructEntry[]> {
+    private readonly structType;
+    private readonly _itemCount;
+    private readonly entryVectors;
+    private readonly validity;
+    constructor(structType: DuckDBStructType, itemCount: number, entryVectors: readonly DuckDBVector<any>[], validity: DuckDBValidity);
+    static fromRawVector(structType: DuckDBStructType, vector: duckdb.Vector, itemCount: number): DuckDBStructVector;
+    get type(): DuckDBStructType;
+    get itemCount(): number;
+    getItem(itemIndex: number): readonly DuckDBStructEntry[] | null;
+    getItemValue(itemIndex: number, entryIndex: number): any | null;
+    slice(offset: number, length: number): DuckDBStructVector;
+}
+export interface DuckDBMapEntry {
+    readonly key: any;
+    readonly value: any;
+}
+export declare class DuckDBMapVector extends DuckDBVector<readonly DuckDBMapEntry[]> {
+    private readonly mapType;
+    private readonly listVector;
+    constructor(mapType: DuckDBMapType, listVector: DuckDBListVector);
+    static fromRawVector(mapType: DuckDBMapType, vector: duckdb.Vector, itemCount: number): DuckDBMapVector;
+    get type(): DuckDBType;
+    get itemCount(): number;
+    getItem(itemIndex: number): readonly DuckDBMapEntry[] | null;
+    slice(offset: number, length: number): DuckDBMapVector;
+}
+export declare class DuckDBArrayVector<TValue = any> extends DuckDBVector<DuckDBVector<TValue>> {
+    private readonly arrayType;
+    private readonly validity;
+    private readonly childData;
+    private readonly _itemCount;
+    constructor(arrayType: DuckDBArrayType, validity: DuckDBValidity, childData: DuckDBVector<TValue>, itemCount: number);
+    static fromRawVector(arrayType: DuckDBArrayType, vector: duckdb.Vector, itemCount: number): DuckDBArrayVector;
+    private static itemSize;
+    get type(): DuckDBArrayType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBVector<TValue> | null;
+    slice(offset: number, length: number): DuckDBArrayVector<TValue>;
+}
+export declare class DuckDBUUIDVector extends DuckDBVector<bigint> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBUUIDVector;
+    get type(): DuckDBUUIDType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBUUIDVector;
+}
+export interface DuckDBUnionAlternative {
+    readonly tag: string;
+    readonly value: any;
+}
+export declare class DuckDBUnionVector extends DuckDBVector<DuckDBUnionAlternative> {
+    private readonly unionType;
+    private readonly structVector;
+    constructor(unionType: DuckDBUnionType, structVector: DuckDBStructVector);
+    static fromRawVector(unionType: DuckDBUnionType, vector: duckdb.Vector, itemCount: number): DuckDBUnionVector;
+    get type(): DuckDBUnionType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBUnionAlternative | null;
+    slice(offset: number, length: number): DuckDBUnionVector;
+}
+export declare class DuckDBBitValue {
+    private readonly data;
+    constructor(data: Uint8Array);
+    static fromString(str: string): DuckDBBitValue;
+    private padding;
+    length(): number;
+    getBool(index: number): boolean;
+    getBit(index: number): 0 | 1;
+    toString(): string;
+}
+export declare class DuckDBBitVector extends DuckDBVector<DuckDBBitValue> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBBitVector;
+    get type(): DuckDBBitType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBBitValue | null;
+    slice(offset: number, length: number): DuckDBBitVector;
+}
+export declare class DuckDBTimeTZValue {
+    /** Ranges from 0 to 86400000000 (= 24 * 60 * 60 * 1000 * 1000) */
+    readonly microseconds: number;
+    /** In seconds, ranges from -57599 to 57599 (= 16 * 60 * 60 - 1) */
+    readonly offset: number;
+    constructor(microseconds: number, offset: number);
+    static TIME_BITS: number;
+    static OFFSET_BITS: number;
+    static MAX_OFFSET: number;
+    static fromBits(bits: bigint): DuckDBTimeTZValue;
+}
+export declare class DuckDBTimeTZVector extends DuckDBVector<DuckDBTimeTZValue> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: BigUint64Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimeTZVector;
+    get type(): DuckDBTimeTZType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBTimeTZValue | null;
+    slice(offset: number, length: number): DuckDBTimeTZVector;
+}
+export declare class DuckDBTimestampTZVector extends DuckDBVector<bigint> {
+    private readonly items;
+    private readonly validity;
+    constructor(items: BigInt64Array, validity: DuckDBValidity);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimestampTZVector;
+    get type(): DuckDBTimestampType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBTimestampTZVector;
+}
+export declare class DuckDBVarIntVector extends DuckDBVector<bigint> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly _itemCount;
+    constructor(dataView: DataView, validity: DuckDBValidity, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBVarIntVector;
+    get type(): DuckDBVarIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    slice(offset: number, length: number): DuckDBVarIntVector;
+}
+export {};