@pezkuwi/types 16.5.5

package/src/interfaces/metadata/v10.ts

@@ -0,0 +1,67 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// order important in structs... :)
+/* eslint-disable sort-keys */
+
+import type { DefinitionsTypes } from '../../types/index.js';
+
+export const v10: DefinitionsTypes = {
+  // v10
+  ErrorMetadataV10: 'ErrorMetadataV9',
+  EventMetadataV10: 'EventMetadataV9',
+  FunctionArgumentMetadataV10: 'FunctionArgumentMetadataV9',
+  FunctionMetadataV10: 'FunctionMetadataV9',
+  MetadataV10: {
+    modules: 'Vec<ModuleMetadataV10>'
+  },
+  ModuleConstantMetadataV10: 'ModuleConstantMetadataV9',
+  ModuleMetadataV10: {
+    name: 'Text',
+    storage: 'Option<StorageMetadataV10>',
+    calls: 'Option<Vec<FunctionMetadataV10>>',
+    events: 'Option<Vec<EventMetadataV10>>',
+    constants: 'Vec<ModuleConstantMetadataV10>',
+    errors: 'Vec<ErrorMetadataV10>'
+  },
+  StorageEntryModifierV10: 'StorageEntryModifierV9',
+  StorageEntryMetadataV10: {
+    name: 'Text',
+    modifier: 'StorageEntryModifierV10',
+    type: 'StorageEntryTypeV10',
+    fallback: 'Bytes',
+    docs: 'Vec<Text>'
+  },
+  StorageEntryTypeV10: {
+    _enum: {
+      Plain: 'Type',
+      Map: {
+        hasher: 'StorageHasherV10',
+        key: 'Type',
+        value: 'Type',
+        linked: 'bool'
+      },
+      DoubleMap: {
+        hasher: 'StorageHasherV10',
+        key1: 'Type',
+        key2: 'Type',
+        value: 'Type',
+        key2Hasher: 'StorageHasherV10'
+      }
+    }
+  },
+  StorageMetadataV10: {
+    prefix: 'Text',
+    items: 'Vec<StorageEntryMetadataV10>'
+  },
+  StorageHasherV10: {
+    _enum: {
+      Blake2_128: null, // eslint-disable-line camelcase
+      Blake2_256: null, // eslint-disable-line camelcase
+      Blake2_128Concat: null, // eslint-disable-line camelcase
+      Twox128: null,
+      Twox256: null,
+      Twox64Concat: null
+    }
+  }
+};

package/src/interfaces/metadata/v11.ts

@@ -0,0 +1,67 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// order important in structs... :)
+/* eslint-disable sort-keys */
+
+import type { DefinitionsTypes } from '../../types/index.js';
+
+import { AllHashers } from './hashers.js';
+
+export const v11: DefinitionsTypes = {
+  // v11
+  ErrorMetadataV11: 'ErrorMetadataV10',
+  EventMetadataV11: 'EventMetadataV10',
+  ExtrinsicMetadataV11: {
+    version: 'u8',
+    signedExtensions: 'Vec<Text>'
+  },
+  FunctionArgumentMetadataV11: 'FunctionArgumentMetadataV10',
+  FunctionMetadataV11: 'FunctionMetadataV10',
+  MetadataV11: {
+    modules: 'Vec<ModuleMetadataV11>',
+    extrinsic: 'ExtrinsicMetadataV11'
+  },
+  ModuleConstantMetadataV11: 'ModuleConstantMetadataV10',
+  ModuleMetadataV11: {
+    name: 'Text',
+    storage: 'Option<StorageMetadataV11>',
+    calls: 'Option<Vec<FunctionMetadataV11>>',
+    events: 'Option<Vec<EventMetadataV11>>',
+    constants: 'Vec<ModuleConstantMetadataV11>',
+    errors: 'Vec<ErrorMetadataV11>'
+  },
+  StorageEntryModifierV11: 'StorageEntryModifierV10',
+  StorageEntryMetadataV11: {
+    name: 'Text',
+    modifier: 'StorageEntryModifierV11',
+    type: 'StorageEntryTypeV11',
+    fallback: 'Bytes',
+    docs: 'Vec<Text>'
+  },
+  StorageEntryTypeV11: {
+    _enum: {
+      Plain: 'Type',
+      Map: {
+        hasher: 'StorageHasherV11',
+        key: 'Type',
+        value: 'Type',
+        linked: 'bool'
+      },
+      DoubleMap: {
+        hasher: 'StorageHasherV11',
+        key1: 'Type',
+        key2: 'Type',
+        value: 'Type',
+        key2Hasher: 'StorageHasherV11'
+      }
+    }
+  },
+  StorageMetadataV11: {
+    prefix: 'Text',
+    items: 'Vec<StorageEntryMetadataV11>'
+  },
+  StorageHasherV11: {
+    _enum: AllHashers
+  }
+};

