@polkadot/types-codec 6.12.2-23 → 6.12.2-27

package/base/UInt.d.ts

@@ -0,0 +1,15 @@
+import type { CodecClass, UIntBitLength } from '../types';
+import { AbstractInt } from '../abstract/AbstractInt';
+/**
+ * @name UInt
+ * @description
+ * A generic unsigned integer codec. For Substrate 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/base/Vec.d.ts

@@ -0,0 +1,28 @@
+import type { HexString } from '@polkadot/util/types';
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+import { AbstractArray } from '../abstract/AbstractArray';
+export declare function decodeVec<T extends Codec>(registry: CodecRegistry, Type: CodecClass<T>, value: Uint8Array | HexString | unknown[], length?: number): [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: CodecRegistry, Type: CodecClass<T> | string, value?: Uint8Array | HexString | unknown[]);
+    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/base/VecAny.d.ts

@@ -0,0 +1,15 @@
+import type { Codec } from '../types';
+import { AbstractArray } from '../abstract/AbstractArray';
+/**
+ * @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/base/VecFixed.d.ts

@@ -0,0 +1,26 @@
+import type { HexString } from '@polkadot/util/types';
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+import { AbstractArray } from '../abstract/AbstractArray';
+/**
+ * @name VecFixed
+ * @description
+ * This manages codec arrays of a fixed length
+ */
+export declare class VecFixed<T extends Codec> extends AbstractArray<T> {
+    #private;
+    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, length: number, value?: Uint8Array | HexString | unknown[]);
+    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;
+    toU8a(): Uint8Array;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/base/index.d.ts

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

package/bundle.d.ts

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

package/detectPackage.d.ts

@@ -0,0 +1 @@
+export {};

package/extended/BTreeMap.d.ts

@@ -0,0 +1,5 @@
+import type { Codec, CodecClass } from '../types';
+import { CodecMap } from './Map';
+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/extended/BTreeSet.d.ts

@@ -0,0 +1,55 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson, Codec, CodecClass, CodecRegistry, ISet, IU8a } from '../types';
+export declare class BTreeSet<V extends Codec = Codec> extends Set<V> implements ISet<V> {
+    #private;
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    readonly initialU8aLength?: number;
+    constructor(registry: CodecRegistry, 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 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): 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 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/extended/BitVec.d.ts

@@ -0,0 +1,26 @@
+import type { AnyU8a, CodecRegistry } from '../types';
+import { Raw } from '../native/Raw';
+/**
+ * @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: CodecRegistry, value?: AnyU8a);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    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/extended/Bytes.d.ts

@@ -0,0 +1,25 @@
+import type { AnyU8a, CodecRegistry } from '../types';
+import { Raw } from '../native/Raw';
+/**
+ * @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: CodecRegistry, value?: AnyU8a);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @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/extended/HashMap.d.ts

@@ -0,0 +1,5 @@
+import type { Codec, CodecClass } from '../types';
+import { CodecMap } from './Map';
+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/extended/Linkage.d.ts

@@ -0,0 +1,31 @@
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+import { Option } from '../base/Option';
+import { Tuple } from '../base/Tuple';
+import { Struct } from '../native/Struct';
+declare 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: CodecRegistry, Type: CodecClass | string, value?: unknown);
+    static withKey<O extends Codec>(Type: CodecClass | string): CodecClass<Linkage<O>>;
+    get previous(): Option<T>;
+    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(): Uint8Array;
+}
+/**
+ * @name LinkageResult
+ * @description A Linkage keys/Values tuple
+ */
+export declare class LinkageResult extends Tuple {
+    constructor(registry: CodecRegistry, [TypeKey, keys]: TypeWithValues, [TypeValue, values]: TypeWithValues);
+}
+export {};

package/extended/Map.d.ts

@@ -0,0 +1,50 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson, Codec, CodecClass, CodecRegistry, IMap, IU8a } from '../types';
+export declare class CodecMap<K extends Codec = Codec, V extends Codec = Codec> extends Map<K, V> implements IMap<K, V> {
+    #private;
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    readonly initialU8aLength?: number;
+    constructor(registry: CodecRegistry, 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 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): Record<string, AnyJson>;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): Record<string, 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/extended/Range.d.ts

