@pezkuwi/types 16.5.6 → 16.5.8

package/build/cjs/types/definitions.d.ts

@@ -0,0 +1,108 @@
+import type { HexString } from '@pezkuwi/util/types';
+export type DefinitionTypeType = string;
+export type DefinitionTypeEnum = {
+    _fallback?: DefinitionTypeType;
+} & ({
+    _enum: DefinitionTypeType[];
+} | {
+    _enum: Record<string, DefinitionTypeType | null>;
+});
+export interface DefinitionTypeSet {
+    _fallback?: DefinitionTypeType;
+    _set: Record<string, number>;
+}
+type DefinitionTypeStructExtra = {
+    _alias?: Record<string, DefinitionTypeType>;
+    _fallback?: DefinitionTypeType;
+} & Record<string, unknown>;
+export type DefinitionTypeStruct = Record<string, DefinitionTypeType> | DefinitionTypeStructExtra;
+export type DefinitionType = string | DefinitionTypeEnum | DefinitionTypeSet | DefinitionTypeStruct;
+export interface DefinitionRpcParam {
+    /** true if the parameter is a blockhash that is to be used in historic queries */
+    isHistoric?: boolean;
+    /** true if this is an optional parameter (we forgo the use of Option<T> types) */
+    isOptional?: boolean;
+    /** The name of the parameter */
+    name: string;
+    /** The type of the parameter */
+    type: DefinitionTypeType;
+}
+export interface DefinitionRpc {
+    /** Alias to a specific method (this allows replacements and renames) */
+    alias?: string[];
+    /** Alias to a section */
+    aliasSection?: string;
+    /** A string describing a deprecated interface, along with to-use information */
+    deprecated?: string;
+    /** The description for this RPC call */
+    description: string;
+    /** The (optional) endpoint override. If not specified the section_method is used */
+    endpoint?: string;
+    /** true if this needs a signed submission, e.g. when submitting extrinsics */
+    isSigned?: boolean;
+    /** true if this is an RPC call that has been marked unsafe */
+    isUnsafe?: boolean;
+    /** Don't log any errors if they occur (should be used sparingly for exceptions only) */
+    noErrorLog?: boolean;
+    /** The applicable parameters for the call */
+    params: DefinitionRpcParam[];
+    /** The return type for the RPC call */
+    type: DefinitionTypeType;
+}
+export interface DefinitionRpcExt extends DefinitionRpc {
+    /** true if this is a method yielding a subscription */
+    isSubscription: boolean;
+    /** The jsonrpc name for this method, typically section_method */
+    jsonrpc: string;
+    /** The method name for this RPC */
+    method: string;
+    /** Optional subscription information in the form [subscription name, subscribe method, unsubscribe method] */
+    pubsub?: [subname: string, subscribe: string, unsubscribe: string];
+    /** The section name for this RPC */
+    section: string;
+}
+export interface DefinitionCallParam {
+    /** The name for this parameter */
+    name: string;
+    /** The return type for this parameter */
+    type: DefinitionTypeType;
+}
+export interface DefinitionCall {
+    /** The description of this runtime call (generally extracted from the Rust code as-is) */
+    description: string;
+    /** The applicable call parameters */
+    params: DefinitionCallParam[];
+    /** The return type for this call */
+    type: DefinitionTypeType;
+}
+export interface DefinitionRpcSub extends DefinitionRpc {
+    /** Subscription information in the form [subscription name, subscribe method, unsubscribe method] */
+    pubsub: [subname: string, subscribe: string, unsubscribe: string];
+}
+export type DefinitionsRpc = Record<string, DefinitionRpc | DefinitionRpcSub>;
+export interface DefinitionsCallEntry {
+    /** The method that are available on this interface */
+    methods: Record<string, DefinitionCall>;
+    /** The version of the runtime api that this definition applies to */
+    version: number;
+}
+export type DefinitionsCall = Record<string, DefinitionsCallEntry[]>;
+export interface DefinitionCallNamed extends DefinitionCall {
+    /** The method for this call (combined with section to form name) */
+    method: string;
+    /** The actual name of the runtime call as exposed by the runtime itself */
+    name: string;
+    /** The section for this call (combined with method to form name) */
+    section: string;
+    /** The hash of this section (these map to what is available in state_getRuntimeVersion) */
+    sectionHash: HexString;
+    /** The version of the runtime interface */
+    version: number;
+}
+export type DefinitionsTypes = Record<string, DefinitionType>;
+export interface Definitions {
+    rpc?: DefinitionsRpc;
+    runtime?: DefinitionsCall;
+    types: DefinitionsTypes;
+}
+export {};