package/src/interfaces/metadata/v12.ts

@@ -0,0 +1,35 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// order important in structs... :)
+/* eslint-disable sort-keys */
+
+import type { DefinitionsTypes } from '../../types/index.js';
+
+export const v12: DefinitionsTypes = {
+  // v12
+  ErrorMetadataV12: 'ErrorMetadataV11',
+  EventMetadataV12: 'EventMetadataV11',
+  ExtrinsicMetadataV12: 'ExtrinsicMetadataV11',
+  FunctionArgumentMetadataV12: 'FunctionArgumentMetadataV11',
+  FunctionMetadataV12: 'FunctionMetadataV11',
+  MetadataV12: {
+    modules: 'Vec<ModuleMetadataV12>',
+    extrinsic: 'ExtrinsicMetadataV12'
+  },
+  ModuleConstantMetadataV12: 'ModuleConstantMetadataV11',
+  ModuleMetadataV12: {
+    name: 'Text',
+    storage: 'Option<StorageMetadataV12>',
+    calls: 'Option<Vec<FunctionMetadataV12>>',
+    events: 'Option<Vec<EventMetadataV12>>',
+    constants: 'Vec<ModuleConstantMetadataV12>',
+    errors: 'Vec<ErrorMetadataV12>',
+    index: 'u8'
+  },
+  StorageEntryModifierV12: 'StorageEntryModifierV11',
+  StorageEntryMetadataV12: 'StorageEntryMetadataV11',
+  StorageEntryTypeV12: 'StorageEntryTypeV11',
+  StorageMetadataV12: 'StorageMetadataV11',
+  StorageHasherV12: 'StorageHasherV11'
+};

package/src/interfaces/metadata/v13.ts

@@ -0,0 +1,66 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// order important in structs... :)
+/* eslint-disable sort-keys */
+
+import type { DefinitionsTypes } from '../../types/index.js';
+
+export const v13: DefinitionsTypes = {
+  // v13
+  ErrorMetadataV13: 'ErrorMetadataV12',
+  EventMetadataV13: 'EventMetadataV12',
+  ExtrinsicMetadataV13: 'ExtrinsicMetadataV12',
+  FunctionArgumentMetadataV13: 'FunctionArgumentMetadataV12',
+  FunctionMetadataV13: 'FunctionMetadataV12',
+  MetadataV13: {
+    modules: 'Vec<ModuleMetadataV13>',
+    extrinsic: 'ExtrinsicMetadataV13'
+  },
+  ModuleConstantMetadataV13: 'ModuleConstantMetadataV12',
+  ModuleMetadataV13: {
+    name: 'Text',
+    storage: 'Option<StorageMetadataV13>',
+    calls: 'Option<Vec<FunctionMetadataV13>>',
+    events: 'Option<Vec<EventMetadataV13>>',
+    constants: 'Vec<ModuleConstantMetadataV13>',
+    errors: 'Vec<ErrorMetadataV13>',
+    index: 'u8'
+  },
+  StorageEntryModifierV13: 'StorageEntryModifierV12',
+  StorageEntryMetadataV13: {
+    name: 'Text',
+    modifier: 'StorageEntryModifierV13',
+    type: 'StorageEntryTypeV13',
+    fallback: 'Bytes',
+    docs: 'Vec<Text>'
+  },
+  StorageEntryTypeV13: {
+    _enum: {
+      Plain: 'Type',
+      Map: {
+        hasher: 'StorageHasherV13',
+        key: 'Type',
+        value: 'Type',
+        linked: 'bool'
+      },
+      DoubleMap: {
+        hasher: 'StorageHasherV13',
+        key1: 'Type',
+        key2: 'Type',
+        value: 'Type',
+        key2Hasher: 'StorageHasherV13'
+      },
+      NMap: {
+        keyVec: 'Vec<Type>',
+        hashers: 'Vec<StorageHasherV13>',
+        value: 'Type'
+      }
+    }
+  },
+  StorageMetadataV13: {
+    prefix: 'Text',
+    items: 'Vec<StorageEntryMetadataV13>'
+  },
+  StorageHasherV13: 'StorageHasherV12'
+};

