@sachitv/avro-typescript 0.4.0

package/esm/schemas/complex/fixed_type.js

@@ -0,0 +1,208 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _a, _FixedType_size, _FixedType_fromJsonString;
+import { WritableTap, } from "../../serialization/tap.js";
+import { NamedType } from "./named_type.js";
+import { Resolver } from "../resolver.js";
+import { throwInvalidError } from "../error.js";
+import { compareUint8Arrays } from "../../serialization/compare_bytes.js";
+/**
+ * Avro `fixed` type representing a fixed-length byte sequence.
+ */
+export class FixedType extends NamedType {
+    /**
+     * Creates a new FixedType.
+     * @param params The fixed type parameters.
+     */
+    constructor(params) {
+        const { size, ...names } = params;
+        if (!Number.isInteger(size) || size < 1) {
+            throw new Error(`Invalid fixed size: ${size}. Size must be a positive integer.`);
+        }
+        super(names);
+        _FixedType_size.set(this, void 0);
+        __classPrivateFieldSet(this, _FixedType_size, size, "f");
+    }
+    /**
+     * Gets the size in bytes.
+     */
+    sizeBytes() {
+        return __classPrivateFieldGet(this, _FixedType_size, "f");
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Skips a fixed-size value by advancing the tap by the fixed size.
+     * @param tap The tap to skip from.
+     */
+    async skip(tap) {
+        await tap.skipFixed(this.sizeBytes());
+    }
+    /**
+     * Gets the size in bytes.
+     */
+    getSize() {
+        return __classPrivateFieldGet(this, _FixedType_size, "f");
+    }
+    /**
+     * Checks if the value is a valid fixed-size byte array.
+     * @param value The value to check.
+     * @param errorHook Optional error hook for invalid values.
+     * @param path The path for error reporting.
+     * @returns True if valid, false otherwise.
+     */
+    check(value, errorHook, path = []) {
+        const isValid = value instanceof Uint8Array && value.length === __classPrivateFieldGet(this, _FixedType_size, "f");
+        if (!isValid && errorHook) {
+            errorHook(path.slice(), value, this);
+        }
+        return isValid;
+    }
+    /**
+     * Reads a fixed-size byte array from the tap.
+     * @param tap The tap to read from.
+     * @returns The read byte array.
+     */
+    async read(tap) {
+        return await tap.readFixed(__classPrivateFieldGet(this, _FixedType_size, "f"));
+    }
+    /**
+     * Writes a fixed-size byte array to the tap.
+     * @param tap The tap to write to.
+     * @param value The byte array to write.
+     */
+    async write(tap, value) {
+        if (!(value instanceof Uint8Array) || value.length !== __classPrivateFieldGet(this, _FixedType_size, "f")) {
+            throwInvalidError([], value, this);
+        }
+        await tap.writeFixed(value, __classPrivateFieldGet(this, _FixedType_size, "f"));
+    }
+    /**
+     * Matches two fixed-size byte arrays from the taps.
+     * @param tap1 The first tap.
+     * @param tap2 The second tap.
+     * @returns The comparison result.
+     */
+    async match(tap1, tap2) {
+        return await tap1.matchFixed(tap2, __classPrivateFieldGet(this, _FixedType_size, "f"));
+    }
+    /**
+     * Compares two fixed values for ordering.
+     * @param val1 The first value to compare.
+     * @param val2 The second value to compare.
+     * @returns A negative number if val1 < val2, zero if equal, positive if val1 > val2.
+     */
+    compare(val1, val2) {
+        if (!(val1 instanceof Uint8Array) || !(val2 instanceof Uint8Array)) {
+            throw new Error("Fixed comparison requires Uint8Array values.");
+        }
+        if (val1.length !== __classPrivateFieldGet(this, _FixedType_size, "f") || val2.length !== __classPrivateFieldGet(this, _FixedType_size, "f")) {
+            throw new Error(`Fixed values must be exactly ${__classPrivateFieldGet(this, _FixedType_size, "f")} bytes.`);
+        }
+        return compareUint8Arrays(val1, val2);
+    }
+    /**
+     * Clones a value into a Uint8Array, validating it against the fixed size.
+     * @param value The value to clone, either a Uint8Array or a string.
+     * @returns A new Uint8Array copy of the value.
+     */
+    cloneFromValue(value) {
+        let bytes;
+        if (value instanceof Uint8Array) {
+            bytes = value;
+        }
+        else if (typeof value === "string") {
+            bytes = __classPrivateFieldGet(_a, _a, "m", _FixedType_fromJsonString).call(_a, value);
+        }
+        else {
+            throwInvalidError([], value, this);
+        }
+        this.check(bytes, throwInvalidError, []);
+        return new Uint8Array(bytes);
+    }
+    /**
+     * Generates a random Uint8Array of the fixed size.
+     * @returns A random Uint8Array with the fixed length.
+     */
+    random() {
+        const bytes = new Uint8Array(__classPrivateFieldGet(this, _FixedType_size, "f"));
+        for (let i = 0; i < __classPrivateFieldGet(this, _FixedType_size, "f"); i++) {
+            bytes[i] = Math.floor(Math.random() * 256);
+        }
+        return bytes;
+    }
+    /**
+     * Converts the fixed type to its JSON schema representation.
+     * @returns The JSON type object.
+     */
+    toJSON() {
+        return {
+            name: this.getFullName(),
+            type: "fixed",
+            size: __classPrivateFieldGet(this, _FixedType_size, "f"),
+        };
+    }
+    /**
+     * Creates a resolver for schema evolution between fixed types.
+     * @param writerType The writer's type to resolve against.
+     * @returns A resolver for reading data written with the writer type.
+     */
+    createResolver(writerType) {
+        if (!(writerType instanceof _a)) {
+            return super.createResolver(writerType);
+        }
+        const acceptableNames = new Set([
+            this.getFullName(),
+            ...this.getAliases(),
+        ]);
+        const writerNames = new Set([
+            writerType.getFullName(),
+            ...writerType.getAliases(),
+        ]);
+        const hasCompatibleName = Array.from(writerNames).some((name) => acceptableNames.has(name));
+        if (!hasCompatibleName) {
+            throw new Error(`Schema evolution not supported from writer type: ${writerType.getFullName()} to reader type: ${this.getFullName()}`);
+        }
+        if (__classPrivateFieldGet(this, _FixedType_size, "f") !== writerType.getSize()) {
+            throw new Error(`Cannot resolve fixed types with different sizes: writer has ${writerType.getSize()}, reader has ${__classPrivateFieldGet(this, _FixedType_size, "f")}`);
+        }
+        // If sizes match and names are compatible, we can use the reader's read method directly
+        return new FixedResolver(this);
+    }
+}
+_a = FixedType, _FixedType_size = new WeakMap(), _FixedType_fromJsonString = function _FixedType_fromJsonString(value) {
+    const bytes = new Uint8Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+        bytes[i] = value.charCodeAt(i) & 0xff;
+    }
+    return bytes;
+};
+class FixedResolver extends Resolver {
+    constructor(reader) {
+        super(reader);
+    }
+    async read(tap) {
+        const reader = this.readerType;
+        return await reader.read(tap);
+    }
+}

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

