@polkadot/types-codec 7.4.1 → 7.4.2-11

package/abstract/AbstractArray.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecRegistry, IU8a, IVec } from '../types';
+import type { AnyJson, Codec, IU8a, IVec, Registry } from '../types';
 /**
  * @name AbstractArray
  * @description
@@ -8,10 +8,10 @@ import type { AnyJson, Codec, CodecRegistry, IU8a, IVec } from '../types';
  * @noInheritDoc
  */
 export declare abstract class AbstractArray<T extends Codec> extends Array<T> implements IVec<T> {
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    protected constructor(registry: CodecRegistry, values: T[], initialU8aLength?: number);
+    protected constructor(registry: Registry, values: T[], initialU8aLength?: number);
     /**
      * @description The length of the value when encoded as a Uint8Array
      */

package/abstract/AbstractInt.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import type { HexString } from '@polkadot/util/types';
-import type { AnyNumber, CodecRegistry, INumber, IU8a, UIntBitLength } from '../types';
+import type { AnyNumber, INumber, IU8a, Registry, UIntBitLength } from '../types';
 import { BN } from '@polkadot/util';
 export declare const DEFAULT_UINT_BITS = 64;
 /**
@@ -10,10 +10,10 @@ export declare const DEFAULT_UINT_BITS = 64;
  */
 export declare abstract class AbstractInt extends BN implements INumber {
     #private;
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly encodedLength: number;
-    constructor(registry: CodecRegistry, value?: AnyNumber, bitLength?: UIntBitLength, isSigned?: boolean);
+    constructor(registry: Registry, value?: AnyNumber, bitLength?: UIntBitLength, isSigned?: boolean);
     /**
      * @description returns a hash of the contents
      */

package/base/Base.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, BareOpts, Codec, CodecRegistry, IU8a } from '../types';
+import type { AnyJson, BareOpts, Codec, IU8a, Registry } from '../types';
 /**
  * @name Base
  * @description A type extends the Base class, when it holds a value
@@ -8,7 +8,7 @@ export declare abstract class Base<T extends Codec> implements Codec {
     #private;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    protected constructor(registry: CodecRegistry, value: T, initialU8aLength?: number);
+    protected constructor(registry: Registry, value: T, initialU8aLength?: number);
     /**
      * @description The length of the value when encoded as a Uint8Array
      */
@@ -22,7 +22,7 @@ export declare abstract class Base<T extends Codec> implements Codec {
      * @description Checks if the value is an empty value
      */
     get isEmpty(): boolean;
-    get registry(): CodecRegistry;
+    get registry(): Registry;
     /**
      * @description Compares the value of the input to see if there is a match
      */

package/base/Compact.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import type { BN } from '@polkadot/util';
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, AnyNumber, CodecClass, CodecRegistry, ICompact, INumber, IU8a } from '../types';
+import type { AnyJson, AnyNumber, CodecClass, ICompact, INumber, IU8a, Registry } from '../types';
 /**
  * @name Compact
  * @description
@@ -12,13 +12,13 @@ import type { AnyJson, AnyNumber, CodecClass, CodecRegistry, ICompact, INumber,
  */
 export declare class Compact<T extends INumber> implements ICompact<T> {
     #private;
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, value?: Compact<T> | AnyNumber);
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: Compact<T> | AnyNumber);
     static with<T extends INumber>(Type: CodecClass<T> | string): CodecClass<Compact<T>>;
     /** @internal */
-    static decodeCompact<T extends INumber>(registry: CodecRegistry, Type: CodecClass<T>, value: Compact<T> | AnyNumber): [T, number];
+    static decodeCompact<T extends INumber>(registry: Registry, Type: CodecClass<T>, value: Compact<T> | AnyNumber): [T, number];
     /**
      * @description The length of the value when encoded as a Uint8Array
      */

