@mtkruto/browser 0.6.1 → 0.119.1

package/esm/tl/1_tl_reader.d.ts

@@ -0,0 +1,39 @@
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2026 Roj <https://roj.im/>
+ *
+ * This file is part of MTKruto.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import type { Schema } from "./0_types.js";
+export declare class TLReader {
+    #private;
+    protected _buffer: Uint8Array;
+    constructor(buffer: Uint8Array);
+    get buffer(): Uint8Array;
+    read(byteCount: number): Uint8Array<ArrayBuffer>;
+    unread(count: number): void;
+    readInt24(isSigned?: boolean): number;
+    readInt32(isSigned?: boolean): number;
+    unreadInt32(): void;
+    readInt64(isSigned?: boolean): bigint;
+    readDouble(): number;
+    readInt128(isSigned?: boolean): bigint;
+    readInt256(isSigned?: boolean): bigint;
+    readBytes(): Uint8Array<ArrayBuffer>;
+    readString(): string;
+    readType(name: string, schema: Schema): Promise<any>;
+}
+//# sourceMappingURL=1_tl_reader.d.ts.map

package/esm/tl/1_tl_reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1_tl_reader.d.ts","sourceRoot":"","sources":["../../src/tl/1_tl_reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAoB,MAAM,EAAE,MAAM,cAAc,CAAC;AAG7D,qBAAa,QAAQ;;IAEnB,SAAS,CAAC,OAAO,EAAE,UAAU,CAAC;gBAElB,MAAM,EAAE,UAAU;IAI9B,IAAI,MAAM,IAAI,UAAU,CAEvB;IAED,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC;IAUhD,MAAM,CAAC,KAAK,EAAE,MAAM;IASpB,SAAS,CAAC,QAAQ,UAAO,GAAG,MAAM;IAKlC,SAAS,CAAC,QAAQ,UAAO,GAAG,MAAM;IAKlC,WAAW;IAIX,SAAS,CAAC,QAAQ,UAAO,GAAG,MAAM;IAKlC,UAAU,IAAI,MAAM;IAKpB,UAAU,CAAC,QAAQ,UAAO,GAAG,MAAM;IAKnC,UAAU,CAAC,QAAQ,UAAO,GAAG,MAAM;IAKnC,SAAS,IAAI,UAAU,CAAC,WAAW,CAAC;IAiBpC,UAAU,IAAI,MAAM;IAId,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;CAkI3D"}

package/esm/tl/1_tl_reader.js

