@sachitv/avro-typescript 0.4.1 → 0.5.0

package/esm/schemas/logical/temporal_logical_types.js

@@ -11,8 +11,8 @@ export class DateLogicalType extends LogicalType {
      * Creates a new DateLogicalType.
      * @param underlying The underlying int type.
      */
-    constructor(underlying) {
-        super(underlying);
+    constructor(underlying, validate = true) {
+        super(underlying, validate);
     }
     /** Checks if the logical type can read from the underlying type. */
     canReadFromLogical(writer) {
@@ -50,8 +50,8 @@ export class TimeMillisLogicalType extends LogicalType {
      * Creates a new TimeMillisLogicalType.
      * @param underlying The underlying int type.
      */
-    constructor(underlying) {
-        super(underlying);
+    constructor(underlying, validate = true) {
+        super(underlying, validate);
     }
     /** Checks if the logical type can read from the underlying type. */
     canReadFromLogical(writer) {
@@ -88,8 +88,8 @@ export class TimeMicrosLogicalType extends LogicalType {
      * Creates a new TimeMicrosLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying) {
-        super(underlying);
+    constructor(underlying, validate = true) {
+        super(underlying, validate);
     }
     /** Checks if the logical type can read from the underlying type. */
     canReadFromLogical(writer) {
@@ -126,8 +126,8 @@ export class TimestampMillisLogicalType extends LogicalType {
      * Creates a new TimestampMillisLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying) {
-        super(underlying);
+    constructor(underlying, validate = true) {
+        super(underlying, validate);
     }
     /** Checks if the logical type can read from the underlying type. */
     canReadFromLogical(writer) {
@@ -175,8 +175,8 @@ export class TimestampMicrosLogicalType extends LogicalType {
      * Creates a new TimestampMicrosLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying) {
-        super(underlying);
+    constructor(underlying, validate = true) {
+        super(underlying, validate);
     }
     /** Checks if the logical type can read from the underlying type. */
     canReadFromLogical(writer) {
@@ -214,8 +214,8 @@ export class TimestampNanosLogicalType extends LogicalType {
      * Creates a new TimestampNanosLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying) {
-        super(underlying);
+    constructor(underlying, validate = true) {
+        super(underlying, validate);
     }
     /** Checks if the logical type can read from the underlying type. */
     canReadFromLogical(writer) {
@@ -253,8 +253,8 @@ export class LocalTimestampMillisLogicalType extends LogicalType {
      * Creates a new LocalTimestampMillisLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying) {
-        super(underlying);
+    constructor(underlying, validate = true) {
+        super(underlying, validate);
     }
     /** Checks if the logical type can read from the underlying type. */
     canReadFromLogical(writer) {
@@ -293,8 +293,8 @@ export class LocalTimestampMicrosLogicalType extends LogicalType {
      * Creates a new LocalTimestampMicrosLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying) {
-        super(underlying);
+    constructor(underlying, validate = true) {
+        super(underlying, validate);
     }
     /** Checks if the logical type can read from the underlying type. */
     canReadFromLogical(writer) {
@@ -332,8 +332,8 @@ export class LocalTimestampNanosLogicalType extends LogicalType {
      * Creates a new LocalTimestampNanosLogicalType.
      * @param underlying The underlying long type.
      */
-    constructor(underlying) {
-        super(underlying);
+    constructor(underlying, validate = true) {
+        super(underlying, validate);
     }
     /** Checks if the logical type can read from the underlying type. */
     canReadFromLogical(writer) {

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

@@ -12,7 +12,7 @@ export declare class UuidLogicalType extends LogicalType<string, string | Uint8A
      * Creates a UUID logical type backed by the given underlying type.
      * @param underlying The underlying StringType or FixedType.
      */
-    constructor(underlying: StringType | FixedType);
+    constructor(underlying: StringType | FixedType, validate?: boolean);
     /**
      * Checks if this UUID logical type can read from the given writer logical type.
      * @param writer The writer logical type.

package/esm/schemas/logical/uuid_logical_type.js

@@ -24,8 +24,8 @@ export class UuidLogicalType extends LogicalType {
      * Creates a UUID logical type backed by the given underlying type.
      * @param underlying The underlying StringType or FixedType.
      */
-    constructor(underlying) {
-        super(underlying);
+    constructor(underlying, validate = true) {
+        super(underlying, validate);
         _UuidLogicalType_underlying.set(this, void 0);
         _UuidLogicalType_named.set(this, void 0);
         __classPrivateFieldSet(this, _UuidLogicalType_underlying, underlying, "f");

package/esm/schemas/primitive/boolean_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 { FixedSizeBaseType } from "./fixed_size_base_type.js";
 import type { JSONType } from "../type.js";
 import { type ErrorHook } from "../error.js";
@@ -6,6 +7,8 @@ import { type ErrorHook } from "../error.js";
  * Boolean type.
  */
 export declare class BooleanType extends FixedSizeBaseType<boolean> {
+    /** Creates a new boolean type. */
+    constructor(validate?: boolean);
     /**
      * Validates if the value is a boolean.
      */
@@ -14,10 +17,8 @@ export declare class BooleanType extends FixedSizeBaseType<boolean> {
      * Reads a boolean value from the tap.
      */
     read(tap: ReadableTapLike): Promise<boolean>;
-    /**
-     * Writes a boolean value to the tap.
-     */
-    write(tap: WritableTapLike, value: boolean): Promise<void>;
+    /** Writes a boolean value to the tap without validation. */
+    writeUnchecked(tap: WritableTapLike, value: boolean): Promise<void>;
     /**
      * Skips a boolean value in the tap.
      */
@@ -46,4 +47,14 @@ export declare class BooleanType extends FixedSizeBaseType<boolean> {
      * Matches two boolean values from the taps.
      */
     match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+    /**
+     * Reads a boolean value synchronously from the tap.
+     */
+    readSync(tap: SyncReadableTapLike): boolean;
+    /** Writes a boolean value synchronously to the tap without validation. */
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: boolean): void;
+    /**
+     * Matches two boolean values synchronously from the taps.
+     */
+    matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
 }

package/esm/schemas/primitive/boolean_type.js

@@ -4,6 +4,10 @@ import { throwInvalidError } from "../error.js";
  * Boolean type.
  */
 export class BooleanType extends FixedSizeBaseType {
+    /** Creates a new boolean type. */
+    constructor(validate = true) {
+        super(validate);
+    }
     /**
      * Validates if the value is a boolean.
      */
@@ -20,13 +24,8 @@ export class BooleanType extends FixedSizeBaseType {
     async read(tap) {
         return await tap.readBoolean();
     }
-    /**
-     * Writes a boolean value to the tap.
-     */
-    async write(tap, value) {
-        if (typeof value !== "boolean") {
-            throwInvalidError([], value, this);
-        }
+    /** Writes a boolean value to the tap without validation. */
+    async writeUnchecked(tap, value) {
         await tap.writeBoolean(value);
     }
     /**
@@ -72,4 +71,20 @@ export class BooleanType extends FixedSizeBaseType {
     async match(tap1, tap2) {
         return await tap1.matchBoolean(tap2);
     }
+    /**
+     * Reads a boolean value synchronously from the tap.
+     */
+    readSync(tap) {
+        return tap.readBoolean();
+    }
+    /** Writes a boolean value synchronously to the tap without validation. */
+    writeSyncUnchecked(tap, value) {
+        tap.writeBoolean(value);
+    }
+    /**
+     * Matches two boolean values synchronously from the taps.
+     */
+    matchSync(tap1, tap2) {
+        return tap1.matchBoolean(tap2);
+    }
 }

package/esm/schemas/primitive/bytes_type.d.ts

@@ -1,4 +1,5 @@
-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";
 import { PrimitiveType } from "./primitive_type.js";
 import type { JSONType, Type } from "../type.js";
 import { Resolver } from "../resolver.js";
@@ -8,6 +9,8 @@ import { type ErrorHook } from "../error.js";
  */
 export declare class BytesType extends PrimitiveType<Uint8Array> {
     #private;
+    /** Creates a new bytes type. */
+    constructor(validate?: boolean);
     /** Checks if the value is a valid bytes array. */
     check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
     /**
@@ -15,17 +18,23 @@ export declare class BytesType extends PrimitiveType<Uint8Array> {
      */
     read(tap: ReadableTapLike): Promise<Uint8Array>;
     /**
-     * Writes a byte array to the tap.
+     * Reads a byte array from the sync tap.
      */
-    write(tap: WritableTapLike, value: Uint8Array): Promise<void>;
+    readSync(tap: SyncReadableTapLike): Uint8Array;
+    /** Writes a byte array to the tap without validation. */
+    writeUnchecked(tap: WritableTapLike, value: Uint8Array): Promise<void>;
+    /** Returns the encoded byte length of the given value. */
+    protected byteLength(value: Uint8Array): number;
+    /** Writes a byte array synchronously to the tap without validation. */
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: Uint8Array): void;
     /**
      * Skips a byte array in the tap.
      */
     skip(tap: ReadableTapLike): Promise<void>;
     /**
-     * Converts a byte array to an ArrayBuffer.
+     * Skips a byte array in the sync tap.
      */
-    toBuffer(value: Uint8Array): Promise<ArrayBuffer>;
+    skipSync(tap: SyncReadableTapLike): void;
     /**
      * Creates a resolver for the writer type.
      */
@@ -46,4 +55,6 @@ export declare class BytesType extends PrimitiveType<Uint8Array> {
     toJSON(): JSONType;
     /** Matches bytes between two taps. */
     match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+    /** Matches bytes between two sync taps. */
+    matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
 }

package/esm/schemas/primitive/bytes_type.js

@@ -4,7 +4,6 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _a, _BytesType_fromJsonString;
-import { WritableTap, } from "../../serialization/tap.js";
 import { PrimitiveType } from "./primitive_type.js";
 import { Resolver } from "../resolver.js";
 import { throwInvalidError } from "../error.js";
@@ -13,6 +12,10 @@ import { calculateVarintSize } from "../../internal/varint.js";
  * Bytes type.
  */
 export class BytesType extends PrimitiveType {
+    /** Creates a new bytes type. */
+    constructor(validate = true) {
+        super(validate);
+    }
     /** Checks if the value is a valid bytes array. */
     check(value, errorHook, path = []) {
         const isValid = value instanceof Uint8Array;
@@ -28,14 +31,23 @@ export class BytesType extends PrimitiveType {
         return await tap.readBytes();
     }
     /**
-     * Writes a byte array to the tap.
+     * Reads a byte array from the sync tap.
      */
-    async write(tap, value) {
-        if (!(value instanceof Uint8Array)) {
-            throwInvalidError([], value, this);
-        }
+    readSync(tap) {
+        return tap.readBytes();
+    }
+    /** Writes a byte array to the tap without validation. */
+    async writeUnchecked(tap, value) {
         await tap.writeBytes(value);
     }
+    /** Returns the encoded byte length of the given value. */
+    byteLength(value) {
+        return calculateVarintSize(value.length) + value.length;
+    }
+    /** Writes a byte array synchronously to the tap without validation. */
+    writeSyncUnchecked(tap, value) {
+        tap.writeBytes(value);
+    }
     /**
      * Skips a byte array in the tap.
      */
@@ -43,17 +55,10 @@ export class BytesType extends PrimitiveType {
         await tap.skipBytes();
     }
     /**
-     * Converts a byte array to an ArrayBuffer.
+     * Skips a byte array in the sync tap.
      */
-    async toBuffer(value) {
-        this.check(value, throwInvalidError, []);
-        // Pre-allocate buffer based on value length for efficiency
-        const lengthSize = calculateVarintSize(value.length);
-        const totalSize = lengthSize + value.length;
-        const buf = new ArrayBuffer(totalSize);
-        const tap = new WritableTap(buf);
-        await this.write(tap, value);
-        return buf;
+    skipSync(tap) {
+        tap.skipBytes();
     }
     /**
      * Creates a resolver for the writer type.
@@ -69,6 +74,12 @@ export class BytesType extends PrimitiveType {
                     const encoder = new TextEncoder();
                     return encoder.encode(str);
                 }
+                readSync(tap) {
+                    const str = tap.readString();
+                    // Convert string to bytes (assuming UTF-8)
+                    const encoder = new TextEncoder();
+                    return encoder.encode(str);
+                }
             }(this);
         }
         else {
@@ -126,6 +137,10 @@ export class BytesType extends PrimitiveType {
     async match(tap1, tap2) {
         return await tap1.matchBytes(tap2);
     }
+    /** Matches bytes between two sync taps. */
+    matchSync(tap1, tap2) {
+        return tap1.matchBytes(tap2);
+    }
 }
 _a = BytesType, _BytesType_fromJsonString = function _BytesType_fromJsonString(value) {
     const bytes = new Uint8Array(value.length);

package/esm/schemas/primitive/double_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 { FixedSizeBaseType } from "./fixed_size_base_type.js";
 import type { JSONType, Type } from "../type.js";
 import { Resolver } from "../resolver.js";
@@ -7,14 +8,24 @@ import { type ErrorHook } from "../error.js";
  * Double type (64-bit).
  */
 export declare class DoubleType extends FixedSizeBaseType<number> {
+    /** Creates a new double type. */
+    constructor(validate?: boolean);
     /** Checks if the value is a valid double. */
     check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
     /** Reads a double value from the tap. */
     read(tap: ReadableTapLike): Promise<number>;
-    /** Writes a double value to the tap. */
-    write(tap: WritableTapLike, value: number): Promise<void>;
+    /** Writes a double value to the tap without validation. */
+    writeUnchecked(tap: WritableTapLike, value: number): Promise<void>;
     /** Skips a double value in the tap. */
     skip(tap: ReadableTapLike): Promise<void>;
+    /** Reads a double value from the sync tap. */
+    readSync(tap: SyncReadableTapLike): number;
+    /** Writes a double value synchronously to the tap without validation. */
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: number): void;
+    /** Skips a double value in the sync tap. */
+    skipSync(tap: SyncReadableTapLike): void;
+    /** Matches two sync taps for equality. */
+    matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
     /**
      * Gets the size in bytes.
      */

package/esm/schemas/primitive/double_type.js

@@ -8,6 +8,10 @@ import { throwInvalidError } from "../error.js";
  * Double type (64-bit).
  */
 export class DoubleType extends FixedSizeBaseType {
+    /** Creates a new double type. */
+    constructor(validate = true) {
+        super(validate);
+    }
     /** Checks if the value is a valid double. */
     check(value, errorHook, path = []) {
         const isValid = typeof value === "number";
@@ -20,17 +24,30 @@ export class DoubleType extends FixedSizeBaseType {
     async read(tap) {
         return await tap.readDouble();
     }
-    /** Writes a double value to the tap. */
-    async write(tap, value) {
-        if (!this.check(value)) {
-            throwInvalidError([], value, this);
-        }
+    /** Writes a double value to the tap without validation. */
+    async writeUnchecked(tap, value) {
         await tap.writeDouble(value);
     }
     /** Skips a double value in the tap. */
     async skip(tap) {
         await tap.skipDouble();
     }
+    /** Reads a double value from the sync tap. */
+    readSync(tap) {
+        return tap.readDouble();
+    }
+    /** Writes a double value synchronously to the tap without validation. */
+    writeSyncUnchecked(tap, value) {
+        tap.writeDouble(value);
+    }
+    /** Skips a double value in the sync tap. */
+    skipSync(tap) {
+        tap.skipDouble();
+    }
+    /** Matches two sync taps for equality. */
+    matchSync(tap1, tap2) {
+        return tap1.matchDouble(tap2);
+    }
     /**
      * Gets the size in bytes.
      */
@@ -63,6 +80,10 @@ export class DoubleType extends FixedSizeBaseType {
                     const intValue = await tap.readInt();
                     return intValue;
                 }
+                readSync(tap) {
+                    const intValue = tap.readInt();
+                    return intValue;
+                }
             }(this);
         }
         else if (writerType instanceof LongType) {
@@ -72,6 +93,10 @@ export class DoubleType extends FixedSizeBaseType {
                     const longValue = await tap.readLong();
                     return Number(longValue);
                 }
+                readSync(tap) {
+                    const longValue = tap.readLong();
+                    return Number(longValue);
+                }
             }(this);
         }
         else if (writerType instanceof FloatType) {
@@ -81,6 +106,10 @@ export class DoubleType extends FixedSizeBaseType {
                     const floatValue = await tap.readFloat();
                     return floatValue;
                 }
+                readSync(tap) {
+                    const floatValue = tap.readFloat();
+                    return floatValue;
+                }
             }(this);
         }
         else {

package/esm/schemas/primitive/fixed_size_base_type.d.ts

@@ -1,4 +1,5 @@
-import { type ReadableTapLike } from "../../serialization/tap.js";
+import type { ReadableTapLike } from "../../serialization/tap.js";
+import type { SyncReadableTapLike } from "../../serialization/tap_sync.js";
 import { BaseType } from "../base_type.js";
 /**
  * Base class for fixed-size Avro types.
@@ -9,20 +10,23 @@ import { BaseType } from "../base_type.js";
  * Provides optimized serialization for types with known fixed byte sizes.
  */
 export declare abstract class FixedSizeBaseType<T = unknown> extends BaseType<T> {
+    /** Creates a new fixed-size base type. */
+    constructor(validate?: boolean);
     /**
      * Returns the fixed size in bytes for this type.
      * @returns The exact size in bytes.
      */
     abstract sizeBytes(): number;
-    /**
-     * Serializes a value into an ArrayBuffer using the exact fixed size.
-     * @param value The value to serialize.
-     * @returns The serialized ArrayBuffer.
-     */
-    toBuffer(value: T): Promise<ArrayBuffer>;
+    /** Returns the fixed byte length for any value of this type. */
+    protected byteLength(_value: T): number;
     /**
      * Skips a fixed-size value by advancing the tap by the fixed size.
      * @param tap The tap to skip from.
      */
     skip(tap: ReadableTapLike): Promise<void>;
+    /**
+     * Skips a fixed-size value synchronously by advancing the tap by the fixed size.
+     * @param tap The sync tap to skip from.
+     */
+    skipSync(tap: SyncReadableTapLike): void;
 }

package/esm/schemas/primitive/fixed_size_base_type.js

@@ -1,6 +1,4 @@
-import { WritableTap } from "../../serialization/tap.js";
 import { BaseType } from "../base_type.js";
-import { throwInvalidError } from "../error.js";
 /**
  * Base class for fixed-size Avro types.
  * Provides optimized serialization for types with known fixed byte sizes.
@@ -10,18 +8,13 @@ import { throwInvalidError } from "../error.js";
  * Provides optimized serialization for types with known fixed byte sizes.
  */
 export class FixedSizeBaseType extends BaseType {
-    /**
-     * Serializes a value into an ArrayBuffer using the exact fixed size.
-     * @param value The value to serialize.
-     * @returns The serialized ArrayBuffer.
-     */
-    async toBuffer(value) {
-        this.check(value, throwInvalidError, []);
-        const size = this.sizeBytes();
-        const buf = new ArrayBuffer(size);
-        const tap = new WritableTap(buf);
-        await this.write(tap, value);
-        return buf;
+    /** Creates a new fixed-size base type. */
+    constructor(validate = true) {
+        super(validate);
+    }
+    /** Returns the fixed byte length for any value of this type. */
+    byteLength(_value) {
+        return this.sizeBytes();
     }
     /**
      * Skips a fixed-size value by advancing the tap by the fixed size.
@@ -30,4 +23,11 @@ export class FixedSizeBaseType extends BaseType {
     async skip(tap) {
         await tap.skipFixed(this.sizeBytes());
     }
+    /**
+     * Skips a fixed-size value synchronously by advancing the tap by the fixed size.
+     * @param tap The sync tap to skip from.
+     */
+    skipSync(tap) {
+        tap.skipFixed(this.sizeBytes());
+    }
 }

package/esm/schemas/primitive/float_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 { FixedSizeBaseType } from "./fixed_size_base_type.js";
 import type { JSONType, Type } from "../type.js";
 import { Resolver } from "../resolver.js";
@@ -7,12 +8,18 @@ import { type ErrorHook } from "../error.js";
  * Float type (32-bit).
  */
 export declare class FloatType extends FixedSizeBaseType<number> {
+    /** Creates a new float type. */
+    constructor(validate?: boolean);
     /** Checks if the value is a valid float. */
     check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
     /** Reads a float value from the tap. */
     read(tap: ReadableTapLike): Promise<number>;
-    /** Writes a float value to the tap. */
-    write(tap: WritableTapLike, value: number): Promise<void>;
+    /** Reads a float value from the sync tap. */
+    readSync(tap: SyncReadableTapLike): number;
+    /** Writes a float value to the tap without validation. */
+    writeUnchecked(tap: WritableTapLike, value: number): Promise<void>;
+    /** Writes a float value synchronously to the tap without validation. */
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: number): void;
     /** Skips a float value in the tap. */
     skip(tap: ReadableTapLike): Promise<void>;
     /**
@@ -35,4 +42,6 @@ export declare class FloatType extends FixedSizeBaseType<number> {
     toJSON(): JSONType;
     /** Matches float values between taps. */
     match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+    /** Matches float values between sync taps. */
+    matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
 }

package/esm/schemas/primitive/float_type.js

@@ -7,6 +7,10 @@ import { throwInvalidError } from "../error.js";
  * Float type (32-bit).
  */
 export class FloatType extends FixedSizeBaseType {
+    /** Creates a new float type. */
+    constructor(validate = true) {
+        super(validate);
+    }
     /** Checks if the value is a valid float. */
     check(value, errorHook, path = []) {
         const isValid = typeof value === "number";
@@ -19,13 +23,18 @@ export class FloatType extends FixedSizeBaseType {
     async read(tap) {
         return await tap.readFloat();
     }
-    /** Writes a float value to the tap. */
-    async write(tap, value) {
-        if (!this.check(value)) {
-            throwInvalidError([], value, this);
-        }
+    /** Reads a float value from the sync tap. */
+    readSync(tap) {
+        return tap.readFloat();
+    }
+    /** Writes a float value to the tap without validation. */
+    async writeUnchecked(tap, value) {
         await tap.writeFloat(value);
     }
+    /** Writes a float value synchronously to the tap without validation. */
+    writeSyncUnchecked(tap, value) {
+        tap.writeFloat(value);
+    }
     /** Skips a float value in the tap. */
     async skip(tap) {
         await tap.skipFloat();
@@ -62,6 +71,10 @@ export class FloatType extends FixedSizeBaseType {
                     const intValue = await tap.readInt();
                     return intValue;
                 }
+                readSync(tap) {
+                    const intValue = tap.readInt();
+                    return intValue;
+                }
             }(this);
         }
         else if (writerType instanceof LongType) {
@@ -71,6 +84,10 @@ export class FloatType extends FixedSizeBaseType {
                     const longValue = await tap.readLong();
                     return Number(longValue);
                 }
+                readSync(tap) {
+                    const longValue = tap.readLong();
+                    return Number(longValue);
+                }
             }(this);
         }
         else {
@@ -85,4 +102,8 @@ export class FloatType extends FixedSizeBaseType {
     async match(tap1, tap2) {
         return await tap1.matchFloat(tap2);
     }
+    /** Matches float values between sync taps. */
+    matchSync(tap1, tap2) {
+        return tap1.matchFloat(tap2);
+    }
 }