@pezkuwi/types-codec 16.5.6 → 16.5.8

package/build-tsc/base/Result.d.ts

@@ -0,0 +1,38 @@
+import type { Codec, CodecClass, IResult, Registry } from '../types/index.js';
+import { Enum } from './Enum.js';
+/**
+ * @name Result
+ * @description
+ * A Result maps to the Rust Result type, that can either wrap a success or error value
+ */
+export declare class Result<O extends Codec, E extends Codec> extends Enum implements IResult<O, E> {
+    constructor(registry: Registry, Ok: CodecClass<O> | string, Err: CodecClass<E> | string, value?: unknown);
+    static with<O extends Codec, E extends Codec>(Types: {
+        Ok: CodecClass<O> | string;
+        Err: CodecClass<E> | string;
+    }): CodecClass<Result<O, E>>;
+    /**
+     * @description Returns the wrapper Err value (if isErr)
+     */
+    get asErr(): E;
+    /**
+     * @description Returns the wrapper Ok value (if isOk)
+     */
+    get asOk(): O;
+    /**
+     * @description Checks if the Result has no value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Checks if the Result wraps an Err value
+     */
+    get isErr(): boolean;
+    /**
+     * @description Checks if the Result wraps an Ok value
+     */
+    get isOk(): boolean;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/build-tsc/base/Tuple.d.ts

@@ -0,0 +1,42 @@
+import type { AnyTupleValue, Codec, CodecClass, DefinitionSetter, Inspect, ITuple, Registry } from '../types/index.js';
+import { AbstractArray } from '../abstract/Array.js';
+type TupleType = (CodecClass | string);
+type TupleTypes = TupleType[] | Record<string, CodecClass | string>;
+type Definition = [CodecClass[], string[]];
+/**
+ * @name Tuple
+ * @description
+ * A Tuple defines an anonymous fixed-length array, where each element has its
+ * own type. It extends the base JS `Array` object.
+ */
+export declare class Tuple extends AbstractArray<Codec> implements ITuple<Codec[]> {
+    #private;
+    constructor(registry: Registry, Types: TupleTypes | TupleType, value?: AnyTupleValue, { definition, setDefinition }?: DefinitionSetter<Definition>);
+    static with(Types: TupleTypes | TupleType): CodecClass<Tuple>;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description The types definition of the tuple
+     */
+    get Types(): string[];
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString(): string;
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}
+export {};

package/build-tsc/base/UInt.d.ts

@@ -0,0 +1,15 @@
+import type { CodecClass, UIntBitLength } from '../types/index.js';
+import { AbstractInt } from '../abstract/Int.js';
+/**
+ * @name UInt
+ * @description
+ * A generic unsigned integer codec. For Bizinikiwi all numbers are Little Endian encoded,
+ * this handles the encoding and decoding of those numbers. Upon construction
+ * the bitLength is provided and any additional use keeps the number to this
+ * length. This extends `BN`, so all methods available on a normal `BN` object
+ * is available here.
+ * @noInheritDoc
+ */
+export declare class UInt extends AbstractInt {
+    static with(bitLength: UIntBitLength, typeName?: string): CodecClass<UInt>;
+}

package/build-tsc/base/Vec.d.ts

@@ -0,0 +1,28 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { Codec, CodecClass, DefinitionSetter, Registry } from '../types/index.js';
+import { AbstractArray } from '../abstract/Array.js';
+export declare function decodeVec<T extends Codec>(registry: Registry, result: T[], value: Uint8Array | HexString | unknown[] | null, startAt: number, Type: CodecClass<T>): [number, number];
+/**
+ * @name Vec
+ * @description
+ * This manages codec arrays. Internally it keeps track of the length (as decoded) and allows
+ * construction with the passed `Type` in the constructor. It is an extension to Array, providing
+ * specific encoding/decoding on top of the base type.
+ */
+export declare class Vec<T extends Codec> extends AbstractArray<T> {
+    #private;
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: Uint8Array | HexString | unknown[], { definition, setDefinition }?: DefinitionSetter<CodecClass<T>>);
+    static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Vec<O>>;
+    /**
+     * @description The type for the items
+     */
+    get Type(): string;
+    /**
+     * @description Finds the index of the value in the array
+     */
+    indexOf(other?: unknown): number;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/build-tsc/base/VecAny.d.ts

@@ -0,0 +1,15 @@
+import type { Codec } from '../types/index.js';
+import { AbstractArray } from '../abstract/Array.js';
+/**
+ * @name VecAny
+ * @description
+ * This manages codec arrays, assuming that the inputs are already of type Codec. Unlike
+ * a vector, this can be used to manage array-like structures with variable arguments of
+ * any types
+ */
+export declare class VecAny<T extends Codec> extends AbstractArray<T> {
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/build-tsc/base/VecFixed.d.ts

@@ -0,0 +1,30 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { Codec, CodecClass, DefinitionSetter, Inspect, Registry } from '../types/index.js';
+import { AbstractArray } from '../abstract/Array.js';
+/**
+ * @name VecFixed
+ * @description
+ * This manages codec arrays of a fixed length
+ */
+export declare class VecFixed<T extends Codec> extends AbstractArray<T> {
+    #private;
+    constructor(registry: Registry, Type: CodecClass<T> | string, length: number, value?: Uint8Array | HexString | unknown[], { definition, setDefinition }?: DefinitionSetter<CodecClass<T>>);
+    static with<O extends Codec>(Type: CodecClass<O> | string, length: number): CodecClass<VecFixed<O>>;
+    /**
+     * @description The type for the items
+     */
+    get Type(): string;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    toU8a(): Uint8Array;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/build-tsc/base/index.d.ts

@@ -0,0 +1,12 @@
+export { Compact } from './Compact.js';
+export { DoNotConstruct } from './DoNotConstruct.js';
+export { Enum } from './Enum.js';
+export { Int } from './Int.js';
+export { Null } from './Null.js';
+export { Option } from './Option.js';
+export { Result } from './Result.js';
+export { Tuple } from './Tuple.js';
+export { UInt } from './UInt.js';
+export { Vec } from './Vec.js';
+export { VecAny } from './VecAny.js';
+export { VecFixed } from './VecFixed.js';

package/build-tsc/bundle.d.ts

@@ -0,0 +1,7 @@
+export { packageInfo } from './packageInfo.js';
+export * from './abstract/index.js';
+export * from './base/index.js';
+export * from './extended/index.js';
+export * from './native/index.js';
+export * from './primitive/index.js';
+export * from './utils/index.js';

package/build-tsc/extended/BTreeMap.d.ts

@@ -0,0 +1,5 @@
+import type { Codec, CodecClass } from '../types/index.js';
+import { CodecMap } from './Map.js';
+export declare class BTreeMap<K extends Codec = Codec, V extends Codec = Codec> extends CodecMap<K, V> {
+    static with<K extends Codec, V extends Codec>(keyType: CodecClass<K> | string, valType: CodecClass<V> | string): CodecClass<CodecMap<K, V>>;
+}

package/build-tsc/extended/BTreeSet.d.ts

@@ -0,0 +1,64 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyJson, Codec, CodecClass, Inspect, ISet, IU8a, Registry } from '../types/index.js';
+export declare class BTreeSet<V extends Codec = Codec> extends Set<V> implements ISet<V> {
+    #private;
+    readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
+    constructor(registry: Registry, valType: CodecClass<V> | string, rawValue?: Uint8Array | string | string[] | Set<any>);
+    static with<V extends Codec>(valType: CodecClass<V> | string): CodecClass<BTreeSet<V>>;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description Returns a hash of the value
+     */
+    get hash(): IU8a;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description The actual set values as a string[]
+     */
+    get strings(): string[];
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+     */
+    toHex(): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended?: boolean, disableAscii?: boolean): AnyJson;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): AnyJson;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive(disableAscii?: boolean): AnyJson;
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString(): string;
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}

