@opcat-labs/opcat 1.0.1 → 1.0.3

package/types/encoding/base58.d.cts

@@ -0,0 +1,106 @@
+export = Base58;
+/**
+ * A Base58 object can encode/decoded Base 58, which is used primarily for
+ * string-formatted Bitcoin addresses and private keys. Addresses and private
+ * keys actually use an additional checksum, and so they actually use the
+ * Base58Check class.
+ *
+ * @param {object} obj Can be a string or buffer.
+ */
+declare function Base58(obj: object): Base58;
+declare class Base58 {
+    /**
+     * A Base58 object can encode/decoded Base 58, which is used primarily for
+     * string-formatted Bitcoin addresses and private keys. Addresses and private
+     * keys actually use an additional checksum, and so they actually use the
+     * Base58Check class.
+     *
+     * @param {object} obj Can be a string or buffer.
+     */
+    constructor(obj: object);
+    /**
+     * Sets the buffer property from the given object.
+     * @param {Object} obj - The object containing the buffer to set.
+     * @param {Buffer} [obj.buf] - The buffer to assign. If not provided, retains current buffer or sets to undefined.
+     * @returns {Base58} Returns the instance for chaining.
+     */
+    set(obj: {
+        buf?: Buffer;
+    }): Base58;
+    buf: any;
+    /**
+     * Sets the internal buffer to the provided buffer and returns the instance for chaining.
+     * @param {Buffer} buf - The buffer to set as the internal buffer.
+     * @returns {Base58} The instance for method chaining.
+     */
+    fromBuffer(buf: Buffer): Base58;
+    /**
+     * Converts a Base58 encoded string to a buffer and stores it in the instance.
+     * @param {string} str - The Base58 encoded string to decode.
+     * @returns {Base58} The current instance for chaining.
+     */
+    fromString(str: string): Base58;
+    /**
+     * Returns the internal buffer containing the Base58 encoded data.
+     * @returns {Buffer} The raw buffer representation of the Base58 data.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Converts the Base58 encoded data to a hexadecimal string.
+     * @returns {string} Hexadecimal representation of the Base58 data.
+     */
+    toHex(): string;
+    /**
+     * Converts the Base58 instance to its string representation.
+     * @returns {string} The Base58 encoded string.
+     */
+    toString(): string;
+}
+declare namespace Base58 {
+    /**
+     * Checks if all characters in the input are valid Base58 characters.
+     * @param {string|Buffer} chars - The input characters to validate (can be a string or Buffer).
+     * @returns {boolean} True if all characters are valid Base58, false otherwise.
+     * @static
+     */
+    function validCharacters(chars: string | Buffer): boolean;
+    /**
+     * Encode a buffer to Bsae 58.
+     *
+     * @param {Buffer} buf Any buffer to be encoded.
+     * @returns {string} A Base 58 encoded string.
+     * @throws {Error} If the input is not a buffer.
+     * @static
+     */
+    function encode(buf: Buffer): string;
+    /**
+     * Decode a Base 58 string to a buffer.
+     *
+     * @param {string} str A Base 58 encoded string.
+     * @returns {Buffer} The decoded buffer.
+     * @throws {Error} If the input is not a string.
+     * @static
+     */
+    function decode(str: string): Buffer;
+    /**
+     * Creates a Base58 encoded string from a buffer.
+     * @param {Buffer} buf - The input buffer to encode.
+     * @returns {Base58} A new Base58 instance containing the encoded string.
+     * @static
+     */
+    function fromBuffer(buf: Buffer): Base58;
+    /**
+     * Converts a hex string to Base58 encoded string.
+     * @param {string} hex - The hex string to convert.
+     * @returns {string} The Base58 encoded string.
+     * @static
+     */
+    function fromHex(hex: string): string;
+    /**
+     * Creates a Base58 instance from a string input.
+     * @param {string} str - The string to convert to Base58.
+     * @returns {Base58} A new Base58 instance containing the encoded string.
+     * @static
+     */
+    function fromString(str: string): Base58;
+}

package/types/encoding/base58check.d.cts