package/build/cjs/types/definitions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/types/detect.d.ts

@@ -0,0 +1,42 @@
+import type { InterfaceTypes } from '@pezkuwi/types/types';
+import type { bool, BTreeMap, BTreeSet, Bytes, CodecSet, Compact, Enum, HashMap, Linkage, Null, Option, OptionBool, Range, RangeInclusive, Result, Struct, u8, U8aFixed, Vec, VecFixed } from '@pezkuwi/types-codec';
+import type { Codec, ICompact, IEnum, IMap, IMethod, INumber, IOption, IResult, ISet, IStruct, ITuple, IU8a, IVec } from '@pezkuwi/types-codec/types';
+export type DetectCodec<T extends Codec, K extends string> = K extends keyof InterfaceTypes ? InterfaceTypes[K] : T extends ICompact | IEnum | IMap | IMethod | INumber | IOption | IResult | ISet | IStruct | ITuple | IU8a | IVec ? T : __Codec<__Codecs<__Tokenize<__Sanitize<K>>[0]>>;
+export type __Codec<V extends Codec[]> = V[0] extends Codec ? V[0] : Codec;
+export type __Sanitize<K extends string> = K extends ` ${infer X}` | `${infer X} ` | ` ${infer X} ` ? __Sanitize<X> : K extends `${infer A} ${infer B}` ? __Sanitize<`${A}${B}`> : K extends `${infer A};${string}]${infer B}` ? __Sanitize<`${A}${B}`> : K extends `${infer X};${string}]` ? __Sanitize<X> : K;
+export type __Value = string | Record<string, unknown> | __Value[];
+export interface __MapWrapOne<C extends Codec> {
+    'BTreeSet<': BTreeSet<C>;
+    'Compact<': C extends INumber ? Compact<C> : Codec;
+    'Linkage<': Linkage<C>;
+    'Option<': C extends bool ? OptionBool : Option<C>;
+    'Range<': C extends INumber ? Range<C> : Codec;
+    'RangeInclusive<': C extends INumber ? RangeInclusive<C> : Codec;
+    'Vec<': C extends u8 ? Bytes : Vec<C>;
+    '[': C extends u8 ? U8aFixed : VecFixed<C>;
+}
+export interface __MapWrapTwo<K extends Codec, V extends Codec> {
+    'BTreeMap<': BTreeMap<K, V>;
+    'HashMap<': HashMap<K, V>;
+    'Result<': Result<K, V>;
+}
+export type __WrapOne = keyof __MapWrapOne<Codec>;
+export type __WrapTwo = keyof __MapWrapTwo<Codec, Codec>;
+export type __Wrap = __WrapOne | __WrapTwo;
+export type __ToTuple<O extends Codec[]> = O[0] extends Codec ? O[1] extends Codec ? ITuple<O> : O[0] : Null;
+export type __CodecsNext<K, C extends Codec[]> = K extends __WrapOne ? C extends [Codec, ...infer X] ? [__MapWrapOne<C[0]>[K], ...X] : Codec : K extends __WrapTwo ? C extends [Codec, Codec, ...infer X] ? [__MapWrapTwo<C[0], C[1]>[K], ...X] : Codec : [
+    K extends keyof InterfaceTypes ? InterfaceTypes[K] : K extends unknown[] ? __ToTuple<__Codecs<K>> : K extends Record<string, unknown> ? K['_enum'] extends true ? Enum : K['_set'] extends true ? CodecSet : Struct : Codec,
+    ...C
+];
+export type __Codecs<T extends unknown[]> = T extends [infer K, ...infer N] ? __CodecsNext<K, __Codecs<N>> : [];
+export type __Combine<V extends __Value[], I extends string> = I extends '' ? V : [...V, I];
+export type __CombineInner<V extends __Value[], I extends string, X extends __Value> = I extends '' ? [...V, X] : [I, ...V, X];
+export type __TokenizeStruct<T extends [__Value[], string], V extends __Value[], I extends string, R extends string> = __Tokenize<T[1], __CombineInner<V, I, R extends `"_set"${string}` ? {
+    _set: true;
+} : R extends `"_enum"${string}` ? {
+    _enum: true;
+} : {
+    _fields: true;
+}>>;
+export type __TokenizeTuple<T extends [__Value[], string], V extends __Value[], I extends string> = __Tokenize<T[1], __CombineInner<V, I, T[0]>>;
+export type __Tokenize<K extends string, V extends __Value[] = [], I extends string = ''> = K extends '' | '>' | ')' | '}' ? [__Combine<V, I>, ''] : K extends `${__Wrap}${infer R}` ? K extends `${infer X}${R}` ? X extends '[' ? __Tokenize<R, [...__Combine<V, I>, '[']> : __Tokenize<R, __Combine<V, `${I}${X}`>> : never : K extends `${',' | '>'}${infer R}` ? __Tokenize<R, __Combine<V, I>> : K extends `${')' | '}'}${infer R}` ? [__Combine<V, I>, R] : K extends `(${infer R}` ? __TokenizeTuple<__Tokenize<R>, V, I> : K extends `{${infer R}` ? __TokenizeStruct<__Tokenize<R>, V, I, R> : K extends `${keyof InterfaceTypes}${',' | '>'}${infer R}` ? K extends `${infer X}${',' | '>'}${R}` ? __Tokenize<R, __Combine<V, `${I}${X}`>> : never : K extends `${infer C}${infer R}` ? __Tokenize<R, V, `${I}${C}`> : [__Combine<V, I>, ''];