package/build-tsc/extended/BitVec.d.ts

@@ -0,0 +1,37 @@
+import type { AnyU8a, Inspect, Registry } from '../types/index.js';
+import { Raw } from '../native/Raw.js';
+/**
+ * @name BitVec
+ * @description
+ * A BitVec that represents an array of bits. The bits are however stored encoded. The difference between this
+ * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
+ */
+export declare class BitVec extends Raw {
+    #private;
+    constructor(registry: Registry, value?: AnyU8a, isMsb?: boolean);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @description Creates a boolean array of the bit values
+     */
+    toBoolArray(): boolean[];
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(): string;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}

package/build-tsc/extended/Bytes.d.ts

@@ -0,0 +1,29 @@
+import type { AnyU8a, Inspect, Registry } from '../types/index.js';
+import { Raw } from '../native/Raw.js';
+/**
+ * @name Bytes
+ * @description
+ * A Bytes wrapper for Vec<u8>. The significant difference between this and a normal Uint8Array
+ * is that this version allows for length-encoding. (i.e. it is a variable-item codec, the same
+ * as what is found in [[Text]] and [[Vec]])
+ */
+export declare class Bytes extends Raw {
+    constructor(registry: Registry, value?: AnyU8a);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(isBare?: boolean): Inspect;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}