@@ -0,0 +1,107 @@
+export = Base58Check;
+/**
+ * A Base58check object can encode/decodd Base 58, which is used primarily for
+ * string-formatted Bitcoin addresses and private keys. This is the same as
+ * Base58, except that it includes a checksum to prevent accidental mistypings.
+ * @constructor
+ * @param {Buffer|string} obj Can be a string or buffer.
+ */
+declare function Base58Check(obj: Buffer | string): Base58Check;
+declare class Base58Check {
+    /**
+     * A Base58check object can encode/decodd Base 58, which is used primarily for
+     * string-formatted Bitcoin addresses and private keys. This is the same as
+     * Base58, except that it includes a checksum to prevent accidental mistypings.
+     * @constructor
+     * @param {Buffer|string} obj Can be a string or buffer.
+     */
+    constructor(obj: Buffer | string);
+    /**
+     * Sets the buffer property from the given object.
+     * @param {Object} obj - The object containing the buffer to set.
+     * @returns {Base58Check} Returns the instance for chaining.
+     */
+    set(obj: any): Base58Check;
+    buf: any;
+    /**
+     * Sets the internal buffer to the provided Buffer object.
+     * @param {Buffer} buf - The buffer to set as the internal state.
+     * @returns {Base58Check} Returns the instance for chaining.
+     */
+    fromBuffer(buf: Buffer): Base58Check;
+    /**
+     * Converts a Base58Check encoded string to a buffer and stores it in the instance.
+     * @param {string} str - The Base58Check encoded string to decode.
+     * @returns {Base58Check} Returns the instance for chaining.
+     */
+    fromString(str: string): Base58Check;
+    /**
+     * Returns the internal buffer containing the Base58Check encoded data.
+     * @returns {Buffer} The raw buffer representation of the Base58Check data.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Converts the Base58Check encoded data to a hexadecimal string.
+     * @returns {string} Hexadecimal representation of the data.
+     */
+    toHex(): string;
+    /**
+     * Converts the Base58Check instance to its string representation.
+     * @returns {string} The Base58Check encoded string.
+     */
+    toString(): string;
+}
+declare namespace Base58Check {
+    /**
+     * Validates the checksum of Base58Check encoded data.
+     * @param {Buffer|string} data - The data to validate, either as a Buffer or Base58 encoded string.
+     * @param {Buffer|string} [checksum] - Optional checksum to validate against, either as a Buffer or Base58 encoded string.
+     * If not provided, the last 4 bytes of the data will be used as checksum.
+     * @returns {boolean} True if the computed checksum matches the provided/embedded checksum.
+     * @static
+     */
+    function validChecksum(data: string | Buffer, checksum?: string | Buffer): boolean;
+    /**
+     * Decodes a Base58Check encoded string and verifies its checksum.
+     * @param {string} s - The Base58Check encoded string to decode.
+     * @returns {Buffer} The decoded data (excluding checksum).
+     * @throws {Error} If input is not a string, too short, or checksum mismatch.
+     * @static
+     */
+    function decode(s: string): Buffer;
+    /**
+     * Calculates the checksum for a given buffer using double SHA-256 hash.
+     * The checksum is the first 4 bytes of the double-hashed result.
+     * @param {Buffer} buffer - The input buffer to calculate checksum for
+     * @returns {Buffer} The 4-byte checksum
+     * @static
+     */
+    function checksum(buffer: Buffer): Buffer;
+    /**
+     * Encodes a buffer into Base58Check format.
+     * @param {Buffer} buf - The input buffer to encode
+     * @returns {string} The Base58Check encoded string
+     * @throws {Error} If input is not a Buffer
+     * @static
+     */
+    function encode(buf: Buffer): string;
+    /**
+     * Creates a Base58Check encoded string from a buffer.
+     * @param {Buffer} buf - The input buffer to encode.
+     * @returns {Base58Check} A new Base58Check instance containing the encoded data.
+     */
+    function fromBuffer(buf: Buffer): Base58Check;
+    /**
+     * Converts a hex string to a Base58Check encoded string.
+     * @param {string} hex - The hex string to convert.
+     * @returns {string} The Base58Check encoded string.
+     */
+    function fromHex(hex: string): string;
+    /**
+     * Converts a Base58Check-encoded string into a Base58 object.
+     * @param {string} str - The Base58Check-encoded string to decode.
+     * @returns {Base58} A new Base58 instance containing the decoded data.
+     */
+    function fromString(str: string): Base58;
+}
+import Base58 = require("./base58.cjs");

package/types/encoding/bufferreader.d.cts