package/build/cjs/types/detect.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/types/events.d.ts

@@ -0,0 +1,28 @@
+import type { Codec } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { EventMetadataLatest } from '../interfaces/metadata/index.js';
+import type { Hash } from '../interfaces/runtime/index.js';
+import type { EventId, Phase } from '../interfaces/system/index.js';
+export interface IEventRecord<T extends Codec[]> extends Codec {
+    readonly phase: Phase;
+    readonly event: IEvent<T>;
+    readonly topics: Hash[];
+}
+export interface IEventData extends Codec {
+    readonly meta: EventMetadataLatest;
+    readonly method: string;
+    readonly names: string[] | null;
+    readonly section: string;
+    readonly typeDef: TypeDef[];
+}
+export interface IEventLike {
+    readonly index: unknown;
+    readonly method: unknown;
+    readonly section: unknown;
+}
+export interface IEvent<T extends Codec[], N = unknown> extends IEventLike, Codec {
+    readonly data: N extends Record<string, Codec> ? N & T & IEventData : T & IEventData;
+    readonly index: EventId;
+    readonly method: string;
+    readonly section: string;
+}

package/build/cjs/types/events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/types/extrinsic.d.ts

@@ -0,0 +1,220 @@
+import type { AnyJson, AnyNumber, AnyTuple, AnyU8a, Codec } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { ExtrinsicStatus } from '../interfaces/author/index.js';
+import type { EcdsaSignature, Ed25519Signature, Sr25519Signature } from '../interfaces/extrinsics/index.js';
+import type { Address, Call, H256, Hash } from '../interfaces/runtime/index.js';
+import type { DispatchError, DispatchInfo, EventRecord } from '../interfaces/system/index.js';
+import type { ICompact, IKeyringPair, IMethod, INumber, IRuntimeVersionBase } from './interfaces.js';
+import type { Registry } from './registry.js';
+export interface ISubmittableResult {
+    readonly dispatchError?: DispatchError | undefined;
+    readonly dispatchInfo?: DispatchInfo | undefined;
+    readonly events: EventRecord[];
+    readonly internalError?: Error | undefined;
+    readonly status: ExtrinsicStatus;
+    readonly isCompleted: boolean;
+    readonly isError: boolean;
+    readonly isFinalized: boolean;
+    readonly isInBlock: boolean;
+    readonly isWarning: boolean;
+    readonly txHash: Hash;
+    readonly txIndex?: number | undefined;
+    filterRecords(section: string, method: string): EventRecord[];
+    findRecord(section: string, method: string): EventRecord | undefined;
+    toHuman(isExtended?: boolean): AnyJson;
+}
+export interface SignerPayloadJSON {
+    /**
+     * @description The ss-58 encoded address
+     */
+    address: string;
+    /**
+     * @description The id of the asset used to pay fees, in hex
+     */
+    assetId?: HexString;
+    /**
+     * @description The checkpoint hash of the block, in hex
+     */
+    blockHash: HexString;
+    /**
+     * @description The checkpoint block number, in hex
+     */
+    blockNumber: HexString;
+    /**
+     * @description The era for this transaction, in hex
+     */
+    era: HexString;
+    /**
+     * @description The genesis hash of the chain, in hex
+     */
+    genesisHash: HexString;
+    /**
+     * @description The metadataHash for the CheckMetadataHash SignedExtension, as hex
+     */
+    metadataHash?: HexString;
+    /**
+     * @description The encoded method (with arguments) in hex
+     */
+    method: string;
+    /**
+     * @description The mode for the CheckMetadataHash SignedExtension, in hex
+     */
+    mode?: number;
+    /**
+     * @description The nonce for this transaction, in hex
+     */
+    nonce: HexString;
+    /**
+     * @description The current spec version for the runtime
+     */
+    specVersion: HexString;
+    /**
+     * @description The tip for this transaction, in hex
+     */
+    tip: HexString;
+    /**
+     * @description The current transaction version for the runtime
+     */
+    transactionVersion: HexString;
+    /**
+     * @description The applicable signed extensions for this runtime
+     */
+    signedExtensions: string[];
+    /**
+     * @description The version of the extrinsic we are dealing with
+     */
+    version: number;
+    /**
+     * @description Optional flag that enables the use of the `signedTransaction` field in
+     * `singAndSend`, `signAsync`, and `dryRun`.
+     */
+    withSignedTransaction?: boolean;
+}
+export interface SignerPayloadRawBase {
+    /**
+     * @description The hex-encoded data for this request
+     */
+    data: string;
+    /**
+     * @description The type of the contained data
+     */
+    type?: 'bytes' | 'payload';
+}
+export interface SignerPayloadRaw extends SignerPayloadRawBase {
+    /**
+     * @description The ss-58 encoded address
+     */
+    address: string;
+    /**
+     * @description The type of the contained data
+     */
+    type: 'bytes' | 'payload';
+}
+export interface ISignerPayload {
+    toPayload(): SignerPayloadJSON;
+    toRaw(): SignerPayloadRaw;
+}
+export interface SignerResult {
+    /**
+     * @description The id for this request
+     */
+    id: number;
+    /**
+     * @description The resulting signature in hex
+     */
+    signature: HexString;
+    /**
+     * @description The payload constructed by the signer. This allows the
+     * inputted signed transaction to bypass `signAndSend` from adding the signature to the payload,
+     * and instead broadcasting the transaction directly. There is a small validation layer. Please refer
+     * to the implementation for more information. If the inputted signed transaction is not actually signed, it will fail with an error.
+     *
+     * This will also work for `signAsync`. The new payload will be added to the Extrinsic, and will be sent once the consumer calls `.send()`.
+     *
+     * NOTE: This is only implemented for `signPayload`, and will only work when the `withSignedTransaction` option is enabled as an option.
+     */
+    signedTransaction?: HexString | Uint8Array;
+}
+export interface Signer {
+    /**
+     * @description signs an extrinsic payload from a serialized form
+     */
+    signPayload?: (payload: SignerPayloadJSON) => Promise<SignerResult>;
+    /**
+     * @description signs a raw payload, only the bytes data as supplied
+     */
+    signRaw?: (raw: SignerPayloadRaw) => Promise<SignerResult>;
+    /**
+     * @description Receives an update for the extrinsic signed by a `signer.sign`
+     */
+    update?: (id: number, status: H256 | ISubmittableResult) => void;
+}
+export interface IExtrinsicEra extends Codec {
+    asImmortalEra: Codec;
+    asMortalEra: Codec;
+}
+export interface SignatureOptions {
+    allowCallDataAlteration?: boolean;
+    blockHash: Uint8Array | string;
+    era?: IExtrinsicEra;
+    genesisHash: Uint8Array | string;
+    nonce: AnyNumber;
+    runtimeVersion: IRuntimeVersionBase;
+    signedExtensions?: string[];
+    signer?: Signer;
+    tip?: AnyNumber;
+    assetId?: AnyNumber | object;
+    mode?: AnyNumber;
+    metadataHash?: Uint8Array | string;
+    withSignedTransaction?: boolean;
+}
+interface ExtrinsicSignatureBase {
+    readonly isSigned: boolean;
+    readonly era: IExtrinsicEra;
+    readonly nonce: ICompact<INumber>;
+    readonly signature: EcdsaSignature | Ed25519Signature | Sr25519Signature;
+    readonly signer: Address;
+    readonly tip: ICompact<INumber>;
+}
+export interface ExtrinsicPayloadValue {
+    blockHash: AnyU8a;
+    era: AnyU8a | IExtrinsicEra;
+    genesisHash: AnyU8a;
+    method: AnyU8a | IMethod<AnyTuple>;
+    nonce: AnyNumber;
+    specVersion: AnyNumber;
+    tip: AnyNumber;
+    transactionVersion: AnyNumber;
+    assetId?: HexString;
+    mode?: AnyNumber;
+    metadataHash?: AnyU8a;
+}
+export interface IExtrinsicSignature extends ExtrinsicSignatureBase, Codec {
+    addSignature(signer: Address | Uint8Array | string, signature: Uint8Array | HexString, payload: Uint8Array | HexString): IExtrinsicSignature;
+    sign(method: Call, account: IKeyringPair, options: SignatureOptions): IExtrinsicSignature;
+    signFake(method: Call, address: Address | Uint8Array | string, options: SignatureOptions): IExtrinsicSignature;
+    readonly registry: Registry;
+}
+interface IExtrinsicSignable<T> extends Codec {
+    addSignature(signer: Address | Uint8Array | string, signature: Uint8Array | HexString, payload: ExtrinsicPayloadValue | Uint8Array | HexString): T;
+    sign(account: IKeyringPair, options: SignatureOptions): T;
+    signFake(address: Address | Uint8Array | string, options: SignatureOptions): T;
+    readonly registry: Registry;
+}
+export interface IExtrinsicImpl extends IExtrinsicSignable<IExtrinsicImpl> {
+    readonly method: Call;
+    readonly signature: IExtrinsicSignature;
+    readonly version: number;
+}
+export interface IExtrinsicV5Impl extends IExtrinsicSignable<IExtrinsicV5Impl> {
+    readonly method: Call;
+    readonly signature: IExtrinsicSignature;
+    readonly version: number;
+}
+export interface IExtrinsic<A extends AnyTuple = AnyTuple> extends IExtrinsicSignable<IExtrinsic<A>>, ExtrinsicSignatureBase, IMethod<A> {
+    readonly length: number;
+    readonly method: IMethod<A>;
+    readonly type: number;
+    readonly version: number;
+}
+export {};