package/build-tsc/extended/HashMap.d.ts

@@ -0,0 +1,5 @@
+import type { Codec, CodecClass } from '../types/index.js';
+import { CodecMap } from './Map.js';
+export declare class HashMap<K extends Codec = Codec, V extends Codec = Codec> extends CodecMap<K, V> {
+    static with<K extends Codec, V extends Codec>(keyType: CodecClass<K> | string, valType: CodecClass<V> | string): CodecClass<CodecMap<K, V>>;
+}

package/build-tsc/extended/Linkage.d.ts

@@ -0,0 +1,37 @@
+import type { Codec, CodecClass, Registry } from '../types/index.js';
+import { Option } from '../base/Option.js';
+import { Tuple } from '../base/Tuple.js';
+import { Struct } from '../native/Struct.js';
+type TypeWithValues = [CodecClass, any[]];
+/**
+ * @name Linkage
+ * @description The wrapper for the result from a LinkedMap
+ */
+export declare class Linkage<T extends Codec> extends Struct {
+    constructor(registry: Registry, Type: CodecClass | string, value?: unknown);
+    static withKey<O extends Codec>(Type: CodecClass | string): CodecClass<Linkage<O>>;
+    /**
+     * @description Returns the next item the Linkage is pointing to
+     */
+    get previous(): Option<T>;
+    /**
+     * @description Returns the previous item the Linkage is pointing to
+     */
+    get next(): Option<T>;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Custom toU8a which with bare mode does not return the linkage if empty
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}
+/**
+ * @name LinkageResult
+ * @description A Linkage keys/Values tuple
+ */
+export declare class LinkageResult extends Tuple {
+    constructor(registry: Registry, [TypeKey, keys]: TypeWithValues, [TypeValue, values]: TypeWithValues);
+}
+export {};

package/build-tsc/extended/Map.d.ts

@@ -0,0 +1,59 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyJson, Codec, CodecClass, IMap, Inspect, IU8a, Registry } from '../types/index.js';
+export declare class CodecMap<K extends Codec = Codec, V extends Codec = Codec> extends Map<K, V> implements IMap<K, V> {
+    #private;
+    readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
+    constructor(registry: Registry, keyType: CodecClass<K> | string, valType: CodecClass<V> | string, rawValue: Uint8Array | string | Map<any, any> | undefined, type?: 'BTreeMap' | 'HashMap');
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description Returns a hash of the value
+     */
+    get hash(): IU8a;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+     */
+    toHex(): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended?: boolean, disableAscii?: boolean): Record<string, AnyJson>;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): Record<string, AnyJson>;
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive(disableAscii?: boolean): AnyJson;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString(): string;
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}

package/build-tsc/extended/OptionBool.d.ts

@@ -0,0 +1,36 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyBool, Inspect, Registry } from '../types/index.js';
+import { Option } from '../base/Option.js';
+import { bool as Bool } from '../native/Bool.js';
+/**
+ * @name OptionBool
+ * @description A specific implementation of Option<bool> than allows for single-byte encoding
+ */
+export declare class OptionBool extends Option<Bool> {
+    constructor(registry: Registry, value?: Option<Bool> | AnyBool | Uint8Array | HexString | null);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description Checks if the value is an empty value (always false)
+     */
+    get isFalse(): boolean;
+    /**
+     * @description Checks if the value is an empty value (always false)
+     */
+    get isTrue(): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(isBare?: boolean): string;
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}

package/build-tsc/extended/Range.d.ts

@@ -0,0 +1,29 @@
+import type { AnyTuple, CodecClass, INumber, Registry } from '../types/index.js';
+import { Tuple } from '../base/Tuple.js';
+type RangeType = 'Range' | 'RangeInclusive';
+interface Options {
+    rangeName?: RangeType;
+}
+/**
+ * @name Range
+ * @description
+ * Rust `Range<T>` representation
+ */
+export declare class Range<T extends INumber> extends Tuple {
+    #private;
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: AnyTuple, { rangeName }?: Options);
+    static with<T extends INumber>(Type: CodecClass<T> | string): CodecClass<Range<T>>;
+    /**
+     * @description Returns the starting range value
+     */
+    get start(): T;
+    /**
+     * @description Returns the ending range value
+     */
+    get end(): T;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}
+export {};