package/src/interfaces/metadata/v14.ts

@@ -0,0 +1,102 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// order important in structs... :)
+/* eslint-disable sort-keys */
+
+import type { DefinitionsTypes } from '../../types/index.js';
+
+import { Si1Variant } from '../scaleInfo/v1.js';
+
+export const v14: DefinitionsTypes = {
+  // registry
+  PortableTypeV14: {
+    id: 'Si1LookupTypeId',
+    type: 'Si1Type'
+  },
+
+  // compatibility with earlier layouts, i.e. don't break previous users
+  ErrorMetadataV14: {
+    ...Si1Variant,
+    args: 'Vec<Type>'
+  },
+  EventMetadataV14: {
+    ...Si1Variant,
+    args: 'Vec<Type>'
+  },
+  FunctionArgumentMetadataV14: {
+    name: 'Text',
+    type: 'Type',
+    typeName: 'Option<Type>'
+  },
+  FunctionMetadataV14: {
+    ...Si1Variant,
+    args: 'Vec<FunctionArgumentMetadataV14>'
+  },
+
+  // V14
+  ExtrinsicMetadataV14: {
+    type: 'SiLookupTypeId',
+    version: 'u8',
+    signedExtensions: 'Vec<SignedExtensionMetadataV14>'
+  },
+  MetadataV14: {
+    lookup: 'PortableRegistry',
+    pallets: 'Vec<PalletMetadataV14>',
+    extrinsic: 'ExtrinsicMetadataV14',
+    type: 'SiLookupTypeId'
+  },
+  PalletCallMetadataV14: {
+    type: 'SiLookupTypeId'
+  },
+  PalletConstantMetadataV14: {
+    name: 'Text',
+    type: 'SiLookupTypeId',
+    value: 'Bytes',
+    docs: 'Vec<Text>'
+  },
+  PalletErrorMetadataV14: {
+    type: 'SiLookupTypeId'
+  },
+  PalletEventMetadataV14: {
+    type: 'SiLookupTypeId'
+  },
+  PalletMetadataV14: {
+    name: 'Text',
+    storage: 'Option<PalletStorageMetadataV14>',
+    calls: 'Option<PalletCallMetadataV14>',
+    events: 'Option<PalletEventMetadataV14>',
+    constants: 'Vec<PalletConstantMetadataV14>',
+    errors: 'Option<PalletErrorMetadataV14>',
+    index: 'u8'
+  },
+  PalletStorageMetadataV14: {
+    prefix: 'Text',
+    // NOTE: Renamed from entries
+    items: 'Vec<StorageEntryMetadataV14>'
+  },
+  SignedExtensionMetadataV14: {
+    identifier: 'Text',
+    type: 'SiLookupTypeId',
+    additionalSigned: 'SiLookupTypeId'
+  },
+  StorageEntryMetadataV14: {
+    name: 'Text',
+    modifier: 'StorageEntryModifierV14',
+    type: 'StorageEntryTypeV14',
+    fallback: 'Bytes',
+    docs: 'Vec<Text>'
+  },
+  StorageEntryModifierV14: 'StorageEntryModifierV13',
+  StorageEntryTypeV14: {
+    _enum: {
+      Plain: 'SiLookupTypeId',
+      Map: {
+        hashers: 'Vec<StorageHasherV14>',
+        key: 'SiLookupTypeId', // NOTE: Renamed from "keys"
+        value: 'SiLookupTypeId'
+      }
+    }
+  },
+  StorageHasherV14: 'StorageHasherV13'
+};

package/src/interfaces/metadata/v15.ts