@@ -0,0 +1,97 @@
+import { type ReadableTapLike, type WritableTapLike } from "../../serialization/tap.js";
+import { BaseType } from "../base_type.js";
+import { Resolver } from "../resolver.js";
+import type { JSONType, Type } from "../type.js";
+import { type ErrorHook } from "../error.js";
+/**
+ * Parameters for creating a MapType.
+ */
+export interface MapTypeParams<T> {
+    /** The type of values in the map. */
+    values: Type<T>;
+}
+/**
+ * Helper function to read a map from a tap.
+ * @param tap The tap to read from.
+ * @param readValue Function to read a single value.
+ * @param collect Function to collect each key-value pair.
+ */
+export declare function readMapInto<T>(tap: ReadableTapLike, readValue: (tap: ReadableTapLike) => Promise<T>, collect: (key: string, value: T) => void): Promise<void>;
+/**
+ * Avro `map` type for string-keyed collections of values matching a schema.
+ */
+export declare class MapType<T = unknown> extends BaseType<Map<string, T>> {
+    #private;
+    /**
+     * Creates a new MapType.
+     * @param params The map type parameters.
+     */
+    constructor(params: MapTypeParams<T>);
+    /**
+     * Gets the type of values in the map.
+     */
+    getValuesType(): Type<T>;
+    /**
+     * Validates if the value is a valid map according to the schema.
+     */
+    check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
+    /**
+     * Writes the map value to the tap.
+     * @param tap The writable tap to write to.
+     * @param value The map value to write.
+     */
+    write(tap: WritableTapLike, value: Map<string, T>): Promise<void>;
+    /**
+     * Reads a map value from the provided tap.
+     */
+    read(tap: ReadableTapLike): Promise<Map<string, T>>;
+    /**
+     * Skips over a map value in the tap without reading it.
+     * @param tap The readable tap to skip from.
+     */
+    skip(tap: ReadableTapLike): Promise<void>;
+    /**
+     * Serializes the map value to an ArrayBuffer.
+     * @param value The map value to serialize.
+     * @returns The serialized ArrayBuffer.
+     */
+    toBuffer(value: Map<string, T>): Promise<ArrayBuffer>;
+    /**
+     * Creates a deep clone of the map from the given value.
+     * @param value The value to clone, which can be a Map or a plain object.
+     * @returns A new Map instance with cloned values.
+     */
+    cloneFromValue(value: unknown): Map<string, T>;
+    /**
+     * Compares two map values. Always throws an error as maps cannot be compared.
+     * @param _val1 First map value.
+     * @param _val2 Second map value.
+     * @returns Never returns, always throws.
+     * @throws Always throws an error.
+     */
+    compare(_val1: Map<string, T>, _val2: Map<string, T>): number;
+    /**
+     * Generates a random map value.
+     * @returns A random Map with string keys and values of the map's value type.
+     */
+    random(): Map<string, T>;
+    /**
+     * Returns the JSON schema representation of the map type.
+     * @returns The JSON representation as JSONType.
+     */
+    toJSON(): JSONType;
+    /**
+     * Compares two encoded buffers. Always throws an error as maps cannot be compared.
+     * @param _tap1 The first tap.
+     * @param _tap2 The second tap.
+     * @returns Never returns, always throws.
+     * @throws Always throws an error.
+     */
+    match(_tap1: ReadableTapLike, _tap2: ReadableTapLike): Promise<number>;
+    /**
+     * Creates a resolver for schema evolution from a writer type to this reader type.
+     * @param writerType The writer schema type.
+     * @returns A resolver for reading the writer type as this type.
+     */
+    createResolver(writerType: Type): Resolver;
+}