package/build-tsc/extended/RangeInclusive.d.ts

@@ -0,0 +1,6 @@
+import type { AnyTuple, CodecClass, INumber, Registry } from '../types/index.js';
+import { Range } from './Range.js';
+export declare class RangeInclusive<T extends INumber = INumber> extends Range<T> {
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: AnyTuple);
+    static with<T extends INumber>(Type: CodecClass<T> | string): CodecClass<RangeInclusive<T>>;
+}

package/build-tsc/extended/Type.d.ts

@@ -0,0 +1,16 @@
+import type { Registry } from '../types/index.js';
+import { Text } from '../native/Text.js';
+/**
+ * @name Type
+ * @description
+ * This is a extended version of Text, specifically to handle types. Here we rely fully
+ * on what Text provides us, however we also adjust the types received from the runtime,
+ * i.e. we remove the `T::` prefixes found in some types for consistency across implementation.
+ */
+export declare class Type extends Text {
+    constructor(registry: Registry, value?: Text | Uint8Array | string);
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/build-tsc/extended/U8aFixed.d.ts

@@ -0,0 +1,16 @@
+import type { AnyU8a, CodecClass, Registry, U8aBitLength } from '../types/index.js';
+import { Raw } from '../native/Raw.js';
+/**
+ * @name U8aFixed
+ * @description
+ * A U8a that manages a a sequence of bytes up to the specified bitLength. Not meant
+ * to be used directly, rather is should be subclassed with the specific lengths.
+ */
+export declare class U8aFixed extends Raw {
+    constructor(registry: Registry, value?: AnyU8a, bitLength?: U8aBitLength);
+    static with(bitLength: U8aBitLength, typeName?: string): CodecClass<U8aFixed>;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/build-tsc/extended/WrapperKeepOpaque.d.ts

@@ -0,0 +1,40 @@
+import type { AnyJson, Codec, CodecClass, Inspect, Registry } from '../types/index.js';
+import { Bytes } from './Bytes.js';
+type OpaqueName = 'WrapperKeepOpaque' | 'WrapperOpaque';
+interface Options {
+    opaqueName?: OpaqueName;
+}
+export declare class WrapperKeepOpaque<T extends Codec> extends Bytes {
+    #private;
+    constructor(registry: Registry, typeName: CodecClass<T> | string, value?: unknown, { opaqueName }?: Options);
+    static with<T extends Codec>(Type: CodecClass<T> | string): CodecClass<WrapperKeepOpaque<T>>;
+    /**
+     * @description Checks if the wrapper is decodable
+     */
+    get isDecoded(): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended?: boolean, disableAscii?: boolean): AnyJson;
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive(disableAscii?: boolean): any;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Converts the Object to to a string (either decoded or bytes)
+     */
+    toString(): string;
+    /**
+     * @description Returns the decoded that the WrapperKeepOpaque represents (if available), throws if non-decodable
+     */
+    unwrap(): T;
+}
+export {};

package/build-tsc/extended/WrapperOpaque.d.ts

@@ -0,0 +1,10 @@
+import type { Codec, CodecClass, Registry } from '../types/index.js';
+import { WrapperKeepOpaque } from './WrapperKeepOpaque.js';
+export declare class WrapperOpaque<T extends Codec> extends WrapperKeepOpaque<T> {
+    constructor(registry: Registry, typeName: CodecClass<T> | string, value?: unknown);
+    static with<T extends Codec>(Type: CodecClass<T> | string): CodecClass<WrapperKeepOpaque<T>>;
+    /**
+     * @description The inner value for this wrapper, in all cases it _should_ be decodable (unlike KeepOpaque)
+     */
+    get inner(): T;
+}

package/build-tsc/extended/index.d.ts

@@ -0,0 +1,14 @@
+export { BitVec } from './BitVec.js';
+export { BTreeMap } from './BTreeMap.js';
+export { BTreeSet } from './BTreeSet.js';
+export { Bytes } from './Bytes.js';
+export { HashMap } from './HashMap.js';
+export { Linkage } from './Linkage.js';
+export { CodecMap, CodecMap as Map } from './Map.js';
+export { OptionBool } from './OptionBool.js';
+export { Range } from './Range.js';
+export { RangeInclusive } from './RangeInclusive.js';
+export { Type } from './Type.js';
+export { U8aFixed } from './U8aFixed.js';
+export { WrapperKeepOpaque } from './WrapperKeepOpaque.js';
+export { WrapperOpaque } from './WrapperOpaque.js';

package/build-tsc/index.d.ts

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';