@@ -0,0 +1,164 @@
+export = BufferReader;
+/**
+ * Creates a BufferReader instance to read from various input types.
+ * @constructor
+ * @param {Buffer|string|Object} buf - Input source (Buffer, hex string, or object with buffer properties)
+ * @throws {TypeError} If input is invalid hex string or unrecognized type
+ * @example
+ * new BufferReader(Buffer.from('abc')) // from Buffer
+ * new BufferReader('616263')          // from hex string
+ * new BufferReader({buf: buffer})      // from object
+ */
+declare function BufferReader(buf: Buffer | string | any): BufferReader;
+declare class BufferReader {
+    /**
+     * Creates a BufferReader instance to read from various input types.
+     * @constructor
+     * @param {Buffer|string|Object} buf - Input source (Buffer, hex string, or object with buffer properties)
+     * @throws {TypeError} If input is invalid hex string or unrecognized type
+     * @example
+     * new BufferReader(Buffer.from('abc')) // from Buffer
+     * new BufferReader('616263')          // from hex string
+     * new BufferReader({buf: buffer})      // from object
+     */
+    constructor(buf: Buffer | string | any);
+    /**
+     * Updates the buffer and position from the given object.
+     * @param {Object} obj - The object containing buffer and position to set.
+     * @param {Buffer} [obj.buf] - The buffer to set (optional, keeps current if not provided).
+     * @param {number} [obj.pos] - The position to set (optional, keeps current if not provided).
+     * @returns {BufferReader} Returns the instance for chaining.
+     */
+    set(obj: {
+        buf?: Buffer;
+        pos?: number;
+    }): BufferReader;
+    buf: any;
+    pos: any;
+    /**
+     * Checks if the reader has reached the end of the buffer.
+     * @returns {boolean} True if the current position is at or beyond the buffer length, false otherwise.
+     */
+    eof(): boolean;
+    /**
+     * Alias for `eof` method - checks if the buffer reader has reached the end of data.
+     * @name BufferReader.prototype.finished
+     * @memberof BufferReader
+     * @instance
+     */
+    finished: any;
+    /**
+     * Reads a specified number of bytes from the buffer and advances the position.
+     * @param {number} len - The number of bytes to read.
+     * @returns {Buffer} The read bytes as a Buffer.
+     * @throws {Error} If the length is undefined.
+     */
+    read(len: number): Buffer;
+    /**
+     * Reads and returns all remaining bytes from the buffer, advancing the position to the end.
+     * @returns {Buffer} The remaining bytes in the buffer.
+     */
+    readAll(): Buffer;
+    /**
+     * Reads an unsigned 8-bit integer from the buffer at the current position.
+     * @returns {number} The unsigned 8-bit integer value read.
+     * @this {BufferReader}
+     */
+    readUInt8(this: BufferReader): number;
+    /**
+     * Reads an unsigned 16-bit integer from the buffer in big-endian format.
+     * Advances the position by 2 bytes.
+     * @returns {number} The read unsigned 16-bit integer value.
+     */
+    readUInt16BE(): number;
+    /**
+     * Reads a 16-bit unsigned integer from the buffer in little-endian format
+     * and advances the position by 2 bytes.
+     * @returns {number} The read unsigned 16-bit integer value
+     */
+    readUInt16LE(): number;
+    /**
+     * Reads an unsigned 32-bit integer from the buffer in big-endian format.
+     * Advances the position by 4 bytes.
+     * @returns {number} The read unsigned 32-bit integer value.
+     */
+    readUInt32BE(): number;
+    /**
+     * Reads an unsigned 32-bit integer from the buffer in little-endian format.
+     * Advances the position by 4 bytes.
+     * @returns {number} The read unsigned 32-bit integer value.
+     */
+    readUInt32LE(): number;
+    /**
+     * Reads a 32-bit signed integer from the buffer in little-endian format.
+     * Advances the position by 4 bytes.
+     * @returns {number} The read 32-bit signed integer.
+     */
+    readInt32LE(): number;
+    /**
+     * Reads an unsigned 64-bit integer in big-endian byte order from the buffer
+     * and returns it as a BN (BigNumber) object.
+     * Advances the position by 8 bytes.
+     * @returns {BN} The parsed 64-bit unsigned integer as a BigNumber
+     */
+    readUInt64BEBN(): BN;
+    /**
+     * Reads an unsigned 64-bit integer in little-endian byte order from the buffer and returns it as a BN (BigNumber).
+     * Optimizes for numbers <= 52 bits by using numeric constructor, falls back to buffer slice for larger numbers.
+     * Advances the buffer position by 8 bytes.
+     * @returns {BN} The parsed 64-bit unsigned integer as a BN instance.
+     */
+    readUInt64LEBN(): BN;
+    /**
+     * Reads a variable-length integer (varint) from the buffer and returns it as a number.
+     * Supports varints up to 53 bits (JavaScript's safe integer limit).
+     * For larger numbers, throws an error suggesting to use `readVarintBN` instead.
+     * @returns {number} The decoded integer value
+     * @throws {Error} If the number exceeds 53-bit precision
+     */
+    readVarintNum(): number;
+    /**
+     * Reads a variable-length buffer from the current position.
+     * First reads a varint to determine the length, then reads the buffer of that size.
+     * @returns {Buffer} The read buffer.
+     * @throws {Error} If the actual read length doesn't match the expected length.
+     */
+    readVarLengthBuffer(): Buffer;
+    /**
+     * Reads a variable-length integer (varint) from the buffer.
+     * The first byte determines the length of the varint:
+     * - 0xfd: 2-byte varint (plus 1 byte for the prefix)
+     * - 0xfe: 4-byte varint (plus 1 byte for the prefix)
+     * - 0xff: 8-byte varint (plus 1 byte for the prefix)
+     * - Otherwise: 1-byte varint (no prefix)
+     * @returns {Buffer} The varint bytes including the prefix (if any)
+     */
+    readVarintBuf(): Buffer;
+    /**
+     * Reads a variable-length integer (varint) from the buffer and returns it as a BN (BigNumber).
+     * Handles different varint sizes (1, 2, 4, or 8 bytes) based on the first byte's value:
+     * - 0xfd: reads next 2 bytes as uint16
+     * - 0xfe: reads next 4 bytes as uint32
+     * - 0xff: reads next 8 bytes as uint64
+     * - default: treats first byte as uint8
+     * @returns {BN} The parsed varint as a BigNumber
+     */
+    readVarintBN(): BN;
+    /**
+     * Reverses the order of bytes in the internal buffer and returns the instance.
+     * @returns {BufferReader} The modified BufferReader instance for chaining.
+     */
+    reverse(): BufferReader;
+    /**
+     * Reads a specified number of bytes from the buffer in reverse order.
+     * @param {number} [len] - The number of bytes to read. If omitted, reads the entire buffer.
+     * @returns {Buffer} The reversed buffer segment.
+     */
+    readReverse(len?: number): Buffer;
+    /**
+     * Gets the number of bytes remaining to be read in the buffer.
+     * @returns {number} The remaining bytes count.
+     */
+    remaining(): number;
+}
+import BN = require("../bn.cjs");

