@polkadot/types-codec 8.5.2-5 → 8.5.2-6

package/base/Compact.d.ts

@@ -2,6 +2,10 @@
 import type { BN } from '@polkadot/util';
 import type { HexString } from '@polkadot/util/types';
 import type { AnyJson, AnyNumber, CodecClass, ICompact, Inspect, INumber, IU8a, Registry } from '../types';
+interface Options<T> {
+    definition?: CodecClass<T>;
+    setDefinition?: (d: CodecClass<T>) => CodecClass<T>;
+}
 /**
  * @name Compact
  * @description
@@ -15,8 +19,8 @@ export declare class Compact<T extends INumber> implements ICompact<T> {
     readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: Registry, Type: CodecClass<T> | string, value?: Compact<T> | AnyNumber);
-    static with<T extends INumber>(Type: CodecClass<T> | string): CodecClass<Compact<T>>;
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: Compact<T> | AnyNumber, { definition, setDefinition }?: Options<T>);
+    static with<O extends INumber>(Type: CodecClass<O> | string): CodecClass<Compact<O>>;
     /** @internal */
     static decodeCompact<T extends INumber>(registry: Registry, Type: CodecClass<T>, value: Compact<T> | AnyNumber): [T, number];
     /**
@@ -85,3 +89,4 @@ export declare class Compact<T extends INumber> implements ICompact<T> {
      */
     unwrap(): T;
 }
+export {};

package/base/Compact.js

@@ -2,6 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 import { compactFromU8a, compactToU8a, isU8a } from '@polkadot/util';
 import { typeToConstructor } from "../utils/index.js";
+
+function noopSetDefinition(d) {
+  return d;
+}
 /**
  * @name Compact
  * @description
@@ -11,22 +15,33 @@ import { typeToConstructor } from "../utils/index.js";
  * a number and making the compact representation thereof
  */
 
