@polkadot-api/substrate-bindings 0.11.1 → 0.13.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as scale_ts from 'scale-ts';
-import { Codec, Encoder, Decoder, StringRecord, CodecType, EncoderType, DecoderType } from 'scale-ts';
-export { Bytes, Codec, CodecType, Decoder, DecoderType, Encoder, EncoderType, Option, Result, ResultPayload, Enum as ScaleEnum, StringRecord, Struct, Tuple, Vector, _void, bool, compact, createCodec, createDecoder, enhanceCodec, enhanceDecoder, enhanceEncoder, i128, i16, i256, i32, i64, i8, str, u128, u16, u256, u32, u64, u8 } from 'scale-ts';
+import { Codec, Encoder, Decoder, StringRecord, CodecType, EncoderType, DecoderType, ResultPayload } from 'scale-ts';
+export { Bytes, Codec, CodecType, Decoder, DecoderType, Encoder, EncoderType, ResultPayload, StringRecord, _void, bool, compact, createCodec, createDecoder, enhanceCodec, enhanceDecoder, enhanceEncoder, i128, i16, i256, i32, i64, i8, str, u128, u16, u256, u32, u64, u8 } from 'scale-ts';
 
 type SS58String = string & {
     __SS58String?: unknown;
@@ -117,23 +117,138 @@ type GetEnum<T extends Enum<any>> = {
 };
 declare const _Enum: {};
 
-type Tuple<T, N extends number> = readonly [T, ...T[]] & {
+type Tuple$1<T, N extends number> = readonly [T, ...T[]] & {
     length: N;
 };
 type Push<T extends any[], V> = [...T, V];
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
 type TuplifyUnion<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<TuplifyUnion<Exclude<T, L>>, L>;
-type RestrictedLenTuple<T, O extends StringRecord<any>> = Tuple<T, TuplifyUnion<keyof O> extends Tuple<any, infer V> ? V : 0>;
+type RestrictedLenTuple<T, O extends StringRecord<any>> = Tuple$1<T, TuplifyUnion<keyof O> extends Tuple$1<any, infer V> ? V : 0>;
 declare const Variant: {
-    <O extends StringRecord<Codec<any>>>(inner: O, indexes?: RestrictedLenTuple<number, O> | undefined): Codec<Enum<{ [K in keyof O]: CodecType<O[K]>; }>>;
-    enc: <O extends StringRecord<Encoder<any>>>(inner: O, x?: RestrictedLenTuple<number, O> | undefined) => Encoder<Enum<{ [K in keyof O]: EncoderType<O[K]>; }>>;
-    dec: <O extends StringRecord<Decoder<any>>>(inner: O, x?: RestrictedLenTuple<number, O> | undefined) => Decoder<Enum<{ [K in keyof O]: DecoderType<O[K]>; }>>;
+    <O extends StringRecord<Codec<any>>>(inner: O, indexes?: RestrictedLenTuple<number, O> | undefined): Codec<Enum<{
+        [K in keyof O]: CodecType<O[K]>;
+    }>> & {
+        inner: O;
+    };
+    enc: <O_1 extends StringRecord<Encoder<any>>>(inner: O_1, x?: RestrictedLenTuple<number, O_1> | undefined) => Encoder<Enum<{
+        [K in keyof O_1]: EncoderType<O_1[K]>;
+    }>> & {
+        inner: O_1;
+    };
+    dec: <O_2 extends StringRecord<Decoder<any>>>(inner: O_2, x?: RestrictedLenTuple<number, O_2> | undefined) => Decoder<Enum<{
+        [K in keyof O_2]: DecoderType<O_2[K]>;
+    }>> & {
+        inner: O_2;
+    };
+};
+declare const ScaleEnum: {
+    <O extends StringRecord<Codec<any>>>(inner: O, indexes?: RestrictedLenTuple<number, O> | undefined): Codec<{
+        [K in keyof O]: {
+            tag: K;
+            value: CodecType<O[K]>;
+        };
+    }[keyof O]> & {
+        inner: O;
+    };
+    enc: <O_1 extends StringRecord<Encoder<any>>>(inner: O_1, x?: RestrictedLenTuple<number, O_1> | undefined) => Encoder<{
+        [K_1 in keyof O_1]: {
+            tag: K_1;
+            value: EncoderType<O_1[K_1]>;
+        };
+    }[keyof O_1]> & {
+        inner: O_1;
+    };
+    dec: <O_2 extends StringRecord<Decoder<any>>>(inner: O_2, x?: RestrictedLenTuple<number, O_2> | undefined) => Decoder<{
+        [K_2 in keyof O_2]: {
+            tag: K_2;
+            value: DecoderType<O_2[K_2]>;
+        };
+    }[keyof O_2]> & {
+        inner: O_2;
+    };
 };
 
 declare const ethAccount: scale_ts.Codec<string>;
 
-declare const blockHeader: scale_ts.Codec<{
+declare const Struct: {
+    <A extends StringRecord<Codec<any>>>(codecs: A): Codec<{
+        [K in keyof A]: CodecType<A[K]>;
+    }> & {
+        inner: A;
+    };
+    enc: <A_1 extends StringRecord<Encoder<any>>>(encoders: A_1) => Encoder<{
+        [K_1 in keyof A_1]: EncoderType<A_1[K_1]>;
+    }> & {
+        inner: A_1;
+    };
+    dec: <A_2 extends StringRecord<Decoder<any>>>(decoders: A_2) => Decoder<{
+        [K_2 in keyof A_2]: DecoderType<A_2[K_2]>;
+    }> & {
+        inner: A_2;
+    };
+};
+declare const Tuple: {
+    <A extends Codec<any>[]>(...inner: A): Codec<{
+        [K in keyof A]: A[K] extends Codec<infer D> ? D : unknown;
+    }> & {
+        inner: A;
+    };
+    enc: <A_1 extends Encoder<any>[]>(...encoders: A_1) => Encoder<{
+        [K_1 in keyof A_1]: A_1[K_1] extends Encoder<infer D_1> ? D_1 : unknown;
+    }> & {
+        inner: A_1;
+    };
+    dec: <A_2 extends Decoder<any>[]>(...decoders: A_2) => Decoder<{
+        [K_2 in keyof A_2]: A_2[K_2] extends Decoder<infer D_2> ? D_2 : unknown;
+    }> & {
+        inner: A_2;
+    };
+};
+declare const Vector: {
+    <T>(inner: Codec<T>, size?: number | undefined): Codec<T[]> & {
+        inner: Codec<T>;
+    };
+    enc: <T_1>(inner: Encoder<T_1>, size?: number | undefined) => Encoder<T_1[]> & {
+        inner: Encoder<T_1>;
+    };
+    dec: <T_2>(getter: Decoder<T_2>, size?: number | undefined) => Decoder<T_2[]> & {
+        inner: Decoder<T_2>;
+    };
+};
+declare const Result: {
+    <OK, KO>(okCodec: Codec<OK>, koCodec: Codec<KO>): Codec<ResultPayload<OK, KO>> & {
+        inner: {
+            ok: Codec<OK>;
+            ko: Codec<KO>;
+        };
+    };
+    dec: <OK_1, KO_1>(okDecoder: Decoder<OK_1>, koDecoder: Decoder<KO_1>) => Decoder<ResultPayload<OK_1, KO_1>> & {
+        inner: {
+            ok: Decoder<OK_1>;
+            ko: Decoder<KO_1>;
+        };
+    };
+    enc: <OK_2, KO_2>(okEncoder: Encoder<OK_2>, koEncoder: Encoder<KO_2>) => Encoder<ResultPayload<OK_2, KO_2>> & {
+        inner: {
+            ok: Encoder<OK_2>;
+            ko: Encoder<KO_2>;
+        };
+    };
+};
+declare const Option: {
+    <T>(inner: Codec<T>): Codec<T | undefined> & {
+        inner: Codec<T>;
+    };
+    enc: <T_1>(inner: Encoder<T_1>) => Encoder<T_1 | undefined> & {
+        inner: Encoder<T_1>;
+    };
+    dec: <T_2>(inner: Decoder<T_2>) => Decoder<T_2 | undefined> & {
+        inner: Decoder<T_2>;
+    };
+};
+
+declare const blockHeader: [scale_ts.Encoder<{
     parentHash: HexString;
     number: number;
     stateRoot: HexString;
@@ -153,7 +268,153 @@ declare const blockHeader: scale_ts.Codec<{
         };
         runtimeUpdated: undefined;
     }>[];
-}>;
+}>, scale_ts.Decoder<{
+    parentHash: HexString;
+    number: number;
+    stateRoot: HexString;
+    extrinsicRoot: HexString;
+    digests: Enum<{
+        consensus: {
+            engine: string;
+            payload: HexString;
+        };
+        seal: {
+            engine: string;
+            payload: HexString;
+        };
+        preRuntime: {
+            engine: string;
+            payload: HexString;
+        };
+        runtimeUpdated: undefined;
+    }>[];
+}>] & {
+    enc: scale_ts.Encoder<{
+        parentHash: HexString;
+        number: number;
+        stateRoot: HexString;
+        extrinsicRoot: HexString;
+        digests: Enum<{
+            consensus: {
+                engine: string;
+                payload: HexString;
+            };
+            seal: {
+                engine: string;
+                payload: HexString;
+            };
+            preRuntime: {
+                engine: string;
+                payload: HexString;
+            };
+            runtimeUpdated: undefined;
+        }>[];
+    }>;
+    dec: scale_ts.Decoder<{
+        parentHash: HexString;
+        number: number;
+        stateRoot: HexString;
+        extrinsicRoot: HexString;
+        digests: Enum<{
+            consensus: {
+                engine: string;
+                payload: HexString;
+            };
+            seal: {
+                engine: string;
+                payload: HexString;
+            };
+            preRuntime: {
+                engine: string;
+                payload: HexString;
+            };
+            runtimeUpdated: undefined;
+        }>[];
+    }>;
+} & {
+    inner: {
+        parentHash: scale_ts.Codec<HexString>;
+        number: scale_ts.Codec<number>;
+        stateRoot: scale_ts.Codec<HexString>;
+        extrinsicRoot: scale_ts.Codec<HexString>;
+        digests: [scale_ts.Encoder<Enum<{
+            consensus: {
+                engine: string;
+                payload: HexString;
+            };
+            seal: {
+                engine: string;
+                payload: HexString;
+            };
+            preRuntime: {
+                engine: string;
+                payload: HexString;
+            };
+            runtimeUpdated: undefined;
+        }>[]>, scale_ts.Decoder<Enum<{
+            consensus: {
+                engine: string;
+                payload: HexString;
+            };
+            seal: {
+                engine: string;
+                payload: HexString;
+            };
+            preRuntime: {
+                engine: string;
+                payload: HexString;
+            };
+            runtimeUpdated: undefined;
+        }>[]>] & {
+            enc: scale_ts.Encoder<Enum<{
+                consensus: {
+                    engine: string;
+                    payload: HexString;
+                };
+                seal: {
+                    engine: string;
+                    payload: HexString;
+                };
+                preRuntime: {
+                    engine: string;
+                    payload: HexString;
+                };
+                runtimeUpdated: undefined;
+            }>[]>;
+            dec: scale_ts.Decoder<Enum<{
+                consensus: {
+                    engine: string;
+                    payload: HexString;
+                };
+                seal: {
+                    engine: string;
+                    payload: HexString;
+                };
+                preRuntime: {
+                    engine: string;
+                    payload: HexString;
+                };
+                runtimeUpdated: undefined;
+            }>[]>;
+        } & {
+            inner: scale_ts.Codec<Enum<{
+                consensus: {
+                    engine: string;
+                    payload: HexString;
+                };
+                seal: {
+                    engine: string;
+                    payload: HexString;
+                };
+                preRuntime: {
+                    engine: string;
+                    payload: HexString;
+                };
+                runtimeUpdated: undefined;
+            }>>;
+        };
+    };
+};
 type BlockHeader = CodecType<typeof blockHeader>;
 
 declare const metadata: Codec<{
@@ -371,6 +632,19 @@ declare const metadata: Codec<{
             apis: {
                 name: string;
                 methods: {
+                    deprecationInfo: {
+                        tag: "NotDeprecated";
+                        value: undefined;
+                    } | {
+                        tag: "DeprecatedWithoutNote";
+                        value: undefined;
+                    } | {
+                        tag: "Deprecated";
+                        value: {
+                            note: string;
+                            since: string | undefined;
+                        };
+                    };
                     name: string;
                     inputs: {
                         name: string;
@@ -380,6 +654,20 @@ declare const metadata: Codec<{
                     docs: string[];
                 }[];
                 docs: string[];
+                version: number;
+                deprecationInfo: {
+                    tag: "NotDeprecated";
+                    value: undefined;
+                } | {
+                    tag: "DeprecatedWithoutNote";
+                    value: undefined;
+                } | {
+                    tag: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                };
             }[];
         };
     } | {
@@ -576,189 +864,1042 @@ declare const metadata: Codec<{
                 value: HexString;
             }][];
         };
-    };
-}>;
-declare const decAnyMetadata: (input: Uint8Array | HexString) => CodecType<typeof metadata>;
-
-declare const extrinsic$1: scale_ts.Codec<{
-    type: number;
-    version: number;
-    signedExtensions: {
-        identifier: string;
-        type: number;
-        additionalSigned: number;
-    }[];
-}>;
-type V14Extrinsic = CodecType<typeof extrinsic$1>;
-declare const v14: scale_ts.Codec<{
-    lookup: {
-        id: number;
-        path: string[];
-        params: {
-            name: string;
-            type: number | undefined;
-        }[];
-        def: {
-            tag: "composite";
-            value: {
-                name: string | undefined;
-                type: number;
-                typeName: string | undefined;
-                docs: string[];
-            }[];
-        } | {
-            tag: "variant";
-            value: {
-                name: string;
-                fields: {
-                    name: string | undefined;
-                    type: number;
-                    typeName: string | undefined;
-                    docs: string[];
+    } | {
+        tag: "v16";
+        value: {
+            lookup: {
+                id: number;
+                path: string[];
+                params: {
+                    name: string;
+                    type: number | undefined;
                 }[];
-                index: number;
-                docs: string[];
-            }[];
-        } | {
-            tag: "sequence";
-            value: number;
-        } | {
-            tag: "array";
-            value: {
-                len: number;
-                type: number;
-            };
-        } | {
-            tag: "tuple";
-            value: number[];
-        } | {
-            tag: "primitive";
-            value: {
-                tag: "bool";
-                value: undefined;
-            } | {
-                tag: "char";
-                value: undefined;
-            } | {
-                tag: "str";
-                value: undefined;
-            } | {
-                tag: "u8";
-                value: undefined;
-            } | {
-                tag: "u16";
-                value: undefined;
-            } | {
-                tag: "u32";
-                value: undefined;
-            } | {
-                tag: "u64";
-                value: undefined;
-            } | {
-                tag: "u128";
-                value: undefined;
-            } | {
-                tag: "u256";
-                value: undefined;
-            } | {
-                tag: "i8";
-                value: undefined;
-            } | {
-                tag: "i16";
-                value: undefined;
-            } | {
-                tag: "i32";
-                value: undefined;
-            } | {
-                tag: "i64";
-                value: undefined;
-            } | {
-                tag: "i128";
-                value: undefined;
-            } | {
-                tag: "i256";
-                value: undefined;
-            };
-        } | {
-            tag: "compact";
-            value: number;
-        } | {
-            tag: "bitSequence";
-            value: {
-                bitStoreType: number;
-                bitOrderType: number;
-            };
-        };
-        docs: string[];
-    }[];
-    pallets: {
-        docs: string[];
-        name: string;
-        storage: {
-            prefix: string;
-            items: {
-                name: string;
-                modifier: number;
-                type: {
-                    tag: "map";
+                def: {
+                    tag: "composite";
                     value: {
-                        hashers: ({
-                            tag: "Blake2128";
-                            value: undefined;
-                        } | {
-                            tag: "Blake2256";
-                            value: undefined;
-                        } | {
-                            tag: "Blake2128Concat";
-                            value: undefined;
-                        } | {
-                            tag: "Twox128";
-                            value: undefined;
-                        } | {
-                            tag: "Twox256";
-                            value: undefined;
-                        } | {
-                            tag: "Twox64Concat";
-                            value: undefined;
-                        } | {
-                            tag: "Identity";
-                            value: undefined;
-                        })[];
-                        key: number;
-                        value: number;
-                    };
+                        name: string | undefined;
+                        type: number;
+                        typeName: string | undefined;
+                        docs: string[];
+                    }[];
                 } | {
-                    tag: "plain";
-                    value: number;
-                };
-                fallback: HexString;
-                docs: string[];
-            }[];
-        } | undefined;
-        calls: number | undefined;
+                    tag: "variant";
+                    value: {
+                        name: string;
+                        fields: {
+                            name: string | undefined;
+                            type: number;
+                            typeName: string | undefined;
+                            docs: string[];
+                        }[];
+                        index: number;
+                        docs: string[];
+                    }[];
+                } | {
+                    tag: "sequence";
+                    value: number;
+                } | {
+                    tag: "array";
+                    value: {
+                        len: number;
+                        type: number;
+                    };
+                } | {
+                    tag: "tuple";
+                    value: number[];
+                } | {
+                    tag: "primitive";
+                    value: {
+                        tag: "bool";
+                        value: undefined;
+                    } | {
+                        tag: "char";
+                        value: undefined;
+                    } | {
+                        tag: "str";
+                        value: undefined;
+                    } | {
+                        tag: "u8";
+                        value: undefined;
+                    } | {
+                        tag: "u16";
+                        value: undefined;
+                    } | {
+                        tag: "u32";
+                        value: undefined;
+                    } | {
+                        tag: "u64";
+                        value: undefined;
+                    } | {
+                        tag: "u128";
+                        value: undefined;
+                    } | {
+                        tag: "u256";
+                        value: undefined;
+                    } | {
+                        tag: "i8";
+                        value: undefined;
+                    } | {
+                        tag: "i16";
+                        value: undefined;
+                    } | {
+                        tag: "i32";
+                        value: undefined;
+                    } | {
+                        tag: "i64";
+                        value: undefined;
+                    } | {
+                        tag: "i128";
+                        value: undefined;
+                    } | {
+                        tag: "i256";
+                        value: undefined;
+                    };
+                } | {
+                    tag: "compact";
+                    value: number;
+                } | {
+                    tag: "bitSequence";
+                    value: {
+                        bitStoreType: number;
+                        bitOrderType: number;
+                    };
+                };
+                docs: string[];
+            }[];
+            pallets: {
+                name: string;
+                storage: {
+                    prefix: string;
+                    items: {
+                        deprecationInfo: {
+                            tag: "NotDeprecated";
+                            value: undefined;
+                        } | {
+                            tag: "DeprecatedWithoutNote";
+                            value: undefined;
+                        } | {
+                            tag: "Deprecated";
+                            value: {
+                                note: string;
+                                since: string | undefined;
+                            };
+                        };
+                        name: string;
+                        modifier: number;
+                        type: {
+                            tag: "map";
+                            value: {
+                                hashers: ({
+                                    tag: "Blake2128";
+                                    value: undefined;
+                                } | {
+                                    tag: "Blake2256";
+                                    value: undefined;
+                                } | {
+                                    tag: "Blake2128Concat";
+                                    value: undefined;
+                                } | {
+                                    tag: "Twox128";
+                                    value: undefined;
+                                } | {
+                                    tag: "Twox256";
+                                    value: undefined;
+                                } | {
+                                    tag: "Twox64Concat";
+                                    value: undefined;
+                                } | {
+                                    tag: "Identity";
+                                    value: undefined;
+                                })[];
+                                key: number;
+                                value: number;
+                            };
+                        } | {
+                            tag: "plain";
+                            value: number;
+                        };
+                        fallback: HexString;
+                        docs: string[];
+                    }[];
+                } | undefined;
+                calls: {
+                    type: number;
+                    deprecationInfo: {
+                        index: number;
+                        deprecation: {
+                            tag: "DeprecatedWithoutNote";
+                            value: undefined;
+                        } | {
+                            tag: "Deprecated";
+                            value: {
+                                note: string;
+                                since: string | undefined;
+                            };
+                        };
+                    }[];
+                } | undefined;
+                events: {
+                    type: number;
+                    deprecationInfo: {
+                        index: number;
+                        deprecation: {
+                            tag: "DeprecatedWithoutNote";
+                            value: undefined;
+                        } | {
+                            tag: "Deprecated";
+                            value: {
+                                note: string;
+                                since: string | undefined;
+                            };
+                        };
+                    }[];
+                } | undefined;
+                constants: {
+                    name: string;
+                    type: number;
+                    value: HexString;
+                    docs: string[];
+                    deprecationInfo: {
+                        tag: "NotDeprecated";
+                        value: undefined;
+                    } | {
+                        tag: "DeprecatedWithoutNote";
+                        value: undefined;
+                    } | {
+                        tag: "Deprecated";
+                        value: {
+                            note: string;
+                            since: string | undefined;
+                        };
+                    };
+                }[];
+                errors: {
+                    type: number;
+                    deprecationInfo: {
+                        index: number;
+                        deprecation: {
+                            tag: "DeprecatedWithoutNote";
+                            value: undefined;
+                        } | {
+                            tag: "Deprecated";
+                            value: {
+                                note: string;
+                                since: string | undefined;
+                            };
+                        };
+                    }[];
+                } | undefined;
+                associatedTypes: {
+                    name: string;
+                    type: number;
+                    docs: string[];
+                }[];
+                viewFns: {
+                    deprecationInfo: {
+                        tag: "NotDeprecated";
+                        value: undefined;
+                    } | {
+                        tag: "DeprecatedWithoutNote";
+                        value: undefined;
+                    } | {
+                        tag: "Deprecated";
+                        value: {
+                            note: string;
+                            since: string | undefined;
+                        };
+                    };
+                    name: string;
+                    inputs: {
+                        name: string;
+                        type: number;
+                    }[];
+                    output: number;
+                    docs: string[];
+                    id: HexString;
+                }[];
+                index: number;
+                docs: string[];
+                deprecationInfo: {
+                    tag: "NotDeprecated";
+                    value: undefined;
+                } | {
+                    tag: "DeprecatedWithoutNote";
+                    value: undefined;
+                } | {
+                    tag: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                };
+            }[];
+            extrinsic: {
+                version: number[];
+                address: number;
+                call: number;
+                signature: number;
+                signedExtensionsByVersion: [number, number[]][];
+                signedExtensions: {
+                    identifier: string;
+                    type: number;
+                    additionalSigned: number;
+                }[];
+            };
+            apis: {
+                name: string;
+                methods: {
+                    deprecationInfo: {
+                        tag: "NotDeprecated";
+                        value: undefined;
+                    } | {
+                        tag: "DeprecatedWithoutNote";
+                        value: undefined;
+                    } | {
+                        tag: "Deprecated";
+                        value: {
+                            note: string;
+                            since: string | undefined;
+                        };
+                    };
+                    name: string;
+                    inputs: {
+                        name: string;
+                        type: number;
+                    }[];
+                    output: number;
+                    docs: string[];
+                }[];
+                docs: string[];
+                version: number;
+                deprecationInfo: {
+                    tag: "NotDeprecated";
+                    value: undefined;
+                } | {
+                    tag: "DeprecatedWithoutNote";
+                    value: undefined;
+                } | {
+                    tag: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                };
+            }[];
+            outerEnums: {
+                call: number;
+                event: number;
+                error: number;
+            };
+            custom: [string, {
+                type: number;
+                value: HexString;
+            }][];
+        };
+    };
+}>;
+type Metadata = CodecType<typeof metadata>;
+declare const decAnyMetadata: (input: Uint8Array | HexString) => CodecType<typeof metadata>;
+
+declare const v14: scale_ts.Codec<{
+    lookup: {
+        id: number;
+        path: string[];
+        params: {
+            name: string;
+            type: number | undefined;
+        }[];
+        def: {
+            tag: "composite";
+            value: {
+                name: string | undefined;
+                type: number;
+                typeName: string | undefined;
+                docs: string[];
+            }[];
+        } | {
+            tag: "variant";
+            value: {
+                name: string;
+                fields: {
+                    name: string | undefined;
+                    type: number;
+                    typeName: string | undefined;
+                    docs: string[];
+                }[];
+                index: number;
+                docs: string[];
+            }[];
+        } | {
+            tag: "sequence";
+            value: number;
+        } | {
+            tag: "array";
+            value: {
+                len: number;
+                type: number;
+            };
+        } | {
+            tag: "tuple";
+            value: number[];
+        } | {
+            tag: "primitive";
+            value: {
+                tag: "bool";
+                value: undefined;
+            } | {
+                tag: "char";
+                value: undefined;
+            } | {
+                tag: "str";
+                value: undefined;
+            } | {
+                tag: "u8";
+                value: undefined;
+            } | {
+                tag: "u16";
+                value: undefined;
+            } | {
+                tag: "u32";
+                value: undefined;
+            } | {
+                tag: "u64";
+                value: undefined;
+            } | {
+                tag: "u128";
+                value: undefined;
+            } | {
+                tag: "u256";
+                value: undefined;
+            } | {
+                tag: "i8";
+                value: undefined;
+            } | {
+                tag: "i16";
+                value: undefined;
+            } | {
+                tag: "i32";
+                value: undefined;
+            } | {
+                tag: "i64";
+                value: undefined;
+            } | {
+                tag: "i128";
+                value: undefined;
+            } | {
+                tag: "i256";
+                value: undefined;
+            };
+        } | {
+            tag: "compact";
+            value: number;
+        } | {
+            tag: "bitSequence";
+            value: {
+                bitStoreType: number;
+                bitOrderType: number;
+            };
+        };
+        docs: string[];
+    }[];
+    pallets: {
+        docs: string[];
+        name: string;
+        storage: {
+            prefix: string;
+            items: {
+                name: string;
+                modifier: number;
+                type: {
+                    tag: "map";
+                    value: {
+                        hashers: ({
+                            tag: "Blake2128";
+                            value: undefined;
+                        } | {
+                            tag: "Blake2256";
+                            value: undefined;
+                        } | {
+                            tag: "Blake2128Concat";
+                            value: undefined;
+                        } | {
+                            tag: "Twox128";
+                            value: undefined;
+                        } | {
+                            tag: "Twox256";
+                            value: undefined;
+                        } | {
+                            tag: "Twox64Concat";
+                            value: undefined;
+                        } | {
+                            tag: "Identity";
+                            value: undefined;
+                        })[];
+                        key: number;
+                        value: number;
+                    };
+                } | {
+                    tag: "plain";
+                    value: number;
+                };
+                fallback: HexString;
+                docs: string[];
+            }[];
+        } | undefined;
+        calls: number | undefined;
+        events: number | undefined;
+        constants: {
+            name: string;
+            type: number;
+            value: HexString;
+            docs: string[];
+        }[];
+        errors: number | undefined;
+        index: number;
+    }[];
+    extrinsic: {
+        type: number;
+        version: number;
+        signedExtensions: {
+            identifier: string;
+            type: number;
+            additionalSigned: number;
+        }[];
+    };
+    type: number;
+    apis: {
+        name: string;
+        methods: {
+            deprecationInfo: {
+                tag: "NotDeprecated";
+                value: undefined;
+            } | {
+                tag: "DeprecatedWithoutNote";
+                value: undefined;
+            } | {
+                tag: "Deprecated";
+                value: {
+                    note: string;
+                    since: string | undefined;
+                };
+            };
+            name: string;
+            inputs: {
+                name: string;
+                type: number;
+            }[];
+            output: number;
+            docs: string[];
+        }[];
+        docs: string[];
+        version: number;
+        deprecationInfo: {
+            tag: "NotDeprecated";
+            value: undefined;
+        } | {
+            tag: "DeprecatedWithoutNote";
+            value: undefined;
+        } | {
+            tag: "Deprecated";
+            value: {
+                note: string;
+                since: string | undefined;
+            };
+        };
+    }[];
+}>;
+type V14 = CodecType<typeof v14>;
+
+declare const v15: scale_ts.Codec<{
+    lookup: {
+        id: number;
+        path: string[];
+        params: {
+            name: string;
+            type: number | undefined;
+        }[];
+        def: {
+            tag: "composite";
+            value: {
+                name: string | undefined;
+                type: number;
+                typeName: string | undefined;
+                docs: string[];
+            }[];
+        } | {
+            tag: "variant";
+            value: {
+                name: string;
+                fields: {
+                    name: string | undefined;
+                    type: number;
+                    typeName: string | undefined;
+                    docs: string[];
+                }[];
+                index: number;
+                docs: string[];
+            }[];
+        } | {
+            tag: "sequence";
+            value: number;
+        } | {
+            tag: "array";
+            value: {
+                len: number;
+                type: number;
+            };
+        } | {
+            tag: "tuple";
+            value: number[];
+        } | {
+            tag: "primitive";
+            value: {
+                tag: "bool";
+                value: undefined;
+            } | {
+                tag: "char";
+                value: undefined;
+            } | {
+                tag: "str";
+                value: undefined;
+            } | {
+                tag: "u8";
+                value: undefined;
+            } | {
+                tag: "u16";
+                value: undefined;
+            } | {
+                tag: "u32";
+                value: undefined;
+            } | {
+                tag: "u64";
+                value: undefined;
+            } | {
+                tag: "u128";
+                value: undefined;
+            } | {
+                tag: "u256";
+                value: undefined;
+            } | {
+                tag: "i8";
+                value: undefined;
+            } | {
+                tag: "i16";
+                value: undefined;
+            } | {
+                tag: "i32";
+                value: undefined;
+            } | {
+                tag: "i64";
+                value: undefined;
+            } | {
+                tag: "i128";
+                value: undefined;
+            } | {
+                tag: "i256";
+                value: undefined;
+            };
+        } | {
+            tag: "compact";
+            value: number;
+        } | {
+            tag: "bitSequence";
+            value: {
+                bitStoreType: number;
+                bitOrderType: number;
+            };
+        };
+        docs: string[];
+    }[];
+    pallets: {
+        docs: string[];
+        name: string;
+        storage: {
+            prefix: string;
+            items: {
+                name: string;
+                modifier: number;
+                type: {
+                    tag: "map";
+                    value: {
+                        hashers: ({
+                            tag: "Blake2128";
+                            value: undefined;
+                        } | {
+                            tag: "Blake2256";
+                            value: undefined;
+                        } | {
+                            tag: "Blake2128Concat";
+                            value: undefined;
+                        } | {
+                            tag: "Twox128";
+                            value: undefined;
+                        } | {
+                            tag: "Twox256";
+                            value: undefined;
+                        } | {
+                            tag: "Twox64Concat";
+                            value: undefined;
+                        } | {
+                            tag: "Identity";
+                            value: undefined;
+                        })[];
+                        key: number;
+                        value: number;
+                    };
+                } | {
+                    tag: "plain";
+                    value: number;
+                };
+                fallback: HexString;
+                docs: string[];
+            }[];
+        } | undefined;
+        calls: number | undefined;
         events: number | undefined;
         constants: {
             name: string;
             type: number;
-            value: HexString;
+            value: HexString;
+            docs: string[];
+        }[];
+        errors: number | undefined;
+        index: number;
+    }[];
+    extrinsic: {
+        version: number;
+        address: number;
+        call: number;
+        signature: number;
+        extra: number;
+        signedExtensions: {
+            identifier: string;
+            type: number;
+            additionalSigned: number;
+        }[];
+    };
+    type: number;
+    apis: {
+        name: string;
+        methods: {
+            name: string;
+            inputs: {
+                name: string;
+                type: number;
+            }[];
+            output: number;
+            docs: string[];
+        }[];
+        docs: string[];
+    }[];
+    outerEnums: {
+        call: number;
+        event: number;
+        error: number;
+    };
+    custom: [string, {
+        type: number;
+        value: HexString;
+    }][];
+}>;
+type V15 = CodecType<typeof v15>;
+
+declare const v16: scale_ts.Codec<{
+    lookup: {
+        id: number;
+        path: string[];
+        params: {
+            name: string;
+            type: number | undefined;
+        }[];
+        def: {
+            tag: "composite";
+            value: {
+                name: string | undefined;
+                type: number;
+                typeName: string | undefined;
+                docs: string[];
+            }[];
+        } | {
+            tag: "variant";
+            value: {
+                name: string;
+                fields: {
+                    name: string | undefined;
+                    type: number;
+                    typeName: string | undefined;
+                    docs: string[];
+                }[];
+                index: number;
+                docs: string[];
+            }[];
+        } | {
+            tag: "sequence";
+            value: number;
+        } | {
+            tag: "array";
+            value: {
+                len: number;
+                type: number;
+            };
+        } | {
+            tag: "tuple";
+            value: number[];
+        } | {
+            tag: "primitive";
+            value: {
+                tag: "bool";
+                value: undefined;
+            } | {
+                tag: "char";
+                value: undefined;
+            } | {
+                tag: "str";
+                value: undefined;
+            } | {
+                tag: "u8";
+                value: undefined;
+            } | {
+                tag: "u16";
+                value: undefined;
+            } | {
+                tag: "u32";
+                value: undefined;
+            } | {
+                tag: "u64";
+                value: undefined;
+            } | {
+                tag: "u128";
+                value: undefined;
+            } | {
+                tag: "u256";
+                value: undefined;
+            } | {
+                tag: "i8";
+                value: undefined;
+            } | {
+                tag: "i16";
+                value: undefined;
+            } | {
+                tag: "i32";
+                value: undefined;
+            } | {
+                tag: "i64";
+                value: undefined;
+            } | {
+                tag: "i128";
+                value: undefined;
+            } | {
+                tag: "i256";
+                value: undefined;
+            };
+        } | {
+            tag: "compact";
+            value: number;
+        } | {
+            tag: "bitSequence";
+            value: {
+                bitStoreType: number;
+                bitOrderType: number;
+            };
+        };
+        docs: string[];
+    }[];
+    pallets: {
+        name: string;
+        storage: {
+            prefix: string;
+            items: {
+                deprecationInfo: {
+                    tag: "NotDeprecated";
+                    value: undefined;
+                } | {
+                    tag: "DeprecatedWithoutNote";
+                    value: undefined;
+                } | {
+                    tag: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                };
+                name: string;
+                modifier: number;
+                type: {
+                    tag: "map";
+                    value: {
+                        hashers: ({
+                            tag: "Blake2128";
+                            value: undefined;
+                        } | {
+                            tag: "Blake2256";
+                            value: undefined;
+                        } | {
+                            tag: "Blake2128Concat";
+                            value: undefined;
+                        } | {
+                            tag: "Twox128";
+                            value: undefined;
+                        } | {
+                            tag: "Twox256";
+                            value: undefined;
+                        } | {
+                            tag: "Twox64Concat";
+                            value: undefined;
+                        } | {
+                            tag: "Identity";
+                            value: undefined;
+                        })[];
+                        key: number;
+                        value: number;
+                    };
+                } | {
+                    tag: "plain";
+                    value: number;
+                };
+                fallback: HexString;
+                docs: string[];
+            }[];
+        } | undefined;
+        calls: {
+            type: number;
+            deprecationInfo: {
+                index: number;
+                deprecation: {
+                    tag: "DeprecatedWithoutNote";
+                    value: undefined;
+                } | {
+                    tag: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                };
+            }[];
+        } | undefined;
+        events: {
+            type: number;
+            deprecationInfo: {
+                index: number;
+                deprecation: {
+                    tag: "DeprecatedWithoutNote";
+                    value: undefined;
+                } | {
+                    tag: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                };
+            }[];
+        } | undefined;
+        constants: {
+            name: string;
+            type: number;
+            value: HexString;
+            docs: string[];
+            deprecationInfo: {
+                tag: "NotDeprecated";
+                value: undefined;
+            } | {
+                tag: "DeprecatedWithoutNote";
+                value: undefined;
+            } | {
+                tag: "Deprecated";
+                value: {
+                    note: string;
+                    since: string | undefined;
+                };
+            };
+        }[];
+        errors: {
+            type: number;
+            deprecationInfo: {
+                index: number;
+                deprecation: {
+                    tag: "DeprecatedWithoutNote";
+                    value: undefined;
+                } | {
+                    tag: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                };
+            }[];
+        } | undefined;
+        associatedTypes: {
+            name: string;
+            type: number;
             docs: string[];
         }[];
-        errors: number | undefined;
+        viewFns: {
+            deprecationInfo: {
+                tag: "NotDeprecated";
+                value: undefined;
+            } | {
+                tag: "DeprecatedWithoutNote";
+                value: undefined;
+            } | {
+                tag: "Deprecated";
+                value: {
+                    note: string;
+                    since: string | undefined;
+                };
+            };
+            name: string;
+            inputs: {
+                name: string;
+                type: number;
+            }[];
+            output: number;
+            docs: string[];
+            id: HexString;
+        }[];
         index: number;
+        docs: string[];
+        deprecationInfo: {
+            tag: "NotDeprecated";
+            value: undefined;
+        } | {
+            tag: "DeprecatedWithoutNote";
+            value: undefined;
+        } | {
+            tag: "Deprecated";
+            value: {
+                note: string;
+                since: string | undefined;
+            };
+        };
     }[];
     extrinsic: {
-        type: number;
-        version: number;
+        version: number[];
+        address: number;
+        call: number;
+        signature: number;
+        signedExtensionsByVersion: [number, number[]][];
         signedExtensions: {
             identifier: string;
             type: number;
             additionalSigned: number;
         }[];
     };
-    type: number;
     apis: {
         name: string;
         methods: {
+            deprecationInfo: {
+                tag: "NotDeprecated";
+                value: undefined;
+            } | {
+                tag: "DeprecatedWithoutNote";
+                value: undefined;
+            } | {
+                tag: "Deprecated";
+                value: {
+                    note: string;
+                    since: string | undefined;
+                };
+            };
             name: string;
             inputs: {
                 name: string;
@@ -768,9 +1909,32 @@ declare const v14: scale_ts.Codec<{
             docs: string[];
         }[];
         docs: string[];
+        version: number;
+        deprecationInfo: {
+            tag: "NotDeprecated";
+            value: undefined;
+        } | {
+            tag: "DeprecatedWithoutNote";
+            value: undefined;
+        } | {
+            tag: "Deprecated";
+            value: {
+                note: string;
+                since: string | undefined;
+            };
+        };
     }[];
+    outerEnums: {
+        call: number;
+        event: number;
+        error: number;
+    };
+    custom: [string, {
+        type: number;
+        value: HexString;
+    }][];
 }>;
-type V14 = CodecType<typeof v14>;
+type V16 = CodecType<typeof v16>;
 
 declare const lookup: scale_ts.Codec<{
     id: number;
@@ -874,212 +2038,174 @@ declare const lookup: scale_ts.Codec<{
 }[]>;
 type V14Lookup = CodecType<typeof lookup>;
 
-declare const extrinsic: scale_ts.Codec<{
-    version: number;
-    address: number;
-    call: number;
-    signature: number;
-    extra: number;
-    signedExtensions: {
-        identifier: string;
-        type: number;
-        additionalSigned: number;
-    }[];
+declare const storageMap: scale_ts.Codec<{
+    hashers: ({
+        tag: "Blake2128";
+        value: undefined;
+    } | {
+        tag: "Blake2256";
+        value: undefined;
+    } | {
+        tag: "Blake2128Concat";
+        value: undefined;
+    } | {
+        tag: "Twox128";
+        value: undefined;
+    } | {
+        tag: "Twox256";
+        value: undefined;
+    } | {
+        tag: "Twox64Concat";
+        value: undefined;
+    } | {
+        tag: "Identity";
+        value: undefined;
+    })[];
+    key: number;
+    value: number;
 }>;
-type V15Extrinsic = CodecType<typeof extrinsic>;
-declare const v15: scale_ts.Codec<{
-    lookup: {
-        id: number;
-        path: string[];
-        params: {
-            name: string;
-            type: number | undefined;
-        }[];
-        def: {
-            tag: "composite";
-            value: {
-                name: string | undefined;
-                type: number;
-                typeName: string | undefined;
-                docs: string[];
-            }[];
-        } | {
-            tag: "variant";
-            value: {
-                name: string;
-                fields: {
-                    name: string | undefined;
-                    type: number;
-                    typeName: string | undefined;
-                    docs: string[];
-                }[];
-                index: number;
-                docs: string[];
-            }[];
-        } | {
-            tag: "sequence";
-            value: number;
-        } | {
-            tag: "array";
-            value: {
-                len: number;
-                type: number;
-            };
-        } | {
-            tag: "tuple";
-            value: number[];
-        } | {
-            tag: "primitive";
-            value: {
-                tag: "bool";
-                value: undefined;
-            } | {
-                tag: "char";
-                value: undefined;
-            } | {
-                tag: "str";
-                value: undefined;
-            } | {
-                tag: "u8";
-                value: undefined;
-            } | {
-                tag: "u16";
-                value: undefined;
-            } | {
-                tag: "u32";
-                value: undefined;
-            } | {
-                tag: "u64";
-                value: undefined;
-            } | {
-                tag: "u128";
-                value: undefined;
-            } | {
-                tag: "u256";
-                value: undefined;
-            } | {
-                tag: "i8";
-                value: undefined;
-            } | {
-                tag: "i16";
-                value: undefined;
-            } | {
-                tag: "i32";
-                value: undefined;
-            } | {
-                tag: "i64";
-                value: undefined;
-            } | {
-                tag: "i128";
-                value: undefined;
-            } | {
-                tag: "i256";
-                value: undefined;
-            };
-        } | {
-            tag: "compact";
-            value: number;
-        } | {
-            tag: "bitSequence";
-            value: {
-                bitStoreType: number;
-                bitOrderType: number;
-            };
+
+declare const itemDeprecation: scale_ts.Codec<{
+    tag: "NotDeprecated";
+    value: undefined;
+} | {
+    tag: "DeprecatedWithoutNote";
+    value: undefined;
+} | {
+    tag: "Deprecated";
+    value: {
+        note: string;
+        since: string | undefined;
+    };
+}>;
+declare const variantDeprecation: scale_ts.Codec<{
+    index: number;
+    deprecation: {
+        tag: "DeprecatedWithoutNote";
+        value: undefined;
+    } | {
+        tag: "Deprecated";
+        value: {
+            note: string;
+            since: string | undefined;
         };
-        docs: string[];
+    };
+}[]>;
+
+declare const viewFunction: scale_ts.Codec<{
+    deprecationInfo: {
+        tag: "NotDeprecated";
+        value: undefined;
+    } | {
+        tag: "DeprecatedWithoutNote";
+        value: undefined;
+    } | {
+        tag: "Deprecated";
+        value: {
+            note: string;
+            since: string | undefined;
+        };
+    };
+    name: string;
+    inputs: {
+        name: string;
+        type: number;
     }[];
-    pallets: {
-        docs: string[];
+    output: number;
+    docs: string[];
+    id: HexString;
+}>;
+
+type EnumRef<T> = ({
+    type: number;
+} & (T extends 16 ? {
+    deprecationInfo: CodecType<typeof variantDeprecation>;
+} : {})) | undefined;
+type DeprecationInfo<T> = T extends 16 ? {
+    deprecationInfo: CodecType<typeof itemDeprecation>;
+} : {};
+type UnifiedMetadata<T extends 14 | 15 | 16 = 14 | 15 | 16> = {
+    version: T;
+    lookup: V14Lookup;
+    pallets: Array<{
         name: string;
         storage: {
             prefix: string;
-            items: {
+            items: Array<{
                 name: string;
                 modifier: number;
                 type: {
-                    tag: "map";
-                    value: {
-                        hashers: ({
-                            tag: "Blake2128";
-                            value: undefined;
-                        } | {
-                            tag: "Blake2256";
-                            value: undefined;
-                        } | {
-                            tag: "Blake2128Concat";
-                            value: undefined;
-                        } | {
-                            tag: "Twox128";
-                            value: undefined;
-                        } | {
-                            tag: "Twox256";
-                            value: undefined;
-                        } | {
-                            tag: "Twox64Concat";
-                            value: undefined;
-                        } | {
-                            tag: "Identity";
-                            value: undefined;
-                        })[];
-                        key: number;
-                        value: number;
-                    };
-                } | {
                     tag: "plain";
                     value: number;
+                } | {
+                    tag: "map";
+                    value: CodecType<typeof storageMap>;
                 };
                 fallback: HexString;
                 docs: string[];
-            }[];
+            } & DeprecationInfo<T>>;
         } | undefined;
-        calls: number | undefined;
-        events: number | undefined;
-        constants: {
+        calls: EnumRef<T>;
+        events: EnumRef<T>;
+        constants: Array<{
             name: string;
             type: number;
             value: HexString;
             docs: string[];
-        }[];
-        errors: number | undefined;
+        } & DeprecationInfo<T>>;
+        errors: EnumRef<T>;
+        associatedTypes: Array<{
+            name: string;
+            type: number;
+            docs: string[];
+        }>;
+        viewFns: Array<CodecType<typeof viewFunction>>;
         index: number;
-    }[];
+        docs: string[];
+    } & DeprecationInfo<T>>;
     extrinsic: {
-        version: number;
-        address: number;
-        call: number;
-        signature: number;
-        extra: number;
-        signedExtensions: {
+        version: number[];
+        signedExtensions: Array<{
             identifier: string;
             type: number;
             additionalSigned: number;
-        }[];
-    };
-    type: number;
-    apis: {
+        }>;
+    } & (T extends 14 ? {
+        type: number;
+    } : {
+        address: number;
+        call: number;
+        signature: number;
+    }) & (T extends 16 ? {
+        signedExtensionsByVersion: Array<[number, number[]]>;
+    } : {});
+    apis: Array<{
         name: string;
-        methods: {
+        methods: Array<{
             name: string;
-            inputs: {
+            inputs: Array<{
                 name: string;
                 type: number;
-            }[];
+            }>;
             output: number;
             docs: string[];
-        }[];
+        } & DeprecationInfo<T>>;
         docs: string[];
-    }[];
+    } & (T extends 16 ? {
+        version: number;
+    } : {}) & DeprecationInfo<T>>;
+} & (T extends 14 ? {} : {
     outerEnums: {
         call: number;
         event: number;
         error: number;
     };
-    custom: [string, {
+    custom: Array<[string, {
         type: number;
         value: HexString;
-    }][];
-}>;
-type V15 = CodecType<typeof v15>;
+    }]>;
+});
+declare const unifyMetadata: (metadata: Metadata | Metadata["metadata"] | V14 | V15 | V16) => UnifiedMetadata;
 
 declare const Blake2256: (encoded: Uint8Array) => Uint8Array<ArrayBufferLike>;
 declare const Blake2128: (encoded: Uint8Array) => Uint8Array<ArrayBufferLike>;
@@ -1105,4 +2231,5 @@ declare const Storage: (pallet: string) => <A extends Array<EncoderWithHash<any>
     dec: (value: string) => { [K in keyof A]: A[K] extends EncoderWithHash<infer V> ? V : unknown; };
 };
 
-export { AccountId, Bin, Binary, type BitSequence, Blake2128, Blake2128Concat, Blake2256, Blake3256, Blake3256Concat, type BlockHeader, type EncoderWithHash, Enum, type EnumVariant, type ExtractEnumValue, FixedSizeBinary, type GetEnum, Hex, type HexString, Identity, type OpaqueKeyHash, type SS58AddressInfo, type SS58String, Self, Storage, Twox128, Twox256, Twox64Concat, type V14, type V14Extrinsic, type V14Lookup, type V15, type V15Extrinsic, Variant, _Enum, bitSequence, blockHeader, char, compactBn, compactNumber, decAnyMetadata, ethAccount, fixedStr, fromBufferToBase58, getMultisigAccountId, getSs58AddressInfo, h64, metadata, selfDecoder, selfEncoder, sortMultisigSignatories, v14, lookup as v14Lookup, v15 };
+export { AccountId, Bin, Binary, Blake2128, Blake2128Concat, Blake2256, Blake3256, Blake3256Concat, Enum, FixedSizeBinary, Hex, Identity, Option, Result, ScaleEnum, Self, Storage, Struct, Tuple, Twox128, Twox256, Twox64Concat, Variant, Vector, _Enum, bitSequence, blockHeader, char, compactBn, compactNumber, decAnyMetadata, ethAccount, fixedStr, fromBufferToBase58, getMultisigAccountId, getSs58AddressInfo, h64, metadata, selfDecoder, selfEncoder, sortMultisigSignatories, unifyMetadata, v14, lookup as v14Lookup, v15, v16 };
+export type { BitSequence, BlockHeader, EncoderWithHash, EnumVariant, ExtractEnumValue, GetEnum, HexString, Metadata, OpaqueKeyHash, SS58AddressInfo, SS58String, UnifiedMetadata, V14, V14Lookup, V15, V16 };