@@ -0,0 +1,220 @@
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2026 Roj <https://roj.im/>
+ *
+ * This file is part of MTKruto.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+// deno-lint-ignore-file no-explicit-any
+import { decodeText, intFromBytes } from "../1_utilities.js";
+import { TLError } from "../0_errors.js";
+import { analyzeOptionalParam, BOOL_FALSE, BOOL_TRUE, constructorIdToHex, getOptionalParamInnerType, getVectorItemType, isOptionalParam, VECTOR, X } from "./0_utilities.js";
+export class TLReader {
+    #path = new Array();
+    _buffer;
+    constructor(buffer) {
+        this._buffer = buffer;
+    }
+    get buffer() {
+        return this._buffer;
+    }
+    read(byteCount) {
+        if (this._buffer.byteLength < byteCount) {
+            throw new TLError("No data remaining", this.#path);
+        }
+        const buffer = this._buffer.slice(0, byteCount);
+        this._buffer = this._buffer.subarray(byteCount);
+        return buffer;
+    }
+    unread(count) {
+        const newOffest = this._buffer.byteOffset - count;
+        if (newOffest < 0) {
+            throw new TLError("No data has been read", this.#path);
+        }
+        this._buffer = new Uint8Array(this._buffer.buffer, newOffest);
+    }
+    readInt24(isSigned = true) {
+        const buffer = this.read(24 / 8);
+        return Number(intFromBytes(buffer, { isSigned }));
+    }
+    readInt32(isSigned = true) {
+        const buffer = this.read(32 / 8);
+        return Number(intFromBytes(buffer, { isSigned }));
+    }
+    unreadInt32() {
+        this.unread(32 / 8);
+    }
+    readInt64(isSigned = true) {
+        const buffer = this.read(64 / 8);
+        return intFromBytes(buffer, { isSigned });
+    }
+    readDouble() {
+        const buffer = this.read(8);
+        return new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength).getFloat64(0, true);
+    }
+    readInt128(isSigned = true) {
+        const buffer = this.read(128 / 8);
+        return intFromBytes(buffer, { isSigned });
+    }
+    readInt256(isSigned = true) {
+        const buffer = this.read(256 / 8);
+        return intFromBytes(buffer, { isSigned });
+    }
+    readBytes() {
+        let L = this.read(1)[0];
+        let padding;
+        if (L > 253) {
+            L = this.readInt24();
+            padding = L % 4;
+        }
+        else {
+            padding = (L + 1) % 4;
+        }
+        const bytes = this.read(L);
+        if (padding > 0) {
+            padding = 4 - padding;
+            this.read(padding);
+        }
+        return bytes;
+    }
+    readString() {
+        return decodeText(this.readBytes());
+    }
+    async readType(name, schema) {
+        if (isOptionalParam(name)) {
+            name = getOptionalParamInnerType(name);
+        }
+        const primitive = this.#deserializePrimitive(name);
+        if (primitive !== undefined) {
+            return primitive;
+        }
+        const id = this.readInt32(false);
+        if (id === BOOL_TRUE) {
+            return true;
+        }
+        else if (id === BOOL_FALSE) {
+            return false;
+        }
+        if (name === X) {
+            const typeName = schema.identifierToName[id];
+            if (!typeName) {
+                throw new TLError(`Unknown constructor ID: ${constructorIdToHex(id)}`, this.#path);
+            }
+            this.unreadInt32();
+            return await this.readType(typeName, schema);
+        }
+        if (id === VECTOR) {
+            return await this.#deserializeVector(name, schema);
+        }
+        const definition = schema.definitions[name];
+        if (definition) {
+            return await this.#deserializeType(name, definition, id, schema);
+        }
+        const deserializedEnum = await this.#deserializeEnum(name, id, schema);
+        if (deserializedEnum !== undefined) {
+            return deserializedEnum;
+        }
+        throw new TLError(`Unknown type: ${name}#${constructorIdToHex(id)}`, this.#path);
+    }
+    async #deserializeEnum(type, id, schema) {
+        const name = schema.identifierToName[id];
+        if (!name) {
+            return;
+        }
+        const definition = schema.definitions[name];
+        if (definition[2] !== type) {
+            return;
+        }
+        return await this.#deserializeType(name, definition, id, schema);
+    }
+    async #deserializeType(type, desc, id, schema) {
+        if (desc[0] !== id) {
+            throw new TLError(`Expected constructor with ID ${constructorIdToHex(desc[0])} but received ${constructorIdToHex(id)}`, this.#path);
+        }
+        let isFirstPathElementExisting = false;
+        const type_ = { _: type };
+        const flagFields = {};
+        for (const [name, fieldType] of desc[1]) {
+            if (isOptionalParam(fieldType)) {
+                const { flagField, bitIndex } = analyzeOptionalParam(fieldType);
+                const bits = flagFields[flagField];
+                if ((bits & (1 << bitIndex)) === 0) {
+                    continue;
+                }
+            }
+            if (fieldType === "#") {
+                flagFields[name] = this.readInt32();
+                continue;
+            }
+            const pathElement = `[${type}.]${name}`;
+            if (isFirstPathElementExisting) {
+                this.#path[this.#path.length - 1] = pathElement;
+            }
+            else {
+                this.#path.push(pathElement);
+                isFirstPathElementExisting = true;
+            }
+            const value = await this.readType(fieldType, schema);
+            if (typeof value !== "boolean" || value) {
+                type_[name] = value;
+            }
+        }
+        return type_;
+    }
+    async #deserializeVector(type, schema) {
+        const itemType = getVectorItemType(type);
+        if (!itemType) {
+            throw new TLError(`Expected Vector but received ${type}`, this.#path);
+        }
+        const size = this.readInt32();
+        const array = new Array();
+        for (let i = 0; i < size; ++i) {
+            array.push(await this.readType(itemType, schema));
+        }
+        return array;
+    }
+    #deserializePrimitive(type) {
+        switch (type) {
+            case "bytes":
+                return this.readBytes();
+            case "int128":
+                return this.readInt128();
+            case "int256":
+                return this.readInt256();
+            case "double":
+                return this.readDouble();
+            case "long":
+                return this.readInt64();
+            case "true":
+                return true;
+            case "int":
+                return this.readInt32();
+            case "Bool": {
+                const id = this.readInt32(false);
+                if (id === BOOL_TRUE) {
+                    return true;
+                }
+                else if (id === BOOL_FALSE) {
+                    return false;
+                }
+                else {
+                    throw new TLError(`Expected boolTrue or boolFalse but received ${constructorIdToHex(id)}`, this.#path);
+                }
+            }
+            case "string":
+                return this.readString();
+        }
+    }
+}

package/esm/tl/1_tl_writer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2026 Roj <https://roj.im/>
+ *
+ * This file is part of MTKruto.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import type { Schema } from "./0_types.js";
+export declare class TLWriter {
+    #private;
+    protected _buffer: Uint8Array<ArrayBuffer>;
+    constructor();
+    get buffer(): Uint8Array<ArrayBuffer>;
+    write(buffer: Uint8Array): typeof this;
+    writeInt24(int: number, isSigned?: boolean): typeof this;
+    writeInt32(int: number, isSigned?: boolean): typeof this;
+    writeInt64(int: bigint, isSigned?: boolean): typeof this;
+    writeDouble(double: number): typeof this;
+    writeInt128(int: bigint, isSigned?: boolean): typeof this;
+    writeInt256(int: bigint, isSigned?: boolean): typeof this;
+    writeBytes(bytes: Uint8Array): typeof this;
+    writeString(string: string): typeof this;
+    writeObject(value: any, schema: Schema): typeof this;
+}
+//# sourceMappingURL=1_tl_writer.d.ts.map

package/esm/tl/1_tl_writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1_tl_writer.d.ts","sourceRoot":"","sources":["../../src/tl/1_tl_writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAI3C,qBAAa,QAAQ;;IACnB,SAAS,CAAC,OAAO,EAAE,UAAU,CAAC,WAAW,CAAC,CAAoB;;IAM9D,IAAI,MAAM,IAAI,UAAU,CAAC,WAAW,CAAC,CAEpC;IAED,KAAK,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,IAAI;IAKtC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,UAAO,GAAG,OAAO,IAAI;IAKrD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,UAAO,GAAG,OAAO,IAAI;IAKrD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,UAAO,GAAG,OAAO,IAAI;IAKrD,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,IAAI;IAOxC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,UAAO,GAAG,OAAO,IAAI;IAKtD,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,UAAO,GAAG,OAAO,IAAI;IAKtD,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,IAAI;IAkB1C,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,IAAI;IAKxC,WAAW,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,IAAI;CAyLrD"}

package/esm/tl/1_tl_writer.js

@@ -0,0 +1,269 @@
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2026 Roj <https://roj.im/>
+ *
+ * This file is part of MTKruto.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+// deno-lint-ignore-file no-explicit-any
+import { concat } from "../0_deps.js";
+import { TLError } from "../0_errors.js";
+import { analyzeOptionalParam, BOOL_FALSE, BOOL_TRUE, getOptionalParamInnerType, getVectorItemType, isOptionalParam, repr, VECTOR } from "./0_utilities.js";
+import { intToBytes } from "../utilities/0_int.js";
+import { encodeText } from "../1_utilities.js";
+export class TLWriter {
+    _buffer = new Uint8Array();
+    #path = new Array();
+    constructor() {
+    }
+    get buffer() {
+        return this._buffer;
+    }
+    write(buffer) {
+        this._buffer = concat([this._buffer, buffer]);
+        return this;
+    }
+    writeInt24(int, isSigned = true) {
+        this.write(intToBytes(int, 24 / 8, { isSigned, path: this.#path }));
+        return this;
+    }
+    writeInt32(int, isSigned = true) {
+        this.write(intToBytes(int, 32 / 8, { isSigned, path: this.#path }));
+        return this;
+    }
+    writeInt64(int, isSigned = true) {
+        this.write(intToBytes(int, 64 / 8, { isSigned, path: this.#path }));
+        return this;
+    }
+    writeDouble(double) {
+        const buffer = new Uint8Array(8);
+        new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength).setFloat64(0, double, true);
+        this.write(buffer);
+        return this;
+    }
+    writeInt128(int, isSigned = true) {
+        this.write(intToBytes(int, 128 / 8, { isSigned, path: this.#path }));
+        return this;
+    }
+    writeInt256(int, isSigned = true) {
+        this.write(intToBytes(int, 256 / 8, { isSigned, path: this.#path }));
+        return this;
+    }
+    writeBytes(bytes) {
+        let padding;
+        if (bytes.length > 253) {
+            this.write(new Uint8Array([254]));
+            this.writeInt24(bytes.length);
+            padding = bytes.length % 4;
+        }
+        else {
+            this.write(new Uint8Array([bytes.length]));
+            padding = (bytes.length + 1) % 4;
+        }
+        this.write(bytes);
+        if (padding > 0) {
+            padding = 4 - padding;
+            this.write(new Uint8Array(padding));
+        }
+        return this;
+    }
+    writeString(string) {
+        this.writeBytes(encodeText(string));
+        return this;
+    }
+    writeObject(value, schema) {
+        this.#serialize(value._, value, schema);
+        return this;
+    }
+    #serialize(type, value, schema) {
+        if (this.#serializePrimitive(type, value)) {
+            return;
+        }
+        if (this.#serializeVector(type, value, schema)) {
+            return;
+        }
+        const maybeDefinition = schema.definitions[value._];
+        if (!maybeDefinition) {
+            throw new TLError(`Unknown constructor: ${value._}`, this.#path);
+        }
+        if (type !== "!X" && !this.#isTypeValid(type, value, schema)) {
+            throw new TLError(`Expected ${type} but instead got ${value._}`, this.#path);
+        }
+        const type__ = value;
+        const [id, parameters_] = maybeDefinition;
+        this.writeInt32(id, false);
+        let isFirstPathElementExisting = false;
+        for (let [name, type] of parameters_.values()) {
+            if (isOptionalParam(type) && type__[name] === undefined) {
+                continue;
+            }
+            if (type === "#") {
+                let flags = 0;
+                const flagField_ = name;
+                for (const [name, type] of parameters_) {
+                    if (isOptionalParam(type)) {
+                        const { flagField, bitIndex } = analyzeOptionalParam(type);
+                        if (flagField === flagField_) {
+                            if (type__[name] !== undefined) {
+                                flags |= 1 << bitIndex;
+                            }
+                        }
+                    }
+                }
+                this.writeInt32(flags);
+                continue;
+            }
+            const pathElement = `[${value._}.]${name}`;
+            if (isFirstPathElementExisting) {
+                this.#path[this.#path.length - 1] = pathElement;
+            }
+            else {
+                this.#path.push(pathElement);
+                isFirstPathElementExisting = true;
+            }
+            if (type__[name] === undefined && !isOptionalParam(type)) {
+                throw new TLError("Missing required field", this.#path);
+            }
+            if (isOptionalParam(type)) {
+                type = getOptionalParamInnerType(type);
+            }
+            this.#serialize(type, type__[name], schema);
+        }
+        return;
+    }
+    #serializeVector(type, value, schema) {
+        const itemType = getVectorItemType(type);
+        if (!itemType) {
+            return false;
+        }
+        if (!Array.isArray(value)) {
+            throw new TLError(`Expected an array but received ${repr(value)}`, this.#path);
+        }
+        this.writeInt32(VECTOR, false);
+        this.writeInt32(value.length);
+        for (const item of value) {
+            this.#serialize(itemType, item, schema);
+        }
+        return true;
+    }
+    #serializePrimitive(type, value) {
+        const valueRepr = repr(value);
+        switch (type) {
+            case "bytes":
+                if ((value instanceof Uint8Array)) {
+                    this.writeBytes(value);
+                }
+                else {
+                    throw new TLError(`Expected Uint8Array but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            case "int128":
+                if (typeof value === "bigint") {
+                    this.writeInt128(value);
+                }
+                else {
+                    throw new TLError(`Expected bigint but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            case "int256":
+                if (typeof value === "bigint") {
+                    this.writeInt256(value);
+                }
+                else {
+                    throw new TLError(`Expected bigint but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            case "long":
+                if (typeof value === "bigint") {
+                    this.writeInt64(value);
+                }
+                else {
+                    throw new TLError(`Expected bigint but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            case "Bool":
+                if (typeof value === "boolean") {
+                    if (value) {
+                        this.writeInt32(BOOL_TRUE);
+                    }
+                    else {
+                        this.writeInt32(BOOL_FALSE);
+                    }
+                }
+                else {
+                    throw new TLError(`Expected boolean but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            case "int":
+                //
+                if (value === null) {
+                    value = 0;
+                }
+                //
+                if (typeof value === "number") {
+                    if (value % 1 === 0) {
+                        this.writeInt32(value);
+                    }
+                    else {
+                        throw new TLError("Expected an integer value but received a floating point", this.#path);
+                    }
+                }
+                else {
+                    throw new TLError(`Expected number but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            case "double":
+                //
+                if (value === null) {
+                    value = 0;
+                }
+                //
+                if (typeof value === "number") {
+                    this.writeDouble(value);
+                }
+                else {
+                    throw new TLError(`Expected number but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            case "string":
+                if (typeof value === "string") {
+                    this.writeString(value);
+                }
+                else if (value instanceof Uint8Array) {
+                    this.writeBytes(value);
+                }
+                else {
+                    this.writeString("");
+                }
+                // else {
+                //   throw new TypeError(`Expected string or Uint8Array but received ${valueRepr}`);
+                // }
+                return true;
+            case "true":
+                if (value !== true) {
+                    throw new TLError(`Expected \`true\` but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+    #isTypeValid(type, value, schema) {
+        if (type === value._) {
+            return true;
+        }
+        return schema.definitions[value._]?.[2] === type;
+    }
+}

package/esm/tl/1_utilities.d.ts

@@ -1,6 +1,6 @@
 /**
  * MTKruto - Cross-runtime JavaScript library for building Telegram clients
- * Copyright (C) 2023-2024 Roj <https://roj.im/>
+ * Copyright (C) 2023-2026 Roj <https://roj.im/>
  *
  * This file is part of MTKruto.
  *
@@ -17,17 +17,12 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-import { AnyType, Enums, Functions, Types } from "./0_api.js";
-export declare function isOptionalParam(ntype: string): boolean;
-export declare function analyzeOptionalParam(ntype: string): {
-    flagField: string;
-    bitIndex: number;
-};
-export declare function isValidType(object: any): object is AnyType;
-export declare function assertIsValidType(object: any): void;
-export declare function is<S extends keyof (Types & Functions)>(typeName: S, value: unknown): value is S extends keyof Types ? Types[S] : S extends keyof Functions ? Functions[S] : never;
-export declare function isOneOf<S extends keyof (Types & Functions)>(typeNames: S[] | readonly S[], value: unknown): value is S extends keyof Types ? Types[S] : S extends keyof Functions ? Functions[S] : never;
-export declare function isOfEnum<S extends keyof Enums>(enumName: S, value: unknown): value is Enums[S];
-export declare function as<S extends keyof Types>(typeName: S, value: unknown): Types[S];
-export declare function isGenericFunction(value: unknown): boolean;
+import type { Schema } from "./0_types.js";
+export declare function isValidObject(object: any, schema: Schema): boolean;
+export declare function assertIsValidObject(object: any, schema: Schema): void;
+export declare function is(typeName: string, value: any, schema: Schema): boolean;
+export declare function isOneOf(names: string[], value: unknown, schema: Schema): boolean;
+export declare function isOfEnum(name: string, value: any, schema: Schema): boolean;
+export declare function as(name: string, value: unknown, schema: Schema): unknown;
+export declare function mustGetReturnType(name: string, schema: Schema): string;
 //# sourceMappingURL=1_utilities.d.ts.map

package/esm/tl/1_utilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"1_utilities.d.ts","sourceRoot":"","sources":["../../src/tl/1_utilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAoB,KAAK,EAAE,MAAM,YAAY,CAAC;AAEhF,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEtD;AACD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAY3F;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,IAAI,OAAO,CAE1D;AACD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,GAAG,QAI5C;AAED,wBAAgB,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,KAAK,GAAG,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,SAAS,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,MAAM,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,CAMjL;AACD,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,KAAK,GAAG,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,SAAS,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,MAAM,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,CAExM;AACD,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,CAE9F;AACD,wBAAgB,EAAE,CAAC,CAAC,SAAS,MAAM,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAM/E;AAWD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEzD"}
+{"version":3,"file":"1_utilities.d.ts","sourceRoot":"","sources":["../../src/tl/1_utilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,wBAAgB,aAAa,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,WAExD;AACD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,QAI9D;AAED,wBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,WAM9D;AACD,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,WAEtE;AACD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,WAEhE;AACD,wBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,WAM9D;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAMtE"}