@sachitv/avro-typescript 0.4.2 → 0.5.0

package/esm/schemas/complex/union_type.d.ts

@@ -2,7 +2,8 @@ import { BaseType } from "../base_type.js";
 import { Resolver } from "../resolver.js";
 import { type JSONType, Type } from "../type.js";
 import { type ErrorHook } from "../error.js";
-import { type ReadableTapLike, type WritableTapLike } from "../../serialization/tap.js";
+import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
+import type { SyncReadableTapLike, SyncWritableTapLike } from "../../serialization/tap_sync.js";
 /**
  * Represents a wrapped value for a union type.
  */
@@ -17,6 +18,8 @@ export type UnionValue = UnionWrappedValue | null;
 export interface UnionTypeParams {
     /** The types that make up the union. */
     types: Type[];
+    /** Whether to validate during writes. Defaults to true. */
+    validate?: boolean;
 }
 /**
  * Avro `union` type that supports values conforming to one of multiple schemas.
@@ -44,12 +47,13 @@ export declare class UnionType extends BaseType<UnionValue> {
      */
     check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
     /**
-     * Serializes the union value to the writable tap.
-     * Writes the branch index as a long, followed by the branch value if not null.
-     * @param tap The writable tap to write to.
-     * @param value The union value to serialize.
+     * Writes union value without validation.
      */
-    write(tap: WritableTapLike, value: UnionValue): Promise<void>;
+    writeUnchecked(tap: WritableTapLike, value: UnionValue): Promise<void>;
+    /**
+     * Writes union value without validation synchronously.
+     */
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: UnionValue): void;
     /**
      * Deserializes a union value from the readable tap.
      * Reads the branch index, and if not null, reads the branch value and wraps it in an object.
@@ -57,6 +61,13 @@ export declare class UnionType extends BaseType<UnionValue> {
      * @returns The deserialized union value.
      */
     read(tap: ReadableTapLike): Promise<UnionValue>;
+    /**
+     * Reads a union branch index and its payload synchronously.
+     */
+    /**
+     * Delegates synchronous read to the branch resolver.
+     */
+    readSync(tap: SyncReadableTapLike): UnionValue;
     /**
      * Skips over a union value in the readable tap.
      * Reads the branch index and skips the branch value if not null.
@@ -64,12 +75,9 @@ export declare class UnionType extends BaseType<UnionValue> {
      */
     skip(tap: ReadableTapLike): Promise<void>;
     /**
-     * Converts the union value to an ArrayBuffer.
-     * Calculates the size needed for the index and branch value, then writes them to a new buffer.
-     * @param value The union value to convert.
-     * @returns The ArrayBuffer containing the serialized value.
+     * Skips a union value by skipping its branch payload synchronously.
      */