package/types/encoding/bufferwriter.d.cts

@@ -0,0 +1,126 @@
+export = BufferWriter;
+/**
+ * BufferWriter is a utility class for efficiently writing and concatenating buffers.
+ * It provides methods for writing various numeric types in both little-endian and big-endian formats,
+ * as well as variable-length integers (varints). The class maintains an internal array of buffers
+ * and can efficiently concatenate them into a single buffer when needed.
+ *
+ * @class
+ * @example
+ * const writer = new BufferWriter();
+ * writer.writeUInt32LE(1234).writeUInt16BE(5678);
+ * const result = writer.toBuffer();
+ */
+declare class BufferWriter {
+    /**
+     * Converts a number to a varint-encoded Buffer.
+     * @param {number} n - The number to encode.
+     * @returns {Buffer} The varint-encoded Buffer.
+     */
+    static varintBufNum(n: number): Buffer;
+    /**
+     * Initializes a new BufferWriter instance.
+     * @param {Object} [obj] - Optional object to set initial buffer content. If not provided,
+     *                         creates an empty buffer writer with empty buffers array and length 0.
+     */
+    constructor(obj?: any);
+    buffers: any[];
+    length: number;
+    /**
+     * Appends a buffer to the internal buffers array and updates the total length.
+     * @param {Buffer} buffer - The buffer to append.
+     * @returns {this} Returns the instance for chaining.
+     */
+    write(buffer: Buffer): this;
+    /**
+     * Sets the internal buffers and calculates total length.
+     * @param {Object} obj - Object containing buffers (either `buffers` or `bufs` property)
+     * @returns {Object} Returns the instance for chaining
+     */
+    set(obj: any): any;
+    /**
+     * Returns the buffer by concatenating all written data.
+     * @returns {Buffer} The concatenated buffer.
+     */
+    concat(): Buffer;
+    /**
+     * Converts the internal buffer chunks into a single Buffer.
+     * If there's only one chunk, returns it directly. Otherwise,
+     * concatenates all chunks into a new Buffer.
+     * @returns {Buffer} The combined buffer
+     */
+    toBuffer(): Buffer;
+    /**
+     * Writes a buffer in reverse order to the current buffer.
+     * @param {Buffer} buf - The buffer to be written in reverse.
+     * @returns {this} Returns the instance for chaining.
+     */
+    writeReverse(buf: Buffer): this;
+    /**
+     * Writes a 16-bit unsigned integer in little-endian format.
+     * @param {number} n - The number to write.
+     * @returns {this} Returns the instance for chaining.
+     */
+    writeUInt16LE(n: number): this;
+    /**
+     * Writes a 16-bit unsigned integer in big-endian byte order.
+     * Internally converts the value to little-endian and reverses the bytes.
+     * @param {number} n - The number to write (0-65535).
+     * @returns {BufferWriter} Returns the BufferWriter instance for chaining.
+     */
+    writeUInt16BE(n: number): BufferWriter;
+    /**
+     * Writes a 32-bit unsigned integer in little-endian format.
+     * @param {number} n - The number to write.
+     * @returns {this} Returns the instance for chaining.
+     */
+    writeUInt32LE(n: number): this;
+    /**
+     * Writes a 32-bit unsigned integer in big-endian format.
+     * @param {number} n - The number to write.
+     * @returns {BufferWriter} Returns the BufferWriter instance for chaining.
+     */
+    writeUInt32BE(n: number): BufferWriter;
+    /**
+     * Writes an unsigned 8-bit integer to the buffer in little-endian format.
+     * @param {number} n - The number to write (0-255)
+     * @returns {this} Returns the BufferWriter instance for chaining
+     */
+    writeUInt8(n: number): this;
+    /**
+     * Writes a 64-bit unsigned integer in little-endian byte order from a BigNumber.
+     * @param {Object} bn - The BigNumber to write.
+     * @returns {this} Returns the BufferWriter instance for chaining.
+     */
+    writeUInt64LEBN(bn: any): this;
+    /**
+     * Writes a 64-bit unsigned integer in big-endian byte order (as BN.js instance).
+     * Internally converts to little-endian and writes reversed for big-endian output.
+     * @param {BN} bn - The BigNumber to write as 64-bit big-endian
+     * @returns {BufferWriter} Returns this instance for chaining
+     */
+    writeUInt64BEBN(bn: BN): BufferWriter;
+    /**
+     * Writes a variable-length integer (varint) to the buffer.
+     * @param {number} n - The number to write as varint
+     * @returns {this} Returns the BufferWriter instance for chaining
+     */
+    writeVarintNum(n: number): this;
+    /**
+     * Writes a 32-bit signed integer in little-endian format to the buffer.
+     * @param {number} n - The integer to write.
+     * @returns {this} Returns the BufferWriter instance for chaining.
+     */
+    writeInt32LE(n: number): this;
+    /**
+     * Writes a variable-length integer (varint) to the buffer using BigNumber.
+     * Handles numbers of different sizes with appropriate encoding:
+     * - Numbers < 253: 1 byte
+     * - Numbers < 0x10000: 1 byte prefix (253) + 2 bytes
+     * - Numbers < 0x100000000: 1 byte prefix (254) + 4 bytes
+     * - Larger numbers: 1 byte prefix (255) + 8 bytes
+     * @param {BN} bn - BigNumber to write as varint
+     * @returns {BufferWriter} Returns this for chaining
+     */
+    writeVarintBN(bn: BN): BufferWriter;
+}