package/build/cjs/types/extrinsic.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/types/index.d.ts

@@ -0,0 +1,12 @@
+import './augmentLookup.js';
+import './augmentRegistry.js';
+export * from '@pezkuwi/types/types/registry';
+export type { Observable } from 'rxjs';
+export * from '../create/types.js';
+export * from './calls.js';
+export * from './codec.js';
+export * from './definitions.js';
+export * from './detect.js';
+export * from './events.js';
+export * from './extrinsic.js';
+export * from './interfaces.js';

package/build/cjs/types/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("./augmentLookup.js");
+require("./augmentRegistry.js");
+tslib_1.__exportStar(require("@pezkuwi/types/types/registry"), exports);
+tslib_1.__exportStar(require("../create/types.js"), exports);
+tslib_1.__exportStar(require("./calls.js"), exports);
+tslib_1.__exportStar(require("./codec.js"), exports);
+tslib_1.__exportStar(require("./definitions.js"), exports);
+tslib_1.__exportStar(require("./detect.js"), exports);
+tslib_1.__exportStar(require("./events.js"), exports);
+tslib_1.__exportStar(require("./extrinsic.js"), exports);
+tslib_1.__exportStar(require("./interfaces.js"), exports);

package/build/cjs/types/interfaces.d.ts

@@ -0,0 +1,40 @@
+import type { SignOptions } from '@pezkuwi/keyring/types';
+import type { AnyTuple, Codec, IMethod as IMethodBase, INumber, IText } from '@pezkuwi/types-codec/types';
+import type { FunctionMetadataLatest, StorageEntryMetadataLatest } from '../interfaces/metadata/index.js';
+import type { Registry } from './registry.js';
+export type { ICompact, IEnum, IMap, INumber, IOption, IResult, ISet, IStruct, IText, ITuple, IU8a, IVec } from '@pezkuwi/types-codec/types';
+export interface IMethod<A extends AnyTuple = AnyTuple, M = FunctionMetadataLatest> extends IMethodBase<A, M> {
+    readonly registry: Registry;
+}
+export interface IKeyringPair {
+    readonly address: string;
+    readonly addressRaw: Uint8Array;
+    readonly publicKey: Uint8Array;
+    sign: (data: Uint8Array, options?: SignOptions) => Uint8Array;
+}
+export interface IRuntimeVersionBase {
+    readonly apis: unknown[];
+    readonly authoringVersion: unknown;
+    readonly implName: unknown;
+    readonly implVersion: unknown;
+    readonly specName: unknown;
+    readonly specVersion: unknown;
+    readonly transactionVersion: unknown;
+}
+export interface IRuntimeVersion extends IRuntimeVersionBase {
+    readonly apis: Codec[];
+    readonly authoringVersion: INumber;
+    readonly implName: IText;
+    readonly implVersion: INumber;
+    readonly specName: IText;
+    readonly specVersion: INumber;
+    readonly transactionVersion: INumber;
+}
+export interface IStorageKey<A extends AnyTuple> {
+    readonly args: A;
+    readonly meta: StorageEntryMetadataLatest | undefined;
+    readonly method: string | undefined;
+    readonly outputType: string;
+    readonly section: string | undefined;
+    is: (key: IStorageKey<AnyTuple>) => key is IStorageKey<A>;
+}