+
 export class Compact {
   #Type;
   #raw;
 
-  constructor(registry, Type, value = 0) {
+  constructor(registry, Type, value = 0, {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
     this.registry = registry;
-    this.#Type = typeToConstructor(registry, Type);
+    this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
     const [raw, decodedLength] = Compact.decodeCompact(registry, this.#Type, value);
     this.initialU8aLength = decodedLength;
     this.#raw = raw;
   }
 
   static with(Type) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Compact {
       constructor(registry, value) {
-        super(registry, Type, value);
+        super(registry, Type, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/base/Enum.d.ts

@@ -3,6 +3,20 @@ import type { AnyJson, Codec, CodecClass, IEnum, Inspect, IU8a, Registry } from
 export interface EnumCodecClass<T = Codec> {
     new (registry: Registry, value?: any, index?: number): T;
 }
+interface Definition {
+    def: TypesDef;
+    isBasic: boolean;
+    isIndexed: boolean;
+}
+interface EntryDef {
+    Type: CodecClass;
+    index: number;
+}
+declare type TypesDef = Record<string, EntryDef>;
+interface Options {
+    definition?: Definition;
+    setDefinition?: (d: Definition) => Definition;
+}
 /**
  * @name Enum
  * @description
@@ -14,7 +28,7 @@ export declare class Enum implements IEnum {
     readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: Registry, Types: Record<string, string | CodecClass> | Record<string, number> | string[], value?: unknown, index?: number);
+    constructor(registry: Registry, Types: Record<string, string | CodecClass> | Record<string, number> | string[], value?: unknown, index?: number, { definition, setDefinition }?: Options);
     static with(Types: Record<string, string | CodecClass> | Record<string, number> | string[]): EnumCodecClass<Enum>;
     /**
      * @description The length of the value when encoded as a Uint8Array
@@ -107,3 +121,4 @@ export declare class Enum implements IEnum {
      */
     toU8a(isBare?: boolean): Uint8Array;
 }
+export {};

package/base/Enum.js

@@ -4,6 +4,10 @@ import { assert, isCodec, isHex, isNumber, isObject, isString, isU8a, isUndefine
 import { mapToTypeMap, typesToMap } from "../utils/index.js";
 import { Null } from "./Null.js"; // export interface, this is used in Enum.with, so required as public by TS
 
+function noopSetDefinition(d) {
+  return d;
+}
+
 function isRustEnum(def) {
   const defValues = Object.values(def);
 
@@ -132,12 +136,15 @@ export class Enum {
   #isIndexed;
   #raw;
 
-  constructor(registry, Types, value, index) {
+  constructor(registry, Types, value, index, {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
     const {
       def,
       isBasic,
       isIndexed
-    } = extractDef(registry, Types); // shortcut isU8a as used in SCALE decoding
+    } = definition || setDefinition(extractDef(registry, Types)); // shortcut isU8a as used in SCALE decoding
 
     const decoded = isU8a(value) && value.length && !isNumber(index) ? createFromValue(registry, def, value[0], value.subarray(1)) : decodeEnum(registry, def, value, index);
     this.registry = registry;
@@ -166,9 +173,16 @@ export class Enum {
       isKeys[i] = `is${name}`;
     }
 
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Enum {
       constructor(registry, value, index) {
-        super(registry, Types, value, index);
+        super(registry, Types, value, index, {
+          definition,
+          setDefinition
+        });
         objectProperties(this, isKeys, (_, i) => this.type === keys[i]);
         objectProperties(this, asKeys, (k, i) => {
           assert(this[isKeys[i]], () => `Cannot convert '${this.type}' via ${k}`);

package/base/Option.d.ts

@@ -1,5 +1,9 @@
 import type { HexString } from '@polkadot/util/types';
 import type { AnyJson, Codec, CodecClass, Inspect, IOption, IU8a, Registry } from '../types';
+interface Options<T> {
+    definition?: CodecClass<T>;
+    setDefinition?: (d: CodecClass<T>) => CodecClass<T>;
+}
 /**
  * @name Option
  * @description
@@ -12,7 +16,7 @@ export declare class Option<T extends Codec> implements IOption<T> {
     #private;
     readonly registry: Registry;
     createdAtHash?: IU8a;
-    constructor(registry: Registry, typeName: CodecClass<T> | string, value?: unknown);
+    constructor(registry: Registry, typeName: CodecClass<T> | string, value?: unknown, { definition, setDefinition }?: Options<T>);
     static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Option<O>>;
     /**
      * @description The length of the value when encoded as a Uint8Array
@@ -90,3 +94,4 @@ export declare class Option<T extends Codec> implements IOption<T> {
      */
     unwrapOrDefault(): T;
 }
+export {};

package/base/Option.js

@@ -4,6 +4,10 @@ import { assert, isCodec, isNull, isU8a, isUndefined, u8aToHex } from '@polkadot
 import { typeToConstructor } from "../utils/index.js";
 import { Null } from "./Null.js";
 
+function noopSetDefinition(d) {
+  return d;
+}
+
 class None extends Null {
   /**
    * @description Returns the base runtime type name for this instance
@@ -50,8 +54,11 @@ export class Option {
   #initialU8aLength;
   #raw;
 
-  constructor(registry, typeName, value) {
-    const Type = typeToConstructor(registry, typeName);
+  constructor(registry, typeName, value, {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
+    const Type = definition || setDefinition(typeToConstructor(registry, typeName));
     const decoded = isU8a(value) && value.length && !isCodec(value) ? value[0] === 0 ? new None(registry) : new Type(registry, value.subarray(1)) : decodeOption(registry, Type, value);
     this.registry = registry;
     this.#Type = Type;
@@ -63,9 +70,19 @@ export class Option {
   }
 
   static with(Type) {
+    let definition;
+
+    const setDefinition = d => {
+      definition = d;
+      return d;
+    };
+
     return class extends Option {
       constructor(registry, value) {
-        super(registry, Type, value);
+        super(registry, Type, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/base/Tuple.d.ts

@@ -1,9 +1,16 @@
 import type { AnyTupleValue, Codec, CodecClass, Inspect, ITuple, Registry } from '../types';
 import { AbstractArray } from '../abstract/AbstractArray';
+declare type TupleCodecClass = CodecClass[] | {
+    [index: string]: CodecClass;
+};
 declare type TupleType = (CodecClass | string);
 declare type TupleTypes = TupleType[] | {
     [index: string]: CodecClass | string;
 };
+interface Options {
+    definition?: TupleCodecClass;
+    setDefinition?: (d: TupleCodecClass) => TupleCodecClass;
+}
 /**
  * @name Tuple
  * @description
@@ -12,7 +19,7 @@ declare type TupleTypes = TupleType[] | {
  */
 export declare class Tuple extends AbstractArray<Codec> implements ITuple<Codec[]> {
     #private;
-    constructor(registry: Registry, Types: TupleTypes | TupleType, value?: AnyTupleValue);
+    constructor(registry: Registry, Types: TupleTypes | TupleType, value?: AnyTupleValue, { definition, setDefinition }?: Options);
     static with(Types: TupleTypes | TupleType): CodecClass<Tuple>;
     /**
      * @description The length of the value when encoded as a Uint8Array

package/base/Tuple.js

@@ -4,7 +4,12 @@ import { isFunction, isHex, isString, isU8a, stringify, u8aConcat, u8aToU8a } fr
 import { AbstractArray } from "../abstract/AbstractArray.js";
 import { decodeU8a, mapToTypeMap, typeToConstructor } from "../utils/index.js";
 
+function noopSetDefinition(d) {
+  return d;
+}
 /** @internal */
+
+
 function decodeTuple(registry, Classes, value) {
   if (isU8a(value) || isHex(value)) {
     return decodeU8a(registry, u8aToU8a(value), Classes);
@@ -36,17 +41,27 @@ function decodeTuple(registry, Classes, value) {
 export class Tuple extends AbstractArray {
   #Types;
 
-  constructor(registry, Types, value) {
-    const Classes = Array.isArray(Types) ? Types.map(t => typeToConstructor(registry, t)) : isFunction(Types) || isString(Types) ? [typeToConstructor(registry, Types)] : mapToTypeMap(registry, Types);
+  constructor(registry, Types, value, {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
+    const Classes = definition || setDefinition(Array.isArray(Types) ? Types.map(t => typeToConstructor(registry, t)) : isFunction(Types) || isString(Types) ? [typeToConstructor(registry, Types)] : mapToTypeMap(registry, Types));
     const [values, decodedLength] = isU8a(value) ? decodeU8a(registry, value, Classes) : decodeTuple(registry, Classes, value);
     super(registry, values, decodedLength);
     this.#Types = Classes;
   }
 
   static with(Types) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Tuple {
       constructor(registry, value) {
-        super(registry, Types, value);
+        super(registry, Types, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/base/Vec.d.ts

@@ -1,6 +1,10 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Codec, CodecClass, Registry } from '../types';
 import { AbstractArray } from '../abstract/AbstractArray';
+interface Options<T> {
+    definition?: CodecClass<T>;
+    setDefinition?: (d: CodecClass<T>) => CodecClass<T>;
+}
 export declare function decodeVec<T extends Codec>(registry: Registry, Type: CodecClass<T>, value: Uint8Array | HexString | unknown[], length?: number): [T[], number, number];
 /**
  * @name Vec
@@ -11,7 +15,7 @@ export declare function decodeVec<T extends Codec>(registry: Registry, Type: Cod
  */
 export declare class Vec<T extends Codec> extends AbstractArray<T> {
     #private;
-    constructor(registry: Registry, Type: CodecClass<T> | string, value?: Uint8Array | HexString | unknown[]);
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: Uint8Array | HexString | unknown[], { definition, setDefinition }?: Options<T>);
     static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Vec<O>>;
     /**
      * @description The type for the items
@@ -26,3 +30,4 @@ export declare class Vec<T extends Codec> extends AbstractArray<T> {
      */
     toRawType(): string;
 }
+export {};

package/base/Vec.js

@@ -5,6 +5,11 @@ import { AbstractArray } from "../abstract/AbstractArray.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 const MAX_LENGTH = 64 * 1024;
 const l = logger('Vec');
+
+function noopSetDefinition(d) {
+  return d;
+}
+
 export function decodeVec(registry, Type, value, length = -1) {
   if (Array.isArray(value)) {
     const result = new Array(value.length);
@@ -46,17 +51,27 @@ export function decodeVec(registry, Type, value, length = -1) {
 export class Vec extends AbstractArray {
   #Type;
 
-  constructor(registry, Type, value = []) {
-    const Clazz = typeToConstructor(registry, Type);
+  constructor(registry, Type, value = [], {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
+    const Clazz = definition || setDefinition(typeToConstructor(registry, Type));
     const [values, decodedLength] = decodeVec(registry, Clazz, value);
     super(registry, values, decodedLength);
     this.#Type = Clazz;
   }
 
   static with(Type) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Vec {
       constructor(registry, value) {
-        super(registry, Type, value);
+        super(registry, Type, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/base/VecFixed.d.ts

@@ -1,6 +1,10 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Codec, CodecClass, Inspect, Registry } from '../types';
 import { AbstractArray } from '../abstract/AbstractArray';
+interface Options<T> {
+    definition?: CodecClass<T>;
+    setDefinition?: (d: CodecClass<T>) => CodecClass<T>;
+}
 /**
  * @name VecFixed
  * @description
@@ -8,7 +12,7 @@ import { AbstractArray } from '../abstract/AbstractArray';
  */
 export declare class VecFixed<T extends Codec> extends AbstractArray<T> {
     #private;
-    constructor(registry: Registry, Type: CodecClass<T> | string, length: number, value?: Uint8Array | HexString | unknown[]);
+    constructor(registry: Registry, Type: CodecClass<T> | string, length: number, value?: Uint8Array | HexString | unknown[], { definition, setDefinition }?: Options<T>);
     static with<O extends Codec>(Type: CodecClass<O> | string, length: number): CodecClass<VecFixed<O>>;
     /**
      * @description The type for the items
@@ -28,3 +32,4 @@ export declare class VecFixed<T extends Codec> extends AbstractArray<T> {
      */
     toRawType(): string;
 }
+export {};

package/base/VecFixed.js

@@ -4,8 +4,13 @@ import { assert, isU8a, u8aConcat } from '@polkadot/util';
 import { AbstractArray } from "../abstract/AbstractArray.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 import { decodeVec } from "./Vec.js";
+
+function noopSetDefinition(d) {
+  return d;
+}
 /** @internal */
 
+
 function decodeVecFixed(registry, value, Type, length) {
   const [values, decodedLength, decodedLengthNoOffset] = decodeVec(registry, Type, value, length);
 
@@ -26,17 +31,27 @@ function decodeVecFixed(registry, value, Type, length) {
 export class VecFixed extends AbstractArray {
   #Type;
 
-  constructor(registry, Type, length, value = []) {
-    const Clazz = typeToConstructor(registry, Type);
+  constructor(registry, Type, length, value = [], {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
+    const Clazz = definition || setDefinition(typeToConstructor(registry, Type));
     const [values,, decodedLengthNoOffset] = isU8a(value) ? decodeU8aVec(registry, value, 0, Clazz, length) : decodeVecFixed(registry, value, Clazz, length);
     super(registry, values, decodedLengthNoOffset);
     this.#Type = Clazz;
   }
 
   static with(Type, length) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends VecFixed {
       constructor(registry, value) {
-        super(registry, Type, length, value);
+        super(registry, Type, length, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/base/Compact.js

@@ -11,7 +11,9 @@ var _utils = require("../utils");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-
+function noopSetDefinition(d) {
+  return d;
+}
 /**
  * @name Compact
  * @description
@@ -20,23 +22,36 @@ var _utils = require("../utils");
  * used by other types to add length-prefixed encoding, or in the case of wrapped types, taking
  * a number and making the compact representation thereof
  */
+
+
 class Compact {
   #Type;
   #raw;
 
   constructor(registry, Type) {
     let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
     this.registry = registry;
-    this.#Type = (0, _utils.typeToConstructor)(registry, Type);
+    this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
     const [raw, decodedLength] = Compact.decodeCompact(registry, this.#Type, value);
     this.initialU8aLength = decodedLength;
     this.#raw = raw;
   }
 
   static with(Type) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Compact {
       constructor(registry, value) {
-        super(registry, Type, value);
+        super(registry, Type, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/base/Enum.js

@@ -13,6 +13,10 @@ var _Null = require("./Null");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+function noopSetDefinition(d) {
+  return d;
+}
+
 function isRustEnum(def) {
   const defValues = Object.values(def);
 
@@ -147,11 +151,15 @@ class Enum {
   #raw;
 
   constructor(registry, Types, value, index) {
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
     const {
       def,
       isBasic,
       isIndexed
-    } = extractDef(registry, Types); // shortcut isU8a as used in SCALE decoding
+    } = definition || setDefinition(extractDef(registry, Types)); // shortcut isU8a as used in SCALE decoding
 
     const decoded = (0, _util.isU8a)(value) && value.length && !(0, _util.isNumber)(index) ? createFromValue(registry, def, value[0], value.subarray(1)) : decodeEnum(registry, def, value, index);
     this.registry = registry;
@@ -183,9 +191,16 @@ class Enum {
       isKeys[i] = `is${name}`;
     }
 
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Enum {
       constructor(registry, value, index) {
-        super(registry, Types, value, index);
+        super(registry, Types, value, index, {
+          definition,
+          setDefinition
+        });
         (0, _util.objectProperties)(this, isKeys, (_, i) => this.type === keys[i]);
         (0, _util.objectProperties)(this, asKeys, (k, i) => {
           (0, _util.assert)(this[isKeys[i]], () => `Cannot convert '${this.type}' via ${k}`);

package/cjs/base/Option.js

@@ -13,6 +13,10 @@ var _Null = require("./Null");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+function noopSetDefinition(d) {
+  return d;
+}
+
 class None extends _Null.Null {
   /**
    * @description Returns the base runtime type name for this instance
@@ -60,7 +64,11 @@ class Option {
   #raw;
 
   constructor(registry, typeName, value) {
-    const Type = (0, _utils.typeToConstructor)(registry, typeName);
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, typeName));
     const decoded = (0, _util.isU8a)(value) && value.length && !(0, _util.isCodec)(value) ? value[0] === 0 ? new None(registry) : new Type(registry, value.subarray(1)) : decodeOption(registry, Type, value);
     this.registry = registry;
     this.#Type = Type;
@@ -72,9 +80,19 @@ class Option {
   }
 
   static with(Type) {
+    let definition;
+
+    const setDefinition = d => {
+      definition = d;
+      return d;
+    };
+
     return class extends Option {
       constructor(registry, value) {
-        super(registry, Type, value);
+        super(registry, Type, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/base/Tuple.js

@@ -13,8 +13,12 @@ var _utils = require("../utils");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-
+function noopSetDefinition(d) {
+  return d;
+}
 /** @internal */
+
+
 function decodeTuple(registry, Classes, value) {
   if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
     return (0, _utils.decodeU8a)(registry, (0, _util.u8aToU8a)(value), Classes);
@@ -47,16 +51,27 @@ class Tuple extends _AbstractArray.AbstractArray {
   #Types;
 
   constructor(registry, Types, value) {
-    const Classes = Array.isArray(Types) ? Types.map(t => (0, _utils.typeToConstructor)(registry, t)) : (0, _util.isFunction)(Types) || (0, _util.isString)(Types) ? [(0, _utils.typeToConstructor)(registry, Types)] : (0, _utils.mapToTypeMap)(registry, Types);
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const Classes = definition || setDefinition(Array.isArray(Types) ? Types.map(t => (0, _utils.typeToConstructor)(registry, t)) : (0, _util.isFunction)(Types) || (0, _util.isString)(Types) ? [(0, _utils.typeToConstructor)(registry, Types)] : (0, _utils.mapToTypeMap)(registry, Types));
     const [values, decodedLength] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, value, Classes) : decodeTuple(registry, Classes, value);
     super(registry, values, decodedLength);
     this.#Types = Classes;
   }
 
   static with(Types) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Tuple {
       constructor(registry, value) {
-        super(registry, Types, value);
+        super(registry, Types, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/base/Vec.js

@@ -17,6 +17,10 @@ var _utils = require("../utils");
 const MAX_LENGTH = 64 * 1024;
 const l = (0, _util.logger)('Vec');
 
+function noopSetDefinition(d) {
+  return d;
+}
+
 function decodeVec(registry, Type, value) {
   let length = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
 
@@ -63,16 +67,27 @@ class Vec extends _AbstractArray.AbstractArray {
 
   constructor(registry, Type) {
     let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-    const Clazz = (0, _utils.typeToConstructor)(registry, Type);
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const Clazz = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
     const [values, decodedLength] = decodeVec(registry, Clazz, value);
     super(registry, values, decodedLength);
     this.#Type = Clazz;
   }
 
   static with(Type) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Vec {
       constructor(registry, value) {
-        super(registry, Type, value);
+        super(registry, Type, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/base/VecFixed.js

@@ -15,8 +15,12 @@ var _Vec = require("./Vec");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-
+function noopSetDefinition(d) {
+  return d;
+}
 /** @internal */
+
+
 function decodeVecFixed(registry, value, Type, length) {
   const [values, decodedLength, decodedLengthNoOffset] = (0, _Vec.decodeVec)(registry, Type, value, length);
 
@@ -39,16 +43,27 @@ class VecFixed extends _AbstractArray.AbstractArray {
 
   constructor(registry, Type, length) {
     let value = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
-    const Clazz = (0, _utils.typeToConstructor)(registry, Type);
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    const Clazz = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
     const [values,, decodedLengthNoOffset] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8aVec)(registry, value, 0, Clazz, length) : decodeVecFixed(registry, value, Clazz, length);
     super(registry, values, decodedLengthNoOffset);
     this.#Type = Clazz;
   }
 
   static with(Type, length) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends VecFixed {
       constructor(registry, value) {
-        super(registry, Type, length, value);
+        super(registry, Type, length, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/native/Struct.js

@@ -11,8 +11,12 @@ var _utils = require("../utils");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-
+function noopSetDefinition(d) {
+  return d;
+}
 /** @internal */
+
+
 function decodeStructFromObject(registry, Types, value, jsonMap) {
   let jsonObj;
   const inputKeys = Object.keys(Types);
@@ -84,7 +88,11 @@ class Struct extends Map {
 
   constructor(registry, Types, value) {
     let jsonMap = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Map();
-    const typeMap = (0, _utils.mapToTypeMap)(registry, Types);
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    const typeMap = definition || setDefinition((0, _utils.mapToTypeMap)(registry, Types));
     const [decoded, decodedLength] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, value, typeMap, true) : (0, _util.isHex)(value) ? (0, _utils.decodeU8a)(registry, (0, _util.u8aToU8a)(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
     super(decoded);
     this.#registry = registry;
@@ -95,9 +103,16 @@ class Struct extends Map {
 
   static with(Types, jsonMap) {
     const keys = Object.keys(Types);
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Struct {
       constructor(registry, value) {
-        super(registry, Types, value, jsonMap);
+        super(registry, Types, value, jsonMap, {
+          definition,
+          setDefinition
+        });
         (0, _util.objectProperties)(this, keys, k => this.get(k));
       }
 

package/cjs/packageInfo.js

@@ -11,6 +11,6 @@ const packageInfo = {
   name: '@polkadot/types-codec',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '8.5.2-5'
+  version: '8.5.2-6'
 };
 exports.packageInfo = packageInfo;

package/native/Struct.d.ts

@@ -1,6 +1,10 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, BareOpts, Codec, CodecClass, Inspect, IStruct, IU8a, Registry } from '../types';
+import type { AnyJson, BareOpts, Codec, CodecClass, CodecClassDef, Inspect, IStruct, IU8a, Registry } from '../types';
 declare type TypesDef<T = Codec> = Record<string, string | CodecClass<T>>;
+interface Options {
+    definition?: CodecClassDef;
+    setDefinition?: (d: CodecClassDef) => CodecClassDef;
+}
 /**
  * @name Struct
  * @description
@@ -23,7 +27,7 @@ export declare class Struct<S extends TypesDef = TypesDef, V extends {
     #private;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: Registry, Types: S, value?: V | Map<unknown, unknown> | unknown[] | HexString | null, jsonMap?: Map<string, string>);
+    constructor(registry: Registry, Types: S, value?: V | Map<unknown, unknown> | unknown[] | HexString | null, jsonMap?: Map<string, string>, { definition, setDefinition }?: Options);
     static with<S extends TypesDef>(Types: S, jsonMap?: Map<string, string>): CodecClass<Struct<S>>;
     /**
      * @description The available keys for this struct

package/native/Struct.js

@@ -3,7 +3,12 @@
 import { assert, isBoolean, isFunction, isHex, isObject, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, u8aConcat, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { compareMap, decodeU8a, mapToTypeMap, typesToMap } from "../utils/index.js";
 
+function noopSetDefinition(d) {
+  return d;
+}
 /** @internal */
+
+
 function decodeStructFromObject(registry, Types, value, jsonMap) {
   let jsonObj;
   const inputKeys = Object.keys(Types);
@@ -73,8 +78,11 @@ export class Struct extends Map {
   #jsonMap;
   #Types;
 
-  constructor(registry, Types, value, jsonMap = new Map()) {
-    const typeMap = mapToTypeMap(registry, Types);
+  constructor(registry, Types, value, jsonMap = new Map(), {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
+    const typeMap = definition || setDefinition(mapToTypeMap(registry, Types));
     const [decoded, decodedLength] = isU8a(value) ? decodeU8a(registry, value, typeMap, true) : isHex(value) ? decodeU8a(registry, u8aToU8a(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
     super(decoded);
     this.#registry = registry;
@@ -85,9 +93,16 @@ export class Struct extends Map {
 
   static with(Types, jsonMap) {
     const keys = Object.keys(Types);
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Struct {
       constructor(registry, value) {
-        super(registry, Types, value, jsonMap);
+        super(registry, Types, value, jsonMap, {
+          definition,
+          setDefinition
+        });
         objectProperties(this, keys, k => this.get(k));
       }
 

package/package.json

@@ -20,7 +20,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "8.5.2-5",
+  "version": "8.5.2-6",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",

package/packageInfo.js

@@ -5,5 +5,5 @@ export const packageInfo = {
   name: '@polkadot/types-codec',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '8.5.2-5'
+  version: '8.5.2-6'
 };