package/esm/schemas/complex/map_type.js

@@ -0,0 +1,290 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _MapType_valuesType, _MapResolver_valueResolver;
+import { WritableTap, } from "../../serialization/tap.js";
+import { encode } from "../../serialization/text_encoding.js";
+import { bigIntToSafeNumber } from "../../serialization/conversion.js";
+import { BaseType } from "../base_type.js";
+import { Resolver } from "../resolver.js";
+import { throwInvalidError } from "../error.js";
+import { calculateVarintSize } from "../../internal/varint.js";
+/**
+ * Helper function to read a map from a tap.
+ * @param tap The tap to read from.
+ * @param readValue Function to read a single value.
+ * @param collect Function to collect each key-value pair.
+ */
+export async function readMapInto(tap, readValue, collect) {
+    while (true) {
+        let rawCount = await tap.readLong();
+        if (rawCount === 0n) {
+            break;
+        }
+        if (rawCount < 0n) {
+            rawCount = -rawCount;
+            await tap.skipLong(); // skip block size
+        }
+        const count = bigIntToSafeNumber(rawCount, "Map block length");
+        for (let i = 0; i < count; i++) {
+            const key = await tap.readString();
+            const value = await readValue(tap);
+            collect(key, value);
+        }
+    }
+}
+/**
+ * Avro `map` type for string-keyed collections of values matching a schema.
+ */
+export class MapType extends BaseType {
+    /**
+     * Creates a new MapType.
+     * @param params The map type parameters.
+     */
+    constructor(params) {
+        super();
+        _MapType_valuesType.set(this, void 0);
+        if (!params.values) {
+            throw new Error("MapType requires a values type.");
+        }
+        __classPrivateFieldSet(this, _MapType_valuesType, params.values, "f");
+    }
+    /**
+     * Gets the type of values in the map.
+     */
+    getValuesType() {
+        return __classPrivateFieldGet(this, _MapType_valuesType, "f");
+    }
+    /**
+     * Validates if the value is a valid map according to the schema.
+     */
+    check(value, errorHook, path = []) {
+        if (!(value instanceof Map)) {
+            if (errorHook) {
+                errorHook(path.slice(), value, this);
+            }
+            return false;
+        }
+        let isValid = true;
+        for (const [key, entry] of value.entries()) {
+            if (typeof key !== "string") {
+                if (errorHook) {
+                    errorHook(path.slice(), value, this);
+                    isValid = false;
+                    continue;
+                }
+                return false;
+            }
+            const entryPath = errorHook ? [...path, key] : undefined;
+            const validEntry = __classPrivateFieldGet(this, _MapType_valuesType, "f").check(entry, errorHook, entryPath);
+            if (!validEntry) {
+                if (!errorHook) {
+                    return false;
+                }
+                isValid = false;
+            }
+        }
+        return isValid;
+    }
+    /**
+     * Writes the map value to the tap.
+     * @param tap The writable tap to write to.
+     * @param value The map value to write.
+     */
+    async write(tap, value) {
+        if (!(value instanceof Map)) {
+            throwInvalidError([], value, this);
+        }
+        if (value.size > 0) {
+            await tap.writeLong(BigInt(value.size));
+            for (const [key, entry] of value) {
+                if (typeof key !== "string") {
+                    throwInvalidError([], value, this);
+                }
+                await tap.writeString(key);
+                await __classPrivateFieldGet(this, _MapType_valuesType, "f").write(tap, entry);
+            }
+        }
+        await tap.writeLong(0n);
+    }
+    /**
+     * Reads a map value from the provided tap.
+     */
+    async read(tap) {
+        const result = new Map();
+        await readMapInto(tap, async (innerTap) => await __classPrivateFieldGet(this, _MapType_valuesType, "f").read(innerTap), (key, value) => {
+            result.set(key, value);
+        });
+        return result;
+    }
+    /**
+     * Skips over a map value in the tap without reading it.
+     * @param tap The readable tap to skip from.
+     */
+    async skip(tap) {
+        while (true) {
+            const rawCount = await tap.readLong();
+            if (rawCount === 0n) {
+                break;
+            }
+            if (rawCount < 0n) {
+                const blockSize = await tap.readLong();
+                const size = bigIntToSafeNumber(blockSize, "Map block size");
+                if (size > 0) {
+                    await tap.skipFixed(size);
+                }
+                continue;
+            }
+            const count = bigIntToSafeNumber(rawCount, "Map block length");
+            for (let i = 0; i < count; i++) {
+                await tap.skipString();
+                await __classPrivateFieldGet(this, _MapType_valuesType, "f").skip(tap);
+            }
+        }
+    }
+    /**
+     * Serializes the map value to an ArrayBuffer.
+     * @param value The map value to serialize.
+     * @returns The serialized ArrayBuffer.
+     */
+    async toBuffer(value) {
+        if (!(value instanceof Map)) {
+            throwInvalidError([], value, this);
+        }
+        const serializedEntries = [];
+        let totalSize = 1; // final zero block terminator
+        for (const [key, entry] of value.entries()) {
+            if (typeof key !== "string") {
+                throwInvalidError([], value, this);
+            }
+            const keyBytes = encode(key);
+            const valueBytes = new Uint8Array(await __classPrivateFieldGet(this, _MapType_valuesType, "f").toBuffer(entry));
+            totalSize += calculateVarintSize(keyBytes.length) + keyBytes.length;
+            totalSize += valueBytes.length;
+            serializedEntries.push({ keyBytes, valueBytes });
+        }
+        if (serializedEntries.length > 0) {
+            totalSize += calculateVarintSize(serializedEntries.length);
+        }
+        const buffer = new ArrayBuffer(totalSize);
+        const tap = new WritableTap(buffer);
+        if (serializedEntries.length > 0) {
+            await tap.writeLong(BigInt(serializedEntries.length));
+            for (const { keyBytes, valueBytes } of serializedEntries) {
+                await tap.writeLong(BigInt(keyBytes.length));
+                await tap.writeFixed(keyBytes);
+                await tap.writeFixed(valueBytes);
+            }
+        }
+        await tap.writeLong(0n);
+        return buffer;
+    }
+    /**
+     * Creates a deep clone of the map from the given value.
+     * @param value The value to clone, which can be a Map or a plain object.
+     * @returns A new Map instance with cloned values.
+     */
+    cloneFromValue(value) {
+        const copy = new Map();
+        if (value instanceof Map) {
+            for (const [key, entry] of value.entries()) {
+                if (typeof key !== "string") {
+                    throw new Error("Map keys must be strings to clone.");
+                }
+                copy.set(key, __classPrivateFieldGet(this, _MapType_valuesType, "f").cloneFromValue(entry));
+            }
+            return copy;
+        }
+        if (!isPlainObject(value)) {
+            throw new Error("Cannot clone non-map value.");
+        }
+        for (const [key, entry] of Object.entries(value)) {
+            copy.set(key, __classPrivateFieldGet(this, _MapType_valuesType, "f").cloneFromValue(entry));
+        }
+        return copy;
+    }
+    /**
+     * Compares two map values. Always throws an error as maps cannot be compared.
+     * @param _val1 First map value.
+     * @param _val2 Second map value.
+     * @returns Never returns, always throws.
+     * @throws Always throws an error.
+     */
+    compare(_val1, _val2) {
+        throw new Error("maps cannot be compared");
+    }
+    /**
+     * Generates a random map value.
+     * @returns A random Map with string keys and values of the map's value type.
+     */
+    random() {
+        const result = new Map();
+        // There should be at least one entry.
+        const entries = Math.ceil(Math.random() * 10);
+        for (let i = 0; i < entries; i++) {
+            const key = crypto.randomUUID();
+            result.set(key, __classPrivateFieldGet(this, _MapType_valuesType, "f").random());
+        }
+        return result;
+    }
+    /**
+     * Returns the JSON schema representation of the map type.
+     * @returns The JSON representation as JSONType.
+     */
+    toJSON() {
+        return {
+            type: "map",
+            values: __classPrivateFieldGet(this, _MapType_valuesType, "f").toJSON(),
+        };
+    }
+    /**
+     * Compares two encoded buffers. Always throws an error as maps cannot be compared.
+     * @param _tap1 The first tap.
+     * @param _tap2 The second tap.
+     * @returns Never returns, always throws.
+     * @throws Always throws an error.
+     */
+    // deno-lint-ignore require-await
+    async match(_tap1, _tap2) {
+        throw new Error("maps cannot be compared");
+    }
+    /**
+     * Creates a resolver for schema evolution from a writer type to this reader type.
+     * @param writerType The writer schema type.
+     * @returns A resolver for reading the writer type as this type.
+     */
+    createResolver(writerType) {
+        if (!(writerType instanceof MapType)) {
+            return super.createResolver(writerType);
+        }
+        const valueResolver = __classPrivateFieldGet(this, _MapType_valuesType, "f").createResolver(writerType.getValuesType());
+        return new MapResolver(this, valueResolver);
+    }
+}
+_MapType_valuesType = new WeakMap();
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+class MapResolver extends Resolver {
+    constructor(reader, valueResolver) {
+        super(reader);
+        _MapResolver_valueResolver.set(this, void 0);
+        __classPrivateFieldSet(this, _MapResolver_valueResolver, valueResolver, "f");
+    }
+    async read(tap) {
+        const result = new Map();
+        await readMapInto(tap, async (innerTap) => await __classPrivateFieldGet(this, _MapResolver_valueResolver, "f").read(innerTap), (key, value) => {
+            result.set(key, value);
+        });
+        return result;
+    }
+}
+_MapResolver_valueResolver = new WeakMap();

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