package/build/cjs/types/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/types/registry.d.ts

@@ -0,0 +1,128 @@
+import type { Observable } from 'rxjs';
+import type { BitVec, Bool, bool, Bytes, F32, f32, F64, f64, I8, i8, I16, i16, I32, i32, I64, i64, I128, i128, I256, i256, ISize, isize, Json, Null, OptionBool, Raw, Text, Type, U8, u8, U16, u16, U32, u32, U64, u64, U128, u128, U256, u256, USize, usize } from '@pezkuwi/types-codec';
+import type { RegistryTypes } from '@pezkuwi/types-codec/types';
+import type { BN } from '@pezkuwi/util';
+import type { HexString } from '@pezkuwi/util/types';
+import type { GenericExtrinsic, GenericExtrinsicEra, GenericExtrinsicPayload, GenericSignerPayload } from '../extrinsic/index.js';
+import type { ExtDef } from '../extrinsic/signedExtensions/types.js';
+import type { GenericCall } from '../generic/index.js';
+import type { HeaderPartial } from '../interfaces/runtime/index.js';
+import type { RuntimeVersionPartial } from '../interfaces/state/index.js';
+import type { Metadata, PortableRegistry } from '../metadata/index.js';
+import type { Data, StorageKey } from '../primitive/index.js';
+import type { DefinitionRpc, DefinitionRpcSub, DefinitionsCall } from './definitions.js';
+export type { Registry, RegistryError, RegistryTypes } from '@pezkuwi/types-codec/types';
+export interface InterfaceTypes {
+    BitVec: BitVec;
+    Bytes: Bytes;
+    Json: Json;
+    Null: Null;
+    OptionBool: OptionBool;
+    Raw: Raw;
+    Text: Text;
+    Type: Type;
+    Bool: Bool;
+    F32: F32;
+    F64: F64;
+    I128: I128;
+    I16: I16;
+    I256: I256;
+    I32: I32;
+    I64: I64;
+    I8: I8;
+    ISize: ISize;
+    U128: U128;
+    U16: U16;
+    U256: U256;
+    U32: U32;
+    U64: U64;
+    U8: U8;
+    USize: USize;
+    bool: bool;
+    f32: f32;
+    f64: f64;
+    i128: i128;
+    i16: i16;
+    i256: i256;
+    i32: i32;
+    i64: i64;
+    i8: i8;
+    isize: isize;
+    u128: u128;
+    u16: u16;
+    u256: u256;
+    u32: u32;
+    u64: u64;
+    u8: u8;
+    usize: usize;
+    Extrinsic: GenericExtrinsic;
+    ExtrinsicEra: GenericExtrinsicEra;
+    ExtrinsicPayload: GenericExtrinsicPayload;
+    SignerPayload: GenericSignerPayload;
+    Call: GenericCall;
+    Data: Data;
+    StorageKey: StorageKey;
+    Metadata: Metadata;
+    PortableRegistry: PortableRegistry;
+    HeaderPartial: HeaderPartial;
+    RuntimeVersionPartial: RuntimeVersionPartial;
+}
+export type CodecHasher = (data: Uint8Array) => Uint8Array;
+export interface ChainUpgradeVersion {
+    apis: [HexString, number][];
+    blockNumber: BN;
+    specVersion: BN;
+}
+export interface ChainUpgrades {
+    genesisHash: Uint8Array;
+    network: string;
+    versions: ChainUpgradeVersion[];
+}
+export interface OverrideVersionedType {
+    minmax: [number | undefined | null, number | undefined | null] | [number?, number?] | (number | undefined | null)[];
+    types: RegistryTypes;
+}
+export type OverrideModuleType = Record<string, string>;
+export type DeriveCustom = Record<string, Record<string, (instanceId: string, api: any) => (...args: any[]) => Observable<any>>>;
+export type AliasDefinition = Record<string, OverrideModuleType>;
+export interface OverrideBundleDefinition {
+    alias?: AliasDefinition;
+    derives?: DeriveCustom;
+    hasher?: (data: Uint8Array) => Uint8Array;
+    instances?: Record<string, string[]>;
+    rpc?: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>;
+    runtime?: DefinitionsCall;
+    signedExtensions?: ExtDef;
+    types?: OverrideVersionedType[];
+}
+export interface OverrideBundleType {
+    chain?: Record<string, OverrideBundleDefinition>;
+    spec?: Record<string, OverrideBundleDefinition>;
+}
+export interface RegisteredTypes {
+    /**
+     * @description Specify the actual hasher override to use in the API. This generally should be done via the typesBundle
+     */
+    hasher?: (data: Uint8Array) => Uint8Array;
+    /**
+     * @description Additional types used by runtime modules. This is necessary if the runtime modules
+     * uses types not available in the base Bizinikiwi runtime.
+     */
+    types?: RegistryTypes;
+    /**
+     * @description Alias types, as received via the metadata, to a JS-specific type to avoid conflicts. For instance, you can rename the `Proposal` in the `treasury` module to `TreasuryProposal` as to not have conflicts with the one for democracy.
+     */
+    typesAlias?: AliasDefinition;
+    /**
+     * @description A bundle of types related to chain & spec that is injected based on what the chain contains
+     */
+    typesBundle?: OverrideBundleType;
+    /**
+     * @description Additional types that are injected based on the chain we are connecting to. There are keyed by the chain, i.e. `{ 'Zagros CC1': { ... } }`
+     */
+    typesChain?: Record<string, RegistryTypes>;
+    /**
+     * @description Additional types that are injected based on the type of node we are connecting to, as set via specName in the runtime version. There are keyed by the node, i.e. `{ 'edgeware': { ... } }`
+     */
+    typesSpec?: Record<string, RegistryTypes>;
+}