@@ -0,0 +1,67 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// order important in structs... :)
+/* eslint-disable sort-keys */
+
+import type { DefinitionsTypes } from '../../types/index.js';
+
+export const v15: DefinitionsTypes = {
+  // new/adjusted in v15
+  CustomMetadata15: {
+    map: 'BTreeMap<Text, CustomValueMetadata15>'
+  },
+  CustomValueMetadata15: {
+    type: 'SiLookupTypeId',
+    value: 'Bytes'
+  },
+  ExtrinsicMetadataV15: {
+    version: 'u8',
+    addressType: 'SiLookupTypeId',
+    callType: 'SiLookupTypeId',
+    signatureType: 'SiLookupTypeId',
+    extraType: 'SiLookupTypeId',
+    signedExtensions: 'Vec<SignedExtensionMetadataV14>'
+  },
+  OuterEnums15: {
+    callType: 'SiLookupTypeId',
+    eventType: 'SiLookupTypeId',
+    errorType: 'SiLookupTypeId'
+  },
+  PalletMetadataV15: {
+    name: 'Text',
+    storage: 'Option<PalletStorageMetadataV14>',
+    calls: 'Option<PalletCallMetadataV14>',
+    events: 'Option<PalletEventMetadataV14>',
+    constants: 'Vec<PalletConstantMetadataV14>',
+    errors: 'Option<PalletErrorMetadataV14>',
+    index: 'u8',
+    docs: 'Vec<Text>'
+  },
+  RuntimeApiMetadataV15: {
+    name: 'Text',
+    methods: 'Vec<RuntimeApiMethodMetadataV15>',
+    docs: 'Vec<Text>'
+  },
+  RuntimeApiMethodMetadataV15: {
+    name: 'Text',
+    inputs: 'Vec<RuntimeApiMethodParamMetadataV15>',
+    output: 'SiLookupTypeId',
+    docs: 'Vec<Text>'
+  },
+  RuntimeApiMethodParamMetadataV15: {
+    name: 'Text',
+    type: 'SiLookupTypeId'
+  },
+
+  // actual v15 definition
+  MetadataV15: {
+    lookup: 'PortableRegistry',
+    pallets: 'Vec<PalletMetadataV15>',
+    extrinsic: 'ExtrinsicMetadataV15',
+    type: 'SiLookupTypeId',
+    apis: 'Vec<RuntimeApiMetadataV15>',
+    outerEnums: 'OuterEnums15',
+    custom: 'CustomMetadata15'
+  }
+};

package/src/interfaces/metadata/v16.ts