package/types/encoding/decode-asm.d.cts

@@ -0,0 +1,2 @@
+export = decodeASM;
+declare function decodeASM(script: any): Buffer;

package/types/encoding/decode-hex.d.cts

@@ -0,0 +1,2 @@
+export = decodeHex;
+declare function decodeHex(hex: any): Uint8Array | Buffer;

package/types/encoding/decode-script-chunks.d.cts

@@ -0,0 +1,14 @@
+export = decodeScriptChunks;
+declare function decodeScriptChunks(script: any): ({
+    opcodenum: any;
+    len: number;
+    buf?: undefined;
+} | {
+    opcodenum: any;
+    buf: any;
+    len: number;
+} | {
+    opcodenum: any;
+    len?: undefined;
+    buf?: undefined;
+})[];

package/types/encoding/encode-hex.d.cts

@@ -0,0 +1,2 @@
+export = encodeHex;
+declare let encodeHex: any;

package/types/encoding/index.d.cts

@@ -0,0 +1,6 @@
+import Base58 = require("./base58.cjs");
+import Base58Check = require("./base58check.cjs");
+import BufferReader = require("./bufferreader.cjs");
+import BufferWriter = require("./bufferwriter.cjs");
+import Varint = require("./varint.cjs");
+export { Base58, Base58Check, BufferReader, BufferWriter, Varint };