@@ -0,0 +1,30 @@
+import type { AnyTuple, CodecClass, CodecRegistry, INumber } from '../types';
+import { Tuple } from '../base/Tuple';
+declare type RangeType = 'Range' | 'RangeInclusive';
+/**
+ * @name Range
+ * @description
+ * Rust `Range<T>` representation
+ */
+export declare class Range<T extends INumber> extends Tuple {
+    #private;
+    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, value?: AnyTuple, rangeName?: RangeType);
+    static with<T extends INumber>(Types: 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 declare class RangeInclusive<T extends INumber = INumber> extends Range<T> {
+    constructor(registry: CodecRegistry, type: CodecClass<T> | string, value?: AnyTuple);
+    static with<T extends INumber>(Types: CodecClass<T> | string): CodecClass<RangeInclusive<T>>;
+}
+export {};

package/extended/Type.d.ts

@@ -0,0 +1,16 @@
+import type { CodecRegistry } from '../types';
+import { Text } from '../native/Text';
+/**
+ * @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: CodecRegistry, value?: Text | Uint8Array | string);
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/extended/U8aFixed.d.ts

@@ -0,0 +1,16 @@
+import type { AnyU8a, CodecClass, CodecRegistry, U8aBitLength } from '../types';
+import { Raw } from '../native/Raw';
+/**
+ * @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: CodecRegistry, 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/extended/WrapperOpaque.d.ts

@@ -0,0 +1,14 @@
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+import { Base } from '../base/Base';
+export declare class WrapperOpaque<T extends Codec> extends Base<T> {
+    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, value?: unknown);
+    static with<T extends Codec>(Type: CodecClass<T> | string): CodecClass<WrapperOpaque<T>>;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}

package/extended/index.d.ts

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

package/index.d.ts

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

package/native/Bool.d.ts

@@ -0,0 +1,62 @@
+import type { HexString } from '@polkadot/util/types';
+import type { Codec, CodecRegistry, IU8a } from '../types';
+/**
+ * @name bool
+ * @description
+ * Representation for a boolean value in the system. It extends the base JS `Boolean` class
+ * @noInheritDoc
+ */
+export declare class bool extends Boolean implements Codec {
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    constructor(registry: CodecRegistry, value?: bool | Boolean | Uint8Array | boolean | number);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash(): IU8a;
+    /**
+     * @description Checks if the value is an empty value (true when it wraps false/default)
+     */
+    get isEmpty(): boolean;
+    /**
+     * @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 Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex(): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(): boolean;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): boolean;
+    /**
+     * @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/native/Date.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="bn.js" />
+import type { HexString } from '@polkadot/util/types';
+import type { AnyNumber, CodecRegistry, INumber, IU8a, UIntBitLength } from '../types';
+import { BN } from '@polkadot/util';
+/**
+ * @name Date
+ * @description
+ * A wrapper around seconds/timestamps. Internally the representation only has
+ * second precicion (aligning with Rust), so any numbers passed an/out are always
+ * per-second. For any encoding/decoding the 1000 multiplier would be applied to
+ * get it in line with JavaScript formats. It extends the base JS `Date` object
+ * and has all the methods available that are applicable to any `Date`
+ * @noInheritDoc
+ */
+export declare class CodecDate extends Date implements INumber {
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    constructor(registry: CodecRegistry, value?: CodecDate | Date | AnyNumber);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description returns a hash of the contents
+     */
+    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 the number of bits in the value
+     */
+    bitLength(): UIntBitLength;
+    /**
+     * @description Returns a BigInt representation of the number
+     */
+    toBigInt(): bigint;
+    /**
+     * @description Returns the BN representation of the timestamp
+     */
+    toBn(): BN;
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex(isLe?: boolean): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(): string;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): any;
+    /**
+     * @description Returns the number representation for the timestamp
+     */
+    toNumber(): number;
+    /**
+     * @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/native/Json.d.ts

@@ -0,0 +1,56 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson, Codec, CodecRegistry, IU8a } from '../types';
+/**
+ * @name Json
+ * @description
+ * Wraps the a JSON structure retrieve via RPC. It extends the standard JS Map with. While it
+ * implements a Codec, it is limited in that it can only be used with input objects via RPC,
+ * i.e. no hex decoding. Unlike a struct, this waps a JSON object with unknown keys
+ * @noInheritDoc
+ */
+export declare class Json extends Map<string, any> implements Codec {
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    constructor(registry: CodecRegistry, value?: Record<string, unknown> | null);
+    /**
+     * @description Always 0, never encodes as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description returns a hash of the contents
+     */
+    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;
+    getT<T>(key: string): T;
+    /**
+     * @description Unimplemented, will throw
+     */
+    toHex(): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(): Record<string, AnyJson>;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): Record<string, AnyJson>;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString(): string;
+    /**
+     * @description Unimplemented, will throw
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}