@@ -0,0 +1,30 @@
+import { BaseType } from "../base_type.js";
+import type { ResolvedNames } from "./resolve_names.js";
+/**
+ * Base class for Avro types that carry a schema name (`record`, `enum`, `fixed`).
+ * Resolves the primary name, namespace, and aliases to fully qualified names.
+ */
+export declare abstract class NamedType<T = unknown> extends BaseType<T> {
+    #private;
+    /**
+     * Creates a new NamedType.
+     * @param resolvedNames The resolved names (full name, namespace, aliases).
+     */
+    protected constructor(resolvedNames: ResolvedNames);
+    /**
+     * Fully qualified schema name.
+     */
+    getFullName(): string;
+    /**
+     * Namespace associated with this type (empty string when unspecified).
+     */
+    getNamespace(): string;
+    /**
+     * Fully qualified aliases for this type.
+     */
+    getAliases(): string[];
+    /**
+     * Checks whether the provided name matches either the full name or any alias.
+     */
+    matchesName(name: string): boolean;
+}

package/esm/schemas/complex/named_type.js

@@ -0,0 +1,57 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _NamedType_fullName, _NamedType_namespace, _NamedType_aliases;
+import { BaseType } from "../base_type.js";
+/**
+ * Base class for Avro types that carry a schema name (`record`, `enum`, `fixed`).
+ * Resolves the primary name, namespace, and aliases to fully qualified names.
+ */
+export class NamedType extends BaseType {
+    /**
+     * Creates a new NamedType.
+     * @param resolvedNames The resolved names (full name, namespace, aliases).
+     */
+    constructor(resolvedNames) {
+        super();
+        _NamedType_fullName.set(this, void 0);
+        _NamedType_namespace.set(this, void 0);
+        _NamedType_aliases.set(this, void 0);
+        __classPrivateFieldSet(this, _NamedType_fullName, resolvedNames.fullName, "f");
+        __classPrivateFieldSet(this, _NamedType_namespace, resolvedNames.namespace, "f");
+        __classPrivateFieldSet(this, _NamedType_aliases, resolvedNames.aliases, "f");
+    }
+    /**
+     * Fully qualified schema name.
+     */
+    getFullName() {
+        return __classPrivateFieldGet(this, _NamedType_fullName, "f");
+    }
+    /**
+     * Namespace associated with this type (empty string when unspecified).
+     */
+    getNamespace() {
+        return __classPrivateFieldGet(this, _NamedType_namespace, "f");
+    }
+    /**
+     * Fully qualified aliases for this type.
+     */
+    getAliases() {
+        return __classPrivateFieldGet(this, _NamedType_aliases, "f").slice();
+    }
+    /**
+     * Checks whether the provided name matches either the full name or any alias.
+     */
+    matchesName(name) {
+        return name === __classPrivateFieldGet(this, _NamedType_fullName, "f") || __classPrivateFieldGet(this, _NamedType_aliases, "f").includes(name);
+    }
+}
+_NamedType_fullName = new WeakMap(), _NamedType_namespace = new WeakMap(), _NamedType_aliases = new WeakMap();