package/build/cjs/types/registry.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/util/index.d.ts

@@ -0,0 +1 @@
+export * from './storage.js';

package/build/cjs/util/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./storage.js"), exports);

package/build/cjs/util/storage.d.ts

@@ -0,0 +1,7 @@
+import type { StorageEntryTypeLatest } from '../interfaces/metadata/index.js';
+import type { SiLookupTypeId } from '../interfaces/scaleInfo/index.js';
+import type { InterfaceTypes, Registry } from '../types/index.js';
+/** @internal */
+export declare function unwrapStorageSi(type: StorageEntryTypeLatest): SiLookupTypeId;
+/** @internal */
+export declare function unwrapStorageType(registry: Registry, type: StorageEntryTypeLatest, isOptional?: boolean): keyof InterfaceTypes;

package/build/cjs/util/storage.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapStorageSi = unwrapStorageSi;
+exports.unwrapStorageType = unwrapStorageType;
+const index_js_1 = require("../metadata/util/index.js");
+/** @internal */
+function unwrapStorageSi(type) {
+    return type.isPlain
+        ? type.asPlain
+        : type.asMap.value;
+}
+/** @internal */
+function unwrapStorageType(registry, type, isOptional) {
+    const outputType = (0, index_js_1.getSiName)(registry.lookup, unwrapStorageSi(type));
+    return isOptional
+        ? `Option<${outputType}>`
+        : outputType;
+}

package/build/codec/index.d.ts

@@ -0,0 +1 @@
+export { BTreeMap, BTreeSet, CodecMap, CodecSet, Compact, DoNotConstruct, Enum, HashMap, Int, Json, Linkage, Map, Option, Range, RangeInclusive, Raw, Result, Set, Struct, Tuple, U8aFixed, UInt, Vec, VecFixed, WrapperKeepOpaque, WrapperOpaque } from '@pezkuwi/types-codec';

package/build/codec/index.js

@@ -0,0 +1 @@
+export { BTreeMap, BTreeSet, CodecMap, CodecSet, Compact, DoNotConstruct, Enum, HashMap, Int, Json, Linkage, Map, Option, Range, RangeInclusive, Raw, Result, Set, Struct, Tuple, U8aFixed, UInt, Vec, VecFixed, WrapperKeepOpaque, WrapperOpaque } from '@pezkuwi/types-codec';