@@ -0,0 +1,168 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// order important in structs... :)
+/* eslint-disable sort-keys */
+
+import type { DefinitionsTypes } from '../../types/index.js';
+
+export const v16: DefinitionsTypes = {
+  // actual v16 definition
+  MetadataV16: {
+    lookup: 'PortableRegistry',
+    pallets: 'Vec<PalletMetadataV16>',
+    extrinsic: 'ExtrinsicMetadataV16',
+    apis: 'Vec<RuntimeApiMetadataV16>',
+    outerEnums: 'OuterEnums15',
+    custom: 'CustomMetadata15'
+  },
+
+  // ---- Pallet definitions ----
+  PalletMetadataV16: {
+    name: 'Text',
+    storage: 'Option<PalletStorageMetadataV16>',
+    calls: 'Option<PalletCallMetadataV16>',
+    events: 'Option<PalletEventMetadataV16>',
+    constants: 'Vec<PalletConstantMetadataV16>',
+    errors: 'Option<PalletErrorMetadataV16>',
+    associatedTypes: 'Vec<PalletAssociatedTypeMetadataV16>',
+    viewFunctions: 'Vec<PalletViewFunctionMetadataV16>',
+    index: 'u8',
+    docs: 'Vec<Text>',
+    // Deprecation info
+    deprecationInfo: 'ItemDeprecationInfoV16'
+  },
+  PalletStorageMetadataV16: {
+    prefix: 'Text',
+    items: 'Vec<StorageEntryMetadataV16>'
+  },
+  StorageEntryMetadataV16: {
+    name: 'Text',
+    modifier: 'StorageEntryModifierV14',
+    type: 'StorageEntryTypeV14',
+    fallback: 'Bytes',
+    docs: 'Vec<Text>',
+    deprecationInfo: 'ItemDeprecationInfoV16'
+  },
+  ItemDeprecationInfoV16: {
+    _enum: {
+      // Item is not deprecated.
+      NotDeprecated: 'Null',
+      // Item is fully deprecated without a note.
+      DeprecatedWithoutNote: 'Null',
+      // Item is fully deprecated with a note and an optional `since` field.
+      Deprecated: {
+        // Note explaining the deprecation
+        note: 'Text',
+        // Optional value for noting the version when the deprecation occurred.
+        since: 'Option<Text>'
+      }
+    }
+  },
+  PalletCallMetadataV16: {
+    type: 'SiLookupTypeId',
+    // Deprecation status of the pallet call
+    deprecationInfo: 'EnumDeprecationInfoV16'
+  },
+  // Deprecation information for enums in which specific variants can be deprecated.
+  // If the map is empty, then nothing is deprecated.
+  EnumDeprecationInfoV16: 'BTreeMap<u8, VariantDeprecationInfoV16>',
+  VariantDeprecationInfoV16: {
+    _enum: {
+      // Dummy variant, just here to force DeprecatedWithoutNote
+      // to have index 1 and Deprecated to have index 2
+      DummyVariant: 'Null',
+      // Variant is deprecated without a note.
+      DeprecatedWithoutNote: 'Null',
+      // Variant is deprecated with a note and an optional `since` field.
+      Deprecated: {
+        // Note explaining the deprecation
+        note: 'Text',
+        // Optional value for noting the version when the deprecation occurred.
+        since: 'Option<Text>'
+      }
+
+    }
+  },
+  PalletEventMetadataV16: {
+    type: 'SiLookupTypeId',
+    // Deprecation info
+    deprecationInfo: 'EnumDeprecationInfoV16'
+  },
+  PalletConstantMetadataV16: {
+    name: 'Text',
+    type: 'SiLookupTypeId',
+    value: 'Bytes',
+    docs: 'Vec<Text>',
+    // Deprecation info
+    deprecationInfo: 'ItemDeprecationInfoV16'
+  },
+  PalletErrorMetadataV16: {
+    type: 'SiLookupTypeId',
+    // Deprecation info
+    deprecationInfo: 'EnumDeprecationInfoV16'
+  },
+  PalletAssociatedTypeMetadataV16: {
+    name: 'Text',
+    type: 'SiLookupTypeId',
+    docs: 'Vec<Text>'
+  },
+  PalletViewFunctionMetadataV16: {
+    id: '[u8; 32]',
+    // Method name.
+    name: 'Text',
+    // Method par  ameters.
+    inputs: 'Vec<RuntimeApiMethodParamMetadataV15>',
+    // Method output.
+    output: 'SiLookupTypeId',
+    // Method documentation.
+    docs: 'Vec<T::String>',
+    // Deprecation info
+    deprecationInfo: 'ItemDeprecationInfoV16'
+  },
+
+  // ---- Extrinsic definitions ----
+  ExtrinsicMetadataV16: {
+  // Extrinsic versions supported by the runtime.
+    versions: 'Vec<u8>',
+    // The type of the address that signs the extrinsic
+    addressType: 'SiLookupTypeId',
+    // The type of the outermost Call enum.
+    callType: 'SiLookupTypeId',
+    // The type of the extrinsic's signature.
+    signatureType: 'SiLookupTypeId',
+    // A mapping of supported transaction extrinsic versions to their respective transaction extension indexes.
+    //
+    // For each supported version number, list the indexes, in order, of the extensions used.
+    transactionExtensionsByVersion: 'BTreeMap<u8, Vec<Compact<u32>>>',
+    // The transaction extensions in the order they appear in the extrinsic.
+    transactionExtensions: 'Vec<TransactionExtensionMetadataV16>'
+  },
+  TransactionExtensionMetadataV16: {
+  // The unique transaction extension identifier, which may be different from the type name.
+    identifier: 'Text',
+    // The type of the transaction extension, with the data to be included in the extrinsic.
+    type: 'SiLookupTypeId',
+    // The type of the implicit data, with the data to be included in the signed payload.
+    implicit: 'SiLookupTypeId'
+  },
+
+  // ---- Runtime Api definitions ----
+  RuntimeApiMetadataV16: {
+    name: 'Text',
+    methods: 'Vec<RuntimeApiMethodMetadataV16>',
+    docs: 'Vec<Text>',
+    // Runtime API version.
+    version: 'Compact<u32>',
+    // Deprecation info
+    deprecationInfo: 'ItemDeprecationInfoV16'
+  },
+  RuntimeApiMethodMetadataV16: {
+    name: 'Text',
+    inputs: 'Vec<RuntimeApiMethodParamMetadataV15>',
+    output: 'SiLookupTypeId',
+    docs: 'Vec<Text>',
+    // Deprecation info
+    deprecationInfo: 'ItemDeprecationInfoV16'
+  }
+};