package/types/encoding/is-hex.d.cts

@@ -0,0 +1,2 @@
+export = isHex;
+declare function isHex(s: any): boolean;

package/types/encoding/varint.d.cts

@@ -0,0 +1,66 @@
+export = Varint;
+/**
+ * Creates a Varint instance from various input types.
+ * @constructor
+ * @param {Buffer|number|BN|Object} buf - Input can be a Buffer, number, BN instance, or object with buffer properties.
+ * @returns {Varint} New Varint instance when called without `new`.
+ */
+declare function Varint(buf: Buffer | number | BN | any): Varint;
+declare class Varint {
+    /**
+     * Creates a Varint instance from various input types.
+     * @constructor
+     * @param {Buffer|number|BN|Object} buf - Input can be a Buffer, number, BN instance, or object with buffer properties.
+     * @returns {Varint} New Varint instance when called without `new`.
+     */
+    constructor(buf: Buffer | number | BN | any);
+    buf: Buffer;
+    /**
+     * Sets the buffer for the Varint instance.
+     * @param {Object} obj - The object containing the buffer to set.
+     * @param {Buffer} [obj.buf] - The buffer to assign. If not provided, keeps the current buffer.
+     * @returns {Varint} The Varint instance for chaining.
+     */
+    set(obj: {
+        buf?: Buffer;
+    }): Varint;
+    /**
+     * Converts a hex string to a Varint buffer and updates the instance.
+     * @param {string} str - Hex string to convert.
+     * @returns {Varint} The updated Varint instance.
+     */
+    fromString(str: string): Varint;
+    /**
+     * Converts the Varint buffer to a hexadecimal string representation.
+     * @returns {string} Hexadecimal string of the buffer.
+     */
+    toString(): string;
+    /**
+     * Sets the internal buffer to the provided buffer and returns the instance.
+     * @param {Buffer} buf - The buffer to set as the internal buffer.
+     * @returns {Varint} The instance for chaining.
+     */
+    fromBuffer(buf: Buffer): Varint;
+    /**
+     * Reads a varint from a buffer reader and stores it in the instance.
+     * @param {Object} br - The buffer reader instance to read from.
+     * @returns {Varint} The current Varint instance for chaining.
+     */
+    fromBufferReader(br: any): Varint;
+    /**
+     * Converts a BigNumber (BN) to a varint and stores it in the buffer.
+     * @param {BN} bn - The BigNumber to convert to varint format.
+     * @returns {Varint} Returns the Varint instance for chaining.
+     */
+    fromBN(bn: BN): Varint;
+    /**
+     * Converts a number to a varint and stores it in the buffer.
+     * @param {number} num - The number to convert to varint format.
+     * @returns {Varint} Returns the instance for chaining.
+     */
+    fromNumber(num: number): Varint;
+    toBuffer(): Buffer;
+    toBN(): any;
+    toNumber(): any;
+}
+import BN = require("../bn.cjs");

package/types/errors/index.d.cts

@@ -0,0 +1,4 @@
+export = OpcatError;
+declare class OpcatError {
+    name: string;
+}

package/types/errors/spec.d.cts

@@ -0,0 +1,22 @@
+declare const _exports: ({
+    name: string;
+    message: string;
+} | {
+    name: string;
+    message: (...args: any[]) => string;
+} | {
+    name: string;
+    message: string;
+    errors: ({
+        name: string;
+        message: string;
+        errors: {
+            name: string;
+            message: string;
+        }[];
+    } | {
+        name: string;
+        message: string;
+    })[];
+})[];
+export = _exports;