package/base/DoNotConstruct.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, CodecRegistry, IU8a } from '../types';
+import type { AnyJson, Codec, CodecClass, IU8a, Registry } from '../types';
 /**
  * @name DoNotConstruct
  * @description
@@ -7,9 +7,9 @@ import type { AnyJson, Codec, CodecClass, CodecRegistry, IU8a } from '../types';
  */
 export declare class DoNotConstruct implements Codec {
     #private;
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
-    constructor(registry: CodecRegistry, typeName?: string);
+    constructor(registry: Registry, typeName?: string);
     static with(typeName?: string): CodecClass;
     /**
      * @description The length of the value when encoded as a Uint8Array

package/base/Enum.d.ts

@@ -1,7 +1,7 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, CodecRegistry, IEnum, IU8a } from '../types';
+import type { AnyJson, Codec, CodecClass, IEnum, IU8a, Registry } from '../types';
 export interface EnumCodecClass<T = Codec> {
-    new (registry: CodecRegistry, value?: any, index?: number): T;
+    new (registry: Registry, value?: any, index?: number): T;
 }
 /**
  * @name Enum
@@ -11,10 +11,10 @@ export interface EnumCodecClass<T = Codec> {
  */
 export declare class Enum implements IEnum {
     #private;
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: CodecRegistry, 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);
     static with(Types: Record<string, string | CodecClass> | Record<string, number> | string[]): EnumCodecClass<Enum>;
     /**
      * @description The length of the value when encoded as a Uint8Array

package/base/Int.d.ts

@@ -1,4 +1,4 @@
-import type { AnyNumber, CodecClass, CodecRegistry, UIntBitLength } from '../types';
+import type { AnyNumber, CodecClass, Registry, UIntBitLength } from '../types';
 import { AbstractInt } from '../abstract/AbstractInt';
 /**
  * @name Int
@@ -11,6 +11,6 @@ import { AbstractInt } from '../abstract/AbstractInt';
  * @noInheritDoc
  */
 export declare class Int extends AbstractInt {
-    constructor(registry: CodecRegistry, value?: AnyNumber, bitLength?: UIntBitLength);
+    constructor(registry: Registry, value?: AnyNumber, bitLength?: UIntBitLength);
     static with(bitLength: UIntBitLength, typeName?: string): CodecClass<Int>;
 }

package/base/Null.d.ts

@@ -1,15 +1,15 @@
 import type { HexString } from '@polkadot/util/types';
-import type { Codec, CodecRegistry, IU8a } from '../types';
+import type { Codec, IU8a, Registry } from '../types';
 /**
  * @name Null
  * @description
  * Implements a type that does not contain anything (apart from `null`)
  */
 export declare class Null implements Codec {
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength = 0;
-    constructor(registry: CodecRegistry);
+    constructor(registry: Registry);
     /**
      * @description The length of the value when encoded as a Uint8Array
      */

package/base/Option.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, CodecRegistry, IOption, IU8a } from '../types';
+import type { AnyJson, Codec, CodecClass, IOption, IU8a, Registry } from '../types';
 /**
  * @name Option
  * @description
@@ -10,9 +10,9 @@ import type { AnyJson, Codec, CodecClass, CodecRegistry, IOption, IU8a } from '.
  */
 export declare class Option<T extends Codec> implements IOption<T> {
     #private;
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
-    constructor(registry: CodecRegistry, typeName: CodecClass<T> | string, value?: unknown);
+    constructor(registry: Registry, typeName: CodecClass<T> | string, value?: unknown);
     static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Option<O>>;
     /**
      * @description The length of the value when encoded as a Uint8Array

package/base/Result.d.ts

@@ -1,4 +1,4 @@
-import type { Codec, CodecClass, CodecRegistry, IResult } from '../types';
+import type { Codec, CodecClass, IResult, Registry } from '../types';
 import { Enum } from './Enum';
 /**
  * @name Result
@@ -6,7 +6,7 @@ import { Enum } from './Enum';
  * A Result maps to the Rust Result type, that can either wrap a success or error value
  */
 export declare class Result<O extends Codec, E extends Codec> extends Enum implements IResult<O, E> {
-    constructor(registry: CodecRegistry, Ok: CodecClass<O> | string, Err: CodecClass<E> | string, value?: unknown);
+    constructor(registry: Registry, Ok: CodecClass<O> | string, Err: CodecClass<E> | string, value?: unknown);
     static with<O extends Codec, E extends Codec>(Types: {
         Ok: CodecClass<O> | string;
         Err: CodecClass<E> | string;

package/base/Tuple.d.ts

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

package/base/Vec.d.ts

@@ -1,7 +1,7 @@
 import type { HexString } from '@polkadot/util/types';
-import type { Codec, CodecClass, CodecRegistry } from '../types';
+import type { Codec, CodecClass, Registry } from '../types';
 import { AbstractArray } from '../abstract/AbstractArray';
-export declare function decodeVec<T extends Codec>(registry: CodecRegistry, Type: CodecClass<T>, value: Uint8Array | HexString | unknown[], length?: number): [T[], number, number];
+export declare function decodeVec<T extends Codec>(registry: Registry, Type: CodecClass<T>, value: Uint8Array | HexString | unknown[], length?: number): [T[], number, number];
 /**
  * @name Vec
  * @description
@@ -11,7 +11,7 @@ export declare function decodeVec<T extends Codec>(registry: CodecRegistry, Type
  */
 export declare class Vec<T extends Codec> extends AbstractArray<T> {
     #private;
-    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, value?: Uint8Array | HexString | unknown[]);
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: Uint8Array | HexString | unknown[]);
     static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Vec<O>>;
     /**
      * @description The type for the items

package/base/VecFixed.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { Codec, CodecClass, CodecRegistry } from '../types';
+import type { Codec, CodecClass, Registry } from '../types';
 import { AbstractArray } from '../abstract/AbstractArray';
 /**
  * @name VecFixed
@@ -8,7 +8,7 @@ import { AbstractArray } from '../abstract/AbstractArray';
  */
 export declare class VecFixed<T extends Codec> extends AbstractArray<T> {
     #private;
-    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, length: number, value?: Uint8Array | HexString | unknown[]);
+    constructor(registry: Registry, Type: CodecClass<T> | string, length: number, value?: Uint8Array | HexString | unknown[]);
     static with<O extends Codec>(Type: CodecClass<O> | string, length: number): CodecClass<VecFixed<O>>;
     /**
      * @description The type for the items

package/extended/BTreeSet.d.ts

@@ -1,11 +1,11 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, CodecRegistry, ISet, IU8a } from '../types';
+import type { AnyJson, Codec, CodecClass, ISet, IU8a, Registry } from '../types';
 export declare class BTreeSet<V extends Codec = Codec> extends Set<V> implements ISet<V> {
     #private;
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: CodecRegistry, valType: CodecClass<V> | string, rawValue?: Uint8Array | string | string[] | Set<any>);
+    constructor(registry: Registry, valType: CodecClass<V> | string, rawValue?: Uint8Array | string | string[] | Set<any>);
     static with<V extends Codec>(valType: CodecClass<V> | string): CodecClass<BTreeSet<V>>;
     /**
      * @description The length of the value when encoded as a Uint8Array

package/extended/BitVec.d.ts

@@ -1,4 +1,4 @@
-import type { AnyU8a, CodecRegistry } from '../types';
+import type { AnyU8a, Registry } from '../types';
 import { Raw } from '../native/Raw';
 /**
  * @name BitVec
@@ -8,7 +8,7 @@ import { Raw } from '../native/Raw';
  */
 export declare class BitVec extends Raw {
     #private;
-    constructor(registry: CodecRegistry, value?: AnyU8a);
+    constructor(registry: Registry, value?: AnyU8a);
     /**
      * @description The length of the value when encoded as a Uint8Array
      */

package/extended/Bytes.d.ts

@@ -1,4 +1,4 @@
-import type { AnyU8a, CodecRegistry } from '../types';
+import type { AnyU8a, Registry } from '../types';
 import { Raw } from '../native/Raw';
 /**
  * @name Bytes
@@ -8,7 +8,7 @@ import { Raw } from '../native/Raw';
  * as what is found in [[Text]] and [[Vec]])
  */
 export declare class Bytes extends Raw {
-    constructor(registry: CodecRegistry, value?: AnyU8a);
+    constructor(registry: Registry, value?: AnyU8a);
     /**
      * @description The length of the value when encoded as a Uint8Array
      */

package/extended/Linkage.d.ts

@@ -1,4 +1,4 @@
-import type { Codec, CodecClass, CodecRegistry } from '../types';
+import type { Codec, CodecClass, Registry } from '../types';
 import { Option } from '../base/Option';
 import { Tuple } from '../base/Tuple';
 import { Struct } from '../native/Struct';
@@ -8,7 +8,7 @@ declare type TypeWithValues = [CodecClass, any[]];
  * @description The wrapper for the result from a LinkedMap
  */
 export declare class Linkage<T extends Codec> extends Struct {
-    constructor(registry: CodecRegistry, Type: CodecClass | string, value?: unknown);
+    constructor(registry: Registry, Type: CodecClass | string, value?: unknown);
     static withKey<O extends Codec>(Type: CodecClass | string): CodecClass<Linkage<O>>;
     get previous(): Option<T>;
     get next(): Option<T>;
@@ -26,6 +26,6 @@ export declare class Linkage<T extends Codec> extends Struct {
  * @description A Linkage keys/Values tuple
  */
 export declare class LinkageResult extends Tuple {
-    constructor(registry: CodecRegistry, [TypeKey, keys]: TypeWithValues, [TypeValue, values]: TypeWithValues);
+    constructor(registry: Registry, [TypeKey, keys]: TypeWithValues, [TypeValue, values]: TypeWithValues);
 }
 export {};

package/extended/Map.d.ts

@@ -1,11 +1,11 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, CodecRegistry, IMap, IU8a } from '../types';
+import type { AnyJson, Codec, CodecClass, IMap, IU8a, Registry } from '../types';
 export declare class CodecMap<K extends Codec = Codec, V extends Codec = Codec> extends Map<K, V> implements IMap<K, V> {
     #private;
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: CodecRegistry, keyType: CodecClass<K> | string, valType: CodecClass<V> | string, rawValue: Uint8Array | string | Map<any, any> | undefined, type?: 'BTreeMap' | 'HashMap');
+    constructor(registry: Registry, keyType: CodecClass<K> | string, valType: CodecClass<V> | string, rawValue: Uint8Array | string | Map<any, any> | undefined, type?: 'BTreeMap' | 'HashMap');
     /**
      * @description The length of the value when encoded as a Uint8Array
      */

package/extended/Range.d.ts

@@ -1,4 +1,4 @@
-import type { AnyTuple, CodecClass, CodecRegistry, INumber } from '../types';
+import type { AnyTuple, CodecClass, INumber, Registry } from '../types';
 import { Tuple } from '../base/Tuple';
 declare type RangeType = 'Range' | 'RangeInclusive';
 /**
@@ -8,7 +8,7 @@ declare type RangeType = 'Range' | 'RangeInclusive';
  */
 export declare class Range<T extends INumber> extends Tuple {
     #private;
-    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, value?: AnyTuple, rangeName?: RangeType);
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: AnyTuple, rangeName?: RangeType);
     static with<T extends INumber>(Types: CodecClass<T> | string): CodecClass<Range<T>>;
     /**
      * @description Returns the starting range value
@@ -24,7 +24,7 @@ export declare class Range<T extends INumber> extends Tuple {
     toRawType(): string;
 }
 export declare class RangeInclusive<T extends INumber = INumber> extends Range<T> {
-    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, value?: AnyTuple);
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: AnyTuple);
     static with<T extends INumber>(Type: CodecClass<T> | string): CodecClass<RangeInclusive<T>>;
 }
 export {};

package/extended/Type.d.ts

@@ -1,4 +1,4 @@
-import type { CodecRegistry } from '../types';
+import type { Registry } from '../types';
 import { Text } from '../native/Text';
 /**
  * @name Type
@@ -8,7 +8,7 @@ import { Text } from '../native/Text';
  * i.e. we remove the `T::` prefixes found in some types for consistency across implementation.
  */
 export declare class Type extends Text {
-    constructor(registry: CodecRegistry, value?: Text | Uint8Array | string);
+    constructor(registry: Registry, value?: Text | Uint8Array | string);
     /**
      * @description Returns the base runtime type name for this instance
      */

package/extended/U8aFixed.d.ts

@@ -1,4 +1,4 @@
-import type { AnyU8a, CodecClass, CodecRegistry, U8aBitLength } from '../types';
+import type { AnyU8a, CodecClass, Registry, U8aBitLength } from '../types';
 import { Raw } from '../native/Raw';
 /**
  * @name U8aFixed
@@ -7,7 +7,7 @@ import { Raw } from '../native/Raw';
  * to be used directly, rather is should be subclassed with the specific lengths.
  */
 export declare class U8aFixed extends Raw {
-    constructor(registry: CodecRegistry, value?: AnyU8a, bitLength?: U8aBitLength);
+    constructor(registry: Registry, value?: AnyU8a, bitLength?: U8aBitLength);
     static with(bitLength: U8aBitLength, typeName?: string): CodecClass<U8aFixed>;
     /**
      * @description Returns the base runtime type name for this instance

package/extended/WrapperKeepOpaque.d.ts

@@ -1,8 +1,8 @@
-import type { AnyJson, AnyU8a, Codec, CodecClass, CodecRegistry } from '../types';
+import type { AnyJson, AnyU8a, Codec, CodecClass, Registry } from '../types';
 import { Bytes } from './Bytes';
 export declare class WrapperKeepOpaque<T extends Codec> extends Bytes {
     #private;
-    constructor(registry: CodecRegistry, typeName: CodecClass<T> | string, value?: AnyU8a | Codec);
+    constructor(registry: Registry, typeName: CodecClass<T> | string, value?: AnyU8a | Codec);
     static with<T extends Codec>(Type: CodecClass<T> | string): CodecClass<WrapperKeepOpaque<T>>;
     /**
      * @description Checks if the wrapper is decodable

package/extended/WrapperOpaque.d.ts

@@ -1,7 +1,7 @@
-import type { Codec, CodecClass, CodecRegistry } from '../types';
+import type { Codec, CodecClass, Registry } from '../types';
 import { Base } from '../base/Base';
 export declare class WrapperOpaque<T extends Codec> extends Base<T> {
-    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, value?: unknown);
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: unknown);
     static with<T extends Codec>(Type: CodecClass<T> | string): CodecClass<WrapperOpaque<T>>;
     /**
      * @description Returns the base runtime type name for this instance

package/native/Bool.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { Codec, CodecRegistry, IU8a } from '../types';
+import type { Codec, IU8a, Registry } from '../types';
 /**
  * @name bool
  * @description
@@ -7,9 +7,9 @@ import type { Codec, CodecRegistry, IU8a } from '../types';
  * @noInheritDoc
  */
 export declare class bool extends Boolean implements Codec {
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
-    constructor(registry: CodecRegistry, value?: bool | Boolean | Uint8Array | boolean | number);
+    constructor(registry: Registry, value?: bool | Boolean | Uint8Array | boolean | number);
     /**
      * @description The length of the value when encoded as a Uint8Array
      */

package/native/Date.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import type { HexString } from '@polkadot/util/types';
-import type { AnyNumber, CodecRegistry, INumber, IU8a, UIntBitLength } from '../types';
+import type { AnyNumber, INumber, IU8a, Registry, UIntBitLength } from '../types';
 import { BN } from '@polkadot/util';
 /**
  * @name Date
@@ -13,9 +13,9 @@ import { BN } from '@polkadot/util';
  * @noInheritDoc
  */
 export declare class CodecDate extends Date implements INumber {
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
-    constructor(registry: CodecRegistry, value?: CodecDate | Date | AnyNumber);
+    constructor(registry: Registry, value?: CodecDate | Date | AnyNumber);
     /**
      * @description The length of the value when encoded as a Uint8Array
      */

package/native/Json.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecRegistry, IU8a } from '../types';
+import type { AnyJson, Codec, IU8a, Registry } from '../types';
 /**
  * @name Json
  * @description
@@ -9,9 +9,9 @@ import type { AnyJson, Codec, CodecRegistry, IU8a } from '../types';
  * @noInheritDoc
  */
 export declare class Json extends Map<string, any> implements Codec {
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
-    constructor(registry: CodecRegistry, value?: Record<string, unknown> | null);
+    constructor(registry: Registry, value?: Record<string, unknown> | null);
     /**
      * @description Always 0, never encodes as a Uint8Array
      */

package/native/Raw.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, AnyU8a, CodecRegistry, IU8a } from '../types';
+import type { AnyJson, AnyU8a, IU8a, Registry } from '../types';
 /**
  * @name Raw
  * @description
@@ -10,10 +10,10 @@ import type { AnyJson, AnyU8a, CodecRegistry, IU8a } from '../types';
  * @noInheritDoc
  */
 export declare class Raw extends Uint8Array implements IU8a {
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: CodecRegistry, value?: AnyU8a, initialU8aLength?: number);
+    constructor(registry: Registry, value?: AnyU8a, initialU8aLength?: number);
     /**
      * @description The length of the value when encoded as a Uint8Array
      */

package/native/Set.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import type { HexString } from '@polkadot/util/types';
-import type { CodecClass, CodecRegistry, ISet, IU8a } from '../types';
+import type { CodecClass, ISet, IU8a, Registry } from '../types';
 import { BN } from '@polkadot/util';
 declare type SetValues = Record<string, number | BN>;
 /**
@@ -11,9 +11,9 @@ declare type SetValues = Record<string, number | BN>;
  */
 export declare class CodecSet extends Set<string> implements ISet<string> {
     #private;
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
-    constructor(registry: CodecRegistry, setValues: SetValues, value?: string[] | Set<string> | Uint8Array | BN | number | string, bitLength?: number);
+    constructor(registry: Registry, setValues: SetValues, value?: string[] | Set<string> | Uint8Array | BN | number | string, bitLength?: number);
     static with(values: SetValues, bitLength?: number): CodecClass<CodecSet>;
     /**
      * @description The length of the value when encoded as a Uint8Array

package/native/Struct.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, BareOpts, Codec, CodecClass, CodecRegistry, IStruct, IU8a } from '../types';
+import type { AnyJson, BareOpts, Codec, CodecClass, IStruct, IU8a, Registry } from '../types';
 declare type TypesDef<T = Codec> = Record<string, string | CodecClass<T>>;
 /**
  * @name Struct
@@ -23,7 +23,7 @@ export declare class Struct<S extends TypesDef = TypesDef, V extends {
     #private;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: CodecRegistry, 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>);
     static with<S extends TypesDef>(Types: S, jsonMap?: Map<string, string>): CodecClass<Struct<S>>;
     /**
      * @description The available keys for this struct
@@ -46,7 +46,7 @@ export declare class Struct<S extends TypesDef = TypesDef, V extends {
      * @description returns a hash of the contents
      */
     get hash(): IU8a;
-    get registry(): CodecRegistry;
+    get registry(): Registry;
     /**
      * @description Compares the value of the input to see if there is a match
      */

package/native/Text.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyU8a, Codec, CodecRegistry, IU8a } from '../types';
+import type { AnyU8a, Codec, IU8a, Registry } from '../types';
 /**
  * @name Text
  * @description
@@ -10,9 +10,9 @@ import type { AnyU8a, Codec, CodecRegistry, IU8a } from '../types';
  */
 export declare class Text extends String implements Codec {
     #private;
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     createdAtHash?: IU8a;
-    constructor(registry: CodecRegistry, value?: null | Text | string | AnyU8a | {
+    constructor(registry: Registry, value?: null | Text | string | AnyU8a | {
         toString: () => string;
     });
     /**

package/package.json

@@ -20,7 +20,7 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "7.4.1",
+  "version": "7.4.2-11",
   "main": "index.cjs",
   "module": "index.js",
   "types": "index.d.ts",

package/packageInfo.cjs

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

package/packageInfo.js

@@ -5,5 +5,5 @@ export const packageInfo = {
   name: '@polkadot/types-codec',
   path: new URL('.', import.meta.url).pathname,
   type: 'esm',
-  version: '7.4.1'
+  version: '7.4.2-11'
 };

package/primitive/USize.d.ts

@@ -1,4 +1,4 @@
-import type { CodecRegistry } from '../types';
+import type { Registry } from '../types';
 import { u32 } from './U32';
 /**
  * @name USize
@@ -8,5 +8,5 @@ import { u32 } from './U32';
  * It is not to be used, since it created consensus mismatches.
  */
 export declare class usize extends u32 {
-    constructor(registry: CodecRegistry, value?: unknown);
+    constructor(registry: Registry, value?: unknown);
 }

package/types/codec.d.ts

@@ -1,7 +1,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { AnyJson } from './helpers';
 import type { IU8a } from './interfaces';
-import type { CodecRegistry } from './registry';
+import type { Registry } from './registry';
 export declare type BareOpts = boolean | Record<string, boolean>;
 /**
  * @name Codec
@@ -30,7 +30,7 @@ export interface Codec {
     /**
      * @description The registry associated with this object
      */
-    readonly registry: CodecRegistry;
+    readonly registry: Registry;
     /**
      * @description The block at which this value was retrieved/created (set to non-empty when retrieved from storage)
      */
@@ -70,7 +70,7 @@ export interface CodecClass<T = Codec> {
      * @description An internal fallback type (previous generation) if encoding fails
      */
     readonly __fallbackType?: string;
-    new (registry: CodecRegistry, ...args: any[]): T;
+    new (registry: Registry, ...args: any[]): T;
 }
 export declare type CodecClassDef<T = Codec> = Record<string, CodecClass<T>>;
 export declare type CodecTo = 'toHex' | 'toJSON' | 'toString' | 'toU8a';

package/types/registry.d.ts

@@ -30,7 +30,7 @@ export interface CallBase<A extends AnyTuple, M = any> extends IMethod<A, M> {
 export interface CallFunction<A extends AnyTuple = AnyTuple, M = any> extends CallBase<A, M> {
     (...args: any[]): IMethod<A, M>;
 }
-export interface CodecRegistry {
+export interface Registry {
     readonly chainDecimals: number[];
     readonly chainSS58: number | undefined;
     readonly chainTokens: string[];

package/utils/decodeU8a.d.ts

@@ -1,4 +1,4 @@
-import type { Codec, CodecClass, CodecRegistry } from '../types';
+import type { Codec, CodecClass, Registry } from '../types';
 /**
  * Given an u8a, and an array of Type constructors, decode the u8a against the
  * types, and return an array of decoded values.
@@ -7,7 +7,7 @@ import type { Codec, CodecClass, CodecRegistry } from '../types';
  * @param result - The result array (will be returned with values pushed)
  * @param types - The array of CodecClass to decode the U8a against.
  */
-export declare function decodeU8a<T extends Codec = Codec, E = T>(registry: CodecRegistry, u8a: Uint8Array, types: CodecClass[] | {
+export declare function decodeU8a<T extends Codec = Codec, E = T>(registry: Registry, u8a: Uint8Array, types: CodecClass[] | {
     [index: string]: CodecClass;
 }, withZip?: boolean): [E[], number];
-export declare function decodeU8aVec<T extends Codec = Codec>(registry: CodecRegistry, u8a: Uint8Array, start: number, Type: CodecClass<T>, count: number): [T[], number, number];
+export declare function decodeU8aVec<T extends Codec = Codec>(registry: Registry, u8a: Uint8Array, start: number, Type: CodecClass<T>, count: number): [T[], number, number];

package/utils/mapToTypeMap.d.ts

@@ -1,5 +1,5 @@
-import type { CodecClass, CodecRegistry } from '../types';
+import type { CodecClass, Registry } from '../types';
 /**
  * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
  */
-export declare function mapToTypeMap(registry: CodecRegistry, input: Record<string, string | CodecClass>): Record<string, CodecClass>;
+export declare function mapToTypeMap(registry: Registry, input: Record<string, string | CodecClass>): Record<string, CodecClass>;

package/utils/typeToConstructor.d.ts

@@ -1,2 +1,2 @@
-import type { Codec, CodecClass, CodecRegistry } from '../types';
-export declare function typeToConstructor<T extends Codec = Codec>(registry: CodecRegistry, type: string | CodecClass<T>): CodecClass<T>;
+import type { Codec, CodecClass, Registry } from '../types';
+export declare function typeToConstructor<T extends Codec = Codec>(registry: Registry, type: string | CodecClass<T>): CodecClass<T>;

package/utils/typesToMap.d.ts

@@ -1,2 +1,2 @@
-import type { CodecClass, CodecRegistry } from '../types';
-export declare function typesToMap(registry: CodecRegistry, Types: Record<string, CodecClass>): Record<string, string>;
+import type { CodecClass, Registry } from '../types';
+export declare function typesToMap(registry: Registry, Types: Record<string, CodecClass>): Record<string, string>;