package/src/interfaces/metadata/v9.ts

@@ -0,0 +1,87 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// order important in structs... :)
+/* eslint-disable sort-keys */
+
+import type { DefinitionsTypes } from '../../types/index.js';
+
+export const v9: DefinitionsTypes = {
+  // v9
+  ErrorMetadataV9: {
+    name: 'Text',
+    docs: 'Vec<Text>'
+  },
+  EventMetadataV9: {
+    name: 'Text',
+    args: 'Vec<Type>',
+    docs: 'Vec<Text>'
+  },
+  FunctionArgumentMetadataV9: {
+    name: 'Text',
+    type: 'Type'
+  },
+  FunctionMetadataV9: {
+    name: 'Text',
+    args: 'Vec<FunctionArgumentMetadataV9>',
+    docs: 'Vec<Text>'
+  },
+  MetadataV9: {
+    modules: 'Vec<ModuleMetadataV9>'
+  },
+  ModuleConstantMetadataV9: {
+    name: 'Text',
+    type: 'Type',
+    value: 'Bytes',
+    docs: 'Vec<Text>'
+  },
+  ModuleMetadataV9: {
+    name: 'Text',
+    storage: 'Option<StorageMetadataV9>',
+    calls: 'Option<Vec<FunctionMetadataV9>>',
+    events: 'Option<Vec<EventMetadataV9>>',
+    constants: 'Vec<ModuleConstantMetadataV9>',
+    errors: 'Vec<ErrorMetadataV9>'
+  },
+  StorageEntryMetadataV9: {
+    name: 'Text',
+    modifier: 'StorageEntryModifierV9',
+    type: 'StorageEntryTypeV9',
+    fallback: 'Bytes',
+    docs: 'Vec<Text>'
+  },
+  StorageEntryModifierV9: {
+    _enum: ['Optional', 'Default', 'Required']
+  },
+  StorageEntryTypeV9: {
+    _enum: {
+      Plain: 'Type',
+      Map: {
+        hasher: 'StorageHasherV9',
+        key: 'Type',
+        value: 'Type',
+        linked: 'bool'
+      },
+      DoubleMap: {
+        hasher: 'StorageHasherV9',
+        key1: 'Type',
+        key2: 'Type',
+        value: 'Type',
+        key2Hasher: 'StorageHasherV9'
+      }
+    }
+  },
+  StorageHasherV9: {
+    _enum: {
+      Blake2_128: null, // eslint-disable-line camelcase
+      Blake2_256: null, // eslint-disable-line camelcase
+      Twox128: null,
+      Twox256: null,
+      Twox64Concat: null
+    }
+  },
+  StorageMetadataV9: {
+    prefix: 'Text',
+    items: 'Vec<StorageEntryMetadataV9>'
+  }
+};

package/src/interfaces/mixnet/definitions.ts

@@ -0,0 +1,33 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Definitions } from '../../types/index.js';
+
+import { runtime } from './runtime.js';
+
+export default {
+  rpc: {},
+  runtime,
+  types: {
+    Mixnode: {
+      externalAddresses: 'Vec<Bytes>',
+      kxPublic: '[u8; 32]',
+      peerId: '[u8; 32]'
+    },
+    MixnodesErr: {
+      _enum: {
+        InsufficientRegistrations: {
+          min: 'u32',
+          num: 'u32'
+        }
+      }
+    },
+    SessionPhase: {
+      _enum: ['CoverToCurrent', 'RequestsToCurrent', 'CoverToPrev', 'DisconnectFromPrev']
+    },
+    SessionStatus: {
+      currentIndex: 'u32',
+      phase: 'SessionPhase'
+    }
+  }
+} as Definitions;