-    toBuffer(value: UnionValue): Promise<ArrayBuffer>;
+    skipSync(tap: SyncReadableTapLike): void;
     /**
      * Creates a deep clone of the given value as a union value.
      * Handles null values and wrapped objects by cloning the inner value using the branch type.
@@ -105,6 +113,10 @@ export declare class UnionType extends BaseType<UnionValue> {
      * @returns Negative if tap1 < tap2, zero if equal, positive if tap1 > tap2.
      */
     match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+    /**
+     * Compares union-encoded buffers synchronously.
+     */
+    matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
     /**
      * Creates a resolver for schema evolution from the writer type to this union type.
      * If the writer is also a union, creates resolvers for each branch.

package/esm/schemas/complex/union_type.js

@@ -9,15 +9,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _UnionType_instances, _UnionType_types, _UnionType_branches, _UnionType_indices, _UnionType_resolveBranch, _UnionType_readBranchIndex, _UnionBranchResolver_branch, _UnionBranchResolver_branchResolver, _UnionFromUnionResolver_resolvers;
+var _UnionType_instances, _UnionType_types, _UnionType_branches, _UnionType_indices, _UnionType_resolveBranch, _UnionType_readBranchIndex, _UnionType_readBranchIndexSync, _UnionBranchResolver_branch, _UnionBranchResolver_branchResolver, _UnionFromUnionResolver_resolvers;
 import { BaseType } from "../base_type.js";
 import { NamedType } from "./named_type.js";
 import { Resolver } from "../resolver.js";
 import { Type } from "../type.js";
 import { throwInvalidError } from "../error.js";
-import { WritableTap, } from "../../serialization/tap.js";
 import { bigIntToSafeNumber } from "../../serialization/conversion.js";
-import { calculateVarintSize } from "../../internal/varint.js";
 function isPlainObject(value) {
     return typeof value === "object" && value !== null &&
         !Array.isArray(value);
@@ -54,7 +52,7 @@ export class UnionType extends BaseType {
      * @param params The union type parameters.
      */
     constructor(params) {
-        super();
+        super(params.validate ?? true);
         _UnionType_instances.add(this);
         _UnionType_types.set(this, void 0);
         _UnionType_branches.set(this, void 0);
@@ -153,16 +151,23 @@ export class UnionType extends BaseType {
         return isValid;
     }
     /**
-     * Serializes the union value to the writable tap.
-     * Writes the branch index as a long, followed by the branch value if not null.
-     * @param tap The writable tap to write to.
-     * @param value The union value to serialize.
+     * Writes union value without validation.
      */
-    async write(tap, value) {
+    async writeUnchecked(tap, value) {
         const { index, branchValue } = __classPrivateFieldGet(this, _UnionType_instances, "m", _UnionType_resolveBranch).call(this, value);
         await tap.writeLong(BigInt(index));
         if (branchValue !== undefined) {
-            await __classPrivateFieldGet(this, _UnionType_branches, "f")[index].type.write(tap, branchValue);
+            await __classPrivateFieldGet(this, _UnionType_branches, "f")[index].type.writeUnchecked(tap, branchValue);
+        }
+    }
+    /**
+     * Writes union value without validation synchronously.
+     */
+    writeSyncUnchecked(tap, value) {
+        const { index, branchValue } = __classPrivateFieldGet(this, _UnionType_instances, "m", _UnionType_resolveBranch).call(this, value);
+        tap.writeLong(BigInt(index));
+        if (branchValue !== undefined) {
+            __classPrivateFieldGet(this, _UnionType_branches, "f")[index].type.writeSyncUnchecked(tap, branchValue);
         }
     }
     /**
@@ -180,6 +185,21 @@ export class UnionType extends BaseType {
         const branchValue = await branch.type.read(tap);
         return { [branch.name]: branchValue };
     }
+    /**
+     * Reads a union branch index and its payload synchronously.
+     */
+    /**
+     * Delegates synchronous read to the branch resolver.
+     */
+    readSync(tap) {
+        const index = __classPrivateFieldGet(this, _UnionType_instances, "m", _UnionType_readBranchIndexSync).call(this, tap);
+        const branch = __classPrivateFieldGet(this, _UnionType_branches, "f")[index];
+        if (branch.isNull) {
+            return null;
+        }
+        const branchValue = branch.type.readSync(tap);
+        return { [branch.name]: branchValue };
+    }
     /**
      * Skips over a union value in the readable tap.
      * Reads the branch index and skips the branch value if not null.
@@ -193,27 +213,14 @@ export class UnionType extends BaseType {
         }
     }
     /**
-     * Converts the union value to an ArrayBuffer.
-     * Calculates the size needed for the index and branch value, then writes them to a new buffer.
-     * @param value The union value to convert.
-     * @returns The ArrayBuffer containing the serialized value.
+     * Skips a union value by skipping its branch payload synchronously.
      */
-    async toBuffer(value) {
-        const { index, branchValue } = __classPrivateFieldGet(this, _UnionType_instances, "m", _UnionType_resolveBranch).call(this, value);
-        const indexSize = calculateVarintSize(index);
-        let totalSize = indexSize;
-        let branchBytes;
-        if (branchValue !== undefined) {
-            branchBytes = new Uint8Array(await __classPrivateFieldGet(this, _UnionType_branches, "f")[index].type.toBuffer(branchValue));
-            totalSize += branchBytes.byteLength;
-        }
-        const buffer = new ArrayBuffer(totalSize);
-        const tap = new WritableTap(buffer);
-        await tap.writeLong(BigInt(index));
-        if (branchBytes) {
-            await tap.writeFixed(branchBytes);
+    skipSync(tap) {
+        const index = __classPrivateFieldGet(this, _UnionType_instances, "m", _UnionType_readBranchIndexSync).call(this, tap);
+        const branch = __classPrivateFieldGet(this, _UnionType_branches, "f")[index];
+        if (!branch.isNull) {
+            branch.type.skipSync(tap);
         }
-        return buffer;
     }
     /**
      * Creates a deep clone of the given value as a union value.
@@ -294,6 +301,21 @@ export class UnionType extends BaseType {
         }
         return idx1 < idx2 ? -1 : 1;
     }
+    /**
+     * Compares union-encoded buffers synchronously.
+     */
+    matchSync(tap1, tap2) {
+        const idx1 = __classPrivateFieldGet(this, _UnionType_instances, "m", _UnionType_readBranchIndexSync).call(this, tap1);
+        const idx2 = __classPrivateFieldGet(this, _UnionType_instances, "m", _UnionType_readBranchIndexSync).call(this, tap2);
+        if (idx1 === idx2) {
+            const branch = __classPrivateFieldGet(this, _UnionType_branches, "f")[idx1];
+            if (branch.isNull) {
+                return 0;
+            }
+            return branch.type.matchSync(tap1, tap2);
+        }
+        return idx1 < idx2 ? -1 : 1;
+    }
     /**
      * Creates a resolver for schema evolution from the writer type to this union type.
      * If the writer is also a union, creates resolvers for each branch.
@@ -355,6 +377,13 @@ _UnionType_types = new WeakMap(), _UnionType_branches = new WeakMap(), _UnionTyp
         throw new Error(`Invalid union index: ${index}`);
     }
     return index;
+}, _UnionType_readBranchIndexSync = function _UnionType_readBranchIndexSync(tap) {
+    const indexBigInt = tap.readLong();
+    const index = bigIntToSafeNumber(indexBigInt, "Union branch index");
+    if (index < 0 || index >= __classPrivateFieldGet(this, _UnionType_branches, "f").length) {
+        throw new Error(`Invalid union index: ${index}`);
+    }
+    return index;
 };
 class UnionBranchResolver extends Resolver {
     constructor(reader, branch, branchResolver) {
@@ -371,6 +400,16 @@ class UnionBranchResolver extends Resolver {
         }
         return { [__classPrivateFieldGet(this, _UnionBranchResolver_branch, "f").name]: resolvedValue };
     }
+    /**
+     * Reads the branch index synchronously and forwards to the per-branch resolver.
+     */
+    readSync(tap) {
+        const resolvedValue = __classPrivateFieldGet(this, _UnionBranchResolver_branchResolver, "f").readSync(tap);
+        if (__classPrivateFieldGet(this, _UnionBranchResolver_branch, "f").isNull) {
+            return null;
+        }
+        return { [__classPrivateFieldGet(this, _UnionBranchResolver_branch, "f").name]: resolvedValue };
+    }
 }
 _UnionBranchResolver_branch = new WeakMap(), _UnionBranchResolver_branchResolver = new WeakMap();
 class UnionFromUnionResolver extends Resolver {
@@ -388,5 +427,14 @@ class UnionFromUnionResolver extends Resolver {
         }
         return await resolver.read(tap);
     }
+    readSync(tap) {
+        const indexBigInt = tap.readLong();
+        const index = bigIntToSafeNumber(indexBigInt, "Union branch index");
+        const resolver = __classPrivateFieldGet(this, _UnionFromUnionResolver_resolvers, "f")[index];
+        if (!resolver) {
+            throw new Error(`Invalid union index: ${index}`);
+        }
+        return resolver.readSync(tap);
+    }
 }
 _UnionFromUnionResolver_resolvers = new WeakMap();

package/esm/schemas/logical/decimal_logical_type.d.ts

@@ -16,7 +16,7 @@ export declare class DecimalLogicalType extends LogicalType<bigint, Uint8Array>
      * @param underlying The underlying bytes or fixed type.
      * @param params The precision and scale parameters.
      */
-    constructor(underlying: BytesType | FixedType, params: DecimalParams);
+    constructor(underlying: BytesType | FixedType, params: DecimalParams, validate?: boolean);
     /**
      * Gets the precision of the decimal.
      */

package/esm/schemas/logical/decimal_logical_type.js

@@ -23,8 +23,8 @@ export class DecimalLogicalType extends LogicalType {
      * @param underlying The underlying bytes or fixed type.
      * @param params The precision and scale parameters.
      */
-    constructor(underlying, params) {
-        super(underlying);
+    constructor(underlying, params, validate = true) {
+        super(underlying, validate);
         _DecimalLogicalType_precision.set(this, void 0);
         _DecimalLogicalType_scale.set(this, void 0);
         _DecimalLogicalType_fixedSize.set(this, void 0);

package/esm/schemas/logical/duration_logical_type.d.ts

@@ -21,7 +21,7 @@ export declare class DurationLogicalType extends NamedLogicalType<DurationValue,
      * Creates a new DurationLogicalType.
      * @param underlying The underlying fixed type (must be 12 bytes).
      */
-    constructor(underlying: FixedType);
+    constructor(underlying: FixedType, validate?: boolean);
     /**
      * Checks if this logical type can read from the given writer logical type.
      * @param writer The writer logical type.

package/esm/schemas/logical/duration_logical_type.js

@@ -9,8 +9,8 @@ export class DurationLogicalType extends NamedLogicalType {
      * Creates a new DurationLogicalType.
      * @param underlying The underlying fixed type (must be 12 bytes).
      */
-    constructor(underlying) {
-        super(underlying);
+    constructor(underlying, validate = true) {
+        super(underlying, validate);
         if (underlying.getSize() !== 12) {
             throw new Error("Duration logical type requires fixed size of 12 bytes.");
         }

package/esm/schemas/logical/logical_type.d.ts

@@ -1,4 +1,5 @@
 import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
+import type { SyncReadableTapLike, SyncWritableTapLike } from "../../serialization/tap_sync.js";
 import { Resolver } from "../resolver.js";
 import type { NamedType } from "../complex/named_type.js";
 import { Type } from "../type.js";
@@ -15,7 +16,7 @@ export declare abstract class LogicalType<TValue, TUnderlying> extends Type<TVal
      * Constructs a new LogicalType.
      * @param underlyingType - The underlying type to wrap.
      */
-    protected constructor(underlyingType: Type<TUnderlying>);
+    protected constructor(underlyingType: Type<TUnderlying>, validate?: boolean);
     /**
      * Gets the underlying type that this logical type wraps.
      */
@@ -41,16 +42,15 @@ export declare abstract class LogicalType<TValue, TUnderlying> extends Type<TVal
      * Determines if this logical type is compatible with the writer logical type for reading.
      */
     protected canReadFromLogical(_writer: LogicalType<unknown, unknown>): boolean;
-    /**
-     * Serializes the logical value to an ArrayBuffer.
-     * @param value The logical value to serialize.
-     */
-    toBuffer(value: TValue): Promise<ArrayBuffer>;
     /**
      * Deserializes a logical value from an ArrayBuffer.
      * @param buffer The buffer to deserialize from.
      */
     fromBuffer(buffer: ArrayBuffer): Promise<TValue>;
+    /**
+     * Converts a synchronous buffer into the logical value by decoding the underlying type.
+     */
+    fromSyncBuffer(buffer: ArrayBuffer): TValue;
     /**
      * Checks if the given value is valid for this type.
      * @param value The value to validate.
@@ -79,15 +79,33 @@ export declare abstract class LogicalType<TValue, TUnderlying> extends Type<TVal
      */
     random(): TValue;
     /**
-     * Writes the value to the tap by writing the underlying value.
+     * Writes logical value without validation.
+     * Applies the logical transform but uses the underlying type's unchecked writer.
+     */
+    writeUnchecked(tap: WritableTapLike, value: TValue): Promise<void>;
+    /**
+     * Writes logical value without validation synchronously.
+     * Applies the logical transform but uses the underlying type's unchecked writer.
      */
-    write(tap: WritableTapLike, value: TValue): Promise<void>;
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: TValue): void;
     /** Reads the value from the tap. */
     read(tap: ReadableTapLike): Promise<TValue>;
+    /**
+     * Reads the logical value synchronously from the underlying type.
+     */
+    readSync(tap: SyncReadableTapLike): TValue;
     /** Skips the value in the tap. */
     skip(tap: ReadableTapLike): Promise<void>;
+    /**
+     * Skips the logical value by skipping the underlying representation.
+     */
+    skipSync(tap: SyncReadableTapLike): void;
     /** Matches the value in the taps. */
     match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+    /**
+     * Compares two sync taps by delegating to the underlying type match.
+     */
+    matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
     /**
      * Creates a resolver for reading from the writer type, handling logical types specially.
      */
@@ -118,7 +136,7 @@ export declare abstract class NamedLogicalType<TValue, TUnderlying> extends Logi
      * Creates a new NamedLogicalType.
      * @param namedType The underlying named type.
      */
-    protected constructor(namedType: NamedType<TUnderlying>);
+    protected constructor(namedType: NamedType<TUnderlying>, validate?: boolean);
     /**
      * Gets the full name of the underlying type.
      */

package/esm/schemas/logical/logical_type.js

@@ -22,8 +22,8 @@ export class LogicalType extends Type {
      * Constructs a new LogicalType.
      * @param underlyingType - The underlying type to wrap.
      */
-    constructor(underlyingType) {
-        super();
+    constructor(underlyingType, validate = true) {
+        super(validate);
         /** The underlying type that this logical type wraps. */
         Object.defineProperty(this, "underlyingType", {
             enumerable: true,
@@ -52,15 +52,6 @@ export class LogicalType extends Type {
     canReadFromLogical(_writer) {
         return _writer.constructor === this.constructor;
     }
-    /**
-     * Serializes the logical value to an ArrayBuffer.
-     * @param value The logical value to serialize.
-     */
-    async toBuffer(value) {
-        this.ensureValid(value, []);
-        const underlying = this.toUnderlying(value);
-        return await this.underlyingType.toBuffer(underlying);
-    }
     /**
      * Deserializes a logical value from an ArrayBuffer.
      * @param buffer The buffer to deserialize from.
@@ -69,6 +60,13 @@ export class LogicalType extends Type {
         const underlying = await this.underlyingType.fromBuffer(buffer);
         return this.fromUnderlying(underlying);
     }
+    /**
+     * Converts a synchronous buffer into the logical value by decoding the underlying type.
+     */
+    fromSyncBuffer(buffer) {
+        const underlying = this.underlyingType.fromSyncBuffer(buffer);
+        return this.fromUnderlying(underlying);
+    }
     /**
      * Checks if the given value is valid for this type.
      * @param value The value to validate.
@@ -127,25 +125,53 @@ export class LogicalType extends Type {
         return this.fromUnderlying(underlying);
     }
     /**
-     * Writes the value to the tap by writing the underlying value.
+     * Writes logical value without validation.
+     * Applies the logical transform but uses the underlying type's unchecked writer.
      */
-    async write(tap, value) {
-        this.ensureValid(value, []);
-        await this.underlyingType.write(tap, this.toUnderlying(value));
+    async writeUnchecked(tap, value) {
+        const underlying = this.toUnderlying(value);
+        await this.underlyingType.writeUnchecked(tap, underlying);
+    }
+    /**
+     * Writes logical value without validation synchronously.
+     * Applies the logical transform but uses the underlying type's unchecked writer.
+     */
+    writeSyncUnchecked(tap, value) {
+        const underlying = this.toUnderlying(value);
+        this.underlyingType.writeSyncUnchecked(tap, underlying);
     }
     /** Reads the value from the tap. */
     async read(tap) {
         const underlying = await this.underlyingType.read(tap);
         return this.fromUnderlying(underlying);
     }
+    /**
+     * Reads the logical value synchronously from the underlying type.
+     */
+    readSync(tap) {
+        const underlying = this.underlyingType.readSync(tap);
+        return this.fromUnderlying(underlying);
+    }
     /** Skips the value in the tap. */
     async skip(tap) {
         await this.underlyingType.skip(tap);
     }
+    /**
+     * Skips the logical value by skipping the underlying representation.
+     */
+    skipSync(tap) {
+        this.underlyingType.skipSync(tap);
+    }
     /** Matches the value in the taps. */
     async match(tap1, tap2) {
         return await this.underlyingType.match(tap1, tap2);
     }
+    /**
+     * Compares two sync taps by delegating to the underlying type match.
+     */
+    matchSync(tap1, tap2) {
+        return this.underlyingType.matchSync(tap1, tap2);
+    }
     /**
      * Creates a resolver for reading from the writer type, handling logical types specially.
      */
@@ -181,6 +207,13 @@ class LogicalResolver extends Resolver {
         const underlying = await __classPrivateFieldGet(this, _LogicalResolver_resolver, "f").read(tap);
         return __classPrivateFieldGet(this, _LogicalResolver_logicalType, "f").convertFromUnderlying(underlying);
     }
+    /**
+     * Synchronously resolves logical values emitted by resolved streams.
+     */
+    readSync(tap) {
+        const underlying = __classPrivateFieldGet(this, _LogicalResolver_resolver, "f").readSync(tap);
+        return __classPrivateFieldGet(this, _LogicalResolver_logicalType, "f").convertFromUnderlying(underlying);
+    }
 }
 _LogicalResolver_logicalType = new WeakMap(), _LogicalResolver_resolver = new WeakMap();
 /**
@@ -196,8 +229,8 @@ export class NamedLogicalType extends LogicalType {
      * Creates a new NamedLogicalType.
      * @param namedType The underlying named type.
      */
-    constructor(namedType) {
-        super(namedType);
+    constructor(namedType, validate = true) {
+        super(namedType, validate);
         /** The underlying named type. */
         Object.defineProperty(this, "namedType", {
             enumerable: true,

package/esm/schemas/logical/temporal_logical_types.d.ts

@@ -11,7 +11,7 @@ export declare class DateLogicalType extends LogicalType<number, number> {
      * Creates a new DateLogicalType.
      * @param underlying The underlying int type.
      */
-    constructor(underlying: IntType);
+    constructor(underlying: IntType, validate?: boolean);
     /** Checks if the logical type can read from the underlying type. */
     protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
     /** Checks if the value is a valid instance of this logical type. */
@@ -35,7 +35,7 @@ export declare class TimeMillisLogicalType extends LogicalType<number, number> {
      * Creates a new TimeMillisLogicalType.
      * @param underlying The underlying int type.
      */
-    constructor(underlying: IntType);
+    constructor(underlying: IntType, validate?: boolean);
     /** Checks if the logical type can read from the underlying type. */
     protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
     /** Checks if the value is a valid instance of this logical type. */
@@ -58,7 +58,7 @@ export declare class TimeMicrosLogicalType extends LogicalType<bigint, bigint> {
      * Creates a new TimeMicrosLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying: LongType);
+    constructor(underlying: LongType, validate?: boolean);
     /** Checks if the logical type can read from the underlying type. */
     protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
     /** Checks if the value is a valid instance of this logical type. */
@@ -82,7 +82,7 @@ export declare class TimestampMillisLogicalType extends LogicalType<Date, bigint
      * Creates a new TimestampMillisLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying: LongType);
+    constructor(underlying: LongType, validate?: boolean);
     /** Checks if the logical type can read from the underlying type. */
     protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
     /** Checks if the value is a valid instance of this logical type. */
@@ -107,7 +107,7 @@ export declare class TimestampMicrosLogicalType extends LogicalType<bigint, bigi
      * Creates a new TimestampMicrosLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying: LongType);
+    constructor(underlying: LongType, validate?: boolean);
     /** Checks if the logical type can read from the underlying type. */
     protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
     /** Checks if the value is a valid instance of this logical type. */
@@ -130,7 +130,7 @@ export declare class TimestampNanosLogicalType extends LogicalType<bigint, bigin
      * Creates a new TimestampNanosLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying: LongType);
+    constructor(underlying: LongType, validate?: boolean);
     /** Checks if the logical type can read from the underlying type. */
     protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
     /** Checks if the value is a valid instance of this logical type. */
@@ -153,7 +153,7 @@ export declare class LocalTimestampMillisLogicalType extends LogicalType<number,
      * Creates a new LocalTimestampMillisLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying: LongType);
+    constructor(underlying: LongType, validate?: boolean);
     /** Checks if the logical type can read from the underlying type. */
     protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
     /** Checks if the value is a valid instance of this logical type. */
@@ -176,7 +176,7 @@ export declare class LocalTimestampMicrosLogicalType extends LogicalType<bigint,
      * Creates a new LocalTimestampMicrosLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying: LongType);
+    constructor(underlying: LongType, validate?: boolean);
     /** Checks if the logical type can read from the underlying type. */
     protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
     /** Checks if the value is a valid instance of this logical type. */
@@ -199,7 +199,7 @@ export declare class LocalTimestampNanosLogicalType extends LogicalType<bigint,
      * Creates a new LocalTimestampNanosLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying: LongType);
+    constructor(underlying: LongType, validate?: boolean);
     /** Checks if the logical type can read from the underlying type. */
     protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
     /** Checks if the value is a valid instance of this logical type. */