moonbeam-types.ts

gistfile1.txt

import type { Codec, HexString } from "@polkadot-api/substrate-bindings"
import {
  Struct,
  u32,
  u128,
  Hex,
  Tuple,
  compactBn,
  Vector,
  Enum,
  _void,
  u8,
  bool,
  u16,
  str,
  u64,
  compactNumber,
  Self,
  fixedStr,
  i64,
} from "@polkadot-api/substrate-bindings"

type IcPallet_balancesTypesAccountData = {
  free: bigint
  reserved: bigint
  frozen: bigint
  flags: bigint
}
const cPallet_balancesTypesAccountData: Codec<IcPallet_balancesTypesAccountData> =
  Struct({ free: u128, reserved: u128, frozen: u128, flags: u128 })

type IcFrame_systemAccountInfo = {
  nonce: number
  consumers: number
  providers: number
  sufficients: number
  data: IcPallet_balancesTypesAccountData
}
const cFrame_systemAccountInfo: Codec<IcFrame_systemAccountInfo> = Struct({
  nonce: u32,
  consumers: u32,
  providers: u32,
  sufficients: u32,
  data: cPallet_balancesTypesAccountData,
})

type Icdc1 = HexString
const cdc1: Codec<Icdc1> = Hex(20)

type IcAccountAccountId20Tupled = [Key: Icdc1]
const cAccountAccountId20Tupled: Codec<IcAccountAccountId20Tupled> = Tuple(cdc1)

type I_emptyTuple = []
const _emptyTuple: Codec<I_emptyTuple> = Tuple()

type IcSp_weightsWeight_v2Weight = { ref_time: bigint; proof_size: bigint }
const cSp_weightsWeight_v2Weight: Codec<IcSp_weightsWeight_v2Weight> = Struct({
  ref_time: compactBn,
  proof_size: compactBn,
})

type IcFrame_supportDispatchPerDispatchClass = {
  normal: IcSp_weightsWeight_v2Weight
  operational: IcSp_weightsWeight_v2Weight
  mandatory: IcSp_weightsWeight_v2Weight
}
const cFrame_supportDispatchPerDispatchClass: Codec<IcFrame_supportDispatchPerDispatchClass> =
  Struct({
    normal: cSp_weightsWeight_v2Weight,
    operational: cSp_weightsWeight_v2Weight,
    mandatory: cSp_weightsWeight_v2Weight,
  })

type Icdc13 = HexString
const cdc13: Codec<Icdc13> = Hex(32)

type Icdc4Tupled = [Key: number]
const cdc4Tupled: Codec<Icdc4Tupled> = Tuple(u32)

type I_bytesSeq = HexString
const _bytesSeq: Codec<I_bytesSeq> = Hex()

type Icdc18 = HexString
const cdc18: Codec<Icdc18> = Hex(4)

type IcSp_runtimeGenericDigestDigestItemPreRuntime = [Icdc18, I_bytesSeq]
const cSp_runtimeGenericDigestDigestItemPreRuntime: Codec<IcSp_runtimeGenericDigestDigestItemPreRuntime> =
  Tuple(cdc18, _bytesSeq)

type IcSp_runtimeGenericDigestDigestItemConsensus = [Icdc18, I_bytesSeq]
const cSp_runtimeGenericDigestDigestItemConsensus: Codec<IcSp_runtimeGenericDigestDigestItemConsensus> =
  Tuple(cdc18, _bytesSeq)

type IcSp_runtimeGenericDigestDigestItemSeal = [Icdc18, I_bytesSeq]
const cSp_runtimeGenericDigestDigestItemSeal: Codec<IcSp_runtimeGenericDigestDigestItemSeal> =
  Tuple(cdc18, _bytesSeq)

type IcSp_runtimeGenericDigestDigestItemOther = I_bytesSeq
const cSp_runtimeGenericDigestDigestItemOther: Codec<IcSp_runtimeGenericDigestDigestItemOther> =
  _bytesSeq

type IcSp_runtimeGenericDigestDigestItem =
  | { tag: "PreRuntime"; value: IcSp_runtimeGenericDigestDigestItemPreRuntime }
  | { tag: "Consensus"; value: IcSp_runtimeGenericDigestDigestItemConsensus }
  | { tag: "Seal"; value: IcSp_runtimeGenericDigestDigestItemSeal }
  | { tag: "Other"; value: IcSp_runtimeGenericDigestDigestItemOther }
  | { tag: "RuntimeEnvironmentUpdated"; value: undefined }
const cSp_runtimeGenericDigestDigestItem: Codec<IcSp_runtimeGenericDigestDigestItem> =
  Enum(
    {
      PreRuntime: cSp_runtimeGenericDigestDigestItemPreRuntime,
      Consensus: cSp_runtimeGenericDigestDigestItemConsensus,
      Seal: cSp_runtimeGenericDigestDigestItemSeal,
      Other: cSp_runtimeGenericDigestDigestItemOther,
      RuntimeEnvironmentUpdated: _void,
    },
    [6, 4, 5, 0, 8],
  )

type Icdc16 = Array<IcSp_runtimeGenericDigestDigestItem>
const cdc16: Codec<Icdc16> = Vector(cSp_runtimeGenericDigestDigestItem)

type IcFrame_systemPhaseApplyExtrinsic = number
const cFrame_systemPhaseApplyExtrinsic: Codec<IcFrame_systemPhaseApplyExtrinsic> =
  u32

type IcFrame_systemPhase =
  | { tag: "ApplyExtrinsic"; value: IcFrame_systemPhaseApplyExtrinsic }
  | { tag: "Finalization"; value: undefined }
  | { tag: "Initialization"; value: undefined }
const cFrame_systemPhase: Codec<IcFrame_systemPhase> = Enum({
  ApplyExtrinsic: cFrame_systemPhaseApplyExtrinsic,
  Finalization: _void,
  Initialization: _void,
})

type IcFrame_supportDispatchDispatchClass =
  | { tag: "Normal"; value: undefined }
  | { tag: "Operational"; value: undefined }
  | { tag: "Mandatory"; value: undefined }
const cFrame_supportDispatchDispatchClass: Codec<IcFrame_supportDispatchDispatchClass> =
  Enum({ Normal: _void, Operational: _void, Mandatory: _void })

type IcFrame_supportDispatchPays =
  | { tag: "Yes"; value: undefined }
  | { tag: "No"; value: undefined }
const cFrame_supportDispatchPays: Codec<IcFrame_supportDispatchPays> = Enum({
  Yes: _void,
  No: _void,
})

type IcFrame_supportDispatchDispatchInfo = {
  weight: IcSp_weightsWeight_v2Weight
  class: IcFrame_supportDispatchDispatchClass
  pays_fee: IcFrame_supportDispatchPays
}
const cFrame_supportDispatchDispatchInfo: Codec<IcFrame_supportDispatchDispatchInfo> =
  Struct({
    weight: cSp_weightsWeight_v2Weight,
    class: cFrame_supportDispatchDispatchClass,
    pays_fee: cFrame_supportDispatchPays,
  })

type IcFrame_systemPalletEventExtrinsicSuccess = {
  dispatch_info: IcFrame_supportDispatchDispatchInfo
}
const cFrame_systemPalletEventExtrinsicSuccess: Codec<IcFrame_systemPalletEventExtrinsicSuccess> =
  Struct({ dispatch_info: cFrame_supportDispatchDispatchInfo })

type IcSp_runtimeModuleError = { index: number; error: Icdc18 }
const cSp_runtimeModuleError: Codec<IcSp_runtimeModuleError> = Struct({
  index: u8,
  error: cdc18,
})

type IcSp_runtimeDispatchErrorModule = IcSp_runtimeModuleError
const cSp_runtimeDispatchErrorModule: Codec<IcSp_runtimeDispatchErrorModule> =
  cSp_runtimeModuleError

type IcSp_runtimeTokenError =
  | { tag: "FundsUnavailable"; value: undefined }
  | { tag: "OnlyProvider"; value: undefined }
  | { tag: "BelowMinimum"; value: undefined }
  | { tag: "CannotCreate"; value: undefined }
  | { tag: "UnknownAsset"; value: undefined }
  | { tag: "Frozen"; value: undefined }
  | { tag: "Unsupported"; value: undefined }
  | { tag: "CannotCreateHold"; value: undefined }
  | { tag: "NotExpendable"; value: undefined }
  | { tag: "Blocked"; value: undefined }
const cSp_runtimeTokenError: Codec<IcSp_runtimeTokenError> = Enum({
  FundsUnavailable: _void,
  OnlyProvider: _void,
  BelowMinimum: _void,
  CannotCreate: _void,
  UnknownAsset: _void,
  Frozen: _void,
  Unsupported: _void,
  CannotCreateHold: _void,
  NotExpendable: _void,
  Blocked: _void,
})

type IcSp_runtimeDispatchErrorToken = IcSp_runtimeTokenError
const cSp_runtimeDispatchErrorToken: Codec<IcSp_runtimeDispatchErrorToken> =
  cSp_runtimeTokenError

type IcSp_arithmeticArithmeticError =
  | { tag: "Underflow"; value: undefined }
  | { tag: "Overflow"; value: undefined }
  | { tag: "DivisionByZero"; value: undefined }
const cSp_arithmeticArithmeticError: Codec<IcSp_arithmeticArithmeticError> =
  Enum({ Underflow: _void, Overflow: _void, DivisionByZero: _void })

type IcSp_runtimeDispatchErrorArithmetic = IcSp_arithmeticArithmeticError
const cSp_runtimeDispatchErrorArithmetic: Codec<IcSp_runtimeDispatchErrorArithmetic> =
  cSp_arithmeticArithmeticError

type IcSp_runtimeTransactionalError =
  | { tag: "LimitReached"; value: undefined }
  | { tag: "NoLayer"; value: undefined }
const cSp_runtimeTransactionalError: Codec<IcSp_runtimeTransactionalError> =
  Enum({ LimitReached: _void, NoLayer: _void })

type IcSp_runtimeDispatchErrorTransactional = IcSp_runtimeTransactionalError
const cSp_runtimeDispatchErrorTransactional: Codec<IcSp_runtimeDispatchErrorTransactional> =
  cSp_runtimeTransactionalError

type IcSp_runtimeDispatchError =
  | { tag: "Other"; value: undefined }
  | { tag: "CannotLookup"; value: undefined }
  | { tag: "BadOrigin"; value: undefined }
  | { tag: "Module"; value: IcSp_runtimeDispatchErrorModule }
  | { tag: "ConsumerRemaining"; value: undefined }
  | { tag: "NoProviders"; value: undefined }
  | { tag: "TooManyConsumers"; value: undefined }
  | { tag: "Token"; value: IcSp_runtimeDispatchErrorToken }
  | { tag: "Arithmetic"; value: IcSp_runtimeDispatchErrorArithmetic }
  | { tag: "Transactional"; value: IcSp_runtimeDispatchErrorTransactional }
  | { tag: "Exhausted"; value: undefined }
  | { tag: "Corruption"; value: undefined }
  | { tag: "Unavailable"; value: undefined }
  | { tag: "RootNotAllowed"; value: undefined }
const cSp_runtimeDispatchError: Codec<IcSp_runtimeDispatchError> = Enum({
  Other: _void,
  CannotLookup: _void,
  BadOrigin: _void,
  Module: cSp_runtimeDispatchErrorModule,
  ConsumerRemaining: _void,
  NoProviders: _void,
  TooManyConsumers: _void,
  Token: cSp_runtimeDispatchErrorToken,
  Arithmetic: cSp_runtimeDispatchErrorArithmetic,
  Transactional: cSp_runtimeDispatchErrorTransactional,
  Exhausted: _void,
  Corruption: _void,
  Unavailable: _void,
  RootNotAllowed: _void,
})

type IcFrame_systemPalletEventExtrinsicFailed = {
  dispatch_error: IcSp_runtimeDispatchError
  dispatch_info: IcFrame_supportDispatchDispatchInfo
}
const cFrame_systemPalletEventExtrinsicFailed: Codec<IcFrame_systemPalletEventExtrinsicFailed> =
  Struct({
    dispatch_error: cSp_runtimeDispatchError,
    dispatch_info: cFrame_supportDispatchDispatchInfo,
  })

type IcFrame_systemPalletEventNewAccount = { account: Icdc1 }
const cFrame_systemPalletEventNewAccount: Codec<IcFrame_systemPalletEventNewAccount> =
  Struct({ account: cdc1 })

type IcFrame_systemPalletEventKilledAccount = { account: Icdc1 }
const cFrame_systemPalletEventKilledAccount: Codec<IcFrame_systemPalletEventKilledAccount> =
  Struct({ account: cdc1 })

type IcFrame_systemPalletEventRemarked = { sender: Icdc1; hash: Icdc13 }
const cFrame_systemPalletEventRemarked: Codec<IcFrame_systemPalletEventRemarked> =
  Struct({ sender: cdc1, hash: cdc13 })

type IcFrame_systemPalletEvent =
  | {
      tag: "ExtrinsicSuccess"
      value: IcFrame_systemPalletEventExtrinsicSuccess
    }
  | { tag: "ExtrinsicFailed"; value: IcFrame_systemPalletEventExtrinsicFailed }
  | { tag: "CodeUpdated"; value: undefined }
  | { tag: "NewAccount"; value: IcFrame_systemPalletEventNewAccount }
  | { tag: "KilledAccount"; value: IcFrame_systemPalletEventKilledAccount }
  | { tag: "Remarked"; value: IcFrame_systemPalletEventRemarked }
const cFrame_systemPalletEvent: Codec<IcFrame_systemPalletEvent> = Enum({
  ExtrinsicSuccess: cFrame_systemPalletEventExtrinsicSuccess,
  ExtrinsicFailed: cFrame_systemPalletEventExtrinsicFailed,
  CodeUpdated: _void,
  NewAccount: cFrame_systemPalletEventNewAccount,
  KilledAccount: cFrame_systemPalletEventKilledAccount,
  Remarked: cFrame_systemPalletEventRemarked,
})

type IcMoonbeam_runtimeRuntimeEventSystem = IcFrame_systemPalletEvent
const cMoonbeam_runtimeRuntimeEventSystem: Codec<IcMoonbeam_runtimeRuntimeEventSystem> =
  cFrame_systemPalletEvent

type IcCumulus_pallet_parachain_systemPalletEventValidationFunctionApplied = {
  relay_chain_block_num: number
}
const cCumulus_pallet_parachain_systemPalletEventValidationFunctionApplied: Codec<IcCumulus_pallet_parachain_systemPalletEventValidationFunctionApplied> =
  Struct({ relay_chain_block_num: u32 })

type IcCumulus_pallet_parachain_systemPalletEventUpgradeAuthorized = {
  code_hash: Icdc13
}
const cCumulus_pallet_parachain_systemPalletEventUpgradeAuthorized: Codec<IcCumulus_pallet_parachain_systemPalletEventUpgradeAuthorized> =
  Struct({ code_hash: cdc13 })

type IcCumulus_pallet_parachain_systemPalletEventDownwardMessagesReceived = {
  count: number
}
const cCumulus_pallet_parachain_systemPalletEventDownwardMessagesReceived: Codec<IcCumulus_pallet_parachain_systemPalletEventDownwardMessagesReceived> =
  Struct({ count: u32 })

type IcCumulus_pallet_parachain_systemPalletEventDownwardMessagesProcessed = {
  weight_used: IcSp_weightsWeight_v2Weight
  dmq_head: Icdc13
}
const cCumulus_pallet_parachain_systemPalletEventDownwardMessagesProcessed: Codec<IcCumulus_pallet_parachain_systemPalletEventDownwardMessagesProcessed> =
  Struct({ weight_used: cSp_weightsWeight_v2Weight, dmq_head: cdc13 })

type IcOptionSome = Icdc13
const cOptionSome: Codec<IcOptionSome> = cdc13

type IcOption =
  | { tag: "None"; value: undefined }
  | { tag: "Some"; value: IcOptionSome }
const cOption: Codec<IcOption> = Enum({ None: _void, Some: cOptionSome })

type IcCumulus_pallet_parachain_systemPalletEventUpwardMessageSent = {
  message_hash: IcOption
}
const cCumulus_pallet_parachain_systemPalletEventUpwardMessageSent: Codec<IcCumulus_pallet_parachain_systemPalletEventUpwardMessageSent> =
  Struct({ message_hash: cOption })

type IcCumulus_pallet_parachain_systemPalletEvent =
  | { tag: "ValidationFunctionStored"; value: undefined }
  | {
      tag: "ValidationFunctionApplied"
      value: IcCumulus_pallet_parachain_systemPalletEventValidationFunctionApplied
    }
  | { tag: "ValidationFunctionDiscarded"; value: undefined }
  | {
      tag: "UpgradeAuthorized"
      value: IcCumulus_pallet_parachain_systemPalletEventUpgradeAuthorized
    }
  | {
      tag: "DownwardMessagesReceived"
      value: IcCumulus_pallet_parachain_systemPalletEventDownwardMessagesReceived
    }
  | {
      tag: "DownwardMessagesProcessed"
      value: IcCumulus_pallet_parachain_systemPalletEventDownwardMessagesProcessed
    }
  | {
      tag: "UpwardMessageSent"
      value: IcCumulus_pallet_parachain_systemPalletEventUpwardMessageSent
    }
const cCumulus_pallet_parachain_systemPalletEvent: Codec<IcCumulus_pallet_parachain_systemPalletEvent> =
  Enum({
    ValidationFunctionStored: _void,
    ValidationFunctionApplied:
      cCumulus_pallet_parachain_systemPalletEventValidationFunctionApplied,
    ValidationFunctionDiscarded: _void,
    UpgradeAuthorized:
      cCumulus_pallet_parachain_systemPalletEventUpgradeAuthorized,
    DownwardMessagesReceived:
      cCumulus_pallet_parachain_systemPalletEventDownwardMessagesReceived,
    DownwardMessagesProcessed:
      cCumulus_pallet_parachain_systemPalletEventDownwardMessagesProcessed,
    UpwardMessageSent:
      cCumulus_pallet_parachain_systemPalletEventUpwardMessageSent,
  })

type IcMoonbeam_runtimeRuntimeEventParachainSystem =
  IcCumulus_pallet_parachain_systemPalletEvent
const cMoonbeam_runtimeRuntimeEventParachainSystem: Codec<IcMoonbeam_runtimeRuntimeEventParachainSystem> =
  cCumulus_pallet_parachain_systemPalletEvent

type IcPallet_balancesPalletEventEndowed = {
  account: Icdc1
  free_balance: bigint
}
const cPallet_balancesPalletEventEndowed: Codec<IcPallet_balancesPalletEventEndowed> =
  Struct({ account: cdc1, free_balance: u128 })

type IcPallet_balancesPalletEventDustLost = { account: Icdc1; amount: bigint }
const cPallet_balancesPalletEventDustLost: Codec<IcPallet_balancesPalletEventDustLost> =
  Struct({ account: cdc1, amount: u128 })

type IcPallet_balancesPalletEventTransfer = {
  from: Icdc1
  to: Icdc1
  amount: bigint
}
const cPallet_balancesPalletEventTransfer: Codec<IcPallet_balancesPalletEventTransfer> =
  Struct({ from: cdc1, to: cdc1, amount: u128 })

type IcPallet_balancesPalletEventBalanceSet = { who: Icdc1; free: bigint }
const cPallet_balancesPalletEventBalanceSet: Codec<IcPallet_balancesPalletEventBalanceSet> =
  Struct({ who: cdc1, free: u128 })

type IcPallet_balancesPalletEventReserved = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventReserved: Codec<IcPallet_balancesPalletEventReserved> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletEventUnreserved = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventUnreserved: Codec<IcPallet_balancesPalletEventUnreserved> =
  Struct({ who: cdc1, amount: u128 })

type IcFrame_supportTraitsTokensMiscBalanceStatus =
  | { tag: "Free"; value: undefined }
  | { tag: "Reserved"; value: undefined }
const cFrame_supportTraitsTokensMiscBalanceStatus: Codec<IcFrame_supportTraitsTokensMiscBalanceStatus> =
  Enum({ Free: _void, Reserved: _void })

type IcPallet_balancesPalletEventReserveRepatriated = {
  from: Icdc1
  to: Icdc1
  amount: bigint
  destination_status: IcFrame_supportTraitsTokensMiscBalanceStatus
}
const cPallet_balancesPalletEventReserveRepatriated: Codec<IcPallet_balancesPalletEventReserveRepatriated> =
  Struct({
    from: cdc1,
    to: cdc1,
    amount: u128,
    destination_status: cFrame_supportTraitsTokensMiscBalanceStatus,
  })

type IcPallet_balancesPalletEventDeposit = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventDeposit: Codec<IcPallet_balancesPalletEventDeposit> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletEventWithdraw = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventWithdraw: Codec<IcPallet_balancesPalletEventWithdraw> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletEventSlashed = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventSlashed: Codec<IcPallet_balancesPalletEventSlashed> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletEventMinted = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventMinted: Codec<IcPallet_balancesPalletEventMinted> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletEventBurned = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventBurned: Codec<IcPallet_balancesPalletEventBurned> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletEventSuspended = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventSuspended: Codec<IcPallet_balancesPalletEventSuspended> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletEventRestored = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventRestored: Codec<IcPallet_balancesPalletEventRestored> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletEventUpgraded = { who: Icdc1 }
const cPallet_balancesPalletEventUpgraded: Codec<IcPallet_balancesPalletEventUpgraded> =
  Struct({ who: cdc1 })

type IcPallet_balancesPalletEventIssued = { amount: bigint }
const cPallet_balancesPalletEventIssued: Codec<IcPallet_balancesPalletEventIssued> =
  Struct({ amount: u128 })

type IcPallet_balancesPalletEventRescinded = { amount: bigint }
const cPallet_balancesPalletEventRescinded: Codec<IcPallet_balancesPalletEventRescinded> =
  Struct({ amount: u128 })

type IcPallet_balancesPalletEventLocked = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventLocked: Codec<IcPallet_balancesPalletEventLocked> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletEventUnlocked = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventUnlocked: Codec<IcPallet_balancesPalletEventUnlocked> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletEventFrozen = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventFrozen: Codec<IcPallet_balancesPalletEventFrozen> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletEventThawed = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletEventThawed: Codec<IcPallet_balancesPalletEventThawed> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletEvent =
  | { tag: "Endowed"; value: IcPallet_balancesPalletEventEndowed }
  | { tag: "DustLost"; value: IcPallet_balancesPalletEventDustLost }
  | { tag: "Transfer"; value: IcPallet_balancesPalletEventTransfer }
  | { tag: "BalanceSet"; value: IcPallet_balancesPalletEventBalanceSet }
  | { tag: "Reserved"; value: IcPallet_balancesPalletEventReserved }
  | { tag: "Unreserved"; value: IcPallet_balancesPalletEventUnreserved }
  | {
      tag: "ReserveRepatriated"
      value: IcPallet_balancesPalletEventReserveRepatriated
    }
  | { tag: "Deposit"; value: IcPallet_balancesPalletEventDeposit }
  | { tag: "Withdraw"; value: IcPallet_balancesPalletEventWithdraw }
  | { tag: "Slashed"; value: IcPallet_balancesPalletEventSlashed }
  | { tag: "Minted"; value: IcPallet_balancesPalletEventMinted }
  | { tag: "Burned"; value: IcPallet_balancesPalletEventBurned }
  | { tag: "Suspended"; value: IcPallet_balancesPalletEventSuspended }
  | { tag: "Restored"; value: IcPallet_balancesPalletEventRestored }
  | { tag: "Upgraded"; value: IcPallet_balancesPalletEventUpgraded }
  | { tag: "Issued"; value: IcPallet_balancesPalletEventIssued }
  | { tag: "Rescinded"; value: IcPallet_balancesPalletEventRescinded }
  | { tag: "Locked"; value: IcPallet_balancesPalletEventLocked }
  | { tag: "Unlocked"; value: IcPallet_balancesPalletEventUnlocked }
  | { tag: "Frozen"; value: IcPallet_balancesPalletEventFrozen }
  | { tag: "Thawed"; value: IcPallet_balancesPalletEventThawed }
const cPallet_balancesPalletEvent: Codec<IcPallet_balancesPalletEvent> = Enum({
  Endowed: cPallet_balancesPalletEventEndowed,
  DustLost: cPallet_balancesPalletEventDustLost,
  Transfer: cPallet_balancesPalletEventTransfer,
  BalanceSet: cPallet_balancesPalletEventBalanceSet,
  Reserved: cPallet_balancesPalletEventReserved,
  Unreserved: cPallet_balancesPalletEventUnreserved,
  ReserveRepatriated: cPallet_balancesPalletEventReserveRepatriated,
  Deposit: cPallet_balancesPalletEventDeposit,
  Withdraw: cPallet_balancesPalletEventWithdraw,
  Slashed: cPallet_balancesPalletEventSlashed,
  Minted: cPallet_balancesPalletEventMinted,
  Burned: cPallet_balancesPalletEventBurned,
  Suspended: cPallet_balancesPalletEventSuspended,
  Restored: cPallet_balancesPalletEventRestored,
  Upgraded: cPallet_balancesPalletEventUpgraded,
  Issued: cPallet_balancesPalletEventIssued,
  Rescinded: cPallet_balancesPalletEventRescinded,
  Locked: cPallet_balancesPalletEventLocked,
  Unlocked: cPallet_balancesPalletEventUnlocked,
  Frozen: cPallet_balancesPalletEventFrozen,
  Thawed: cPallet_balancesPalletEventThawed,
})

type IcMoonbeam_runtimeRuntimeEventBalances = IcPallet_balancesPalletEvent
const cMoonbeam_runtimeRuntimeEventBalances: Codec<IcMoonbeam_runtimeRuntimeEventBalances> =
  cPallet_balancesPalletEvent

type IcPallet_transaction_paymentPalletEventTransactionFeePaid = {
  who: Icdc1
  actual_fee: bigint
  tip: bigint
}
const cPallet_transaction_paymentPalletEventTransactionFeePaid: Codec<IcPallet_transaction_paymentPalletEventTransactionFeePaid> =
  Struct({ who: cdc1, actual_fee: u128, tip: u128 })

type IcPallet_transaction_paymentPalletEvent = {
  tag: "TransactionFeePaid"
  value: IcPallet_transaction_paymentPalletEventTransactionFeePaid
}
const cPallet_transaction_paymentPalletEvent: Codec<IcPallet_transaction_paymentPalletEvent> =
  Enum({
    TransactionFeePaid:
      cPallet_transaction_paymentPalletEventTransactionFeePaid,
  })

type IcMoonbeam_runtimeRuntimeEventTransactionPayment =
  IcPallet_transaction_paymentPalletEvent
const cMoonbeam_runtimeRuntimeEventTransactionPayment: Codec<IcMoonbeam_runtimeRuntimeEventTransactionPayment> =
  cPallet_transaction_paymentPalletEvent

type IcPallet_parachain_stakingPalletEventNewRound = {
  starting_block: number
  round: number
  selected_collators_number: number
  total_balance: bigint
}
const cPallet_parachain_stakingPalletEventNewRound: Codec<IcPallet_parachain_stakingPalletEventNewRound> =
  Struct({
    starting_block: u32,
    round: u32,
    selected_collators_number: u32,
    total_balance: u128,
  })

type IcPallet_parachain_stakingPalletEventJoinedCollatorCandidates = {
  account: Icdc1
  amount_locked: bigint
  new_total_amt_locked: bigint
}
const cPallet_parachain_stakingPalletEventJoinedCollatorCandidates: Codec<IcPallet_parachain_stakingPalletEventJoinedCollatorCandidates> =
  Struct({ account: cdc1, amount_locked: u128, new_total_amt_locked: u128 })

type IcPallet_parachain_stakingPalletEventCollatorChosen = {
  round: number
  collator_account: Icdc1
  total_exposed_amount: bigint
}
const cPallet_parachain_stakingPalletEventCollatorChosen: Codec<IcPallet_parachain_stakingPalletEventCollatorChosen> =
  Struct({ round: u32, collator_account: cdc1, total_exposed_amount: u128 })

type IcPallet_parachain_stakingPalletEventCandidateBondLessRequested = {
  candidate: Icdc1
  amount_to_decrease: bigint
  execute_round: number
}
const cPallet_parachain_stakingPalletEventCandidateBondLessRequested: Codec<IcPallet_parachain_stakingPalletEventCandidateBondLessRequested> =
  Struct({ candidate: cdc1, amount_to_decrease: u128, execute_round: u32 })

type IcPallet_parachain_stakingPalletEventCandidateBondedMore = {
  candidate: Icdc1
  amount: bigint
  new_total_bond: bigint
}
const cPallet_parachain_stakingPalletEventCandidateBondedMore: Codec<IcPallet_parachain_stakingPalletEventCandidateBondedMore> =
  Struct({ candidate: cdc1, amount: u128, new_total_bond: u128 })

type IcPallet_parachain_stakingPalletEventCandidateBondedLess = {
  candidate: Icdc1
  amount: bigint
  new_bond: bigint
}
const cPallet_parachain_stakingPalletEventCandidateBondedLess: Codec<IcPallet_parachain_stakingPalletEventCandidateBondedLess> =
  Struct({ candidate: cdc1, amount: u128, new_bond: u128 })

type IcPallet_parachain_stakingPalletEventCandidateWentOffline = {
  candidate: Icdc1
}
const cPallet_parachain_stakingPalletEventCandidateWentOffline: Codec<IcPallet_parachain_stakingPalletEventCandidateWentOffline> =
  Struct({ candidate: cdc1 })

type IcPallet_parachain_stakingPalletEventCandidateBackOnline = {
  candidate: Icdc1
}
const cPallet_parachain_stakingPalletEventCandidateBackOnline: Codec<IcPallet_parachain_stakingPalletEventCandidateBackOnline> =
  Struct({ candidate: cdc1 })

type IcPallet_parachain_stakingPalletEventCandidateScheduledExit = {
  exit_allowed_round: number
  candidate: Icdc1
  scheduled_exit: number
}
const cPallet_parachain_stakingPalletEventCandidateScheduledExit: Codec<IcPallet_parachain_stakingPalletEventCandidateScheduledExit> =
  Struct({ exit_allowed_round: u32, candidate: cdc1, scheduled_exit: u32 })

type IcPallet_parachain_stakingPalletEventCancelledCandidateExit = {
  candidate: Icdc1
}
const cPallet_parachain_stakingPalletEventCancelledCandidateExit: Codec<IcPallet_parachain_stakingPalletEventCancelledCandidateExit> =
  Struct({ candidate: cdc1 })

type IcPallet_parachain_stakingPalletEventCancelledCandidateBondLess = {
  candidate: Icdc1
  amount: bigint
  execute_round: number
}
const cPallet_parachain_stakingPalletEventCancelledCandidateBondLess: Codec<IcPallet_parachain_stakingPalletEventCancelledCandidateBondLess> =
  Struct({ candidate: cdc1, amount: u128, execute_round: u32 })

type IcPallet_parachain_stakingPalletEventCandidateLeft = {
  ex_candidate: Icdc1
  unlocked_amount: bigint
  new_total_amt_locked: bigint
}
const cPallet_parachain_stakingPalletEventCandidateLeft: Codec<IcPallet_parachain_stakingPalletEventCandidateLeft> =
  Struct({
    ex_candidate: cdc1,
    unlocked_amount: u128,
    new_total_amt_locked: u128,
  })

type IcPallet_parachain_stakingPalletEventDelegationDecreaseScheduled = {
  delegator: Icdc1
  candidate: Icdc1
  amount_to_decrease: bigint
  execute_round: number
}
const cPallet_parachain_stakingPalletEventDelegationDecreaseScheduled: Codec<IcPallet_parachain_stakingPalletEventDelegationDecreaseScheduled> =
  Struct({
    delegator: cdc1,
    candidate: cdc1,
    amount_to_decrease: u128,
    execute_round: u32,
  })

type IcPallet_parachain_stakingPalletEventDelegationIncreased = {
  delegator: Icdc1
  candidate: Icdc1
  amount: bigint
  in_top: boolean
}
const cPallet_parachain_stakingPalletEventDelegationIncreased: Codec<IcPallet_parachain_stakingPalletEventDelegationIncreased> =
  Struct({ delegator: cdc1, candidate: cdc1, amount: u128, in_top: bool })

type IcPallet_parachain_stakingPalletEventDelegationDecreased = {
  delegator: Icdc1
  candidate: Icdc1
  amount: bigint
  in_top: boolean
}
const cPallet_parachain_stakingPalletEventDelegationDecreased: Codec<IcPallet_parachain_stakingPalletEventDelegationDecreased> =
  Struct({ delegator: cdc1, candidate: cdc1, amount: u128, in_top: bool })

type IcPallet_parachain_stakingPalletEventDelegatorExitScheduled = {
  round: number
  delegator: Icdc1
  scheduled_exit: number
}
const cPallet_parachain_stakingPalletEventDelegatorExitScheduled: Codec<IcPallet_parachain_stakingPalletEventDelegatorExitScheduled> =
  Struct({ round: u32, delegator: cdc1, scheduled_exit: u32 })

type IcPallet_parachain_stakingPalletEventDelegationRevocationScheduled = {
  round: number
  delegator: Icdc1
  candidate: Icdc1
  scheduled_exit: number
}
const cPallet_parachain_stakingPalletEventDelegationRevocationScheduled: Codec<IcPallet_parachain_stakingPalletEventDelegationRevocationScheduled> =
  Struct({ round: u32, delegator: cdc1, candidate: cdc1, scheduled_exit: u32 })

type IcPallet_parachain_stakingPalletEventDelegatorLeft = {
  delegator: Icdc1
  unstaked_amount: bigint
}
const cPallet_parachain_stakingPalletEventDelegatorLeft: Codec<IcPallet_parachain_stakingPalletEventDelegatorLeft> =
  Struct({ delegator: cdc1, unstaked_amount: u128 })

type IcPallet_parachain_stakingPalletEventDelegationRevoked = {
  delegator: Icdc1
  candidate: Icdc1
  unstaked_amount: bigint
}
const cPallet_parachain_stakingPalletEventDelegationRevoked: Codec<IcPallet_parachain_stakingPalletEventDelegationRevoked> =
  Struct({ delegator: cdc1, candidate: cdc1, unstaked_amount: u128 })

type IcPallet_parachain_stakingPalletEventDelegationKicked = {
  delegator: Icdc1
  candidate: Icdc1
  unstaked_amount: bigint
}
const cPallet_parachain_stakingPalletEventDelegationKicked: Codec<IcPallet_parachain_stakingPalletEventDelegationKicked> =
  Struct({ delegator: cdc1, candidate: cdc1, unstaked_amount: u128 })

type IcPallet_parachain_stakingPalletEventDelegatorExitCancelled = {
  delegator: Icdc1
}
const cPallet_parachain_stakingPalletEventDelegatorExitCancelled: Codec<IcPallet_parachain_stakingPalletEventDelegatorExitCancelled> =
  Struct({ delegator: cdc1 })

type IcPallet_parachain_stakingDelegation_requestsDelegationActionRevoke =
  bigint
const cPallet_parachain_stakingDelegation_requestsDelegationActionRevoke: Codec<IcPallet_parachain_stakingDelegation_requestsDelegationActionRevoke> =
  u128

type IcPallet_parachain_stakingDelegation_requestsDelegationActionDecrease =
  bigint
const cPallet_parachain_stakingDelegation_requestsDelegationActionDecrease: Codec<IcPallet_parachain_stakingDelegation_requestsDelegationActionDecrease> =
  u128

type IcPallet_parachain_stakingDelegation_requestsDelegationAction =
  | {
      tag: "Revoke"
      value: IcPallet_parachain_stakingDelegation_requestsDelegationActionRevoke
    }
  | {
      tag: "Decrease"
      value: IcPallet_parachain_stakingDelegation_requestsDelegationActionDecrease
    }
const cPallet_parachain_stakingDelegation_requestsDelegationAction: Codec<IcPallet_parachain_stakingDelegation_requestsDelegationAction> =
  Enum({
    Revoke: cPallet_parachain_stakingDelegation_requestsDelegationActionRevoke,
    Decrease:
      cPallet_parachain_stakingDelegation_requestsDelegationActionDecrease,
  })

type IcPallet_parachain_stakingDelegation_requestsCancelledScheduledRequest = {
  when_executable: number
  action: IcPallet_parachain_stakingDelegation_requestsDelegationAction
}
const cPallet_parachain_stakingDelegation_requestsCancelledScheduledRequest: Codec<IcPallet_parachain_stakingDelegation_requestsCancelledScheduledRequest> =
  Struct({
    when_executable: u32,
    action: cPallet_parachain_stakingDelegation_requestsDelegationAction,
  })

type IcPallet_parachain_stakingPalletEventCancelledDelegationRequest = {
  delegator: Icdc1
  cancelled_request: IcPallet_parachain_stakingDelegation_requestsCancelledScheduledRequest
  collator: Icdc1
}
const cPallet_parachain_stakingPalletEventCancelledDelegationRequest: Codec<IcPallet_parachain_stakingPalletEventCancelledDelegationRequest> =
  Struct({
    delegator: cdc1,
    cancelled_request:
      cPallet_parachain_stakingDelegation_requestsCancelledScheduledRequest,
    collator: cdc1,
  })

type IcPallet_parachain_stakingTypesDelegatorAddedAddedToTop = {
  new_total: bigint
}
const cPallet_parachain_stakingTypesDelegatorAddedAddedToTop: Codec<IcPallet_parachain_stakingTypesDelegatorAddedAddedToTop> =
  Struct({ new_total: u128 })

type IcPallet_parachain_stakingTypesDelegatorAdded =
  | {
      tag: "AddedToTop"
      value: IcPallet_parachain_stakingTypesDelegatorAddedAddedToTop
    }
  | { tag: "AddedToBottom"; value: undefined }
const cPallet_parachain_stakingTypesDelegatorAdded: Codec<IcPallet_parachain_stakingTypesDelegatorAdded> =
  Enum({
    AddedToTop: cPallet_parachain_stakingTypesDelegatorAddedAddedToTop,
    AddedToBottom: _void,
  })

type IcPallet_parachain_stakingPalletEventDelegation = {
  delegator: Icdc1
  locked_amount: bigint
  candidate: Icdc1
  delegator_position: IcPallet_parachain_stakingTypesDelegatorAdded
  auto_compound: number
}
const cPallet_parachain_stakingPalletEventDelegation: Codec<IcPallet_parachain_stakingPalletEventDelegation> =
  Struct({
    delegator: cdc1,
    locked_amount: u128,
    candidate: cdc1,
    delegator_position: cPallet_parachain_stakingTypesDelegatorAdded,
    auto_compound: u8,
  })

type IcPallet_parachain_stakingPalletEventDelegatorLeftCandidate = {
  delegator: Icdc1
  candidate: Icdc1
  unstaked_amount: bigint
  total_candidate_staked: bigint
}
const cPallet_parachain_stakingPalletEventDelegatorLeftCandidate: Codec<IcPallet_parachain_stakingPalletEventDelegatorLeftCandidate> =
  Struct({
    delegator: cdc1,
    candidate: cdc1,
    unstaked_amount: u128,
    total_candidate_staked: u128,
  })

type IcPallet_parachain_stakingPalletEventRewarded = {
  account: Icdc1
  rewards: bigint
}
const cPallet_parachain_stakingPalletEventRewarded: Codec<IcPallet_parachain_stakingPalletEventRewarded> =
  Struct({ account: cdc1, rewards: u128 })

type IcPallet_parachain_stakingPalletEventReservedForParachainBond = {
  account: Icdc1
  value: bigint
}
const cPallet_parachain_stakingPalletEventReservedForParachainBond: Codec<IcPallet_parachain_stakingPalletEventReservedForParachainBond> =
  Struct({ account: cdc1, value: u128 })

type IcPallet_parachain_stakingPalletEventParachainBondAccountSet = {
  old: Icdc1
  new: Icdc1
}
const cPallet_parachain_stakingPalletEventParachainBondAccountSet: Codec<IcPallet_parachain_stakingPalletEventParachainBondAccountSet> =
  Struct({ old: cdc1, new: cdc1 })

type IcPallet_parachain_stakingPalletEventParachainBondReservePercentSet = {
  old: number
  new: number
}
const cPallet_parachain_stakingPalletEventParachainBondReservePercentSet: Codec<IcPallet_parachain_stakingPalletEventParachainBondReservePercentSet> =
  Struct({ old: u8, new: u8 })

type IcPallet_parachain_stakingPalletEventInflationSet = {
  annual_min: number
  annual_ideal: number
  annual_max: number
  round_min: number
  round_ideal: number
  round_max: number
}
const cPallet_parachain_stakingPalletEventInflationSet: Codec<IcPallet_parachain_stakingPalletEventInflationSet> =
  Struct({
    annual_min: u32,
    annual_ideal: u32,
    annual_max: u32,
    round_min: u32,
    round_ideal: u32,
    round_max: u32,
  })

type IcPallet_parachain_stakingPalletEventStakeExpectationsSet = {
  expect_min: bigint
  expect_ideal: bigint
  expect_max: bigint
}
const cPallet_parachain_stakingPalletEventStakeExpectationsSet: Codec<IcPallet_parachain_stakingPalletEventStakeExpectationsSet> =
  Struct({ expect_min: u128, expect_ideal: u128, expect_max: u128 })

type IcPallet_parachain_stakingPalletEventTotalSelectedSet = {
  old: number
  new: number
}
const cPallet_parachain_stakingPalletEventTotalSelectedSet: Codec<IcPallet_parachain_stakingPalletEventTotalSelectedSet> =
  Struct({ old: u32, new: u32 })

type IcPallet_parachain_stakingPalletEventCollatorCommissionSet = {
  old: number
  new: number
}
const cPallet_parachain_stakingPalletEventCollatorCommissionSet: Codec<IcPallet_parachain_stakingPalletEventCollatorCommissionSet> =
  Struct({ old: u32, new: u32 })

type IcPallet_parachain_stakingPalletEventBlocksPerRoundSet = {
  current_round: number
  first_block: number
  old: number
  new: number
  new_per_round_inflation_min: number
  new_per_round_inflation_ideal: number
  new_per_round_inflation_max: number
}
const cPallet_parachain_stakingPalletEventBlocksPerRoundSet: Codec<IcPallet_parachain_stakingPalletEventBlocksPerRoundSet> =
  Struct({
    current_round: u32,
    first_block: u32,
    old: u32,
    new: u32,
    new_per_round_inflation_min: u32,
    new_per_round_inflation_ideal: u32,
    new_per_round_inflation_max: u32,
  })

type IcPallet_parachain_stakingPalletEventAutoCompoundSet = {
  candidate: Icdc1
  delegator: Icdc1
  value: number
}
const cPallet_parachain_stakingPalletEventAutoCompoundSet: Codec<IcPallet_parachain_stakingPalletEventAutoCompoundSet> =
  Struct({ candidate: cdc1, delegator: cdc1, value: u8 })

type IcPallet_parachain_stakingPalletEventCompounded = {
  candidate: Icdc1
  delegator: Icdc1
  amount: bigint
}
const cPallet_parachain_stakingPalletEventCompounded: Codec<IcPallet_parachain_stakingPalletEventCompounded> =
  Struct({ candidate: cdc1, delegator: cdc1, amount: u128 })

type IcPallet_parachain_stakingPalletEvent =
  | { tag: "NewRound"; value: IcPallet_parachain_stakingPalletEventNewRound }
  | {
      tag: "JoinedCollatorCandidates"
      value: IcPallet_parachain_stakingPalletEventJoinedCollatorCandidates
    }
  | {
      tag: "CollatorChosen"
      value: IcPallet_parachain_stakingPalletEventCollatorChosen
    }
  | {
      tag: "CandidateBondLessRequested"
      value: IcPallet_parachain_stakingPalletEventCandidateBondLessRequested
    }
  | {
      tag: "CandidateBondedMore"
      value: IcPallet_parachain_stakingPalletEventCandidateBondedMore
    }
  | {
      tag: "CandidateBondedLess"
      value: IcPallet_parachain_stakingPalletEventCandidateBondedLess
    }
  | {
      tag: "CandidateWentOffline"
      value: IcPallet_parachain_stakingPalletEventCandidateWentOffline
    }
  | {
      tag: "CandidateBackOnline"
      value: IcPallet_parachain_stakingPalletEventCandidateBackOnline
    }
  | {
      tag: "CandidateScheduledExit"
      value: IcPallet_parachain_stakingPalletEventCandidateScheduledExit
    }
  | {
      tag: "CancelledCandidateExit"
      value: IcPallet_parachain_stakingPalletEventCancelledCandidateExit
    }
  | {
      tag: "CancelledCandidateBondLess"
      value: IcPallet_parachain_stakingPalletEventCancelledCandidateBondLess
    }
  | {
      tag: "CandidateLeft"
      value: IcPallet_parachain_stakingPalletEventCandidateLeft
    }
  | {
      tag: "DelegationDecreaseScheduled"
      value: IcPallet_parachain_stakingPalletEventDelegationDecreaseScheduled
    }
  | {
      tag: "DelegationIncreased"
      value: IcPallet_parachain_stakingPalletEventDelegationIncreased
    }
  | {
      tag: "DelegationDecreased"
      value: IcPallet_parachain_stakingPalletEventDelegationDecreased
    }
  | {
      tag: "DelegatorExitScheduled"
      value: IcPallet_parachain_stakingPalletEventDelegatorExitScheduled
    }
  | {
      tag: "DelegationRevocationScheduled"
      value: IcPallet_parachain_stakingPalletEventDelegationRevocationScheduled
    }
  | {
      tag: "DelegatorLeft"
      value: IcPallet_parachain_stakingPalletEventDelegatorLeft
    }
  | {
      tag: "DelegationRevoked"
      value: IcPallet_parachain_stakingPalletEventDelegationRevoked
    }
  | {
      tag: "DelegationKicked"
      value: IcPallet_parachain_stakingPalletEventDelegationKicked
    }
  | {
      tag: "DelegatorExitCancelled"
      value: IcPallet_parachain_stakingPalletEventDelegatorExitCancelled
    }
  | {
      tag: "CancelledDelegationRequest"
      value: IcPallet_parachain_stakingPalletEventCancelledDelegationRequest
    }
  | {
      tag: "Delegation"
      value: IcPallet_parachain_stakingPalletEventDelegation
    }
  | {
      tag: "DelegatorLeftCandidate"
      value: IcPallet_parachain_stakingPalletEventDelegatorLeftCandidate
    }
  | { tag: "Rewarded"; value: IcPallet_parachain_stakingPalletEventRewarded }
  | {
      tag: "ReservedForParachainBond"
      value: IcPallet_parachain_stakingPalletEventReservedForParachainBond
    }
  | {
      tag: "ParachainBondAccountSet"
      value: IcPallet_parachain_stakingPalletEventParachainBondAccountSet
    }
  | {
      tag: "ParachainBondReservePercentSet"
      value: IcPallet_parachain_stakingPalletEventParachainBondReservePercentSet
    }
  | {
      tag: "InflationSet"
      value: IcPallet_parachain_stakingPalletEventInflationSet
    }
  | {
      tag: "StakeExpectationsSet"
      value: IcPallet_parachain_stakingPalletEventStakeExpectationsSet
    }
  | {
      tag: "TotalSelectedSet"
      value: IcPallet_parachain_stakingPalletEventTotalSelectedSet
    }
  | {
      tag: "CollatorCommissionSet"
      value: IcPallet_parachain_stakingPalletEventCollatorCommissionSet
    }
  | {
      tag: "BlocksPerRoundSet"
      value: IcPallet_parachain_stakingPalletEventBlocksPerRoundSet
    }
  | {
      tag: "AutoCompoundSet"
      value: IcPallet_parachain_stakingPalletEventAutoCompoundSet
    }
  | {
      tag: "Compounded"
      value: IcPallet_parachain_stakingPalletEventCompounded
    }
const cPallet_parachain_stakingPalletEvent: Codec<IcPallet_parachain_stakingPalletEvent> =
  Enum({
    NewRound: cPallet_parachain_stakingPalletEventNewRound,
    JoinedCollatorCandidates:
      cPallet_parachain_stakingPalletEventJoinedCollatorCandidates,
    CollatorChosen: cPallet_parachain_stakingPalletEventCollatorChosen,
    CandidateBondLessRequested:
      cPallet_parachain_stakingPalletEventCandidateBondLessRequested,
    CandidateBondedMore:
      cPallet_parachain_stakingPalletEventCandidateBondedMore,
    CandidateBondedLess:
      cPallet_parachain_stakingPalletEventCandidateBondedLess,
    CandidateWentOffline:
      cPallet_parachain_stakingPalletEventCandidateWentOffline,
    CandidateBackOnline:
      cPallet_parachain_stakingPalletEventCandidateBackOnline,
    CandidateScheduledExit:
      cPallet_parachain_stakingPalletEventCandidateScheduledExit,
    CancelledCandidateExit:
      cPallet_parachain_stakingPalletEventCancelledCandidateExit,
    CancelledCandidateBondLess:
      cPallet_parachain_stakingPalletEventCancelledCandidateBondLess,
    CandidateLeft: cPallet_parachain_stakingPalletEventCandidateLeft,
    DelegationDecreaseScheduled:
      cPallet_parachain_stakingPalletEventDelegationDecreaseScheduled,
    DelegationIncreased:
      cPallet_parachain_stakingPalletEventDelegationIncreased,
    DelegationDecreased:
      cPallet_parachain_stakingPalletEventDelegationDecreased,
    DelegatorExitScheduled:
      cPallet_parachain_stakingPalletEventDelegatorExitScheduled,
    DelegationRevocationScheduled:
      cPallet_parachain_stakingPalletEventDelegationRevocationScheduled,
    DelegatorLeft: cPallet_parachain_stakingPalletEventDelegatorLeft,
    DelegationRevoked: cPallet_parachain_stakingPalletEventDelegationRevoked,
    DelegationKicked: cPallet_parachain_stakingPalletEventDelegationKicked,
    DelegatorExitCancelled:
      cPallet_parachain_stakingPalletEventDelegatorExitCancelled,
    CancelledDelegationRequest:
      cPallet_parachain_stakingPalletEventCancelledDelegationRequest,
    Delegation: cPallet_parachain_stakingPalletEventDelegation,
    DelegatorLeftCandidate:
      cPallet_parachain_stakingPalletEventDelegatorLeftCandidate,
    Rewarded: cPallet_parachain_stakingPalletEventRewarded,
    ReservedForParachainBond:
      cPallet_parachain_stakingPalletEventReservedForParachainBond,
    ParachainBondAccountSet:
      cPallet_parachain_stakingPalletEventParachainBondAccountSet,
    ParachainBondReservePercentSet:
      cPallet_parachain_stakingPalletEventParachainBondReservePercentSet,
    InflationSet: cPallet_parachain_stakingPalletEventInflationSet,
    StakeExpectationsSet:
      cPallet_parachain_stakingPalletEventStakeExpectationsSet,
    TotalSelectedSet: cPallet_parachain_stakingPalletEventTotalSelectedSet,
    CollatorCommissionSet:
      cPallet_parachain_stakingPalletEventCollatorCommissionSet,
    BlocksPerRoundSet: cPallet_parachain_stakingPalletEventBlocksPerRoundSet,
    AutoCompoundSet: cPallet_parachain_stakingPalletEventAutoCompoundSet,
    Compounded: cPallet_parachain_stakingPalletEventCompounded,
  })

type IcMoonbeam_runtimeRuntimeEventParachainStaking =
  IcPallet_parachain_stakingPalletEvent
const cMoonbeam_runtimeRuntimeEventParachainStaking: Codec<IcMoonbeam_runtimeRuntimeEventParachainStaking> =
  cPallet_parachain_stakingPalletEvent

type IcPallet_author_slot_filterPalletEventEligibleUpdated = number
const cPallet_author_slot_filterPalletEventEligibleUpdated: Codec<IcPallet_author_slot_filterPalletEventEligibleUpdated> =
  u32

type IcPallet_author_slot_filterPalletEvent = {
  tag: "EligibleUpdated"
  value: IcPallet_author_slot_filterPalletEventEligibleUpdated
}
const cPallet_author_slot_filterPalletEvent: Codec<IcPallet_author_slot_filterPalletEvent> =
  Enum({
    EligibleUpdated: cPallet_author_slot_filterPalletEventEligibleUpdated,
  })

type IcMoonbeam_runtimeRuntimeEventAuthorFilter =
  IcPallet_author_slot_filterPalletEvent
const cMoonbeam_runtimeRuntimeEventAuthorFilter: Codec<IcMoonbeam_runtimeRuntimeEventAuthorFilter> =
  cPallet_author_slot_filterPalletEvent

type IcPallet_author_mappingPalletEventKeysRegistered = {
  nimbus_id: Icdc13
  account_id: Icdc1
  keys: Icdc13
}
const cPallet_author_mappingPalletEventKeysRegistered: Codec<IcPallet_author_mappingPalletEventKeysRegistered> =
  Struct({ nimbus_id: cdc13, account_id: cdc1, keys: cdc13 })

type IcPallet_author_mappingPalletEventKeysRemoved = {
  nimbus_id: Icdc13
  account_id: Icdc1
  keys: Icdc13
}
const cPallet_author_mappingPalletEventKeysRemoved: Codec<IcPallet_author_mappingPalletEventKeysRemoved> =
  Struct({ nimbus_id: cdc13, account_id: cdc1, keys: cdc13 })

type IcPallet_author_mappingPalletEventKeysRotated = {
  new_nimbus_id: Icdc13
  account_id: Icdc1
  new_keys: Icdc13
}
const cPallet_author_mappingPalletEventKeysRotated: Codec<IcPallet_author_mappingPalletEventKeysRotated> =
  Struct({ new_nimbus_id: cdc13, account_id: cdc1, new_keys: cdc13 })

type IcPallet_author_mappingPalletEvent =
  | {
      tag: "KeysRegistered"
      value: IcPallet_author_mappingPalletEventKeysRegistered
    }
  | { tag: "KeysRemoved"; value: IcPallet_author_mappingPalletEventKeysRemoved }
  | { tag: "KeysRotated"; value: IcPallet_author_mappingPalletEventKeysRotated }
const cPallet_author_mappingPalletEvent: Codec<IcPallet_author_mappingPalletEvent> =
  Enum({
    KeysRegistered: cPallet_author_mappingPalletEventKeysRegistered,
    KeysRemoved: cPallet_author_mappingPalletEventKeysRemoved,
    KeysRotated: cPallet_author_mappingPalletEventKeysRotated,
  })

type IcMoonbeam_runtimeRuntimeEventAuthorMapping =
  IcPallet_author_mappingPalletEvent
const cMoonbeam_runtimeRuntimeEventAuthorMapping: Codec<IcMoonbeam_runtimeRuntimeEventAuthorMapping> =
  cPallet_author_mappingPalletEvent

type IcPallet_moonbeam_orbitersPalletEventOrbiterJoinCollatorPool = {
  collator: Icdc1
  orbiter: Icdc1
}
const cPallet_moonbeam_orbitersPalletEventOrbiterJoinCollatorPool: Codec<IcPallet_moonbeam_orbitersPalletEventOrbiterJoinCollatorPool> =
  Struct({ collator: cdc1, orbiter: cdc1 })

type IcPallet_moonbeam_orbitersPalletEventOrbiterLeaveCollatorPool = {
  collator: Icdc1
  orbiter: Icdc1
}
const cPallet_moonbeam_orbitersPalletEventOrbiterLeaveCollatorPool: Codec<IcPallet_moonbeam_orbitersPalletEventOrbiterLeaveCollatorPool> =
  Struct({ collator: cdc1, orbiter: cdc1 })

type IcPallet_moonbeam_orbitersPalletEventOrbiterRewarded = {
  account: Icdc1
  rewards: bigint
}
const cPallet_moonbeam_orbitersPalletEventOrbiterRewarded: Codec<IcPallet_moonbeam_orbitersPalletEventOrbiterRewarded> =
  Struct({ account: cdc1, rewards: u128 })

type IcPallet_moonbeam_orbitersPalletEventOrbiterRotation = {
  collator: Icdc1
  old_orbiter: IcOption
  new_orbiter: IcOption
}
const cPallet_moonbeam_orbitersPalletEventOrbiterRotation: Codec<IcPallet_moonbeam_orbitersPalletEventOrbiterRotation> =
  Struct({ collator: cdc1, old_orbiter: cOption, new_orbiter: cOption })

type IcPallet_moonbeam_orbitersPalletEventOrbiterRegistered = {
  account: Icdc1
  deposit: bigint
}
const cPallet_moonbeam_orbitersPalletEventOrbiterRegistered: Codec<IcPallet_moonbeam_orbitersPalletEventOrbiterRegistered> =
  Struct({ account: cdc1, deposit: u128 })

type IcPallet_moonbeam_orbitersPalletEventOrbiterUnregistered = {
  account: Icdc1
}
const cPallet_moonbeam_orbitersPalletEventOrbiterUnregistered: Codec<IcPallet_moonbeam_orbitersPalletEventOrbiterUnregistered> =
  Struct({ account: cdc1 })

type IcPallet_moonbeam_orbitersPalletEvent =
  | {
      tag: "OrbiterJoinCollatorPool"
      value: IcPallet_moonbeam_orbitersPalletEventOrbiterJoinCollatorPool
    }
  | {
      tag: "OrbiterLeaveCollatorPool"
      value: IcPallet_moonbeam_orbitersPalletEventOrbiterLeaveCollatorPool
    }
  | {
      tag: "OrbiterRewarded"
      value: IcPallet_moonbeam_orbitersPalletEventOrbiterRewarded
    }
  | {
      tag: "OrbiterRotation"
      value: IcPallet_moonbeam_orbitersPalletEventOrbiterRotation
    }
  | {
      tag: "OrbiterRegistered"
      value: IcPallet_moonbeam_orbitersPalletEventOrbiterRegistered
    }
  | {
      tag: "OrbiterUnregistered"
      value: IcPallet_moonbeam_orbitersPalletEventOrbiterUnregistered
    }
const cPallet_moonbeam_orbitersPalletEvent: Codec<IcPallet_moonbeam_orbitersPalletEvent> =
  Enum({
    OrbiterJoinCollatorPool:
      cPallet_moonbeam_orbitersPalletEventOrbiterJoinCollatorPool,
    OrbiterLeaveCollatorPool:
      cPallet_moonbeam_orbitersPalletEventOrbiterLeaveCollatorPool,
    OrbiterRewarded: cPallet_moonbeam_orbitersPalletEventOrbiterRewarded,
    OrbiterRotation: cPallet_moonbeam_orbitersPalletEventOrbiterRotation,
    OrbiterRegistered: cPallet_moonbeam_orbitersPalletEventOrbiterRegistered,
    OrbiterUnregistered:
      cPallet_moonbeam_orbitersPalletEventOrbiterUnregistered,
  })

type IcMoonbeam_runtimeRuntimeEventMoonbeamOrbiters =
  IcPallet_moonbeam_orbitersPalletEvent
const cMoonbeam_runtimeRuntimeEventMoonbeamOrbiters: Codec<IcMoonbeam_runtimeRuntimeEventMoonbeamOrbiters> =
  cPallet_moonbeam_orbitersPalletEvent

type IcPallet_utilityPalletEventBatchInterrupted = {
  index: number
  error: IcSp_runtimeDispatchError
}
const cPallet_utilityPalletEventBatchInterrupted: Codec<IcPallet_utilityPalletEventBatchInterrupted> =
  Struct({ index: u32, error: cSp_runtimeDispatchError })

type IcPallet_utilityPalletEventItemFailed = {
  error: IcSp_runtimeDispatchError
}
const cPallet_utilityPalletEventItemFailed: Codec<IcPallet_utilityPalletEventItemFailed> =
  Struct({ error: cSp_runtimeDispatchError })

type IcResultOk = undefined
const cResultOk: Codec<IcResultOk> = _void

type IcResultErr = IcSp_runtimeDispatchError
const cResultErr: Codec<IcResultErr> = cSp_runtimeDispatchError

type IcResult =
  | { tag: "Ok"; value: IcResultOk }
  | { tag: "Err"; value: IcResultErr }
const cResult: Codec<IcResult> = Enum({ Ok: cResultOk, Err: cResultErr })

type IcPallet_utilityPalletEventDispatchedAs = { result: IcResult }
const cPallet_utilityPalletEventDispatchedAs: Codec<IcPallet_utilityPalletEventDispatchedAs> =
  Struct({ result: cResult })

type IcPallet_utilityPalletEvent =
  | {
      tag: "BatchInterrupted"
      value: IcPallet_utilityPalletEventBatchInterrupted
    }
  | { tag: "BatchCompleted"; value: undefined }
  | { tag: "BatchCompletedWithErrors"; value: undefined }
  | { tag: "ItemCompleted"; value: undefined }
  | { tag: "ItemFailed"; value: IcPallet_utilityPalletEventItemFailed }
  | { tag: "DispatchedAs"; value: IcPallet_utilityPalletEventDispatchedAs }
const cPallet_utilityPalletEvent: Codec<IcPallet_utilityPalletEvent> = Enum({
  BatchInterrupted: cPallet_utilityPalletEventBatchInterrupted,
  BatchCompleted: _void,
  BatchCompletedWithErrors: _void,
  ItemCompleted: _void,
  ItemFailed: cPallet_utilityPalletEventItemFailed,
  DispatchedAs: cPallet_utilityPalletEventDispatchedAs,
})

type IcMoonbeam_runtimeRuntimeEventUtility = IcPallet_utilityPalletEvent
const cMoonbeam_runtimeRuntimeEventUtility: Codec<IcMoonbeam_runtimeRuntimeEventUtility> =
  cPallet_utilityPalletEvent

type IcPallet_proxyPalletEventProxyExecuted = { result: IcResult }
const cPallet_proxyPalletEventProxyExecuted: Codec<IcPallet_proxyPalletEventProxyExecuted> =
  Struct({ result: cResult })

type IcMoonbeam_runtimeProxyType =
  | { tag: "Any"; value: undefined }
  | { tag: "NonTransfer"; value: undefined }
  | { tag: "Governance"; value: undefined }
  | { tag: "Staking"; value: undefined }
  | { tag: "CancelProxy"; value: undefined }
  | { tag: "Balances"; value: undefined }
  | { tag: "AuthorMapping"; value: undefined }
  | { tag: "IdentityJudgement"; value: undefined }
const cMoonbeam_runtimeProxyType: Codec<IcMoonbeam_runtimeProxyType> = Enum({
  Any: _void,
  NonTransfer: _void,
  Governance: _void,
  Staking: _void,
  CancelProxy: _void,
  Balances: _void,
  AuthorMapping: _void,
  IdentityJudgement: _void,
})

type IcPallet_proxyPalletEventPureCreated = {
  pure: Icdc1
  who: Icdc1
  proxy_type: IcMoonbeam_runtimeProxyType
  disambiguation_index: number
}
const cPallet_proxyPalletEventPureCreated: Codec<IcPallet_proxyPalletEventPureCreated> =
  Struct({
    pure: cdc1,
    who: cdc1,
    proxy_type: cMoonbeam_runtimeProxyType,
    disambiguation_index: u16,
  })

type IcPallet_proxyPalletEventAnnounced = {
  real: Icdc1
  proxy: Icdc1
  call_hash: Icdc13
}
const cPallet_proxyPalletEventAnnounced: Codec<IcPallet_proxyPalletEventAnnounced> =
  Struct({ real: cdc1, proxy: cdc1, call_hash: cdc13 })

type IcPallet_proxyPalletEventProxyAdded = {
  delegator: Icdc1
  delegatee: Icdc1
  proxy_type: IcMoonbeam_runtimeProxyType
  delay: number
}
const cPallet_proxyPalletEventProxyAdded: Codec<IcPallet_proxyPalletEventProxyAdded> =
  Struct({
    delegator: cdc1,
    delegatee: cdc1,
    proxy_type: cMoonbeam_runtimeProxyType,
    delay: u32,
  })

type IcPallet_proxyPalletEventProxyRemoved = {
  delegator: Icdc1
  delegatee: Icdc1
  proxy_type: IcMoonbeam_runtimeProxyType
  delay: number
}
const cPallet_proxyPalletEventProxyRemoved: Codec<IcPallet_proxyPalletEventProxyRemoved> =
  Struct({
    delegator: cdc1,
    delegatee: cdc1,
    proxy_type: cMoonbeam_runtimeProxyType,
    delay: u32,
  })

type IcPallet_proxyPalletEvent =
  | { tag: "ProxyExecuted"; value: IcPallet_proxyPalletEventProxyExecuted }
  | { tag: "PureCreated"; value: IcPallet_proxyPalletEventPureCreated }
  | { tag: "Announced"; value: IcPallet_proxyPalletEventAnnounced }
  | { tag: "ProxyAdded"; value: IcPallet_proxyPalletEventProxyAdded }
  | { tag: "ProxyRemoved"; value: IcPallet_proxyPalletEventProxyRemoved }
const cPallet_proxyPalletEvent: Codec<IcPallet_proxyPalletEvent> = Enum({
  ProxyExecuted: cPallet_proxyPalletEventProxyExecuted,
  PureCreated: cPallet_proxyPalletEventPureCreated,
  Announced: cPallet_proxyPalletEventAnnounced,
  ProxyAdded: cPallet_proxyPalletEventProxyAdded,
  ProxyRemoved: cPallet_proxyPalletEventProxyRemoved,
})

type IcMoonbeam_runtimeRuntimeEventProxy = IcPallet_proxyPalletEvent
const cMoonbeam_runtimeRuntimeEventProxy: Codec<IcMoonbeam_runtimeRuntimeEventProxy> =
  cPallet_proxyPalletEvent

type IcPallet_maintenance_modePalletEventFailedToSuspendIdleXcmExecution = {
  error: IcSp_runtimeDispatchError
}
const cPallet_maintenance_modePalletEventFailedToSuspendIdleXcmExecution: Codec<IcPallet_maintenance_modePalletEventFailedToSuspendIdleXcmExecution> =
  Struct({ error: cSp_runtimeDispatchError })

type IcPallet_maintenance_modePalletEventFailedToResumeIdleXcmExecution = {
  error: IcSp_runtimeDispatchError
}
const cPallet_maintenance_modePalletEventFailedToResumeIdleXcmExecution: Codec<IcPallet_maintenance_modePalletEventFailedToResumeIdleXcmExecution> =
  Struct({ error: cSp_runtimeDispatchError })

type IcPallet_maintenance_modePalletEvent =
  | { tag: "EnteredMaintenanceMode"; value: undefined }
  | { tag: "NormalOperationResumed"; value: undefined }
  | {
      tag: "FailedToSuspendIdleXcmExecution"
      value: IcPallet_maintenance_modePalletEventFailedToSuspendIdleXcmExecution
    }
  | {
      tag: "FailedToResumeIdleXcmExecution"
      value: IcPallet_maintenance_modePalletEventFailedToResumeIdleXcmExecution
    }
const cPallet_maintenance_modePalletEvent: Codec<IcPallet_maintenance_modePalletEvent> =
  Enum({
    EnteredMaintenanceMode: _void,
    NormalOperationResumed: _void,
    FailedToSuspendIdleXcmExecution:
      cPallet_maintenance_modePalletEventFailedToSuspendIdleXcmExecution,
    FailedToResumeIdleXcmExecution:
      cPallet_maintenance_modePalletEventFailedToResumeIdleXcmExecution,
  })

type IcMoonbeam_runtimeRuntimeEventMaintenanceMode =
  IcPallet_maintenance_modePalletEvent
const cMoonbeam_runtimeRuntimeEventMaintenanceMode: Codec<IcMoonbeam_runtimeRuntimeEventMaintenanceMode> =
  cPallet_maintenance_modePalletEvent

type IcPallet_identityPalletEventIdentitySet = { who: Icdc1 }
const cPallet_identityPalletEventIdentitySet: Codec<IcPallet_identityPalletEventIdentitySet> =
  Struct({ who: cdc1 })

type IcPallet_identityPalletEventIdentityCleared = {
  who: Icdc1
  deposit: bigint
}
const cPallet_identityPalletEventIdentityCleared: Codec<IcPallet_identityPalletEventIdentityCleared> =
  Struct({ who: cdc1, deposit: u128 })

type IcPallet_identityPalletEventIdentityKilled = {
  who: Icdc1
  deposit: bigint
}
const cPallet_identityPalletEventIdentityKilled: Codec<IcPallet_identityPalletEventIdentityKilled> =
  Struct({ who: cdc1, deposit: u128 })

type IcPallet_identityPalletEventJudgementRequested = {
  who: Icdc1
  registrar_index: number
}
const cPallet_identityPalletEventJudgementRequested: Codec<IcPallet_identityPalletEventJudgementRequested> =
  Struct({ who: cdc1, registrar_index: u32 })

type IcPallet_identityPalletEventJudgementUnrequested = {
  who: Icdc1
  registrar_index: number
}
const cPallet_identityPalletEventJudgementUnrequested: Codec<IcPallet_identityPalletEventJudgementUnrequested> =
  Struct({ who: cdc1, registrar_index: u32 })

type IcPallet_identityPalletEventJudgementGiven = {
  target: Icdc1
  registrar_index: number
}
const cPallet_identityPalletEventJudgementGiven: Codec<IcPallet_identityPalletEventJudgementGiven> =
  Struct({ target: cdc1, registrar_index: u32 })

type IcPallet_identityPalletEventRegistrarAdded = { registrar_index: number }
const cPallet_identityPalletEventRegistrarAdded: Codec<IcPallet_identityPalletEventRegistrarAdded> =
  Struct({ registrar_index: u32 })

type IcPallet_identityPalletEventSubIdentityAdded = {
  sub: Icdc1
  main: Icdc1
  deposit: bigint
}
const cPallet_identityPalletEventSubIdentityAdded: Codec<IcPallet_identityPalletEventSubIdentityAdded> =
  Struct({ sub: cdc1, main: cdc1, deposit: u128 })

type IcPallet_identityPalletEventSubIdentityRemoved = {
  sub: Icdc1
  main: Icdc1
  deposit: bigint
}
const cPallet_identityPalletEventSubIdentityRemoved: Codec<IcPallet_identityPalletEventSubIdentityRemoved> =
  Struct({ sub: cdc1, main: cdc1, deposit: u128 })

type IcPallet_identityPalletEventSubIdentityRevoked = {
  sub: Icdc1
  main: Icdc1
  deposit: bigint
}
const cPallet_identityPalletEventSubIdentityRevoked: Codec<IcPallet_identityPalletEventSubIdentityRevoked> =
  Struct({ sub: cdc1, main: cdc1, deposit: u128 })

type IcPallet_identityPalletEvent =
  | { tag: "IdentitySet"; value: IcPallet_identityPalletEventIdentitySet }
  | {
      tag: "IdentityCleared"
      value: IcPallet_identityPalletEventIdentityCleared
    }
  | { tag: "IdentityKilled"; value: IcPallet_identityPalletEventIdentityKilled }
  | {
      tag: "JudgementRequested"
      value: IcPallet_identityPalletEventJudgementRequested
    }
  | {
      tag: "JudgementUnrequested"
      value: IcPallet_identityPalletEventJudgementUnrequested
    }
  | { tag: "JudgementGiven"; value: IcPallet_identityPalletEventJudgementGiven }
  | { tag: "RegistrarAdded"; value: IcPallet_identityPalletEventRegistrarAdded }
  | {
      tag: "SubIdentityAdded"
      value: IcPallet_identityPalletEventSubIdentityAdded
    }
  | {
      tag: "SubIdentityRemoved"
      value: IcPallet_identityPalletEventSubIdentityRemoved
    }
  | {
      tag: "SubIdentityRevoked"
      value: IcPallet_identityPalletEventSubIdentityRevoked
    }
const cPallet_identityPalletEvent: Codec<IcPallet_identityPalletEvent> = Enum({
  IdentitySet: cPallet_identityPalletEventIdentitySet,
  IdentityCleared: cPallet_identityPalletEventIdentityCleared,
  IdentityKilled: cPallet_identityPalletEventIdentityKilled,
  JudgementRequested: cPallet_identityPalletEventJudgementRequested,
  JudgementUnrequested: cPallet_identityPalletEventJudgementUnrequested,
  JudgementGiven: cPallet_identityPalletEventJudgementGiven,
  RegistrarAdded: cPallet_identityPalletEventRegistrarAdded,
  SubIdentityAdded: cPallet_identityPalletEventSubIdentityAdded,
  SubIdentityRemoved: cPallet_identityPalletEventSubIdentityRemoved,
  SubIdentityRevoked: cPallet_identityPalletEventSubIdentityRevoked,
})

type IcMoonbeam_runtimeRuntimeEventIdentity = IcPallet_identityPalletEvent
const cMoonbeam_runtimeRuntimeEventIdentity: Codec<IcMoonbeam_runtimeRuntimeEventIdentity> =
  cPallet_identityPalletEvent

type IcPallet_migrationsPalletEventRuntimeUpgradeCompleted = {
  weight: IcSp_weightsWeight_v2Weight
}
const cPallet_migrationsPalletEventRuntimeUpgradeCompleted: Codec<IcPallet_migrationsPalletEventRuntimeUpgradeCompleted> =
  Struct({ weight: cSp_weightsWeight_v2Weight })

type IcPallet_migrationsPalletEventMigrationStarted = {
  migration_name: I_bytesSeq
}
const cPallet_migrationsPalletEventMigrationStarted: Codec<IcPallet_migrationsPalletEventMigrationStarted> =
  Struct({ migration_name: _bytesSeq })

type IcPallet_migrationsPalletEventMigrationCompleted = {
  migration_name: I_bytesSeq
  consumed_weight: IcSp_weightsWeight_v2Weight
}
const cPallet_migrationsPalletEventMigrationCompleted: Codec<IcPallet_migrationsPalletEventMigrationCompleted> =
  Struct({
    migration_name: _bytesSeq,
    consumed_weight: cSp_weightsWeight_v2Weight,
  })

type IcPallet_migrationsPalletEventFailedToSuspendIdleXcmExecution = {
  error: IcSp_runtimeDispatchError
}
const cPallet_migrationsPalletEventFailedToSuspendIdleXcmExecution: Codec<IcPallet_migrationsPalletEventFailedToSuspendIdleXcmExecution> =
  Struct({ error: cSp_runtimeDispatchError })

type IcPallet_migrationsPalletEventFailedToResumeIdleXcmExecution = {
  error: IcSp_runtimeDispatchError
}
const cPallet_migrationsPalletEventFailedToResumeIdleXcmExecution: Codec<IcPallet_migrationsPalletEventFailedToResumeIdleXcmExecution> =
  Struct({ error: cSp_runtimeDispatchError })

type IcPallet_migrationsPalletEvent =
  | { tag: "RuntimeUpgradeStarted"; value: undefined }
  | {
      tag: "RuntimeUpgradeCompleted"
      value: IcPallet_migrationsPalletEventRuntimeUpgradeCompleted
    }
  | {
      tag: "MigrationStarted"
      value: IcPallet_migrationsPalletEventMigrationStarted
    }
  | {
      tag: "MigrationCompleted"
      value: IcPallet_migrationsPalletEventMigrationCompleted
    }
  | {
      tag: "FailedToSuspendIdleXcmExecution"
      value: IcPallet_migrationsPalletEventFailedToSuspendIdleXcmExecution
    }
  | {
      tag: "FailedToResumeIdleXcmExecution"
      value: IcPallet_migrationsPalletEventFailedToResumeIdleXcmExecution
    }
const cPallet_migrationsPalletEvent: Codec<IcPallet_migrationsPalletEvent> =
  Enum({
    RuntimeUpgradeStarted: _void,
    RuntimeUpgradeCompleted:
      cPallet_migrationsPalletEventRuntimeUpgradeCompleted,
    MigrationStarted: cPallet_migrationsPalletEventMigrationStarted,
    MigrationCompleted: cPallet_migrationsPalletEventMigrationCompleted,
    FailedToSuspendIdleXcmExecution:
      cPallet_migrationsPalletEventFailedToSuspendIdleXcmExecution,
    FailedToResumeIdleXcmExecution:
      cPallet_migrationsPalletEventFailedToResumeIdleXcmExecution,
  })

type IcMoonbeam_runtimeRuntimeEventMigrations = IcPallet_migrationsPalletEvent
const cMoonbeam_runtimeRuntimeEventMigrations: Codec<IcMoonbeam_runtimeRuntimeEventMigrations> =
  cPallet_migrationsPalletEvent

type IcPallet_multisigPalletEventNewMultisig = {
  approving: Icdc1
  multisig: Icdc1
  call_hash: Icdc13
}
const cPallet_multisigPalletEventNewMultisig: Codec<IcPallet_multisigPalletEventNewMultisig> =
  Struct({ approving: cdc1, multisig: cdc1, call_hash: cdc13 })

type IcPallet_multisigTimepoint = { height: number; index: number }
const cPallet_multisigTimepoint: Codec<IcPallet_multisigTimepoint> = Struct({
  height: u32,
  index: u32,
})

type IcPallet_multisigPalletEventMultisigApproval = {
  approving: Icdc1
  timepoint: IcPallet_multisigTimepoint
  multisig: Icdc1
  call_hash: Icdc13
}
const cPallet_multisigPalletEventMultisigApproval: Codec<IcPallet_multisigPalletEventMultisigApproval> =
  Struct({
    approving: cdc1,
    timepoint: cPallet_multisigTimepoint,
    multisig: cdc1,
    call_hash: cdc13,
  })

type IcPallet_multisigPalletEventMultisigExecuted = {
  approving: Icdc1
  timepoint: IcPallet_multisigTimepoint
  multisig: Icdc1
  call_hash: Icdc13
  result: IcResult
}
const cPallet_multisigPalletEventMultisigExecuted: Codec<IcPallet_multisigPalletEventMultisigExecuted> =
  Struct({
    approving: cdc1,
    timepoint: cPallet_multisigTimepoint,
    multisig: cdc1,
    call_hash: cdc13,
    result: cResult,
  })

type IcPallet_multisigPalletEventMultisigCancelled = {
  cancelling: Icdc1
  timepoint: IcPallet_multisigTimepoint
  multisig: Icdc1
  call_hash: Icdc13
}
const cPallet_multisigPalletEventMultisigCancelled: Codec<IcPallet_multisigPalletEventMultisigCancelled> =
  Struct({
    cancelling: cdc1,
    timepoint: cPallet_multisigTimepoint,
    multisig: cdc1,
    call_hash: cdc13,
  })

type IcPallet_multisigPalletEvent =
  | { tag: "NewMultisig"; value: IcPallet_multisigPalletEventNewMultisig }
  | {
      tag: "MultisigApproval"
      value: IcPallet_multisigPalletEventMultisigApproval
    }
  | {
      tag: "MultisigExecuted"
      value: IcPallet_multisigPalletEventMultisigExecuted
    }
  | {
      tag: "MultisigCancelled"
      value: IcPallet_multisigPalletEventMultisigCancelled
    }
const cPallet_multisigPalletEvent: Codec<IcPallet_multisigPalletEvent> = Enum({
  NewMultisig: cPallet_multisigPalletEventNewMultisig,
  MultisigApproval: cPallet_multisigPalletEventMultisigApproval,
  MultisigExecuted: cPallet_multisigPalletEventMultisigExecuted,
  MultisigCancelled: cPallet_multisigPalletEventMultisigCancelled,
})

type IcMoonbeam_runtimeRuntimeEventMultisig = IcPallet_multisigPalletEvent
const cMoonbeam_runtimeRuntimeEventMultisig: Codec<IcMoonbeam_runtimeRuntimeEventMultisig> =
  cPallet_multisigPalletEvent

type Icdc65 = Array<Icdc13>
const cdc65: Codec<Icdc65> = Vector(cdc13)

type IcEthereumLogLog = { address: Icdc1; topics: Icdc65; data: I_bytesSeq }
const cEthereumLogLog: Codec<IcEthereumLogLog> = Struct({
  address: cdc1,
  topics: cdc65,
  data: _bytesSeq,
})

type IcPallet_evmPalletEventLog = { log: IcEthereumLogLog }
const cPallet_evmPalletEventLog: Codec<IcPallet_evmPalletEventLog> = Struct({
  log: cEthereumLogLog,
})

type IcPallet_evmPalletEventCreated = { address: Icdc1 }
const cPallet_evmPalletEventCreated: Codec<IcPallet_evmPalletEventCreated> =
  Struct({ address: cdc1 })

type IcPallet_evmPalletEventCreatedFailed = { address: Icdc1 }
const cPallet_evmPalletEventCreatedFailed: Codec<IcPallet_evmPalletEventCreatedFailed> =
  Struct({ address: cdc1 })

type IcPallet_evmPalletEventExecuted = { address: Icdc1 }
const cPallet_evmPalletEventExecuted: Codec<IcPallet_evmPalletEventExecuted> =
  Struct({ address: cdc1 })

type IcPallet_evmPalletEventExecutedFailed = { address: Icdc1 }
const cPallet_evmPalletEventExecutedFailed: Codec<IcPallet_evmPalletEventExecutedFailed> =
  Struct({ address: cdc1 })

type IcPallet_evmPalletEvent =
  | { tag: "Log"; value: IcPallet_evmPalletEventLog }
  | { tag: "Created"; value: IcPallet_evmPalletEventCreated }
  | { tag: "CreatedFailed"; value: IcPallet_evmPalletEventCreatedFailed }
  | { tag: "Executed"; value: IcPallet_evmPalletEventExecuted }
  | { tag: "ExecutedFailed"; value: IcPallet_evmPalletEventExecutedFailed }
const cPallet_evmPalletEvent: Codec<IcPallet_evmPalletEvent> = Enum({
  Log: cPallet_evmPalletEventLog,
  Created: cPallet_evmPalletEventCreated,
  CreatedFailed: cPallet_evmPalletEventCreatedFailed,
  Executed: cPallet_evmPalletEventExecuted,
  ExecutedFailed: cPallet_evmPalletEventExecutedFailed,
})

type IcMoonbeam_runtimeRuntimeEventEVM = IcPallet_evmPalletEvent
const cMoonbeam_runtimeRuntimeEventEVM: Codec<IcMoonbeam_runtimeRuntimeEventEVM> =
  cPallet_evmPalletEvent

type IcEvm_coreErrorExitSucceed =
  | { tag: "Stopped"; value: undefined }
  | { tag: "Returned"; value: undefined }
  | { tag: "Suicided"; value: undefined }
const cEvm_coreErrorExitSucceed: Codec<IcEvm_coreErrorExitSucceed> = Enum({
  Stopped: _void,
  Returned: _void,
  Suicided: _void,
})

type IcEvm_coreErrorExitReasonSucceed = IcEvm_coreErrorExitSucceed
const cEvm_coreErrorExitReasonSucceed: Codec<IcEvm_coreErrorExitReasonSucceed> =
  cEvm_coreErrorExitSucceed

type IcEvm_coreErrorExitErrorInvalidCode = number
const cEvm_coreErrorExitErrorInvalidCode: Codec<IcEvm_coreErrorExitErrorInvalidCode> =
  u8

type IcEvm_coreErrorExitErrorOther = string
const cEvm_coreErrorExitErrorOther: Codec<IcEvm_coreErrorExitErrorOther> = str

type IcEvm_coreErrorExitError =
  | { tag: "StackUnderflow"; value: undefined }
  | { tag: "StackOverflow"; value: undefined }
  | { tag: "InvalidJump"; value: undefined }
  | { tag: "InvalidRange"; value: undefined }
  | { tag: "DesignatedInvalid"; value: undefined }
  | { tag: "CallTooDeep"; value: undefined }
  | { tag: "CreateCollision"; value: undefined }
  | { tag: "CreateContractLimit"; value: undefined }
  | { tag: "InvalidCode"; value: IcEvm_coreErrorExitErrorInvalidCode }
  | { tag: "OutOfOffset"; value: undefined }
  | { tag: "OutOfGas"; value: undefined }
  | { tag: "OutOfFund"; value: undefined }
  | { tag: "PCUnderflow"; value: undefined }
  | { tag: "CreateEmpty"; value: undefined }
  | { tag: "Other"; value: IcEvm_coreErrorExitErrorOther }
  | { tag: "MaxNonce"; value: undefined }
const cEvm_coreErrorExitError: Codec<IcEvm_coreErrorExitError> = Enum(
  {
    StackUnderflow: _void,
    StackOverflow: _void,
    InvalidJump: _void,
    InvalidRange: _void,
    DesignatedInvalid: _void,
    CallTooDeep: _void,
    CreateCollision: _void,
    CreateContractLimit: _void,
    InvalidCode: cEvm_coreErrorExitErrorInvalidCode,
    OutOfOffset: _void,
    OutOfGas: _void,
    OutOfFund: _void,
    PCUnderflow: _void,
    CreateEmpty: _void,
    Other: cEvm_coreErrorExitErrorOther,
    MaxNonce: _void,
  },
  [0, 1, 2, 3, 4, 5, 6, 7, 15, 8, 9, 10, 11, 12, 13, 14],
)

type IcEvm_coreErrorExitReasonError = IcEvm_coreErrorExitError
const cEvm_coreErrorExitReasonError: Codec<IcEvm_coreErrorExitReasonError> =
  cEvm_coreErrorExitError

type IcEvm_coreErrorExitRevert = { tag: "Reverted"; value: undefined }
const cEvm_coreErrorExitRevert: Codec<IcEvm_coreErrorExitRevert> = Enum({
  Reverted: _void,
})

type IcEvm_coreErrorExitReasonRevert = IcEvm_coreErrorExitRevert
const cEvm_coreErrorExitReasonRevert: Codec<IcEvm_coreErrorExitReasonRevert> =
  cEvm_coreErrorExitRevert

type IcEvm_coreErrorExitFatalCallErrorAsFatal = IcEvm_coreErrorExitError
const cEvm_coreErrorExitFatalCallErrorAsFatal: Codec<IcEvm_coreErrorExitFatalCallErrorAsFatal> =
  cEvm_coreErrorExitError

type IcEvm_coreErrorExitFatalOther = string
const cEvm_coreErrorExitFatalOther: Codec<IcEvm_coreErrorExitFatalOther> = str

type IcEvm_coreErrorExitFatal =
  | { tag: "NotSupported"; value: undefined }
  | { tag: "UnhandledInterrupt"; value: undefined }
  | { tag: "CallErrorAsFatal"; value: IcEvm_coreErrorExitFatalCallErrorAsFatal }
  | { tag: "Other"; value: IcEvm_coreErrorExitFatalOther }
const cEvm_coreErrorExitFatal: Codec<IcEvm_coreErrorExitFatal> = Enum({
  NotSupported: _void,
  UnhandledInterrupt: _void,
  CallErrorAsFatal: cEvm_coreErrorExitFatalCallErrorAsFatal,
  Other: cEvm_coreErrorExitFatalOther,
})

type IcEvm_coreErrorExitReasonFatal = IcEvm_coreErrorExitFatal
const cEvm_coreErrorExitReasonFatal: Codec<IcEvm_coreErrorExitReasonFatal> =
  cEvm_coreErrorExitFatal

type IcEvm_coreErrorExitReason =
  | { tag: "Succeed"; value: IcEvm_coreErrorExitReasonSucceed }
  | { tag: "Error"; value: IcEvm_coreErrorExitReasonError }
  | { tag: "Revert"; value: IcEvm_coreErrorExitReasonRevert }
  | { tag: "Fatal"; value: IcEvm_coreErrorExitReasonFatal }
const cEvm_coreErrorExitReason: Codec<IcEvm_coreErrorExitReason> = Enum({
  Succeed: cEvm_coreErrorExitReasonSucceed,
  Error: cEvm_coreErrorExitReasonError,
  Revert: cEvm_coreErrorExitReasonRevert,
  Fatal: cEvm_coreErrorExitReasonFatal,
})

type IcPallet_ethereumPalletEventExecuted = {
  from: Icdc1
  to: Icdc1
  transaction_hash: Icdc13
  exit_reason: IcEvm_coreErrorExitReason
  extra_data: I_bytesSeq
}
const cPallet_ethereumPalletEventExecuted: Codec<IcPallet_ethereumPalletEventExecuted> =
  Struct({
    from: cdc1,
    to: cdc1,
    transaction_hash: cdc13,
    exit_reason: cEvm_coreErrorExitReason,
    extra_data: _bytesSeq,
  })

type IcPallet_ethereumPalletEvent = {
  tag: "Executed"
  value: IcPallet_ethereumPalletEventExecuted
}
const cPallet_ethereumPalletEvent: Codec<IcPallet_ethereumPalletEvent> = Enum({
  Executed: cPallet_ethereumPalletEventExecuted,
})

type IcMoonbeam_runtimeRuntimeEventEthereum = IcPallet_ethereumPalletEvent
const cMoonbeam_runtimeRuntimeEventEthereum: Codec<IcMoonbeam_runtimeRuntimeEventEthereum> =
  cPallet_ethereumPalletEvent

type IcPallet_schedulerPalletEventScheduled = { when: number; index: number }
const cPallet_schedulerPalletEventScheduled: Codec<IcPallet_schedulerPalletEventScheduled> =
  Struct({ when: u32, index: u32 })

type IcPallet_schedulerPalletEventCanceled = { when: number; index: number }
const cPallet_schedulerPalletEventCanceled: Codec<IcPallet_schedulerPalletEventCanceled> =
  Struct({ when: u32, index: u32 })

type Icdc76 = [number, number]
const cdc76: Codec<Icdc76> = Tuple(u32, u32)

type IcPallet_schedulerPalletEventDispatched = {
  task: Icdc76
  id: IcOption
  result: IcResult
}
const cPallet_schedulerPalletEventDispatched: Codec<IcPallet_schedulerPalletEventDispatched> =
  Struct({ task: cdc76, id: cOption, result: cResult })

type IcPallet_schedulerPalletEventCallUnavailable = {
  task: Icdc76
  id: IcOption
}
const cPallet_schedulerPalletEventCallUnavailable: Codec<IcPallet_schedulerPalletEventCallUnavailable> =
  Struct({ task: cdc76, id: cOption })

type IcPallet_schedulerPalletEventPeriodicFailed = {
  task: Icdc76
  id: IcOption
}
const cPallet_schedulerPalletEventPeriodicFailed: Codec<IcPallet_schedulerPalletEventPeriodicFailed> =
  Struct({ task: cdc76, id: cOption })

type IcPallet_schedulerPalletEventPermanentlyOverweight = {
  task: Icdc76
  id: IcOption
}
const cPallet_schedulerPalletEventPermanentlyOverweight: Codec<IcPallet_schedulerPalletEventPermanentlyOverweight> =
  Struct({ task: cdc76, id: cOption })

type IcPallet_schedulerPalletEvent =
  | { tag: "Scheduled"; value: IcPallet_schedulerPalletEventScheduled }
  | { tag: "Canceled"; value: IcPallet_schedulerPalletEventCanceled }
  | { tag: "Dispatched"; value: IcPallet_schedulerPalletEventDispatched }
  | {
      tag: "CallUnavailable"
      value: IcPallet_schedulerPalletEventCallUnavailable
    }
  | {
      tag: "PeriodicFailed"
      value: IcPallet_schedulerPalletEventPeriodicFailed
    }
  | {
      tag: "PermanentlyOverweight"
      value: IcPallet_schedulerPalletEventPermanentlyOverweight
    }
const cPallet_schedulerPalletEvent: Codec<IcPallet_schedulerPalletEvent> = Enum(
  {
    Scheduled: cPallet_schedulerPalletEventScheduled,
    Canceled: cPallet_schedulerPalletEventCanceled,
    Dispatched: cPallet_schedulerPalletEventDispatched,
    CallUnavailable: cPallet_schedulerPalletEventCallUnavailable,
    PeriodicFailed: cPallet_schedulerPalletEventPeriodicFailed,
    PermanentlyOverweight: cPallet_schedulerPalletEventPermanentlyOverweight,
  },
)

type IcMoonbeam_runtimeRuntimeEventScheduler = IcPallet_schedulerPalletEvent
const cMoonbeam_runtimeRuntimeEventScheduler: Codec<IcMoonbeam_runtimeRuntimeEventScheduler> =
  cPallet_schedulerPalletEvent

type IcPallet_democracyPalletEventProposed = {
  proposal_index: number
  deposit: bigint
}
const cPallet_democracyPalletEventProposed: Codec<IcPallet_democracyPalletEventProposed> =
  Struct({ proposal_index: u32, deposit: u128 })

type IcPallet_democracyPalletEventTabled = {
  proposal_index: number
  deposit: bigint
}
const cPallet_democracyPalletEventTabled: Codec<IcPallet_democracyPalletEventTabled> =
  Struct({ proposal_index: u32, deposit: u128 })

type IcPallet_democracyVote_thresholdVoteThreshold =
  | { tag: "SuperMajorityApprove"; value: undefined }
  | { tag: "SuperMajorityAgainst"; value: undefined }
  | { tag: "SimpleMajority"; value: undefined }
const cPallet_democracyVote_thresholdVoteThreshold: Codec<IcPallet_democracyVote_thresholdVoteThreshold> =
  Enum({
    SuperMajorityApprove: _void,
    SuperMajorityAgainst: _void,
    SimpleMajority: _void,
  })

type IcPallet_democracyPalletEventStarted = {
  ref_index: number
  threshold: IcPallet_democracyVote_thresholdVoteThreshold
}
const cPallet_democracyPalletEventStarted: Codec<IcPallet_democracyPalletEventStarted> =
  Struct({
    ref_index: u32,
    threshold: cPallet_democracyVote_thresholdVoteThreshold,
  })

type IcPallet_democracyPalletEventPassed = { ref_index: number }
const cPallet_democracyPalletEventPassed: Codec<IcPallet_democracyPalletEventPassed> =
  Struct({ ref_index: u32 })

type IcPallet_democracyPalletEventNotPassed = { ref_index: number }
const cPallet_democracyPalletEventNotPassed: Codec<IcPallet_democracyPalletEventNotPassed> =
  Struct({ ref_index: u32 })

type IcPallet_democracyPalletEventCancelled = { ref_index: number }
const cPallet_democracyPalletEventCancelled: Codec<IcPallet_democracyPalletEventCancelled> =
  Struct({ ref_index: u32 })

type IcPallet_democracyPalletEventDelegated = { who: Icdc1; target: Icdc1 }
const cPallet_democracyPalletEventDelegated: Codec<IcPallet_democracyPalletEventDelegated> =
  Struct({ who: cdc1, target: cdc1 })

type IcPallet_democracyPalletEventUndelegated = { account: Icdc1 }
const cPallet_democracyPalletEventUndelegated: Codec<IcPallet_democracyPalletEventUndelegated> =
  Struct({ account: cdc1 })

type IcPallet_democracyPalletEventVetoed = {
  who: Icdc1
  proposal_hash: Icdc13
  until: number
}
const cPallet_democracyPalletEventVetoed: Codec<IcPallet_democracyPalletEventVetoed> =
  Struct({ who: cdc1, proposal_hash: cdc13, until: u32 })

type IcPallet_democracyPalletEventBlacklisted = { proposal_hash: Icdc13 }
const cPallet_democracyPalletEventBlacklisted: Codec<IcPallet_democracyPalletEventBlacklisted> =
  Struct({ proposal_hash: cdc13 })

type IcPallet_democracyVoteAccountVoteStandard = {
  vote: number
  balance: bigint
}
const cPallet_democracyVoteAccountVoteStandard: Codec<IcPallet_democracyVoteAccountVoteStandard> =
  Struct({ vote: u8, balance: u128 })

type IcPallet_democracyVoteAccountVoteSplit = { aye: bigint; nay: bigint }
const cPallet_democracyVoteAccountVoteSplit: Codec<IcPallet_democracyVoteAccountVoteSplit> =
  Struct({ aye: u128, nay: u128 })

type IcPallet_democracyVoteAccountVote =
  | { tag: "Standard"; value: IcPallet_democracyVoteAccountVoteStandard }
  | { tag: "Split"; value: IcPallet_democracyVoteAccountVoteSplit }
const cPallet_democracyVoteAccountVote: Codec<IcPallet_democracyVoteAccountVote> =
  Enum({
    Standard: cPallet_democracyVoteAccountVoteStandard,
    Split: cPallet_democracyVoteAccountVoteSplit,
  })

type IcPallet_democracyPalletEventVoted = {
  voter: Icdc1
  ref_index: number
  vote: IcPallet_democracyVoteAccountVote
}
const cPallet_democracyPalletEventVoted: Codec<IcPallet_democracyPalletEventVoted> =
  Struct({
    voter: cdc1,
    ref_index: u32,
    vote: cPallet_democracyVoteAccountVote,
  })

type IcPallet_democracyPalletEventSeconded = {
  seconder: Icdc1
  prop_index: number
}
const cPallet_democracyPalletEventSeconded: Codec<IcPallet_democracyPalletEventSeconded> =
  Struct({ seconder: cdc1, prop_index: u32 })

type IcPallet_democracyPalletEventProposalCanceled = { prop_index: number }
const cPallet_democracyPalletEventProposalCanceled: Codec<IcPallet_democracyPalletEventProposalCanceled> =
  Struct({ prop_index: u32 })

type IcPallet_democracyTypesMetadataOwnerProposal = number
const cPallet_democracyTypesMetadataOwnerProposal: Codec<IcPallet_democracyTypesMetadataOwnerProposal> =
  u32

type IcPallet_democracyTypesMetadataOwnerReferendum = number
const cPallet_democracyTypesMetadataOwnerReferendum: Codec<IcPallet_democracyTypesMetadataOwnerReferendum> =
  u32

type IcPallet_democracyTypesMetadataOwner =
  | { tag: "External"; value: undefined }
  | { tag: "Proposal"; value: IcPallet_democracyTypesMetadataOwnerProposal }
  | { tag: "Referendum"; value: IcPallet_democracyTypesMetadataOwnerReferendum }
const cPallet_democracyTypesMetadataOwner: Codec<IcPallet_democracyTypesMetadataOwner> =
  Enum({
    External: _void,
    Proposal: cPallet_democracyTypesMetadataOwnerProposal,
    Referendum: cPallet_democracyTypesMetadataOwnerReferendum,
  })

type IcPallet_democracyPalletEventMetadataSet = {
  owner: IcPallet_democracyTypesMetadataOwner
  hash: Icdc13
}
const cPallet_democracyPalletEventMetadataSet: Codec<IcPallet_democracyPalletEventMetadataSet> =
  Struct({ owner: cPallet_democracyTypesMetadataOwner, hash: cdc13 })

type IcPallet_democracyPalletEventMetadataCleared = {
  owner: IcPallet_democracyTypesMetadataOwner
  hash: Icdc13
}
const cPallet_democracyPalletEventMetadataCleared: Codec<IcPallet_democracyPalletEventMetadataCleared> =
  Struct({ owner: cPallet_democracyTypesMetadataOwner, hash: cdc13 })

type IcPallet_democracyPalletEventMetadataTransferred = {
  prev_owner: IcPallet_democracyTypesMetadataOwner
  owner: IcPallet_democracyTypesMetadataOwner
  hash: Icdc13
}
const cPallet_democracyPalletEventMetadataTransferred: Codec<IcPallet_democracyPalletEventMetadataTransferred> =
  Struct({
    prev_owner: cPallet_democracyTypesMetadataOwner,
    owner: cPallet_democracyTypesMetadataOwner,
    hash: cdc13,
  })

type IcPallet_democracyPalletEvent =
  | { tag: "Proposed"; value: IcPallet_democracyPalletEventProposed }
  | { tag: "Tabled"; value: IcPallet_democracyPalletEventTabled }
  | { tag: "ExternalTabled"; value: undefined }
  | { tag: "Started"; value: IcPallet_democracyPalletEventStarted }
  | { tag: "Passed"; value: IcPallet_democracyPalletEventPassed }
  | { tag: "NotPassed"; value: IcPallet_democracyPalletEventNotPassed }
  | { tag: "Cancelled"; value: IcPallet_democracyPalletEventCancelled }
  | { tag: "Delegated"; value: IcPallet_democracyPalletEventDelegated }
  | { tag: "Undelegated"; value: IcPallet_democracyPalletEventUndelegated }
  | { tag: "Vetoed"; value: IcPallet_democracyPalletEventVetoed }
  | { tag: "Blacklisted"; value: IcPallet_democracyPalletEventBlacklisted }
  | { tag: "Voted"; value: IcPallet_democracyPalletEventVoted }
  | { tag: "Seconded"; value: IcPallet_democracyPalletEventSeconded }
  | {
      tag: "ProposalCanceled"
      value: IcPallet_democracyPalletEventProposalCanceled
    }
  | { tag: "MetadataSet"; value: IcPallet_democracyPalletEventMetadataSet }
  | {
      tag: "MetadataCleared"
      value: IcPallet_democracyPalletEventMetadataCleared
    }
  | {
      tag: "MetadataTransferred"
      value: IcPallet_democracyPalletEventMetadataTransferred
    }
const cPallet_democracyPalletEvent: Codec<IcPallet_democracyPalletEvent> = Enum(
  {
    Proposed: cPallet_democracyPalletEventProposed,
    Tabled: cPallet_democracyPalletEventTabled,
    ExternalTabled: _void,
    Started: cPallet_democracyPalletEventStarted,
    Passed: cPallet_democracyPalletEventPassed,
    NotPassed: cPallet_democracyPalletEventNotPassed,
    Cancelled: cPallet_democracyPalletEventCancelled,
    Delegated: cPallet_democracyPalletEventDelegated,
    Undelegated: cPallet_democracyPalletEventUndelegated,
    Vetoed: cPallet_democracyPalletEventVetoed,
    Blacklisted: cPallet_democracyPalletEventBlacklisted,
    Voted: cPallet_democracyPalletEventVoted,
    Seconded: cPallet_democracyPalletEventSeconded,
    ProposalCanceled: cPallet_democracyPalletEventProposalCanceled,
    MetadataSet: cPallet_democracyPalletEventMetadataSet,
    MetadataCleared: cPallet_democracyPalletEventMetadataCleared,
    MetadataTransferred: cPallet_democracyPalletEventMetadataTransferred,
  },
)

type IcMoonbeam_runtimeRuntimeEventDemocracy = IcPallet_democracyPalletEvent
const cMoonbeam_runtimeRuntimeEventDemocracy: Codec<IcMoonbeam_runtimeRuntimeEventDemocracy> =
  cPallet_democracyPalletEvent

type IcPallet_preimagePalletEventNoted = { hash: Icdc13 }
const cPallet_preimagePalletEventNoted: Codec<IcPallet_preimagePalletEventNoted> =
  Struct({ hash: cdc13 })

type IcPallet_preimagePalletEventRequested = { hash: Icdc13 }
const cPallet_preimagePalletEventRequested: Codec<IcPallet_preimagePalletEventRequested> =
  Struct({ hash: cdc13 })

type IcPallet_preimagePalletEventCleared = { hash: Icdc13 }
const cPallet_preimagePalletEventCleared: Codec<IcPallet_preimagePalletEventCleared> =
  Struct({ hash: cdc13 })

type IcPallet_preimagePalletEvent =
  | { tag: "Noted"; value: IcPallet_preimagePalletEventNoted }
  | { tag: "Requested"; value: IcPallet_preimagePalletEventRequested }
  | { tag: "Cleared"; value: IcPallet_preimagePalletEventCleared }
const cPallet_preimagePalletEvent: Codec<IcPallet_preimagePalletEvent> = Enum({
  Noted: cPallet_preimagePalletEventNoted,
  Requested: cPallet_preimagePalletEventRequested,
  Cleared: cPallet_preimagePalletEventCleared,
})

type IcMoonbeam_runtimeRuntimeEventPreimage = IcPallet_preimagePalletEvent
const cMoonbeam_runtimeRuntimeEventPreimage: Codec<IcMoonbeam_runtimeRuntimeEventPreimage> =
  cPallet_preimagePalletEvent

type IcPallet_conviction_votingPalletEventDelegated = [Icdc1, Icdc1]
const cPallet_conviction_votingPalletEventDelegated: Codec<IcPallet_conviction_votingPalletEventDelegated> =
  Tuple(cdc1, cdc1)

type IcPallet_conviction_votingPalletEventUndelegated = Icdc1
const cPallet_conviction_votingPalletEventUndelegated: Codec<IcPallet_conviction_votingPalletEventUndelegated> =
  cdc1

type IcPallet_conviction_votingPalletEvent =
  | { tag: "Delegated"; value: IcPallet_conviction_votingPalletEventDelegated }
  | {
      tag: "Undelegated"
      value: IcPallet_conviction_votingPalletEventUndelegated
    }
const cPallet_conviction_votingPalletEvent: Codec<IcPallet_conviction_votingPalletEvent> =
  Enum({
    Delegated: cPallet_conviction_votingPalletEventDelegated,
    Undelegated: cPallet_conviction_votingPalletEventUndelegated,
  })

type IcMoonbeam_runtimeRuntimeEventConvictionVoting =
  IcPallet_conviction_votingPalletEvent
const cMoonbeam_runtimeRuntimeEventConvictionVoting: Codec<IcMoonbeam_runtimeRuntimeEventConvictionVoting> =
  cPallet_conviction_votingPalletEvent

type IcFrame_supportTraitsPreimagesBoundedLegacy = { hash: Icdc13 }
const cFrame_supportTraitsPreimagesBoundedLegacy: Codec<IcFrame_supportTraitsPreimagesBoundedLegacy> =
  Struct({ hash: cdc13 })

type IcFrame_supportTraitsPreimagesBoundedInline = I_bytesSeq
const cFrame_supportTraitsPreimagesBoundedInline: Codec<IcFrame_supportTraitsPreimagesBoundedInline> =
  _bytesSeq

type IcFrame_supportTraitsPreimagesBoundedLookup = { hash: Icdc13; len: number }
const cFrame_supportTraitsPreimagesBoundedLookup: Codec<IcFrame_supportTraitsPreimagesBoundedLookup> =
  Struct({ hash: cdc13, len: u32 })

type IcFrame_supportTraitsPreimagesBounded =
  | { tag: "Legacy"; value: IcFrame_supportTraitsPreimagesBoundedLegacy }
  | { tag: "Inline"; value: IcFrame_supportTraitsPreimagesBoundedInline }
  | { tag: "Lookup"; value: IcFrame_supportTraitsPreimagesBoundedLookup }
const cFrame_supportTraitsPreimagesBounded: Codec<IcFrame_supportTraitsPreimagesBounded> =
  Enum({
    Legacy: cFrame_supportTraitsPreimagesBoundedLegacy,
    Inline: cFrame_supportTraitsPreimagesBoundedInline,
    Lookup: cFrame_supportTraitsPreimagesBoundedLookup,
  })

type IcPallet_referendaPalletEventSubmitted = {
  index: number
  track: number
  proposal: IcFrame_supportTraitsPreimagesBounded
}
const cPallet_referendaPalletEventSubmitted: Codec<IcPallet_referendaPalletEventSubmitted> =
  Struct({
    index: u32,
    track: u16,
    proposal: cFrame_supportTraitsPreimagesBounded,
  })

type IcPallet_referendaPalletEventDecisionDepositPlaced = {
  index: number
  who: Icdc1
  amount: bigint
}
const cPallet_referendaPalletEventDecisionDepositPlaced: Codec<IcPallet_referendaPalletEventDecisionDepositPlaced> =
  Struct({ index: u32, who: cdc1, amount: u128 })

type IcPallet_referendaPalletEventDecisionDepositRefunded = {
  index: number
  who: Icdc1
  amount: bigint
}
const cPallet_referendaPalletEventDecisionDepositRefunded: Codec<IcPallet_referendaPalletEventDecisionDepositRefunded> =
  Struct({ index: u32, who: cdc1, amount: u128 })

type IcPallet_referendaPalletEventDepositSlashed = {
  who: Icdc1
  amount: bigint
}
const cPallet_referendaPalletEventDepositSlashed: Codec<IcPallet_referendaPalletEventDepositSlashed> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_conviction_votingTypesTally = {
  ayes: bigint
  nays: bigint
  support: bigint
}
const cPallet_conviction_votingTypesTally: Codec<IcPallet_conviction_votingTypesTally> =
  Struct({ ayes: u128, nays: u128, support: u128 })

type IcPallet_referendaPalletEventDecisionStarted = {
  index: number
  track: number
  proposal: IcFrame_supportTraitsPreimagesBounded
  tally: IcPallet_conviction_votingTypesTally
}
const cPallet_referendaPalletEventDecisionStarted: Codec<IcPallet_referendaPalletEventDecisionStarted> =
  Struct({
    index: u32,
    track: u16,
    proposal: cFrame_supportTraitsPreimagesBounded,
    tally: cPallet_conviction_votingTypesTally,
  })

type IcPallet_referendaPalletEventConfirmStarted = { index: number }
const cPallet_referendaPalletEventConfirmStarted: Codec<IcPallet_referendaPalletEventConfirmStarted> =
  Struct({ index: u32 })

type IcPallet_referendaPalletEventConfirmAborted = { index: number }
const cPallet_referendaPalletEventConfirmAborted: Codec<IcPallet_referendaPalletEventConfirmAborted> =
  Struct({ index: u32 })

type IcPallet_referendaPalletEventConfirmed = {
  index: number
  tally: IcPallet_conviction_votingTypesTally
}
const cPallet_referendaPalletEventConfirmed: Codec<IcPallet_referendaPalletEventConfirmed> =
  Struct({ index: u32, tally: cPallet_conviction_votingTypesTally })

type IcPallet_referendaPalletEventApproved = { index: number }
const cPallet_referendaPalletEventApproved: Codec<IcPallet_referendaPalletEventApproved> =
  Struct({ index: u32 })

type IcPallet_referendaPalletEventRejected = {
  index: number
  tally: IcPallet_conviction_votingTypesTally
}
const cPallet_referendaPalletEventRejected: Codec<IcPallet_referendaPalletEventRejected> =
  Struct({ index: u32, tally: cPallet_conviction_votingTypesTally })

type IcPallet_referendaPalletEventTimedOut = {
  index: number
  tally: IcPallet_conviction_votingTypesTally
}
const cPallet_referendaPalletEventTimedOut: Codec<IcPallet_referendaPalletEventTimedOut> =
  Struct({ index: u32, tally: cPallet_conviction_votingTypesTally })

type IcPallet_referendaPalletEventCancelled = {
  index: number
  tally: IcPallet_conviction_votingTypesTally
}
const cPallet_referendaPalletEventCancelled: Codec<IcPallet_referendaPalletEventCancelled> =
  Struct({ index: u32, tally: cPallet_conviction_votingTypesTally })

type IcPallet_referendaPalletEventKilled = {
  index: number
  tally: IcPallet_conviction_votingTypesTally
}
const cPallet_referendaPalletEventKilled: Codec<IcPallet_referendaPalletEventKilled> =
  Struct({ index: u32, tally: cPallet_conviction_votingTypesTally })

type IcPallet_referendaPalletEventSubmissionDepositRefunded = {
  index: number
  who: Icdc1
  amount: bigint
}
const cPallet_referendaPalletEventSubmissionDepositRefunded: Codec<IcPallet_referendaPalletEventSubmissionDepositRefunded> =
  Struct({ index: u32, who: cdc1, amount: u128 })

type IcPallet_referendaPalletEventMetadataSet = { index: number; hash: Icdc13 }
const cPallet_referendaPalletEventMetadataSet: Codec<IcPallet_referendaPalletEventMetadataSet> =
  Struct({ index: u32, hash: cdc13 })

type IcPallet_referendaPalletEventMetadataCleared = {
  index: number
  hash: Icdc13
}
const cPallet_referendaPalletEventMetadataCleared: Codec<IcPallet_referendaPalletEventMetadataCleared> =
  Struct({ index: u32, hash: cdc13 })

type IcPallet_referendaPalletEvent =
  | { tag: "Submitted"; value: IcPallet_referendaPalletEventSubmitted }
  | {
      tag: "DecisionDepositPlaced"
      value: IcPallet_referendaPalletEventDecisionDepositPlaced
    }
  | {
      tag: "DecisionDepositRefunded"
      value: IcPallet_referendaPalletEventDecisionDepositRefunded
    }
  | {
      tag: "DepositSlashed"
      value: IcPallet_referendaPalletEventDepositSlashed
    }
  | {
      tag: "DecisionStarted"
      value: IcPallet_referendaPalletEventDecisionStarted
    }
  | {
      tag: "ConfirmStarted"
      value: IcPallet_referendaPalletEventConfirmStarted
    }
  | {
      tag: "ConfirmAborted"
      value: IcPallet_referendaPalletEventConfirmAborted
    }
  | { tag: "Confirmed"; value: IcPallet_referendaPalletEventConfirmed }
  | { tag: "Approved"; value: IcPallet_referendaPalletEventApproved }
  | { tag: "Rejected"; value: IcPallet_referendaPalletEventRejected }
  | { tag: "TimedOut"; value: IcPallet_referendaPalletEventTimedOut }
  | { tag: "Cancelled"; value: IcPallet_referendaPalletEventCancelled }
  | { tag: "Killed"; value: IcPallet_referendaPalletEventKilled }
  | {
      tag: "SubmissionDepositRefunded"
      value: IcPallet_referendaPalletEventSubmissionDepositRefunded
    }
  | { tag: "MetadataSet"; value: IcPallet_referendaPalletEventMetadataSet }
  | {
      tag: "MetadataCleared"
      value: IcPallet_referendaPalletEventMetadataCleared
    }
const cPallet_referendaPalletEvent: Codec<IcPallet_referendaPalletEvent> = Enum(
  {
    Submitted: cPallet_referendaPalletEventSubmitted,
    DecisionDepositPlaced: cPallet_referendaPalletEventDecisionDepositPlaced,
    DecisionDepositRefunded:
      cPallet_referendaPalletEventDecisionDepositRefunded,
    DepositSlashed: cPallet_referendaPalletEventDepositSlashed,
    DecisionStarted: cPallet_referendaPalletEventDecisionStarted,
    ConfirmStarted: cPallet_referendaPalletEventConfirmStarted,
    ConfirmAborted: cPallet_referendaPalletEventConfirmAborted,
    Confirmed: cPallet_referendaPalletEventConfirmed,
    Approved: cPallet_referendaPalletEventApproved,
    Rejected: cPallet_referendaPalletEventRejected,
    TimedOut: cPallet_referendaPalletEventTimedOut,
    Cancelled: cPallet_referendaPalletEventCancelled,
    Killed: cPallet_referendaPalletEventKilled,
    SubmissionDepositRefunded:
      cPallet_referendaPalletEventSubmissionDepositRefunded,
    MetadataSet: cPallet_referendaPalletEventMetadataSet,
    MetadataCleared: cPallet_referendaPalletEventMetadataCleared,
  },
)

type IcMoonbeam_runtimeRuntimeEventReferenda = IcPallet_referendaPalletEvent
const cMoonbeam_runtimeRuntimeEventReferenda: Codec<IcMoonbeam_runtimeRuntimeEventReferenda> =
  cPallet_referendaPalletEvent

type IcPallet_whitelistPalletEventCallWhitelisted = { call_hash: Icdc13 }
const cPallet_whitelistPalletEventCallWhitelisted: Codec<IcPallet_whitelistPalletEventCallWhitelisted> =
  Struct({ call_hash: cdc13 })

type IcPallet_whitelistPalletEventWhitelistedCallRemoved = { call_hash: Icdc13 }
const cPallet_whitelistPalletEventWhitelistedCallRemoved: Codec<IcPallet_whitelistPalletEventWhitelistedCallRemoved> =
  Struct({ call_hash: cdc13 })

type IcPallet_whitelistPalletEventWhitelistedCallDispatched = {
  call_hash: Icdc13
  result: IcResult
}
const cPallet_whitelistPalletEventWhitelistedCallDispatched: Codec<IcPallet_whitelistPalletEventWhitelistedCallDispatched> =
  Struct({ call_hash: cdc13, result: cResult })

type IcPallet_whitelistPalletEvent =
  | {
      tag: "CallWhitelisted"
      value: IcPallet_whitelistPalletEventCallWhitelisted
    }
  | {
      tag: "WhitelistedCallRemoved"
      value: IcPallet_whitelistPalletEventWhitelistedCallRemoved
    }
  | {
      tag: "WhitelistedCallDispatched"
      value: IcPallet_whitelistPalletEventWhitelistedCallDispatched
    }
const cPallet_whitelistPalletEvent: Codec<IcPallet_whitelistPalletEvent> = Enum(
  {
    CallWhitelisted: cPallet_whitelistPalletEventCallWhitelisted,
    WhitelistedCallRemoved: cPallet_whitelistPalletEventWhitelistedCallRemoved,
    WhitelistedCallDispatched:
      cPallet_whitelistPalletEventWhitelistedCallDispatched,
  },
)

type IcMoonbeam_runtimeRuntimeEventWhitelist = IcPallet_whitelistPalletEvent
const cMoonbeam_runtimeRuntimeEventWhitelist: Codec<IcMoonbeam_runtimeRuntimeEventWhitelist> =
  cPallet_whitelistPalletEvent

type IcPallet_collectivePalletEventProposed = {
  account: Icdc1
  proposal_index: number
  proposal_hash: Icdc13
  threshold: number
}
const cPallet_collectivePalletEventProposed: Codec<IcPallet_collectivePalletEventProposed> =
  Struct({
    account: cdc1,
    proposal_index: u32,
    proposal_hash: cdc13,
    threshold: u32,
  })

type IcPallet_collectivePalletEventVoted = {
  account: Icdc1
  proposal_hash: Icdc13
  voted: boolean
  yes: number
  no: number
}
const cPallet_collectivePalletEventVoted: Codec<IcPallet_collectivePalletEventVoted> =
  Struct({
    account: cdc1,
    proposal_hash: cdc13,
    voted: bool,
    yes: u32,
    no: u32,
  })

type IcPallet_collectivePalletEventApproved = { proposal_hash: Icdc13 }
const cPallet_collectivePalletEventApproved: Codec<IcPallet_collectivePalletEventApproved> =
  Struct({ proposal_hash: cdc13 })

type IcPallet_collectivePalletEventDisapproved = { proposal_hash: Icdc13 }
const cPallet_collectivePalletEventDisapproved: Codec<IcPallet_collectivePalletEventDisapproved> =
  Struct({ proposal_hash: cdc13 })

type IcPallet_collectivePalletEventExecuted = {
  proposal_hash: Icdc13
  result: IcResult
}
const cPallet_collectivePalletEventExecuted: Codec<IcPallet_collectivePalletEventExecuted> =
  Struct({ proposal_hash: cdc13, result: cResult })

type IcPallet_collectivePalletEventMemberExecuted = {
  proposal_hash: Icdc13
  result: IcResult
}
const cPallet_collectivePalletEventMemberExecuted: Codec<IcPallet_collectivePalletEventMemberExecuted> =
  Struct({ proposal_hash: cdc13, result: cResult })

type IcPallet_collectivePalletEventClosed = {
  proposal_hash: Icdc13
  yes: number
  no: number
}
const cPallet_collectivePalletEventClosed: Codec<IcPallet_collectivePalletEventClosed> =
  Struct({ proposal_hash: cdc13, yes: u32, no: u32 })

type IcPallet_collectivePalletEvent =
  | { tag: "Proposed"; value: IcPallet_collectivePalletEventProposed }
  | { tag: "Voted"; value: IcPallet_collectivePalletEventVoted }
  | { tag: "Approved"; value: IcPallet_collectivePalletEventApproved }
  | { tag: "Disapproved"; value: IcPallet_collectivePalletEventDisapproved }
  | { tag: "Executed"; value: IcPallet_collectivePalletEventExecuted }
  | {
      tag: "MemberExecuted"
      value: IcPallet_collectivePalletEventMemberExecuted
    }
  | { tag: "Closed"; value: IcPallet_collectivePalletEventClosed }
const cPallet_collectivePalletEvent: Codec<IcPallet_collectivePalletEvent> =
  Enum({
    Proposed: cPallet_collectivePalletEventProposed,
    Voted: cPallet_collectivePalletEventVoted,
    Approved: cPallet_collectivePalletEventApproved,
    Disapproved: cPallet_collectivePalletEventDisapproved,
    Executed: cPallet_collectivePalletEventExecuted,
    MemberExecuted: cPallet_collectivePalletEventMemberExecuted,
    Closed: cPallet_collectivePalletEventClosed,
  })

type IcMoonbeam_runtimeRuntimeEventCouncilCollective =
  IcPallet_collectivePalletEvent
const cMoonbeam_runtimeRuntimeEventCouncilCollective: Codec<IcMoonbeam_runtimeRuntimeEventCouncilCollective> =
  cPallet_collectivePalletEvent

type IcMoonbeam_runtimeRuntimeEventTechCommitteeCollective =
  IcPallet_collectivePalletEvent
const cMoonbeam_runtimeRuntimeEventTechCommitteeCollective: Codec<IcMoonbeam_runtimeRuntimeEventTechCommitteeCollective> =
  cPallet_collectivePalletEvent

type IcMoonbeam_runtimeRuntimeEventTreasuryCouncilCollective =
  IcPallet_collectivePalletEvent
const cMoonbeam_runtimeRuntimeEventTreasuryCouncilCollective: Codec<IcMoonbeam_runtimeRuntimeEventTreasuryCouncilCollective> =
  cPallet_collectivePalletEvent

type IcMoonbeam_runtimeRuntimeEventOpenTechCommitteeCollective =
  IcPallet_collectivePalletEvent
const cMoonbeam_runtimeRuntimeEventOpenTechCommitteeCollective: Codec<IcMoonbeam_runtimeRuntimeEventOpenTechCommitteeCollective> =
  cPallet_collectivePalletEvent

type IcPallet_treasuryPalletEventProposed = { proposal_index: number }
const cPallet_treasuryPalletEventProposed: Codec<IcPallet_treasuryPalletEventProposed> =
  Struct({ proposal_index: u32 })

type IcPallet_treasuryPalletEventSpending = { budget_remaining: bigint }
const cPallet_treasuryPalletEventSpending: Codec<IcPallet_treasuryPalletEventSpending> =
  Struct({ budget_remaining: u128 })

type IcPallet_treasuryPalletEventAwarded = {
  proposal_index: number
  award: bigint
  account: Icdc1
}
const cPallet_treasuryPalletEventAwarded: Codec<IcPallet_treasuryPalletEventAwarded> =
  Struct({ proposal_index: u32, award: u128, account: cdc1 })

type IcPallet_treasuryPalletEventRejected = {
  proposal_index: number
  slashed: bigint
}
const cPallet_treasuryPalletEventRejected: Codec<IcPallet_treasuryPalletEventRejected> =
  Struct({ proposal_index: u32, slashed: u128 })

type IcPallet_treasuryPalletEventBurnt = { burnt_funds: bigint }
const cPallet_treasuryPalletEventBurnt: Codec<IcPallet_treasuryPalletEventBurnt> =
  Struct({ burnt_funds: u128 })

type IcPallet_treasuryPalletEventRollover = { rollover_balance: bigint }
const cPallet_treasuryPalletEventRollover: Codec<IcPallet_treasuryPalletEventRollover> =
  Struct({ rollover_balance: u128 })

type IcPallet_treasuryPalletEventDeposit = { value: bigint }
const cPallet_treasuryPalletEventDeposit: Codec<IcPallet_treasuryPalletEventDeposit> =
  Struct({ value: u128 })

type IcPallet_treasuryPalletEventSpendApproved = {
  proposal_index: number
  amount: bigint
  beneficiary: Icdc1
}
const cPallet_treasuryPalletEventSpendApproved: Codec<IcPallet_treasuryPalletEventSpendApproved> =
  Struct({ proposal_index: u32, amount: u128, beneficiary: cdc1 })

type IcPallet_treasuryPalletEventUpdatedInactive = {
  reactivated: bigint
  deactivated: bigint
}
const cPallet_treasuryPalletEventUpdatedInactive: Codec<IcPallet_treasuryPalletEventUpdatedInactive> =
  Struct({ reactivated: u128, deactivated: u128 })

type IcPallet_treasuryPalletEvent =
  | { tag: "Proposed"; value: IcPallet_treasuryPalletEventProposed }
  | { tag: "Spending"; value: IcPallet_treasuryPalletEventSpending }
  | { tag: "Awarded"; value: IcPallet_treasuryPalletEventAwarded }
  | { tag: "Rejected"; value: IcPallet_treasuryPalletEventRejected }
  | { tag: "Burnt"; value: IcPallet_treasuryPalletEventBurnt }
  | { tag: "Rollover"; value: IcPallet_treasuryPalletEventRollover }
  | { tag: "Deposit"; value: IcPallet_treasuryPalletEventDeposit }
  | { tag: "SpendApproved"; value: IcPallet_treasuryPalletEventSpendApproved }
  | {
      tag: "UpdatedInactive"
      value: IcPallet_treasuryPalletEventUpdatedInactive
    }
const cPallet_treasuryPalletEvent: Codec<IcPallet_treasuryPalletEvent> = Enum({
  Proposed: cPallet_treasuryPalletEventProposed,
  Spending: cPallet_treasuryPalletEventSpending,
  Awarded: cPallet_treasuryPalletEventAwarded,
  Rejected: cPallet_treasuryPalletEventRejected,
  Burnt: cPallet_treasuryPalletEventBurnt,
  Rollover: cPallet_treasuryPalletEventRollover,
  Deposit: cPallet_treasuryPalletEventDeposit,
  SpendApproved: cPallet_treasuryPalletEventSpendApproved,
  UpdatedInactive: cPallet_treasuryPalletEventUpdatedInactive,
})

type IcMoonbeam_runtimeRuntimeEventTreasury = IcPallet_treasuryPalletEvent
const cMoonbeam_runtimeRuntimeEventTreasury: Codec<IcMoonbeam_runtimeRuntimeEventTreasury> =
  cPallet_treasuryPalletEvent

type IcPallet_crowdloan_rewardsPalletEventInitialPaymentMade = [Icdc1, bigint]
const cPallet_crowdloan_rewardsPalletEventInitialPaymentMade: Codec<IcPallet_crowdloan_rewardsPalletEventInitialPaymentMade> =
  Tuple(cdc1, u128)

type IcPallet_crowdloan_rewardsPalletEventNativeIdentityAssociated = [
  Icdc13,
  Icdc1,
  bigint,
]
const cPallet_crowdloan_rewardsPalletEventNativeIdentityAssociated: Codec<IcPallet_crowdloan_rewardsPalletEventNativeIdentityAssociated> =
  Tuple(cdc13, cdc1, u128)

type IcPallet_crowdloan_rewardsPalletEventRewardsPaid = [Icdc1, bigint]
const cPallet_crowdloan_rewardsPalletEventRewardsPaid: Codec<IcPallet_crowdloan_rewardsPalletEventRewardsPaid> =
  Tuple(cdc1, u128)

type IcPallet_crowdloan_rewardsPalletEventRewardAddressUpdated = [Icdc1, Icdc1]
const cPallet_crowdloan_rewardsPalletEventRewardAddressUpdated: Codec<IcPallet_crowdloan_rewardsPalletEventRewardAddressUpdated> =
  Tuple(cdc1, cdc1)

type IcPallet_crowdloan_rewardsPalletEventInitializedAlreadyInitializedAccount =
  [Icdc13, IcOption, bigint]
const cPallet_crowdloan_rewardsPalletEventInitializedAlreadyInitializedAccount: Codec<IcPallet_crowdloan_rewardsPalletEventInitializedAlreadyInitializedAccount> =
  Tuple(cdc13, cOption, u128)

type IcPallet_crowdloan_rewardsPalletEventInitializedAccountWithNotEnoughContribution =
  [Icdc13, IcOption, bigint]
const cPallet_crowdloan_rewardsPalletEventInitializedAccountWithNotEnoughContribution: Codec<IcPallet_crowdloan_rewardsPalletEventInitializedAccountWithNotEnoughContribution> =
  Tuple(cdc13, cOption, u128)

type IcPallet_crowdloan_rewardsPalletEvent =
  | {
      tag: "InitialPaymentMade"
      value: IcPallet_crowdloan_rewardsPalletEventInitialPaymentMade
    }
  | {
      tag: "NativeIdentityAssociated"
      value: IcPallet_crowdloan_rewardsPalletEventNativeIdentityAssociated
    }
  | {
      tag: "RewardsPaid"
      value: IcPallet_crowdloan_rewardsPalletEventRewardsPaid
    }
  | {
      tag: "RewardAddressUpdated"
      value: IcPallet_crowdloan_rewardsPalletEventRewardAddressUpdated
    }
  | {
      tag: "InitializedAlreadyInitializedAccount"
      value: IcPallet_crowdloan_rewardsPalletEventInitializedAlreadyInitializedAccount
    }
  | {
      tag: "InitializedAccountWithNotEnoughContribution"
      value: IcPallet_crowdloan_rewardsPalletEventInitializedAccountWithNotEnoughContribution
    }
const cPallet_crowdloan_rewardsPalletEvent: Codec<IcPallet_crowdloan_rewardsPalletEvent> =
  Enum({
    InitialPaymentMade: cPallet_crowdloan_rewardsPalletEventInitialPaymentMade,
    NativeIdentityAssociated:
      cPallet_crowdloan_rewardsPalletEventNativeIdentityAssociated,
    RewardsPaid: cPallet_crowdloan_rewardsPalletEventRewardsPaid,
    RewardAddressUpdated:
      cPallet_crowdloan_rewardsPalletEventRewardAddressUpdated,
    InitializedAlreadyInitializedAccount:
      cPallet_crowdloan_rewardsPalletEventInitializedAlreadyInitializedAccount,
    InitializedAccountWithNotEnoughContribution:
      cPallet_crowdloan_rewardsPalletEventInitializedAccountWithNotEnoughContribution,
  })

type IcMoonbeam_runtimeRuntimeEventCrowdloanRewards =
  IcPallet_crowdloan_rewardsPalletEvent
const cMoonbeam_runtimeRuntimeEventCrowdloanRewards: Codec<IcMoonbeam_runtimeRuntimeEventCrowdloanRewards> =
  cPallet_crowdloan_rewardsPalletEvent

type IcCumulus_pallet_xcmp_queuePalletEventSuccess = {
  message_hash: IcOption
  weight: IcSp_weightsWeight_v2Weight
}
const cCumulus_pallet_xcmp_queuePalletEventSuccess: Codec<IcCumulus_pallet_xcmp_queuePalletEventSuccess> =
  Struct({ message_hash: cOption, weight: cSp_weightsWeight_v2Weight })

type IcXcmV3TraitsErrorTrap = bigint
const cXcmV3TraitsErrorTrap: Codec<IcXcmV3TraitsErrorTrap> = u64

type IcXcmV3TraitsErrorWeightLimitReached = IcSp_weightsWeight_v2Weight
const cXcmV3TraitsErrorWeightLimitReached: Codec<IcXcmV3TraitsErrorWeightLimitReached> =
  cSp_weightsWeight_v2Weight

type IcXcmV3TraitsError =
  | { tag: "Overflow"; value: undefined }
  | { tag: "Unimplemented"; value: undefined }
  | { tag: "UntrustedReserveLocation"; value: undefined }
  | { tag: "UntrustedTeleportLocation"; value: undefined }
  | { tag: "LocationFull"; value: undefined }
  | { tag: "LocationNotInvertible"; value: undefined }
  | { tag: "BadOrigin"; value: undefined }
  | { tag: "InvalidLocation"; value: undefined }
  | { tag: "AssetNotFound"; value: undefined }
  | { tag: "FailedToTransactAsset"; value: undefined }
  | { tag: "NotWithdrawable"; value: undefined }
  | { tag: "LocationCannotHold"; value: undefined }
  | { tag: "ExceedsMaxMessageSize"; value: undefined }
  | { tag: "DestinationUnsupported"; value: undefined }
  | { tag: "Transport"; value: undefined }
  | { tag: "Unroutable"; value: undefined }
  | { tag: "UnknownClaim"; value: undefined }
  | { tag: "FailedToDecode"; value: undefined }
  | { tag: "MaxWeightInvalid"; value: undefined }
  | { tag: "NotHoldingFees"; value: undefined }
  | { tag: "TooExpensive"; value: undefined }
  | { tag: "Trap"; value: IcXcmV3TraitsErrorTrap }
  | { tag: "ExpectationFalse"; value: undefined }
  | { tag: "PalletNotFound"; value: undefined }
  | { tag: "NameMismatch"; value: undefined }
  | { tag: "VersionIncompatible"; value: undefined }
  | { tag: "HoldingWouldOverflow"; value: undefined }
  | { tag: "ExportError"; value: undefined }
  | { tag: "ReanchorFailed"; value: undefined }
  | { tag: "NoDeal"; value: undefined }
  | { tag: "FeesNotMet"; value: undefined }
  | { tag: "LockError"; value: undefined }
  | { tag: "NoPermission"; value: undefined }
  | { tag: "Unanchored"; value: undefined }
  | { tag: "NotDepositable"; value: undefined }
  | { tag: "UnhandledXcmVersion"; value: undefined }
  | { tag: "WeightLimitReached"; value: IcXcmV3TraitsErrorWeightLimitReached }
  | { tag: "Barrier"; value: undefined }
  | { tag: "WeightNotComputable"; value: undefined }
  | { tag: "ExceedsStackLimit"; value: undefined }
const cXcmV3TraitsError: Codec<IcXcmV3TraitsError> = Enum({
  Overflow: _void,
  Unimplemented: _void,
  UntrustedReserveLocation: _void,
  UntrustedTeleportLocation: _void,
  LocationFull: _void,
  LocationNotInvertible: _void,
  BadOrigin: _void,
  InvalidLocation: _void,
  AssetNotFound: _void,
  FailedToTransactAsset: _void,
  NotWithdrawable: _void,
  LocationCannotHold: _void,
  ExceedsMaxMessageSize: _void,
  DestinationUnsupported: _void,
  Transport: _void,
  Unroutable: _void,
  UnknownClaim: _void,
  FailedToDecode: _void,
  MaxWeightInvalid: _void,
  NotHoldingFees: _void,
  TooExpensive: _void,
  Trap: cXcmV3TraitsErrorTrap,
  ExpectationFalse: _void,
  PalletNotFound: _void,
  NameMismatch: _void,
  VersionIncompatible: _void,
  HoldingWouldOverflow: _void,
  ExportError: _void,
  ReanchorFailed: _void,
  NoDeal: _void,
  FeesNotMet: _void,
  LockError: _void,
  NoPermission: _void,
  Unanchored: _void,
  NotDepositable: _void,
  UnhandledXcmVersion: _void,
  WeightLimitReached: cXcmV3TraitsErrorWeightLimitReached,
  Barrier: _void,
  WeightNotComputable: _void,
  ExceedsStackLimit: _void,
})

type IcCumulus_pallet_xcmp_queuePalletEventFail = {
  message_hash: IcOption
  error: IcXcmV3TraitsError
  weight: IcSp_weightsWeight_v2Weight
}
const cCumulus_pallet_xcmp_queuePalletEventFail: Codec<IcCumulus_pallet_xcmp_queuePalletEventFail> =
  Struct({
    message_hash: cOption,
    error: cXcmV3TraitsError,
    weight: cSp_weightsWeight_v2Weight,
  })

type IcCumulus_pallet_xcmp_queuePalletEventBadVersion = {
  message_hash: IcOption
}
const cCumulus_pallet_xcmp_queuePalletEventBadVersion: Codec<IcCumulus_pallet_xcmp_queuePalletEventBadVersion> =
  Struct({ message_hash: cOption })

type IcCumulus_pallet_xcmp_queuePalletEventBadFormat = {
  message_hash: IcOption
}
const cCumulus_pallet_xcmp_queuePalletEventBadFormat: Codec<IcCumulus_pallet_xcmp_queuePalletEventBadFormat> =
  Struct({ message_hash: cOption })

type IcCumulus_pallet_xcmp_queuePalletEventXcmpMessageSent = {
  message_hash: IcOption
}
const cCumulus_pallet_xcmp_queuePalletEventXcmpMessageSent: Codec<IcCumulus_pallet_xcmp_queuePalletEventXcmpMessageSent> =
  Struct({ message_hash: cOption })

type IcCumulus_pallet_xcmp_queuePalletEventOverweightEnqueued = {
  sender: number
  sent_at: number
  index: bigint
  required: IcSp_weightsWeight_v2Weight
}
const cCumulus_pallet_xcmp_queuePalletEventOverweightEnqueued: Codec<IcCumulus_pallet_xcmp_queuePalletEventOverweightEnqueued> =
  Struct({
    sender: u32,
    sent_at: u32,
    index: u64,
    required: cSp_weightsWeight_v2Weight,
  })

type IcCumulus_pallet_xcmp_queuePalletEventOverweightServiced = {
  index: bigint
  used: IcSp_weightsWeight_v2Weight
}
const cCumulus_pallet_xcmp_queuePalletEventOverweightServiced: Codec<IcCumulus_pallet_xcmp_queuePalletEventOverweightServiced> =
  Struct({ index: u64, used: cSp_weightsWeight_v2Weight })

type IcCumulus_pallet_xcmp_queuePalletEvent =
  | { tag: "Success"; value: IcCumulus_pallet_xcmp_queuePalletEventSuccess }
  | { tag: "Fail"; value: IcCumulus_pallet_xcmp_queuePalletEventFail }
  | {
      tag: "BadVersion"
      value: IcCumulus_pallet_xcmp_queuePalletEventBadVersion
    }
  | { tag: "BadFormat"; value: IcCumulus_pallet_xcmp_queuePalletEventBadFormat }
  | {
      tag: "XcmpMessageSent"
      value: IcCumulus_pallet_xcmp_queuePalletEventXcmpMessageSent
    }
  | {
      tag: "OverweightEnqueued"
      value: IcCumulus_pallet_xcmp_queuePalletEventOverweightEnqueued
    }
  | {
      tag: "OverweightServiced"
      value: IcCumulus_pallet_xcmp_queuePalletEventOverweightServiced
    }
const cCumulus_pallet_xcmp_queuePalletEvent: Codec<IcCumulus_pallet_xcmp_queuePalletEvent> =
  Enum({
    Success: cCumulus_pallet_xcmp_queuePalletEventSuccess,
    Fail: cCumulus_pallet_xcmp_queuePalletEventFail,
    BadVersion: cCumulus_pallet_xcmp_queuePalletEventBadVersion,
    BadFormat: cCumulus_pallet_xcmp_queuePalletEventBadFormat,
    XcmpMessageSent: cCumulus_pallet_xcmp_queuePalletEventXcmpMessageSent,
    OverweightEnqueued: cCumulus_pallet_xcmp_queuePalletEventOverweightEnqueued,
    OverweightServiced: cCumulus_pallet_xcmp_queuePalletEventOverweightServiced,
  })

type IcMoonbeam_runtimeRuntimeEventXcmpQueue =
  IcCumulus_pallet_xcmp_queuePalletEvent
const cMoonbeam_runtimeRuntimeEventXcmpQueue: Codec<IcMoonbeam_runtimeRuntimeEventXcmpQueue> =
  cCumulus_pallet_xcmp_queuePalletEvent

type IcCumulus_pallet_xcmPalletEventInvalidFormat = Icdc13
const cCumulus_pallet_xcmPalletEventInvalidFormat: Codec<IcCumulus_pallet_xcmPalletEventInvalidFormat> =
  cdc13

type IcCumulus_pallet_xcmPalletEventUnsupportedVersion = Icdc13
const cCumulus_pallet_xcmPalletEventUnsupportedVersion: Codec<IcCumulus_pallet_xcmPalletEventUnsupportedVersion> =
  cdc13

type IcXcmV3TraitsOutcomeComplete = IcSp_weightsWeight_v2Weight
const cXcmV3TraitsOutcomeComplete: Codec<IcXcmV3TraitsOutcomeComplete> =
  cSp_weightsWeight_v2Weight

type IcXcmV3TraitsOutcomeIncomplete = [
  IcSp_weightsWeight_v2Weight,
  IcXcmV3TraitsError,
]
const cXcmV3TraitsOutcomeIncomplete: Codec<IcXcmV3TraitsOutcomeIncomplete> =
  Tuple(cSp_weightsWeight_v2Weight, cXcmV3TraitsError)

type IcXcmV3TraitsOutcomeError = IcXcmV3TraitsError
const cXcmV3TraitsOutcomeError: Codec<IcXcmV3TraitsOutcomeError> =
  cXcmV3TraitsError

type IcXcmV3TraitsOutcome =
  | { tag: "Complete"; value: IcXcmV3TraitsOutcomeComplete }
  | { tag: "Incomplete"; value: IcXcmV3TraitsOutcomeIncomplete }
  | { tag: "Error"; value: IcXcmV3TraitsOutcomeError }
const cXcmV3TraitsOutcome: Codec<IcXcmV3TraitsOutcome> = Enum({
  Complete: cXcmV3TraitsOutcomeComplete,
  Incomplete: cXcmV3TraitsOutcomeIncomplete,
  Error: cXcmV3TraitsOutcomeError,
})

type IcCumulus_pallet_xcmPalletEventExecutedDownward = [
  Icdc13,
  IcXcmV3TraitsOutcome,
]
const cCumulus_pallet_xcmPalletEventExecutedDownward: Codec<IcCumulus_pallet_xcmPalletEventExecutedDownward> =
  Tuple(cdc13, cXcmV3TraitsOutcome)

type IcCumulus_pallet_xcmPalletEvent =
  | {
      tag: "InvalidFormat"
      value: IcCumulus_pallet_xcmPalletEventInvalidFormat
    }
  | {
      tag: "UnsupportedVersion"
      value: IcCumulus_pallet_xcmPalletEventUnsupportedVersion
    }
  | {
      tag: "ExecutedDownward"
      value: IcCumulus_pallet_xcmPalletEventExecutedDownward
    }
const cCumulus_pallet_xcmPalletEvent: Codec<IcCumulus_pallet_xcmPalletEvent> =
  Enum({
    InvalidFormat: cCumulus_pallet_xcmPalletEventInvalidFormat,
    UnsupportedVersion: cCumulus_pallet_xcmPalletEventUnsupportedVersion,
    ExecutedDownward: cCumulus_pallet_xcmPalletEventExecutedDownward,
  })

type IcMoonbeam_runtimeRuntimeEventCumulusXcm = IcCumulus_pallet_xcmPalletEvent
const cMoonbeam_runtimeRuntimeEventCumulusXcm: Codec<IcMoonbeam_runtimeRuntimeEventCumulusXcm> =
  cCumulus_pallet_xcmPalletEvent

type IcCumulus_pallet_dmp_queuePalletEventInvalidFormat = { message_id: Icdc13 }
const cCumulus_pallet_dmp_queuePalletEventInvalidFormat: Codec<IcCumulus_pallet_dmp_queuePalletEventInvalidFormat> =
  Struct({ message_id: cdc13 })

type IcCumulus_pallet_dmp_queuePalletEventUnsupportedVersion = {
  message_id: Icdc13
}
const cCumulus_pallet_dmp_queuePalletEventUnsupportedVersion: Codec<IcCumulus_pallet_dmp_queuePalletEventUnsupportedVersion> =
  Struct({ message_id: cdc13 })

type IcCumulus_pallet_dmp_queuePalletEventExecutedDownward = {
  message_id: Icdc13
  outcome: IcXcmV3TraitsOutcome
}
const cCumulus_pallet_dmp_queuePalletEventExecutedDownward: Codec<IcCumulus_pallet_dmp_queuePalletEventExecutedDownward> =
  Struct({ message_id: cdc13, outcome: cXcmV3TraitsOutcome })

type IcCumulus_pallet_dmp_queuePalletEventWeightExhausted = {
  message_id: Icdc13
  remaining_weight: IcSp_weightsWeight_v2Weight
  required_weight: IcSp_weightsWeight_v2Weight
}
const cCumulus_pallet_dmp_queuePalletEventWeightExhausted: Codec<IcCumulus_pallet_dmp_queuePalletEventWeightExhausted> =
  Struct({
    message_id: cdc13,
    remaining_weight: cSp_weightsWeight_v2Weight,
    required_weight: cSp_weightsWeight_v2Weight,
  })

type IcCumulus_pallet_dmp_queuePalletEventOverweightEnqueued = {
  message_id: Icdc13
  overweight_index: bigint
  required_weight: IcSp_weightsWeight_v2Weight
}
const cCumulus_pallet_dmp_queuePalletEventOverweightEnqueued: Codec<IcCumulus_pallet_dmp_queuePalletEventOverweightEnqueued> =
  Struct({
    message_id: cdc13,
    overweight_index: u64,
    required_weight: cSp_weightsWeight_v2Weight,
  })

type IcCumulus_pallet_dmp_queuePalletEventOverweightServiced = {
  overweight_index: bigint
  weight_used: IcSp_weightsWeight_v2Weight
}
const cCumulus_pallet_dmp_queuePalletEventOverweightServiced: Codec<IcCumulus_pallet_dmp_queuePalletEventOverweightServiced> =
  Struct({ overweight_index: u64, weight_used: cSp_weightsWeight_v2Weight })

type IcCumulus_pallet_dmp_queuePalletEventMaxMessagesExhausted = {
  message_id: Icdc13
}
const cCumulus_pallet_dmp_queuePalletEventMaxMessagesExhausted: Codec<IcCumulus_pallet_dmp_queuePalletEventMaxMessagesExhausted> =
  Struct({ message_id: cdc13 })

type IcCumulus_pallet_dmp_queuePalletEvent =
  | {
      tag: "InvalidFormat"
      value: IcCumulus_pallet_dmp_queuePalletEventInvalidFormat
    }
  | {
      tag: "UnsupportedVersion"
      value: IcCumulus_pallet_dmp_queuePalletEventUnsupportedVersion
    }
  | {
      tag: "ExecutedDownward"
      value: IcCumulus_pallet_dmp_queuePalletEventExecutedDownward
    }
  | {
      tag: "WeightExhausted"
      value: IcCumulus_pallet_dmp_queuePalletEventWeightExhausted
    }
  | {
      tag: "OverweightEnqueued"
      value: IcCumulus_pallet_dmp_queuePalletEventOverweightEnqueued
    }
  | {
      tag: "OverweightServiced"
      value: IcCumulus_pallet_dmp_queuePalletEventOverweightServiced
    }
  | {
      tag: "MaxMessagesExhausted"
      value: IcCumulus_pallet_dmp_queuePalletEventMaxMessagesExhausted
    }
const cCumulus_pallet_dmp_queuePalletEvent: Codec<IcCumulus_pallet_dmp_queuePalletEvent> =
  Enum({
    InvalidFormat: cCumulus_pallet_dmp_queuePalletEventInvalidFormat,
    UnsupportedVersion: cCumulus_pallet_dmp_queuePalletEventUnsupportedVersion,
    ExecutedDownward: cCumulus_pallet_dmp_queuePalletEventExecutedDownward,
    WeightExhausted: cCumulus_pallet_dmp_queuePalletEventWeightExhausted,
    OverweightEnqueued: cCumulus_pallet_dmp_queuePalletEventOverweightEnqueued,
    OverweightServiced: cCumulus_pallet_dmp_queuePalletEventOverweightServiced,
    MaxMessagesExhausted:
      cCumulus_pallet_dmp_queuePalletEventMaxMessagesExhausted,
  })

type IcMoonbeam_runtimeRuntimeEventDmpQueue =
  IcCumulus_pallet_dmp_queuePalletEvent
const cMoonbeam_runtimeRuntimeEventDmpQueue: Codec<IcMoonbeam_runtimeRuntimeEventDmpQueue> =
  cCumulus_pallet_dmp_queuePalletEvent

type IcPallet_xcmPalletEventAttempted = IcXcmV3TraitsOutcome
const cPallet_xcmPalletEventAttempted: Codec<IcPallet_xcmPalletEventAttempted> =
  cXcmV3TraitsOutcome

type IcXcmV3JunctionJunctionParachain = number
const cXcmV3JunctionJunctionParachain: Codec<IcXcmV3JunctionJunctionParachain> =
  compactNumber

type IcXcmV3JunctionJunctionAccountId32 = { network: IcOption; id: Icdc13 }
const cXcmV3JunctionJunctionAccountId32: Codec<IcXcmV3JunctionJunctionAccountId32> =
  Struct({ network: cOption, id: cdc13 })

type IcXcmV3JunctionJunctionAccountIndex64 = {
  network: IcOption
  index: bigint
}
const cXcmV3JunctionJunctionAccountIndex64: Codec<IcXcmV3JunctionJunctionAccountIndex64> =
  Struct({ network: cOption, index: compactBn })

type IcXcmV3JunctionJunctionAccountKey20 = { network: IcOption; key: Icdc1 }
const cXcmV3JunctionJunctionAccountKey20: Codec<IcXcmV3JunctionJunctionAccountKey20> =
  Struct({ network: cOption, key: cdc1 })

type IcXcmV3JunctionJunctionPalletInstance = number
const cXcmV3JunctionJunctionPalletInstance: Codec<IcXcmV3JunctionJunctionPalletInstance> =
  u8

type IcXcmV3JunctionJunctionGeneralIndex = bigint
const cXcmV3JunctionJunctionGeneralIndex: Codec<IcXcmV3JunctionJunctionGeneralIndex> =
  compactBn

type IcXcmV3JunctionJunctionGeneralKey = { length: number; data: Icdc13 }
const cXcmV3JunctionJunctionGeneralKey: Codec<IcXcmV3JunctionJunctionGeneralKey> =
  Struct({ length: u8, data: cdc13 })

type IcXcmV3JunctionBodyIdMoniker = Icdc18
const cXcmV3JunctionBodyIdMoniker: Codec<IcXcmV3JunctionBodyIdMoniker> = cdc18

type IcXcmV3JunctionBodyIdIndex = number
const cXcmV3JunctionBodyIdIndex: Codec<IcXcmV3JunctionBodyIdIndex> =
  compactNumber

type IcXcmV3JunctionBodyId =
  | { tag: "Unit"; value: undefined }
  | { tag: "Moniker"; value: IcXcmV3JunctionBodyIdMoniker }
  | { tag: "Index"; value: IcXcmV3JunctionBodyIdIndex }
  | { tag: "Executive"; value: undefined }
  | { tag: "Technical"; value: undefined }
  | { tag: "Legislative"; value: undefined }
  | { tag: "Judicial"; value: undefined }
  | { tag: "Defense"; value: undefined }
  | { tag: "Administration"; value: undefined }
  | { tag: "Treasury"; value: undefined }
const cXcmV3JunctionBodyId: Codec<IcXcmV3JunctionBodyId> = Enum({
  Unit: _void,
  Moniker: cXcmV3JunctionBodyIdMoniker,
  Index: cXcmV3JunctionBodyIdIndex,
  Executive: _void,
  Technical: _void,
  Legislative: _void,
  Judicial: _void,
  Defense: _void,
  Administration: _void,
  Treasury: _void,
})

type IcXcmV3JunctionBodyPartMembers = { count: number }
const cXcmV3JunctionBodyPartMembers: Codec<IcXcmV3JunctionBodyPartMembers> =
  Struct({ count: compactNumber })

type IcXcmV3JunctionBodyPartFraction = { nom: number; denom: number }
const cXcmV3JunctionBodyPartFraction: Codec<IcXcmV3JunctionBodyPartFraction> =
  Struct({ nom: compactNumber, denom: compactNumber })

type IcXcmV3JunctionBodyPartAtLeastProportion = { nom: number; denom: number }
const cXcmV3JunctionBodyPartAtLeastProportion: Codec<IcXcmV3JunctionBodyPartAtLeastProportion> =
  Struct({ nom: compactNumber, denom: compactNumber })

type IcXcmV3JunctionBodyPartMoreThanProportion = { nom: number; denom: number }
const cXcmV3JunctionBodyPartMoreThanProportion: Codec<IcXcmV3JunctionBodyPartMoreThanProportion> =
  Struct({ nom: compactNumber, denom: compactNumber })

type IcXcmV3JunctionBodyPart =
  | { tag: "Voice"; value: undefined }
  | { tag: "Members"; value: IcXcmV3JunctionBodyPartMembers }
  | { tag: "Fraction"; value: IcXcmV3JunctionBodyPartFraction }
  | {
      tag: "AtLeastProportion"
      value: IcXcmV3JunctionBodyPartAtLeastProportion
    }
  | {
      tag: "MoreThanProportion"
      value: IcXcmV3JunctionBodyPartMoreThanProportion
    }
const cXcmV3JunctionBodyPart: Codec<IcXcmV3JunctionBodyPart> = Enum({
  Voice: _void,
  Members: cXcmV3JunctionBodyPartMembers,
  Fraction: cXcmV3JunctionBodyPartFraction,
  AtLeastProportion: cXcmV3JunctionBodyPartAtLeastProportion,
  MoreThanProportion: cXcmV3JunctionBodyPartMoreThanProportion,
})

type IcXcmV3JunctionJunctionPlurality = {
  id: IcXcmV3JunctionBodyId
  part: IcXcmV3JunctionBodyPart
}
const cXcmV3JunctionJunctionPlurality: Codec<IcXcmV3JunctionJunctionPlurality> =
  Struct({ id: cXcmV3JunctionBodyId, part: cXcmV3JunctionBodyPart })

type IcXcmV3JunctionNetworkIdByGenesis = Icdc13
const cXcmV3JunctionNetworkIdByGenesis: Codec<IcXcmV3JunctionNetworkIdByGenesis> =
  cdc13

type IcXcmV3JunctionNetworkIdByFork = {
  block_number: bigint
  block_hash: Icdc13
}
const cXcmV3JunctionNetworkIdByFork: Codec<IcXcmV3JunctionNetworkIdByFork> =
  Struct({ block_number: u64, block_hash: cdc13 })

type IcXcmV3JunctionNetworkIdEthereum = { chain_id: bigint }
const cXcmV3JunctionNetworkIdEthereum: Codec<IcXcmV3JunctionNetworkIdEthereum> =
  Struct({ chain_id: compactBn })

type IcXcmV3JunctionNetworkId =
  | { tag: "ByGenesis"; value: IcXcmV3JunctionNetworkIdByGenesis }
  | { tag: "ByFork"; value: IcXcmV3JunctionNetworkIdByFork }
  | { tag: "Polkadot"; value: undefined }
  | { tag: "Kusama"; value: undefined }
  | { tag: "Westend"; value: undefined }
  | { tag: "Rococo"; value: undefined }
  | { tag: "Wococo"; value: undefined }
  | { tag: "Ethereum"; value: IcXcmV3JunctionNetworkIdEthereum }
  | { tag: "BitcoinCore"; value: undefined }
  | { tag: "BitcoinCash"; value: undefined }
const cXcmV3JunctionNetworkId: Codec<IcXcmV3JunctionNetworkId> = Enum({
  ByGenesis: cXcmV3JunctionNetworkIdByGenesis,
  ByFork: cXcmV3JunctionNetworkIdByFork,
  Polkadot: _void,
  Kusama: _void,
  Westend: _void,
  Rococo: _void,
  Wococo: _void,
  Ethereum: cXcmV3JunctionNetworkIdEthereum,
  BitcoinCore: _void,
  BitcoinCash: _void,
})

type IcXcmV3JunctionJunctionGlobalConsensus = IcXcmV3JunctionNetworkId
const cXcmV3JunctionJunctionGlobalConsensus: Codec<IcXcmV3JunctionJunctionGlobalConsensus> =
  cXcmV3JunctionNetworkId

type IcXcmV3JunctionJunction =
  | { tag: "Parachain"; value: IcXcmV3JunctionJunctionParachain }
  | { tag: "AccountId32"; value: IcXcmV3JunctionJunctionAccountId32 }
  | { tag: "AccountIndex64"; value: IcXcmV3JunctionJunctionAccountIndex64 }
  | { tag: "AccountKey20"; value: IcXcmV3JunctionJunctionAccountKey20 }
  | { tag: "PalletInstance"; value: IcXcmV3JunctionJunctionPalletInstance }
  | { tag: "GeneralIndex"; value: IcXcmV3JunctionJunctionGeneralIndex }
  | { tag: "GeneralKey"; value: IcXcmV3JunctionJunctionGeneralKey }
  | { tag: "OnlyChild"; value: undefined }
  | { tag: "Plurality"; value: IcXcmV3JunctionJunctionPlurality }
  | { tag: "GlobalConsensus"; value: IcXcmV3JunctionJunctionGlobalConsensus }
const cXcmV3JunctionJunction: Codec<IcXcmV3JunctionJunction> = Enum({
  Parachain: cXcmV3JunctionJunctionParachain,
  AccountId32: cXcmV3JunctionJunctionAccountId32,
  AccountIndex64: cXcmV3JunctionJunctionAccountIndex64,
  AccountKey20: cXcmV3JunctionJunctionAccountKey20,
  PalletInstance: cXcmV3JunctionJunctionPalletInstance,
  GeneralIndex: cXcmV3JunctionJunctionGeneralIndex,
  GeneralKey: cXcmV3JunctionJunctionGeneralKey,
  OnlyChild: _void,
  Plurality: cXcmV3JunctionJunctionPlurality,
  GlobalConsensus: cXcmV3JunctionJunctionGlobalConsensus,
})

type IcXcmV3JunctionsJunctionsX1 = IcXcmV3JunctionJunction
const cXcmV3JunctionsJunctionsX1: Codec<IcXcmV3JunctionsJunctionsX1> =
  cXcmV3JunctionJunction

type IcXcmV3JunctionsJunctionsX2 = [
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
]
const cXcmV3JunctionsJunctionsX2: Codec<IcXcmV3JunctionsJunctionsX2> = Tuple(
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
)

type IcXcmV3JunctionsJunctionsX3 = [
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
]
const cXcmV3JunctionsJunctionsX3: Codec<IcXcmV3JunctionsJunctionsX3> = Tuple(
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
)

type IcXcmV3JunctionsJunctionsX4 = [
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
]
const cXcmV3JunctionsJunctionsX4: Codec<IcXcmV3JunctionsJunctionsX4> = Tuple(
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
)

type IcXcmV3JunctionsJunctionsX5 = [
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
]
const cXcmV3JunctionsJunctionsX5: Codec<IcXcmV3JunctionsJunctionsX5> = Tuple(
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
)

type IcXcmV3JunctionsJunctionsX6 = [
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
]
const cXcmV3JunctionsJunctionsX6: Codec<IcXcmV3JunctionsJunctionsX6> = Tuple(
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
)

type IcXcmV3JunctionsJunctionsX7 = [
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
]
const cXcmV3JunctionsJunctionsX7: Codec<IcXcmV3JunctionsJunctionsX7> = Tuple(
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
)

type IcXcmV3JunctionsJunctionsX8 = [
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
  IcXcmV3JunctionJunction,
]
const cXcmV3JunctionsJunctionsX8: Codec<IcXcmV3JunctionsJunctionsX8> = Tuple(
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
  cXcmV3JunctionJunction,
)

type IcXcmV3JunctionsJunctions =
  | { tag: "Here"; value: undefined }
  | { tag: "X1"; value: IcXcmV3JunctionsJunctionsX1 }
  | { tag: "X2"; value: IcXcmV3JunctionsJunctionsX2 }
  | { tag: "X3"; value: IcXcmV3JunctionsJunctionsX3 }
  | { tag: "X4"; value: IcXcmV3JunctionsJunctionsX4 }
  | { tag: "X5"; value: IcXcmV3JunctionsJunctionsX5 }
  | { tag: "X6"; value: IcXcmV3JunctionsJunctionsX6 }
  | { tag: "X7"; value: IcXcmV3JunctionsJunctionsX7 }
  | { tag: "X8"; value: IcXcmV3JunctionsJunctionsX8 }
const cXcmV3JunctionsJunctions: Codec<IcXcmV3JunctionsJunctions> = Enum({
  Here: _void,
  X1: cXcmV3JunctionsJunctionsX1,
  X2: cXcmV3JunctionsJunctionsX2,
  X3: cXcmV3JunctionsJunctionsX3,
  X4: cXcmV3JunctionsJunctionsX4,
  X5: cXcmV3JunctionsJunctionsX5,
  X6: cXcmV3JunctionsJunctionsX6,
  X7: cXcmV3JunctionsJunctionsX7,
  X8: cXcmV3JunctionsJunctionsX8,
})

type IcXcmV3MultilocationMultiLocation = {
  parents: number
  interior: IcXcmV3JunctionsJunctions
}
const cXcmV3MultilocationMultiLocation: Codec<IcXcmV3MultilocationMultiLocation> =
  Struct({ parents: u8, interior: cXcmV3JunctionsJunctions })

type IcXcmV3MultiassetAssetIdConcrete = IcXcmV3MultilocationMultiLocation
const cXcmV3MultiassetAssetIdConcrete: Codec<IcXcmV3MultiassetAssetIdConcrete> =
  cXcmV3MultilocationMultiLocation

type IcXcmV3MultiassetAssetIdAbstract = Icdc13
const cXcmV3MultiassetAssetIdAbstract: Codec<IcXcmV3MultiassetAssetIdAbstract> =
  cdc13

type IcXcmV3MultiassetAssetId =
  | { tag: "Concrete"; value: IcXcmV3MultiassetAssetIdConcrete }
  | { tag: "Abstract"; value: IcXcmV3MultiassetAssetIdAbstract }
const cXcmV3MultiassetAssetId: Codec<IcXcmV3MultiassetAssetId> = Enum({
  Concrete: cXcmV3MultiassetAssetIdConcrete,
  Abstract: cXcmV3MultiassetAssetIdAbstract,
})

type IcXcmV3MultiassetFungibilityFungible = bigint
const cXcmV3MultiassetFungibilityFungible: Codec<IcXcmV3MultiassetFungibilityFungible> =
  compactBn

type IcXcmV3MultiassetAssetInstanceIndex = bigint
const cXcmV3MultiassetAssetInstanceIndex: Codec<IcXcmV3MultiassetAssetInstanceIndex> =
  compactBn

type IcXcmV3MultiassetAssetInstanceArray4 = Icdc18
const cXcmV3MultiassetAssetInstanceArray4: Codec<IcXcmV3MultiassetAssetInstanceArray4> =
  cdc18

type Icdc154 = HexString
const cdc154: Codec<Icdc154> = Hex(8)

type IcXcmV3MultiassetAssetInstanceArray8 = Icdc154
const cXcmV3MultiassetAssetInstanceArray8: Codec<IcXcmV3MultiassetAssetInstanceArray8> =
  cdc154

type Icdc162 = HexString
const cdc162: Codec<Icdc162> = Hex(16)

type IcXcmV3MultiassetAssetInstanceArray16 = Icdc162
const cXcmV3MultiassetAssetInstanceArray16: Codec<IcXcmV3MultiassetAssetInstanceArray16> =
  cdc162

type IcXcmV3MultiassetAssetInstanceArray32 = Icdc13
const cXcmV3MultiassetAssetInstanceArray32: Codec<IcXcmV3MultiassetAssetInstanceArray32> =
  cdc13

type IcXcmV3MultiassetAssetInstance =
  | { tag: "Undefined"; value: undefined }
  | { tag: "Index"; value: IcXcmV3MultiassetAssetInstanceIndex }
  | { tag: "Array4"; value: IcXcmV3MultiassetAssetInstanceArray4 }
  | { tag: "Array8"; value: IcXcmV3MultiassetAssetInstanceArray8 }
  | { tag: "Array16"; value: IcXcmV3MultiassetAssetInstanceArray16 }
  | { tag: "Array32"; value: IcXcmV3MultiassetAssetInstanceArray32 }
const cXcmV3MultiassetAssetInstance: Codec<IcXcmV3MultiassetAssetInstance> =
  Enum({
    Undefined: _void,
    Index: cXcmV3MultiassetAssetInstanceIndex,
    Array4: cXcmV3MultiassetAssetInstanceArray4,
    Array8: cXcmV3MultiassetAssetInstanceArray8,
    Array16: cXcmV3MultiassetAssetInstanceArray16,
    Array32: cXcmV3MultiassetAssetInstanceArray32,
  })

type IcXcmV3MultiassetFungibilityNonFungible = IcXcmV3MultiassetAssetInstance
const cXcmV3MultiassetFungibilityNonFungible: Codec<IcXcmV3MultiassetFungibilityNonFungible> =
  cXcmV3MultiassetAssetInstance

type IcXcmV3MultiassetFungibility =
  | { tag: "Fungible"; value: IcXcmV3MultiassetFungibilityFungible }
  | { tag: "NonFungible"; value: IcXcmV3MultiassetFungibilityNonFungible }
const cXcmV3MultiassetFungibility: Codec<IcXcmV3MultiassetFungibility> = Enum({
  Fungible: cXcmV3MultiassetFungibilityFungible,
  NonFungible: cXcmV3MultiassetFungibilityNonFungible,
})

type IcXcmV3MultiassetMultiAsset = {
  id: IcXcmV3MultiassetAssetId
  fun: IcXcmV3MultiassetFungibility
}
const cXcmV3MultiassetMultiAsset: Codec<IcXcmV3MultiassetMultiAsset> = Struct({
  id: cXcmV3MultiassetAssetId,
  fun: cXcmV3MultiassetFungibility,
})

type Icdc267 = Array<IcXcmV3MultiassetMultiAsset>
const cdc267: Codec<Icdc267> = Vector(cXcmV3MultiassetMultiAsset)

type IcXcmV3InstructionWithdrawAsset = Icdc267
const cXcmV3InstructionWithdrawAsset: Codec<IcXcmV3InstructionWithdrawAsset> =
  cdc267

type IcXcmV3InstructionReserveAssetDeposited = Icdc267
const cXcmV3InstructionReserveAssetDeposited: Codec<IcXcmV3InstructionReserveAssetDeposited> =
  cdc267

type IcXcmV3InstructionReceiveTeleportedAsset = Icdc267
const cXcmV3InstructionReceiveTeleportedAsset: Codec<IcXcmV3InstructionReceiveTeleportedAsset> =
  cdc267

type IcXcmV3ResponseAssets = Icdc267
const cXcmV3ResponseAssets: Codec<IcXcmV3ResponseAssets> = cdc267

type IcXcmV3ResponseExecutionResult = IcOption
const cXcmV3ResponseExecutionResult: Codec<IcXcmV3ResponseExecutionResult> =
  cOption

type IcXcmV3ResponseVersion = number
const cXcmV3ResponseVersion: Codec<IcXcmV3ResponseVersion> = u32

type IcXcmV3PalletInfo = {
  index: number
  name: I_bytesSeq
  module_name: I_bytesSeq
  major: number
  minor: number
  patch: number
}
const cXcmV3PalletInfo: Codec<IcXcmV3PalletInfo> = Struct({
  index: compactNumber,
  name: _bytesSeq,
  module_name: _bytesSeq,
  major: compactNumber,
  minor: compactNumber,
  patch: compactNumber,
})

type Icdc279 = Array<IcXcmV3PalletInfo>
const cdc279: Codec<Icdc279> = Vector(cXcmV3PalletInfo)

type IcXcmV3ResponsePalletsInfo = Icdc279
const cXcmV3ResponsePalletsInfo: Codec<IcXcmV3ResponsePalletsInfo> = cdc279

type IcXcmV3MaybeErrorCodeError = I_bytesSeq
const cXcmV3MaybeErrorCodeError: Codec<IcXcmV3MaybeErrorCodeError> = _bytesSeq

type IcXcmV3MaybeErrorCodeTruncatedError = I_bytesSeq
const cXcmV3MaybeErrorCodeTruncatedError: Codec<IcXcmV3MaybeErrorCodeTruncatedError> =
  _bytesSeq

type IcXcmV3MaybeErrorCode =
  | { tag: "Success"; value: undefined }
  | { tag: "Error"; value: IcXcmV3MaybeErrorCodeError }
  | { tag: "TruncatedError"; value: IcXcmV3MaybeErrorCodeTruncatedError }
const cXcmV3MaybeErrorCode: Codec<IcXcmV3MaybeErrorCode> = Enum({
  Success: _void,
  Error: cXcmV3MaybeErrorCodeError,
  TruncatedError: cXcmV3MaybeErrorCodeTruncatedError,
})

type IcXcmV3ResponseDispatchResult = IcXcmV3MaybeErrorCode
const cXcmV3ResponseDispatchResult: Codec<IcXcmV3ResponseDispatchResult> =
  cXcmV3MaybeErrorCode

type IcXcmV3Response =
  | { tag: "Null"; value: undefined }
  | { tag: "Assets"; value: IcXcmV3ResponseAssets }
  | { tag: "ExecutionResult"; value: IcXcmV3ResponseExecutionResult }
  | { tag: "Version"; value: IcXcmV3ResponseVersion }
  | { tag: "PalletsInfo"; value: IcXcmV3ResponsePalletsInfo }
  | { tag: "DispatchResult"; value: IcXcmV3ResponseDispatchResult }
const cXcmV3Response: Codec<IcXcmV3Response> = Enum({
  Null: _void,
  Assets: cXcmV3ResponseAssets,
  ExecutionResult: cXcmV3ResponseExecutionResult,
  Version: cXcmV3ResponseVersion,
  PalletsInfo: cXcmV3ResponsePalletsInfo,
  DispatchResult: cXcmV3ResponseDispatchResult,
})

type IcXcmV3InstructionQueryResponse = {
  query_id: bigint
  response: IcXcmV3Response
  max_weight: IcSp_weightsWeight_v2Weight
  querier: IcOption
}
const cXcmV3InstructionQueryResponse: Codec<IcXcmV3InstructionQueryResponse> =
  Struct({
    query_id: compactBn,
    response: cXcmV3Response,
    max_weight: cSp_weightsWeight_v2Weight,
    querier: cOption,
  })

type IcXcmV3InstructionTransferAsset = {
  assets: Icdc267
  beneficiary: IcXcmV3MultilocationMultiLocation
}
const cXcmV3InstructionTransferAsset: Codec<IcXcmV3InstructionTransferAsset> =
  Struct({ assets: cdc267, beneficiary: cXcmV3MultilocationMultiLocation })

type Icdc264Circular = Icdc264
const cdc264Circular: Codec<Icdc264Circular> = Self(() => cdc264)

type IcXcmV3InstructionTransferReserveAsset = {
  assets: Icdc267
  dest: IcXcmV3MultilocationMultiLocation
  xcm: Icdc264Circular
}
const cXcmV3InstructionTransferReserveAsset: Codec<IcXcmV3InstructionTransferReserveAsset> =
  Struct({
    assets: cdc267,
    dest: cXcmV3MultilocationMultiLocation,
    xcm: cdc264Circular,
  })

type IcXcmV2OriginKind =
  | { tag: "Native"; value: undefined }
  | { tag: "SovereignAccount"; value: undefined }
  | { tag: "Superuser"; value: undefined }
  | { tag: "Xcm"; value: undefined }
const cXcmV2OriginKind: Codec<IcXcmV2OriginKind> = Enum({
  Native: _void,
  SovereignAccount: _void,
  Superuser: _void,
  Xcm: _void,
})

type IcXcmV3InstructionTransact = {
  origin_kind: IcXcmV2OriginKind
  require_weight_at_most: IcSp_weightsWeight_v2Weight
  call: I_bytesSeq
}
const cXcmV3InstructionTransact: Codec<IcXcmV3InstructionTransact> = Struct({
  origin_kind: cXcmV2OriginKind,
  require_weight_at_most: cSp_weightsWeight_v2Weight,
  call: _bytesSeq,
})

type IcXcmV3InstructionHrmpNewChannelOpenRequest = {
  sender: number
  max_message_size: number
  max_capacity: number
}
const cXcmV3InstructionHrmpNewChannelOpenRequest: Codec<IcXcmV3InstructionHrmpNewChannelOpenRequest> =
  Struct({
    sender: compactNumber,
    max_message_size: compactNumber,
    max_capacity: compactNumber,
  })

type IcXcmV3InstructionHrmpChannelAccepted = { recipient: number }
const cXcmV3InstructionHrmpChannelAccepted: Codec<IcXcmV3InstructionHrmpChannelAccepted> =
  Struct({ recipient: compactNumber })

type IcXcmV3InstructionHrmpChannelClosing = {
  initiator: number
  sender: number
  recipient: number
}
const cXcmV3InstructionHrmpChannelClosing: Codec<IcXcmV3InstructionHrmpChannelClosing> =
  Struct({
    initiator: compactNumber,
    sender: compactNumber,
    recipient: compactNumber,
  })

type IcXcmV3InstructionDescendOrigin = IcXcmV3JunctionsJunctions
const cXcmV3InstructionDescendOrigin: Codec<IcXcmV3InstructionDescendOrigin> =
  cXcmV3JunctionsJunctions

type IcXcmV3QueryResponseInfo = {
  destination: IcXcmV3MultilocationMultiLocation
  query_id: bigint
  max_weight: IcSp_weightsWeight_v2Weight
}
const cXcmV3QueryResponseInfo: Codec<IcXcmV3QueryResponseInfo> = Struct({
  destination: cXcmV3MultilocationMultiLocation,
  query_id: compactBn,
  max_weight: cSp_weightsWeight_v2Weight,
})

type IcXcmV3InstructionReportError = IcXcmV3QueryResponseInfo
const cXcmV3InstructionReportError: Codec<IcXcmV3InstructionReportError> =
  cXcmV3QueryResponseInfo

type IcXcmV3MultiassetMultiAssetFilterDefinite = Icdc267
const cXcmV3MultiassetMultiAssetFilterDefinite: Codec<IcXcmV3MultiassetMultiAssetFilterDefinite> =
  cdc267

type IcXcmV3MultiassetWildFungibility =
  | { tag: "Fungible"; value: undefined }
  | { tag: "NonFungible"; value: undefined }
const cXcmV3MultiassetWildFungibility: Codec<IcXcmV3MultiassetWildFungibility> =
  Enum({ Fungible: _void, NonFungible: _void })

type IcXcmV3MultiassetWildMultiAssetAllOf = {
  id: IcXcmV3MultiassetAssetId
  fun: IcXcmV3MultiassetWildFungibility
}
const cXcmV3MultiassetWildMultiAssetAllOf: Codec<IcXcmV3MultiassetWildMultiAssetAllOf> =
  Struct({ id: cXcmV3MultiassetAssetId, fun: cXcmV3MultiassetWildFungibility })

type IcXcmV3MultiassetWildMultiAssetAllCounted = number
const cXcmV3MultiassetWildMultiAssetAllCounted: Codec<IcXcmV3MultiassetWildMultiAssetAllCounted> =
  compactNumber

type IcXcmV3MultiassetWildMultiAssetAllOfCounted = {
  id: IcXcmV3MultiassetAssetId
  fun: IcXcmV3MultiassetWildFungibility
  count: number
}
const cXcmV3MultiassetWildMultiAssetAllOfCounted: Codec<IcXcmV3MultiassetWildMultiAssetAllOfCounted> =
  Struct({
    id: cXcmV3MultiassetAssetId,
    fun: cXcmV3MultiassetWildFungibility,
    count: compactNumber,
  })

type IcXcmV3MultiassetWildMultiAsset =
  | { tag: "All"; value: undefined }
  | { tag: "AllOf"; value: IcXcmV3MultiassetWildMultiAssetAllOf }
  | { tag: "AllCounted"; value: IcXcmV3MultiassetWildMultiAssetAllCounted }
  | { tag: "AllOfCounted"; value: IcXcmV3MultiassetWildMultiAssetAllOfCounted }
const cXcmV3MultiassetWildMultiAsset: Codec<IcXcmV3MultiassetWildMultiAsset> =
  Enum({
    All: _void,
    AllOf: cXcmV3MultiassetWildMultiAssetAllOf,
    AllCounted: cXcmV3MultiassetWildMultiAssetAllCounted,
    AllOfCounted: cXcmV3MultiassetWildMultiAssetAllOfCounted,
  })

type IcXcmV3MultiassetMultiAssetFilterWild = IcXcmV3MultiassetWildMultiAsset
const cXcmV3MultiassetMultiAssetFilterWild: Codec<IcXcmV3MultiassetMultiAssetFilterWild> =
  cXcmV3MultiassetWildMultiAsset

type IcXcmV3MultiassetMultiAssetFilter =
  | { tag: "Definite"; value: IcXcmV3MultiassetMultiAssetFilterDefinite }
  | { tag: "Wild"; value: IcXcmV3MultiassetMultiAssetFilterWild }
const cXcmV3MultiassetMultiAssetFilter: Codec<IcXcmV3MultiassetMultiAssetFilter> =
  Enum({
    Definite: cXcmV3MultiassetMultiAssetFilterDefinite,
    Wild: cXcmV3MultiassetMultiAssetFilterWild,
  })

type IcXcmV3InstructionDepositAsset = {
  assets: IcXcmV3MultiassetMultiAssetFilter
  beneficiary: IcXcmV3MultilocationMultiLocation
}
const cXcmV3InstructionDepositAsset: Codec<IcXcmV3InstructionDepositAsset> =
  Struct({
    assets: cXcmV3MultiassetMultiAssetFilter,
    beneficiary: cXcmV3MultilocationMultiLocation,
  })

type IcXcmV3InstructionDepositReserveAsset = {
  assets: IcXcmV3MultiassetMultiAssetFilter
  dest: IcXcmV3MultilocationMultiLocation
  xcm: Icdc264Circular
}
const cXcmV3InstructionDepositReserveAsset: Codec<IcXcmV3InstructionDepositReserveAsset> =
  Struct({
    assets: cXcmV3MultiassetMultiAssetFilter,
    dest: cXcmV3MultilocationMultiLocation,
    xcm: cdc264Circular,
  })

type IcXcmV3InstructionExchangeAsset = {
  give: IcXcmV3MultiassetMultiAssetFilter
  want: Icdc267
  maximal: boolean
}
const cXcmV3InstructionExchangeAsset: Codec<IcXcmV3InstructionExchangeAsset> =
  Struct({
    give: cXcmV3MultiassetMultiAssetFilter,
    want: cdc267,
    maximal: bool,
  })

type IcXcmV3InstructionInitiateReserveWithdraw = {
  assets: IcXcmV3MultiassetMultiAssetFilter
  reserve: IcXcmV3MultilocationMultiLocation
  xcm: Icdc264Circular
}
const cXcmV3InstructionInitiateReserveWithdraw: Codec<IcXcmV3InstructionInitiateReserveWithdraw> =
  Struct({
    assets: cXcmV3MultiassetMultiAssetFilter,
    reserve: cXcmV3MultilocationMultiLocation,
    xcm: cdc264Circular,
  })

type IcXcmV3InstructionInitiateTeleport = {
  assets: IcXcmV3MultiassetMultiAssetFilter
  dest: IcXcmV3MultilocationMultiLocation
  xcm: Icdc264Circular
}
const cXcmV3InstructionInitiateTeleport: Codec<IcXcmV3InstructionInitiateTeleport> =
  Struct({
    assets: cXcmV3MultiassetMultiAssetFilter,
    dest: cXcmV3MultilocationMultiLocation,
    xcm: cdc264Circular,
  })

type IcXcmV3InstructionReportHolding = {
  response_info: IcXcmV3QueryResponseInfo
  assets: IcXcmV3MultiassetMultiAssetFilter
}
const cXcmV3InstructionReportHolding: Codec<IcXcmV3InstructionReportHolding> =
  Struct({
    response_info: cXcmV3QueryResponseInfo,
    assets: cXcmV3MultiassetMultiAssetFilter,
  })

type IcXcmV3WeightLimitLimited = IcSp_weightsWeight_v2Weight
const cXcmV3WeightLimitLimited: Codec<IcXcmV3WeightLimitLimited> =
  cSp_weightsWeight_v2Weight

type IcXcmV3WeightLimit =
  | { tag: "Unlimited"; value: undefined }
  | { tag: "Limited"; value: IcXcmV3WeightLimitLimited }
const cXcmV3WeightLimit: Codec<IcXcmV3WeightLimit> = Enum({
  Unlimited: _void,
  Limited: cXcmV3WeightLimitLimited,
})

type IcXcmV3InstructionBuyExecution = {
  fees: IcXcmV3MultiassetMultiAsset
  weight_limit: IcXcmV3WeightLimit
}
const cXcmV3InstructionBuyExecution: Codec<IcXcmV3InstructionBuyExecution> =
  Struct({ fees: cXcmV3MultiassetMultiAsset, weight_limit: cXcmV3WeightLimit })

type IcXcmV3InstructionSetErrorHandler = Icdc264Circular
const cXcmV3InstructionSetErrorHandler: Codec<IcXcmV3InstructionSetErrorHandler> =
  cdc264Circular

type IcXcmV3InstructionSetAppendix = Icdc264Circular
const cXcmV3InstructionSetAppendix: Codec<IcXcmV3InstructionSetAppendix> =
  cdc264Circular

type IcXcmV3InstructionClaimAsset = {
  assets: Icdc267
  ticket: IcXcmV3MultilocationMultiLocation
}
const cXcmV3InstructionClaimAsset: Codec<IcXcmV3InstructionClaimAsset> = Struct(
  { assets: cdc267, ticket: cXcmV3MultilocationMultiLocation },
)

type IcXcmV3InstructionTrap = bigint
const cXcmV3InstructionTrap: Codec<IcXcmV3InstructionTrap> = compactBn

type IcXcmV3InstructionSubscribeVersion = {
  query_id: bigint
  max_response_weight: IcSp_weightsWeight_v2Weight
}
const cXcmV3InstructionSubscribeVersion: Codec<IcXcmV3InstructionSubscribeVersion> =
  Struct({
    query_id: compactBn,
    max_response_weight: cSp_weightsWeight_v2Weight,
  })

type IcXcmV3InstructionBurnAsset = Icdc267
const cXcmV3InstructionBurnAsset: Codec<IcXcmV3InstructionBurnAsset> = cdc267

type IcXcmV3InstructionExpectAsset = Icdc267
const cXcmV3InstructionExpectAsset: Codec<IcXcmV3InstructionExpectAsset> =
  cdc267

type IcXcmV3InstructionExpectOrigin = IcOption
const cXcmV3InstructionExpectOrigin: Codec<IcXcmV3InstructionExpectOrigin> =
  cOption

type IcXcmV3InstructionExpectError = IcOption
const cXcmV3InstructionExpectError: Codec<IcXcmV3InstructionExpectError> =
  cOption

type IcXcmV3InstructionExpectTransactStatus = IcXcmV3MaybeErrorCode
const cXcmV3InstructionExpectTransactStatus: Codec<IcXcmV3InstructionExpectTransactStatus> =
  cXcmV3MaybeErrorCode

type IcXcmV3InstructionQueryPallet = {
  module_name: I_bytesSeq
  response_info: IcXcmV3QueryResponseInfo
}
const cXcmV3InstructionQueryPallet: Codec<IcXcmV3InstructionQueryPallet> =
  Struct({ module_name: _bytesSeq, response_info: cXcmV3QueryResponseInfo })

type IcXcmV3InstructionExpectPallet = {
  index: number
  name: I_bytesSeq
  module_name: I_bytesSeq
  crate_major: number
  min_crate_minor: number
}
const cXcmV3InstructionExpectPallet: Codec<IcXcmV3InstructionExpectPallet> =
  Struct({
    index: compactNumber,
    name: _bytesSeq,
    module_name: _bytesSeq,
    crate_major: compactNumber,
    min_crate_minor: compactNumber,
  })

type IcXcmV3InstructionReportTransactStatus = IcXcmV3QueryResponseInfo
const cXcmV3InstructionReportTransactStatus: Codec<IcXcmV3InstructionReportTransactStatus> =
  cXcmV3QueryResponseInfo

type IcXcmV3InstructionUniversalOrigin = IcXcmV3JunctionJunction
const cXcmV3InstructionUniversalOrigin: Codec<IcXcmV3InstructionUniversalOrigin> =
  cXcmV3JunctionJunction

type IcXcmV3InstructionExportMessage = {
  network: IcXcmV3JunctionNetworkId
  destination: IcXcmV3JunctionsJunctions
  xcm: Icdc264Circular
}
const cXcmV3InstructionExportMessage: Codec<IcXcmV3InstructionExportMessage> =
  Struct({
    network: cXcmV3JunctionNetworkId,
    destination: cXcmV3JunctionsJunctions,
    xcm: cdc264Circular,
  })

type IcXcmV3InstructionLockAsset = {
  asset: IcXcmV3MultiassetMultiAsset
  unlocker: IcXcmV3MultilocationMultiLocation
}
const cXcmV3InstructionLockAsset: Codec<IcXcmV3InstructionLockAsset> = Struct({
  asset: cXcmV3MultiassetMultiAsset,
  unlocker: cXcmV3MultilocationMultiLocation,
})

type IcXcmV3InstructionUnlockAsset = {
  asset: IcXcmV3MultiassetMultiAsset
  target: IcXcmV3MultilocationMultiLocation
}
const cXcmV3InstructionUnlockAsset: Codec<IcXcmV3InstructionUnlockAsset> =
  Struct({
    asset: cXcmV3MultiassetMultiAsset,
    target: cXcmV3MultilocationMultiLocation,
  })

type IcXcmV3InstructionNoteUnlockable = {
  asset: IcXcmV3MultiassetMultiAsset
  owner: IcXcmV3MultilocationMultiLocation
}
const cXcmV3InstructionNoteUnlockable: Codec<IcXcmV3InstructionNoteUnlockable> =
  Struct({
    asset: cXcmV3MultiassetMultiAsset,
    owner: cXcmV3MultilocationMultiLocation,
  })

type IcXcmV3InstructionRequestUnlock = {
  asset: IcXcmV3MultiassetMultiAsset
  locker: IcXcmV3MultilocationMultiLocation
}
const cXcmV3InstructionRequestUnlock: Codec<IcXcmV3InstructionRequestUnlock> =
  Struct({
    asset: cXcmV3MultiassetMultiAsset,
    locker: cXcmV3MultilocationMultiLocation,
  })

type IcXcmV3InstructionSetFeesMode = { jit_withdraw: boolean }
const cXcmV3InstructionSetFeesMode: Codec<IcXcmV3InstructionSetFeesMode> =
  Struct({ jit_withdraw: bool })

type IcXcmV3InstructionSetTopic = Icdc13
const cXcmV3InstructionSetTopic: Codec<IcXcmV3InstructionSetTopic> = cdc13

type IcXcmV3InstructionAliasOrigin = IcXcmV3MultilocationMultiLocation
const cXcmV3InstructionAliasOrigin: Codec<IcXcmV3InstructionAliasOrigin> =
  cXcmV3MultilocationMultiLocation

type IcXcmV3InstructionUnpaidExecution = {
  weight_limit: IcXcmV3WeightLimit
  check_origin: IcOption
}
const cXcmV3InstructionUnpaidExecution: Codec<IcXcmV3InstructionUnpaidExecution> =
  Struct({ weight_limit: cXcmV3WeightLimit, check_origin: cOption })

type IcXcmV3Instruction =
  | { tag: "WithdrawAsset"; value: IcXcmV3InstructionWithdrawAsset }
  | {
      tag: "ReserveAssetDeposited"
      value: IcXcmV3InstructionReserveAssetDeposited
    }
  | {
      tag: "ReceiveTeleportedAsset"
      value: IcXcmV3InstructionReceiveTeleportedAsset
    }
  | { tag: "QueryResponse"; value: IcXcmV3InstructionQueryResponse }
  | { tag: "TransferAsset"; value: IcXcmV3InstructionTransferAsset }
  | {
      tag: "TransferReserveAsset"
      value: IcXcmV3InstructionTransferReserveAsset
    }
  | { tag: "Transact"; value: IcXcmV3InstructionTransact }
  | {
      tag: "HrmpNewChannelOpenRequest"
      value: IcXcmV3InstructionHrmpNewChannelOpenRequest
    }
  | { tag: "HrmpChannelAccepted"; value: IcXcmV3InstructionHrmpChannelAccepted }
  | { tag: "HrmpChannelClosing"; value: IcXcmV3InstructionHrmpChannelClosing }
  | { tag: "ClearOrigin"; value: undefined }
  | { tag: "DescendOrigin"; value: IcXcmV3InstructionDescendOrigin }
  | { tag: "ReportError"; value: IcXcmV3InstructionReportError }
  | { tag: "DepositAsset"; value: IcXcmV3InstructionDepositAsset }
  | { tag: "DepositReserveAsset"; value: IcXcmV3InstructionDepositReserveAsset }
  | { tag: "ExchangeAsset"; value: IcXcmV3InstructionExchangeAsset }
  | {
      tag: "InitiateReserveWithdraw"
      value: IcXcmV3InstructionInitiateReserveWithdraw
    }
  | { tag: "InitiateTeleport"; value: IcXcmV3InstructionInitiateTeleport }
  | { tag: "ReportHolding"; value: IcXcmV3InstructionReportHolding }
  | { tag: "BuyExecution"; value: IcXcmV3InstructionBuyExecution }
  | { tag: "RefundSurplus"; value: undefined }
  | { tag: "SetErrorHandler"; value: IcXcmV3InstructionSetErrorHandler }
  | { tag: "SetAppendix"; value: IcXcmV3InstructionSetAppendix }
  | { tag: "ClearError"; value: undefined }
  | { tag: "ClaimAsset"; value: IcXcmV3InstructionClaimAsset }
  | { tag: "Trap"; value: IcXcmV3InstructionTrap }
  | { tag: "SubscribeVersion"; value: IcXcmV3InstructionSubscribeVersion }
  | { tag: "UnsubscribeVersion"; value: undefined }
  | { tag: "BurnAsset"; value: IcXcmV3InstructionBurnAsset }
  | { tag: "ExpectAsset"; value: IcXcmV3InstructionExpectAsset }
  | { tag: "ExpectOrigin"; value: IcXcmV3InstructionExpectOrigin }
  | { tag: "ExpectError"; value: IcXcmV3InstructionExpectError }
  | {
      tag: "ExpectTransactStatus"
      value: IcXcmV3InstructionExpectTransactStatus
    }
  | { tag: "QueryPallet"; value: IcXcmV3InstructionQueryPallet }
  | { tag: "ExpectPallet"; value: IcXcmV3InstructionExpectPallet }
  | {
      tag: "ReportTransactStatus"
      value: IcXcmV3InstructionReportTransactStatus
    }
  | { tag: "ClearTransactStatus"; value: undefined }
  | { tag: "UniversalOrigin"; value: IcXcmV3InstructionUniversalOrigin }
  | { tag: "ExportMessage"; value: IcXcmV3InstructionExportMessage }
  | { tag: "LockAsset"; value: IcXcmV3InstructionLockAsset }
  | { tag: "UnlockAsset"; value: IcXcmV3InstructionUnlockAsset }
  | { tag: "NoteUnlockable"; value: IcXcmV3InstructionNoteUnlockable }
  | { tag: "RequestUnlock"; value: IcXcmV3InstructionRequestUnlock }
  | { tag: "SetFeesMode"; value: IcXcmV3InstructionSetFeesMode }
  | { tag: "SetTopic"; value: IcXcmV3InstructionSetTopic }
  | { tag: "ClearTopic"; value: undefined }
  | { tag: "AliasOrigin"; value: IcXcmV3InstructionAliasOrigin }
  | { tag: "UnpaidExecution"; value: IcXcmV3InstructionUnpaidExecution }
const cXcmV3Instruction: Codec<IcXcmV3Instruction> = Enum({
  WithdrawAsset: cXcmV3InstructionWithdrawAsset,
  ReserveAssetDeposited: cXcmV3InstructionReserveAssetDeposited,
  ReceiveTeleportedAsset: cXcmV3InstructionReceiveTeleportedAsset,
  QueryResponse: cXcmV3InstructionQueryResponse,
  TransferAsset: cXcmV3InstructionTransferAsset,
  TransferReserveAsset: cXcmV3InstructionTransferReserveAsset,
  Transact: cXcmV3InstructionTransact,
  HrmpNewChannelOpenRequest: cXcmV3InstructionHrmpNewChannelOpenRequest,
  HrmpChannelAccepted: cXcmV3InstructionHrmpChannelAccepted,
  HrmpChannelClosing: cXcmV3InstructionHrmpChannelClosing,
  ClearOrigin: _void,
  DescendOrigin: cXcmV3InstructionDescendOrigin,
  ReportError: cXcmV3InstructionReportError,
  DepositAsset: cXcmV3InstructionDepositAsset,
  DepositReserveAsset: cXcmV3InstructionDepositReserveAsset,
  ExchangeAsset: cXcmV3InstructionExchangeAsset,
  InitiateReserveWithdraw: cXcmV3InstructionInitiateReserveWithdraw,
  InitiateTeleport: cXcmV3InstructionInitiateTeleport,
  ReportHolding: cXcmV3InstructionReportHolding,
  BuyExecution: cXcmV3InstructionBuyExecution,
  RefundSurplus: _void,
  SetErrorHandler: cXcmV3InstructionSetErrorHandler,
  SetAppendix: cXcmV3InstructionSetAppendix,
  ClearError: _void,
  ClaimAsset: cXcmV3InstructionClaimAsset,
  Trap: cXcmV3InstructionTrap,
  SubscribeVersion: cXcmV3InstructionSubscribeVersion,
  UnsubscribeVersion: _void,
  BurnAsset: cXcmV3InstructionBurnAsset,
  ExpectAsset: cXcmV3InstructionExpectAsset,
  ExpectOrigin: cXcmV3InstructionExpectOrigin,
  ExpectError: cXcmV3InstructionExpectError,
  ExpectTransactStatus: cXcmV3InstructionExpectTransactStatus,
  QueryPallet: cXcmV3InstructionQueryPallet,
  ExpectPallet: cXcmV3InstructionExpectPallet,
  ReportTransactStatus: cXcmV3InstructionReportTransactStatus,
  ClearTransactStatus: _void,
  UniversalOrigin: cXcmV3InstructionUniversalOrigin,
  ExportMessage: cXcmV3InstructionExportMessage,
  LockAsset: cXcmV3InstructionLockAsset,
  UnlockAsset: cXcmV3InstructionUnlockAsset,
  NoteUnlockable: cXcmV3InstructionNoteUnlockable,
  RequestUnlock: cXcmV3InstructionRequestUnlock,
  SetFeesMode: cXcmV3InstructionSetFeesMode,
  SetTopic: cXcmV3InstructionSetTopic,
  ClearTopic: _void,
  AliasOrigin: cXcmV3InstructionAliasOrigin,
  UnpaidExecution: cXcmV3InstructionUnpaidExecution,
})

type Icdc264 = Array<IcXcmV3Instruction>
const cdc264: Codec<Icdc264> = Vector(cXcmV3Instruction)

type IcPallet_xcmPalletEventSent = [
  IcXcmV3MultilocationMultiLocation,
  IcXcmV3MultilocationMultiLocation,
  Icdc264,
]
const cPallet_xcmPalletEventSent: Codec<IcPallet_xcmPalletEventSent> = Tuple(
  cXcmV3MultilocationMultiLocation,
  cXcmV3MultilocationMultiLocation,
  cdc264,
)

type IcPallet_xcmPalletEventUnexpectedResponse = [
  IcXcmV3MultilocationMultiLocation,
  bigint,
]
const cPallet_xcmPalletEventUnexpectedResponse: Codec<IcPallet_xcmPalletEventUnexpectedResponse> =
  Tuple(cXcmV3MultilocationMultiLocation, u64)

type IcPallet_xcmPalletEventResponseReady = [bigint, IcXcmV3Response]
const cPallet_xcmPalletEventResponseReady: Codec<IcPallet_xcmPalletEventResponseReady> =
  Tuple(u64, cXcmV3Response)

type IcPallet_xcmPalletEventNotified = [bigint, number, number]
const cPallet_xcmPalletEventNotified: Codec<IcPallet_xcmPalletEventNotified> =
  Tuple(u64, u8, u8)

type IcPallet_xcmPalletEventNotifyOverweight = [
  bigint,
  number,
  number,
  IcSp_weightsWeight_v2Weight,
  IcSp_weightsWeight_v2Weight,
]
const cPallet_xcmPalletEventNotifyOverweight: Codec<IcPallet_xcmPalletEventNotifyOverweight> =
  Tuple(u64, u8, u8, cSp_weightsWeight_v2Weight, cSp_weightsWeight_v2Weight)

type IcPallet_xcmPalletEventNotifyDispatchError = [bigint, number, number]
const cPallet_xcmPalletEventNotifyDispatchError: Codec<IcPallet_xcmPalletEventNotifyDispatchError> =
  Tuple(u64, u8, u8)

type IcPallet_xcmPalletEventNotifyDecodeFailed = [bigint, number, number]
const cPallet_xcmPalletEventNotifyDecodeFailed: Codec<IcPallet_xcmPalletEventNotifyDecodeFailed> =
  Tuple(u64, u8, u8)

type IcPallet_xcmPalletEventInvalidResponder = [
  IcXcmV3MultilocationMultiLocation,
  bigint,
  IcOption,
]
const cPallet_xcmPalletEventInvalidResponder: Codec<IcPallet_xcmPalletEventInvalidResponder> =
  Tuple(cXcmV3MultilocationMultiLocation, u64, cOption)

type IcPallet_xcmPalletEventInvalidResponderVersion = [
  IcXcmV3MultilocationMultiLocation,
  bigint,
]
const cPallet_xcmPalletEventInvalidResponderVersion: Codec<IcPallet_xcmPalletEventInvalidResponderVersion> =
  Tuple(cXcmV3MultilocationMultiLocation, u64)

type IcPallet_xcmPalletEventResponseTaken = bigint
const cPallet_xcmPalletEventResponseTaken: Codec<IcPallet_xcmPalletEventResponseTaken> =
  u64

type IcXcmV2JunctionJunctionParachain = number
const cXcmV2JunctionJunctionParachain: Codec<IcXcmV2JunctionJunctionParachain> =
  compactNumber

type IcXcmV2NetworkIdNamed = I_bytesSeq
const cXcmV2NetworkIdNamed: Codec<IcXcmV2NetworkIdNamed> = _bytesSeq

type IcXcmV2NetworkId =
  | { tag: "Any"; value: undefined }
  | { tag: "Named"; value: IcXcmV2NetworkIdNamed }
  | { tag: "Polkadot"; value: undefined }
  | { tag: "Kusama"; value: undefined }
const cXcmV2NetworkId: Codec<IcXcmV2NetworkId> = Enum({
  Any: _void,
  Named: cXcmV2NetworkIdNamed,
  Polkadot: _void,
  Kusama: _void,
})

type IcXcmV2JunctionJunctionAccountId32 = {
  network: IcXcmV2NetworkId
  id: Icdc13
}
const cXcmV2JunctionJunctionAccountId32: Codec<IcXcmV2JunctionJunctionAccountId32> =
  Struct({ network: cXcmV2NetworkId, id: cdc13 })

type IcXcmV2JunctionJunctionAccountIndex64 = {
  network: IcXcmV2NetworkId
  index: bigint
}
const cXcmV2JunctionJunctionAccountIndex64: Codec<IcXcmV2JunctionJunctionAccountIndex64> =
  Struct({ network: cXcmV2NetworkId, index: compactBn })

type IcXcmV2JunctionJunctionAccountKey20 = {
  network: IcXcmV2NetworkId
  key: Icdc1
}
const cXcmV2JunctionJunctionAccountKey20: Codec<IcXcmV2JunctionJunctionAccountKey20> =
  Struct({ network: cXcmV2NetworkId, key: cdc1 })

type IcXcmV2JunctionJunctionPalletInstance = number
const cXcmV2JunctionJunctionPalletInstance: Codec<IcXcmV2JunctionJunctionPalletInstance> =
  u8

type IcXcmV2JunctionJunctionGeneralIndex = bigint
const cXcmV2JunctionJunctionGeneralIndex: Codec<IcXcmV2JunctionJunctionGeneralIndex> =
  compactBn

type IcXcmV2JunctionJunctionGeneralKey = I_bytesSeq
const cXcmV2JunctionJunctionGeneralKey: Codec<IcXcmV2JunctionJunctionGeneralKey> =
  _bytesSeq

type IcXcmV2BodyIdNamed = I_bytesSeq
const cXcmV2BodyIdNamed: Codec<IcXcmV2BodyIdNamed> = _bytesSeq

type IcXcmV2BodyIdIndex = number
const cXcmV2BodyIdIndex: Codec<IcXcmV2BodyIdIndex> = compactNumber

type IcXcmV2BodyId =
  | { tag: "Unit"; value: undefined }
  | { tag: "Named"; value: IcXcmV2BodyIdNamed }
  | { tag: "Index"; value: IcXcmV2BodyIdIndex }
  | { tag: "Executive"; value: undefined }
  | { tag: "Technical"; value: undefined }
  | { tag: "Legislative"; value: undefined }
  | { tag: "Judicial"; value: undefined }
  | { tag: "Defense"; value: undefined }
  | { tag: "Administration"; value: undefined }
  | { tag: "Treasury"; value: undefined }
const cXcmV2BodyId: Codec<IcXcmV2BodyId> = Enum({
  Unit: _void,
  Named: cXcmV2BodyIdNamed,
  Index: cXcmV2BodyIdIndex,
  Executive: _void,
  Technical: _void,
  Legislative: _void,
  Judicial: _void,
  Defense: _void,
  Administration: _void,
  Treasury: _void,
})

type IcXcmV2BodyPartMembers = { count: number }
const cXcmV2BodyPartMembers: Codec<IcXcmV2BodyPartMembers> = Struct({
  count: compactNumber,
})

type IcXcmV2BodyPartFraction = { nom: number; denom: number }
const cXcmV2BodyPartFraction: Codec<IcXcmV2BodyPartFraction> = Struct({
  nom: compactNumber,
  denom: compactNumber,
})

type IcXcmV2BodyPartAtLeastProportion = { nom: number; denom: number }
const cXcmV2BodyPartAtLeastProportion: Codec<IcXcmV2BodyPartAtLeastProportion> =
  Struct({ nom: compactNumber, denom: compactNumber })

type IcXcmV2BodyPartMoreThanProportion = { nom: number; denom: number }
const cXcmV2BodyPartMoreThanProportion: Codec<IcXcmV2BodyPartMoreThanProportion> =
  Struct({ nom: compactNumber, denom: compactNumber })

type IcXcmV2BodyPart =
  | { tag: "Voice"; value: undefined }
  | { tag: "Members"; value: IcXcmV2BodyPartMembers }
  | { tag: "Fraction"; value: IcXcmV2BodyPartFraction }
  | { tag: "AtLeastProportion"; value: IcXcmV2BodyPartAtLeastProportion }
  | { tag: "MoreThanProportion"; value: IcXcmV2BodyPartMoreThanProportion }
const cXcmV2BodyPart: Codec<IcXcmV2BodyPart> = Enum({
  Voice: _void,
  Members: cXcmV2BodyPartMembers,
  Fraction: cXcmV2BodyPartFraction,
  AtLeastProportion: cXcmV2BodyPartAtLeastProportion,
  MoreThanProportion: cXcmV2BodyPartMoreThanProportion,
})

type IcXcmV2JunctionJunctionPlurality = {
  id: IcXcmV2BodyId
  part: IcXcmV2BodyPart
}
const cXcmV2JunctionJunctionPlurality: Codec<IcXcmV2JunctionJunctionPlurality> =
  Struct({ id: cXcmV2BodyId, part: cXcmV2BodyPart })

type IcXcmV2JunctionJunction =
  | { tag: "Parachain"; value: IcXcmV2JunctionJunctionParachain }
  | { tag: "AccountId32"; value: IcXcmV2JunctionJunctionAccountId32 }
  | { tag: "AccountIndex64"; value: IcXcmV2JunctionJunctionAccountIndex64 }
  | { tag: "AccountKey20"; value: IcXcmV2JunctionJunctionAccountKey20 }
  | { tag: "PalletInstance"; value: IcXcmV2JunctionJunctionPalletInstance }
  | { tag: "GeneralIndex"; value: IcXcmV2JunctionJunctionGeneralIndex }
  | { tag: "GeneralKey"; value: IcXcmV2JunctionJunctionGeneralKey }
  | { tag: "OnlyChild"; value: undefined }
  | { tag: "Plurality"; value: IcXcmV2JunctionJunctionPlurality }
const cXcmV2JunctionJunction: Codec<IcXcmV2JunctionJunction> = Enum({
  Parachain: cXcmV2JunctionJunctionParachain,
  AccountId32: cXcmV2JunctionJunctionAccountId32,
  AccountIndex64: cXcmV2JunctionJunctionAccountIndex64,
  AccountKey20: cXcmV2JunctionJunctionAccountKey20,
  PalletInstance: cXcmV2JunctionJunctionPalletInstance,
  GeneralIndex: cXcmV2JunctionJunctionGeneralIndex,
  GeneralKey: cXcmV2JunctionJunctionGeneralKey,
  OnlyChild: _void,
  Plurality: cXcmV2JunctionJunctionPlurality,
})

type IcXcmV2MultilocationJunctionsX1 = IcXcmV2JunctionJunction
const cXcmV2MultilocationJunctionsX1: Codec<IcXcmV2MultilocationJunctionsX1> =
  cXcmV2JunctionJunction

type IcXcmV2MultilocationJunctionsX2 = [
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
]
const cXcmV2MultilocationJunctionsX2: Codec<IcXcmV2MultilocationJunctionsX2> =
  Tuple(cXcmV2JunctionJunction, cXcmV2JunctionJunction)

type IcXcmV2MultilocationJunctionsX3 = [
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
]
const cXcmV2MultilocationJunctionsX3: Codec<IcXcmV2MultilocationJunctionsX3> =
  Tuple(cXcmV2JunctionJunction, cXcmV2JunctionJunction, cXcmV2JunctionJunction)

type IcXcmV2MultilocationJunctionsX4 = [
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
]
const cXcmV2MultilocationJunctionsX4: Codec<IcXcmV2MultilocationJunctionsX4> =
  Tuple(
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
  )

type IcXcmV2MultilocationJunctionsX5 = [
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
]
const cXcmV2MultilocationJunctionsX5: Codec<IcXcmV2MultilocationJunctionsX5> =
  Tuple(
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
  )

type IcXcmV2MultilocationJunctionsX6 = [
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
]
const cXcmV2MultilocationJunctionsX6: Codec<IcXcmV2MultilocationJunctionsX6> =
  Tuple(
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
  )

type IcXcmV2MultilocationJunctionsX7 = [
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
]
const cXcmV2MultilocationJunctionsX7: Codec<IcXcmV2MultilocationJunctionsX7> =
  Tuple(
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
  )

type IcXcmV2MultilocationJunctionsX8 = [
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
  IcXcmV2JunctionJunction,
]
const cXcmV2MultilocationJunctionsX8: Codec<IcXcmV2MultilocationJunctionsX8> =
  Tuple(
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
    cXcmV2JunctionJunction,
  )

type IcXcmV2MultilocationJunctions =
  | { tag: "Here"; value: undefined }
  | { tag: "X1"; value: IcXcmV2MultilocationJunctionsX1 }
  | { tag: "X2"; value: IcXcmV2MultilocationJunctionsX2 }
  | { tag: "X3"; value: IcXcmV2MultilocationJunctionsX3 }
  | { tag: "X4"; value: IcXcmV2MultilocationJunctionsX4 }
  | { tag: "X5"; value: IcXcmV2MultilocationJunctionsX5 }
  | { tag: "X6"; value: IcXcmV2MultilocationJunctionsX6 }
  | { tag: "X7"; value: IcXcmV2MultilocationJunctionsX7 }
  | { tag: "X8"; value: IcXcmV2MultilocationJunctionsX8 }
const cXcmV2MultilocationJunctions: Codec<IcXcmV2MultilocationJunctions> = Enum(
  {
    Here: _void,
    X1: cXcmV2MultilocationJunctionsX1,
    X2: cXcmV2MultilocationJunctionsX2,
    X3: cXcmV2MultilocationJunctionsX3,
    X4: cXcmV2MultilocationJunctionsX4,
    X5: cXcmV2MultilocationJunctionsX5,
    X6: cXcmV2MultilocationJunctionsX6,
    X7: cXcmV2MultilocationJunctionsX7,
    X8: cXcmV2MultilocationJunctionsX8,
  },
)

type IcXcmV2MultilocationMultiLocation = {
  parents: number
  interior: IcXcmV2MultilocationJunctions
}
const cXcmV2MultilocationMultiLocation: Codec<IcXcmV2MultilocationMultiLocation> =
  Struct({ parents: u8, interior: cXcmV2MultilocationJunctions })

type IcXcmV2MultiassetAssetIdConcrete = IcXcmV2MultilocationMultiLocation
const cXcmV2MultiassetAssetIdConcrete: Codec<IcXcmV2MultiassetAssetIdConcrete> =
  cXcmV2MultilocationMultiLocation

type IcXcmV2MultiassetAssetIdAbstract = I_bytesSeq
const cXcmV2MultiassetAssetIdAbstract: Codec<IcXcmV2MultiassetAssetIdAbstract> =
  _bytesSeq

type IcXcmV2MultiassetAssetId =
  | { tag: "Concrete"; value: IcXcmV2MultiassetAssetIdConcrete }
  | { tag: "Abstract"; value: IcXcmV2MultiassetAssetIdAbstract }
const cXcmV2MultiassetAssetId: Codec<IcXcmV2MultiassetAssetId> = Enum({
  Concrete: cXcmV2MultiassetAssetIdConcrete,
  Abstract: cXcmV2MultiassetAssetIdAbstract,
})

type IcXcmV2MultiassetFungibilityFungible = bigint
const cXcmV2MultiassetFungibilityFungible: Codec<IcXcmV2MultiassetFungibilityFungible> =
  compactBn

type IcXcmV2MultiassetAssetInstanceIndex = bigint
const cXcmV2MultiassetAssetInstanceIndex: Codec<IcXcmV2MultiassetAssetInstanceIndex> =
  compactBn

type IcXcmV2MultiassetAssetInstanceArray4 = Icdc18
const cXcmV2MultiassetAssetInstanceArray4: Codec<IcXcmV2MultiassetAssetInstanceArray4> =
  cdc18

type IcXcmV2MultiassetAssetInstanceArray8 = Icdc154
const cXcmV2MultiassetAssetInstanceArray8: Codec<IcXcmV2MultiassetAssetInstanceArray8> =
  cdc154

type IcXcmV2MultiassetAssetInstanceArray16 = Icdc162
const cXcmV2MultiassetAssetInstanceArray16: Codec<IcXcmV2MultiassetAssetInstanceArray16> =
  cdc162

type IcXcmV2MultiassetAssetInstanceArray32 = Icdc13
const cXcmV2MultiassetAssetInstanceArray32: Codec<IcXcmV2MultiassetAssetInstanceArray32> =
  cdc13

type IcXcmV2MultiassetAssetInstanceBlob = I_bytesSeq
const cXcmV2MultiassetAssetInstanceBlob: Codec<IcXcmV2MultiassetAssetInstanceBlob> =
  _bytesSeq

type IcXcmV2MultiassetAssetInstance =
  | { tag: "Undefined"; value: undefined }
  | { tag: "Index"; value: IcXcmV2MultiassetAssetInstanceIndex }
  | { tag: "Array4"; value: IcXcmV2MultiassetAssetInstanceArray4 }
  | { tag: "Array8"; value: IcXcmV2MultiassetAssetInstanceArray8 }
  | { tag: "Array16"; value: IcXcmV2MultiassetAssetInstanceArray16 }
  | { tag: "Array32"; value: IcXcmV2MultiassetAssetInstanceArray32 }
  | { tag: "Blob"; value: IcXcmV2MultiassetAssetInstanceBlob }
const cXcmV2MultiassetAssetInstance: Codec<IcXcmV2MultiassetAssetInstance> =
  Enum({
    Undefined: _void,
    Index: cXcmV2MultiassetAssetInstanceIndex,
    Array4: cXcmV2MultiassetAssetInstanceArray4,
    Array8: cXcmV2MultiassetAssetInstanceArray8,
    Array16: cXcmV2MultiassetAssetInstanceArray16,
    Array32: cXcmV2MultiassetAssetInstanceArray32,
    Blob: cXcmV2MultiassetAssetInstanceBlob,
  })

type IcXcmV2MultiassetFungibilityNonFungible = IcXcmV2MultiassetAssetInstance
const cXcmV2MultiassetFungibilityNonFungible: Codec<IcXcmV2MultiassetFungibilityNonFungible> =
  cXcmV2MultiassetAssetInstance

type IcXcmV2MultiassetFungibility =
  | { tag: "Fungible"; value: IcXcmV2MultiassetFungibilityFungible }
  | { tag: "NonFungible"; value: IcXcmV2MultiassetFungibilityNonFungible }
const cXcmV2MultiassetFungibility: Codec<IcXcmV2MultiassetFungibility> = Enum({
  Fungible: cXcmV2MultiassetFungibilityFungible,
  NonFungible: cXcmV2MultiassetFungibilityNonFungible,
})

type IcXcmV2MultiassetMultiAsset = {
  id: IcXcmV2MultiassetAssetId
  fun: IcXcmV2MultiassetFungibility
}
const cXcmV2MultiassetMultiAsset: Codec<IcXcmV2MultiassetMultiAsset> = Struct({
  id: cXcmV2MultiassetAssetId,
  fun: cXcmV2MultiassetFungibility,
})

type Icdc248 = Array<IcXcmV2MultiassetMultiAsset>
const cdc248: Codec<Icdc248> = Vector(cXcmV2MultiassetMultiAsset)

type IcXcmVersionedMultiAssetsV2 = Icdc248
const cXcmVersionedMultiAssetsV2: Codec<IcXcmVersionedMultiAssetsV2> = cdc248

type IcXcmVersionedMultiAssetsV3 = Icdc267
const cXcmVersionedMultiAssetsV3: Codec<IcXcmVersionedMultiAssetsV3> = cdc267

type IcXcmVersionedMultiAssets =
  | { tag: "V2"; value: IcXcmVersionedMultiAssetsV2 }
  | { tag: "V3"; value: IcXcmVersionedMultiAssetsV3 }
const cXcmVersionedMultiAssets: Codec<IcXcmVersionedMultiAssets> = Enum(
  { V2: cXcmVersionedMultiAssetsV2, V3: cXcmVersionedMultiAssetsV3 },
  [1, 3],
)

type IcPallet_xcmPalletEventAssetsTrapped = [
  Icdc13,
  IcXcmV3MultilocationMultiLocation,
  IcXcmVersionedMultiAssets,
]
const cPallet_xcmPalletEventAssetsTrapped: Codec<IcPallet_xcmPalletEventAssetsTrapped> =
  Tuple(cdc13, cXcmV3MultilocationMultiLocation, cXcmVersionedMultiAssets)

type IcPallet_xcmPalletEventVersionChangeNotified = [
  IcXcmV3MultilocationMultiLocation,
  number,
  Icdc267,
]
const cPallet_xcmPalletEventVersionChangeNotified: Codec<IcPallet_xcmPalletEventVersionChangeNotified> =
  Tuple(cXcmV3MultilocationMultiLocation, u32, cdc267)

type IcPallet_xcmPalletEventSupportedVersionChanged = [
  IcXcmV3MultilocationMultiLocation,
  number,
]
const cPallet_xcmPalletEventSupportedVersionChanged: Codec<IcPallet_xcmPalletEventSupportedVersionChanged> =
  Tuple(cXcmV3MultilocationMultiLocation, u32)

type IcPallet_xcmPalletEventNotifyTargetSendFail = [
  IcXcmV3MultilocationMultiLocation,
  bigint,
  IcXcmV3TraitsError,
]
const cPallet_xcmPalletEventNotifyTargetSendFail: Codec<IcPallet_xcmPalletEventNotifyTargetSendFail> =
  Tuple(cXcmV3MultilocationMultiLocation, u64, cXcmV3TraitsError)

type IcXcmVersionedMultiLocationV2 = IcXcmV2MultilocationMultiLocation
const cXcmVersionedMultiLocationV2: Codec<IcXcmVersionedMultiLocationV2> =
  cXcmV2MultilocationMultiLocation

type IcXcmVersionedMultiLocationV3 = IcXcmV3MultilocationMultiLocation
const cXcmVersionedMultiLocationV3: Codec<IcXcmVersionedMultiLocationV3> =
  cXcmV3MultilocationMultiLocation

type IcXcmVersionedMultiLocation =
  | { tag: "V2"; value: IcXcmVersionedMultiLocationV2 }
  | { tag: "V3"; value: IcXcmVersionedMultiLocationV3 }
const cXcmVersionedMultiLocation: Codec<IcXcmVersionedMultiLocation> = Enum(
  { V2: cXcmVersionedMultiLocationV2, V3: cXcmVersionedMultiLocationV3 },
  [1, 3],
)

type IcPallet_xcmPalletEventNotifyTargetMigrationFail = [
  IcXcmVersionedMultiLocation,
  bigint,
]
const cPallet_xcmPalletEventNotifyTargetMigrationFail: Codec<IcPallet_xcmPalletEventNotifyTargetMigrationFail> =
  Tuple(cXcmVersionedMultiLocation, u64)

type IcPallet_xcmPalletEventInvalidQuerierVersion = [
  IcXcmV3MultilocationMultiLocation,
  bigint,
]
const cPallet_xcmPalletEventInvalidQuerierVersion: Codec<IcPallet_xcmPalletEventInvalidQuerierVersion> =
  Tuple(cXcmV3MultilocationMultiLocation, u64)

type IcPallet_xcmPalletEventInvalidQuerier = [
  IcXcmV3MultilocationMultiLocation,
  bigint,
  IcXcmV3MultilocationMultiLocation,
  IcOption,
]
const cPallet_xcmPalletEventInvalidQuerier: Codec<IcPallet_xcmPalletEventInvalidQuerier> =
  Tuple(
    cXcmV3MultilocationMultiLocation,
    u64,
    cXcmV3MultilocationMultiLocation,
    cOption,
  )

type IcPallet_xcmPalletEventVersionNotifyStarted = [
  IcXcmV3MultilocationMultiLocation,
  Icdc267,
]
const cPallet_xcmPalletEventVersionNotifyStarted: Codec<IcPallet_xcmPalletEventVersionNotifyStarted> =
  Tuple(cXcmV3MultilocationMultiLocation, cdc267)

type IcPallet_xcmPalletEventVersionNotifyRequested = [
  IcXcmV3MultilocationMultiLocation,
  Icdc267,
]
const cPallet_xcmPalletEventVersionNotifyRequested: Codec<IcPallet_xcmPalletEventVersionNotifyRequested> =
  Tuple(cXcmV3MultilocationMultiLocation, cdc267)

type IcPallet_xcmPalletEventVersionNotifyUnrequested = [
  IcXcmV3MultilocationMultiLocation,
  Icdc267,
]
const cPallet_xcmPalletEventVersionNotifyUnrequested: Codec<IcPallet_xcmPalletEventVersionNotifyUnrequested> =
  Tuple(cXcmV3MultilocationMultiLocation, cdc267)

type IcPallet_xcmPalletEventFeesPaid = [
  IcXcmV3MultilocationMultiLocation,
  Icdc267,
]
const cPallet_xcmPalletEventFeesPaid: Codec<IcPallet_xcmPalletEventFeesPaid> =
  Tuple(cXcmV3MultilocationMultiLocation, cdc267)

type IcPallet_xcmPalletEventAssetsClaimed = [
  Icdc13,
  IcXcmV3MultilocationMultiLocation,
  IcXcmVersionedMultiAssets,
]
const cPallet_xcmPalletEventAssetsClaimed: Codec<IcPallet_xcmPalletEventAssetsClaimed> =
  Tuple(cdc13, cXcmV3MultilocationMultiLocation, cXcmVersionedMultiAssets)

type IcPallet_xcmPalletEvent =
  | { tag: "Attempted"; value: IcPallet_xcmPalletEventAttempted }
  | { tag: "Sent"; value: IcPallet_xcmPalletEventSent }
  | {
      tag: "UnexpectedResponse"
      value: IcPallet_xcmPalletEventUnexpectedResponse
    }
  | { tag: "ResponseReady"; value: IcPallet_xcmPalletEventResponseReady }
  | { tag: "Notified"; value: IcPallet_xcmPalletEventNotified }
  | { tag: "NotifyOverweight"; value: IcPallet_xcmPalletEventNotifyOverweight }
  | {
      tag: "NotifyDispatchError"
      value: IcPallet_xcmPalletEventNotifyDispatchError
    }
  | {
      tag: "NotifyDecodeFailed"
      value: IcPallet_xcmPalletEventNotifyDecodeFailed
    }
  | { tag: "InvalidResponder"; value: IcPallet_xcmPalletEventInvalidResponder }
  | {
      tag: "InvalidResponderVersion"
      value: IcPallet_xcmPalletEventInvalidResponderVersion
    }
  | { tag: "ResponseTaken"; value: IcPallet_xcmPalletEventResponseTaken }
  | { tag: "AssetsTrapped"; value: IcPallet_xcmPalletEventAssetsTrapped }
  | {
      tag: "VersionChangeNotified"
      value: IcPallet_xcmPalletEventVersionChangeNotified
    }
  | {
      tag: "SupportedVersionChanged"
      value: IcPallet_xcmPalletEventSupportedVersionChanged
    }
  | {
      tag: "NotifyTargetSendFail"
      value: IcPallet_xcmPalletEventNotifyTargetSendFail
    }
  | {
      tag: "NotifyTargetMigrationFail"
      value: IcPallet_xcmPalletEventNotifyTargetMigrationFail
    }
  | {
      tag: "InvalidQuerierVersion"
      value: IcPallet_xcmPalletEventInvalidQuerierVersion
    }
  | { tag: "InvalidQuerier"; value: IcPallet_xcmPalletEventInvalidQuerier }
  | {
      tag: "VersionNotifyStarted"
      value: IcPallet_xcmPalletEventVersionNotifyStarted
    }
  | {
      tag: "VersionNotifyRequested"
      value: IcPallet_xcmPalletEventVersionNotifyRequested
    }
  | {
      tag: "VersionNotifyUnrequested"
      value: IcPallet_xcmPalletEventVersionNotifyUnrequested
    }
  | { tag: "FeesPaid"; value: IcPallet_xcmPalletEventFeesPaid }
  | { tag: "AssetsClaimed"; value: IcPallet_xcmPalletEventAssetsClaimed }
const cPallet_xcmPalletEvent: Codec<IcPallet_xcmPalletEvent> = Enum({
  Attempted: cPallet_xcmPalletEventAttempted,
  Sent: cPallet_xcmPalletEventSent,
  UnexpectedResponse: cPallet_xcmPalletEventUnexpectedResponse,
  ResponseReady: cPallet_xcmPalletEventResponseReady,
  Notified: cPallet_xcmPalletEventNotified,
  NotifyOverweight: cPallet_xcmPalletEventNotifyOverweight,
  NotifyDispatchError: cPallet_xcmPalletEventNotifyDispatchError,
  NotifyDecodeFailed: cPallet_xcmPalletEventNotifyDecodeFailed,
  InvalidResponder: cPallet_xcmPalletEventInvalidResponder,
  InvalidResponderVersion: cPallet_xcmPalletEventInvalidResponderVersion,
  ResponseTaken: cPallet_xcmPalletEventResponseTaken,
  AssetsTrapped: cPallet_xcmPalletEventAssetsTrapped,
  VersionChangeNotified: cPallet_xcmPalletEventVersionChangeNotified,
  SupportedVersionChanged: cPallet_xcmPalletEventSupportedVersionChanged,
  NotifyTargetSendFail: cPallet_xcmPalletEventNotifyTargetSendFail,
  NotifyTargetMigrationFail: cPallet_xcmPalletEventNotifyTargetMigrationFail,
  InvalidQuerierVersion: cPallet_xcmPalletEventInvalidQuerierVersion,
  InvalidQuerier: cPallet_xcmPalletEventInvalidQuerier,
  VersionNotifyStarted: cPallet_xcmPalletEventVersionNotifyStarted,
  VersionNotifyRequested: cPallet_xcmPalletEventVersionNotifyRequested,
  VersionNotifyUnrequested: cPallet_xcmPalletEventVersionNotifyUnrequested,
  FeesPaid: cPallet_xcmPalletEventFeesPaid,
  AssetsClaimed: cPallet_xcmPalletEventAssetsClaimed,
})

type IcMoonbeam_runtimeRuntimeEventPolkadotXcm = IcPallet_xcmPalletEvent
const cMoonbeam_runtimeRuntimeEventPolkadotXcm: Codec<IcMoonbeam_runtimeRuntimeEventPolkadotXcm> =
  cPallet_xcmPalletEvent

type IcPallet_assetsPalletEventCreated = {
  asset_id: bigint
  creator: Icdc1
  owner: Icdc1
}
const cPallet_assetsPalletEventCreated: Codec<IcPallet_assetsPalletEventCreated> =
  Struct({ asset_id: u128, creator: cdc1, owner: cdc1 })

type IcPallet_assetsPalletEventIssued = {
  asset_id: bigint
  owner: Icdc1
  amount: bigint
}
const cPallet_assetsPalletEventIssued: Codec<IcPallet_assetsPalletEventIssued> =
  Struct({ asset_id: u128, owner: cdc1, amount: u128 })

type IcPallet_assetsPalletEventTransferred = {
  asset_id: bigint
  from: Icdc1
  to: Icdc1
  amount: bigint
}
const cPallet_assetsPalletEventTransferred: Codec<IcPallet_assetsPalletEventTransferred> =
  Struct({ asset_id: u128, from: cdc1, to: cdc1, amount: u128 })

type IcPallet_assetsPalletEventBurned = {
  asset_id: bigint
  owner: Icdc1
  balance: bigint
}
const cPallet_assetsPalletEventBurned: Codec<IcPallet_assetsPalletEventBurned> =
  Struct({ asset_id: u128, owner: cdc1, balance: u128 })

type IcPallet_assetsPalletEventTeamChanged = {
  asset_id: bigint
  issuer: Icdc1
  admin: Icdc1
  freezer: Icdc1
}
const cPallet_assetsPalletEventTeamChanged: Codec<IcPallet_assetsPalletEventTeamChanged> =
  Struct({ asset_id: u128, issuer: cdc1, admin: cdc1, freezer: cdc1 })

type IcPallet_assetsPalletEventOwnerChanged = { asset_id: bigint; owner: Icdc1 }
const cPallet_assetsPalletEventOwnerChanged: Codec<IcPallet_assetsPalletEventOwnerChanged> =
  Struct({ asset_id: u128, owner: cdc1 })

type IcPallet_assetsPalletEventFrozen = { asset_id: bigint; who: Icdc1 }
const cPallet_assetsPalletEventFrozen: Codec<IcPallet_assetsPalletEventFrozen> =
  Struct({ asset_id: u128, who: cdc1 })

type IcPallet_assetsPalletEventThawed = { asset_id: bigint; who: Icdc1 }
const cPallet_assetsPalletEventThawed: Codec<IcPallet_assetsPalletEventThawed> =
  Struct({ asset_id: u128, who: cdc1 })

type IcPallet_assetsPalletEventAssetFrozen = { asset_id: bigint }
const cPallet_assetsPalletEventAssetFrozen: Codec<IcPallet_assetsPalletEventAssetFrozen> =
  Struct({ asset_id: u128 })

type IcPallet_assetsPalletEventAssetThawed = { asset_id: bigint }
const cPallet_assetsPalletEventAssetThawed: Codec<IcPallet_assetsPalletEventAssetThawed> =
  Struct({ asset_id: u128 })

type IcPallet_assetsPalletEventAccountsDestroyed = {
  asset_id: bigint
  accounts_destroyed: number
  accounts_remaining: number
}
const cPallet_assetsPalletEventAccountsDestroyed: Codec<IcPallet_assetsPalletEventAccountsDestroyed> =
  Struct({ asset_id: u128, accounts_destroyed: u32, accounts_remaining: u32 })

type IcPallet_assetsPalletEventApprovalsDestroyed = {
  asset_id: bigint
  approvals_destroyed: number
  approvals_remaining: number
}
const cPallet_assetsPalletEventApprovalsDestroyed: Codec<IcPallet_assetsPalletEventApprovalsDestroyed> =
  Struct({ asset_id: u128, approvals_destroyed: u32, approvals_remaining: u32 })

type IcPallet_assetsPalletEventDestructionStarted = { asset_id: bigint }
const cPallet_assetsPalletEventDestructionStarted: Codec<IcPallet_assetsPalletEventDestructionStarted> =
  Struct({ asset_id: u128 })

type IcPallet_assetsPalletEventDestroyed = { asset_id: bigint }
const cPallet_assetsPalletEventDestroyed: Codec<IcPallet_assetsPalletEventDestroyed> =
  Struct({ asset_id: u128 })

type IcPallet_assetsPalletEventForceCreated = { asset_id: bigint; owner: Icdc1 }
const cPallet_assetsPalletEventForceCreated: Codec<IcPallet_assetsPalletEventForceCreated> =
  Struct({ asset_id: u128, owner: cdc1 })

type IcPallet_assetsPalletEventMetadataSet = {
  asset_id: bigint
  name: I_bytesSeq
  symbol: I_bytesSeq
  decimals: number
  is_frozen: boolean
}
const cPallet_assetsPalletEventMetadataSet: Codec<IcPallet_assetsPalletEventMetadataSet> =
  Struct({
    asset_id: u128,
    name: _bytesSeq,
    symbol: _bytesSeq,
    decimals: u8,
    is_frozen: bool,
  })

type IcPallet_assetsPalletEventMetadataCleared = { asset_id: bigint }
const cPallet_assetsPalletEventMetadataCleared: Codec<IcPallet_assetsPalletEventMetadataCleared> =
  Struct({ asset_id: u128 })

type IcPallet_assetsPalletEventApprovedTransfer = {
  asset_id: bigint
  source: Icdc1
  delegate: Icdc1
  amount: bigint
}
const cPallet_assetsPalletEventApprovedTransfer: Codec<IcPallet_assetsPalletEventApprovedTransfer> =
  Struct({ asset_id: u128, source: cdc1, delegate: cdc1, amount: u128 })

type IcPallet_assetsPalletEventApprovalCancelled = {
  asset_id: bigint
  owner: Icdc1
  delegate: Icdc1
}
const cPallet_assetsPalletEventApprovalCancelled: Codec<IcPallet_assetsPalletEventApprovalCancelled> =
  Struct({ asset_id: u128, owner: cdc1, delegate: cdc1 })

type IcPallet_assetsPalletEventTransferredApproved = {
  asset_id: bigint
  owner: Icdc1
  delegate: Icdc1
  destination: Icdc1
  amount: bigint
}
const cPallet_assetsPalletEventTransferredApproved: Codec<IcPallet_assetsPalletEventTransferredApproved> =
  Struct({
    asset_id: u128,
    owner: cdc1,
    delegate: cdc1,
    destination: cdc1,
    amount: u128,
  })

type IcPallet_assetsPalletEventAssetStatusChanged = { asset_id: bigint }
const cPallet_assetsPalletEventAssetStatusChanged: Codec<IcPallet_assetsPalletEventAssetStatusChanged> =
  Struct({ asset_id: u128 })

type IcPallet_assetsPalletEventAssetMinBalanceChanged = {
  asset_id: bigint
  new_min_balance: bigint
}
const cPallet_assetsPalletEventAssetMinBalanceChanged: Codec<IcPallet_assetsPalletEventAssetMinBalanceChanged> =
  Struct({ asset_id: u128, new_min_balance: u128 })

type IcPallet_assetsPalletEventTouched = {
  asset_id: bigint
  who: Icdc1
  depositor: Icdc1
}
const cPallet_assetsPalletEventTouched: Codec<IcPallet_assetsPalletEventTouched> =
  Struct({ asset_id: u128, who: cdc1, depositor: cdc1 })

type IcPallet_assetsPalletEventBlocked = { asset_id: bigint; who: Icdc1 }
const cPallet_assetsPalletEventBlocked: Codec<IcPallet_assetsPalletEventBlocked> =
  Struct({ asset_id: u128, who: cdc1 })

type IcPallet_assetsPalletEvent =
  | { tag: "Created"; value: IcPallet_assetsPalletEventCreated }
  | { tag: "Issued"; value: IcPallet_assetsPalletEventIssued }
  | { tag: "Transferred"; value: IcPallet_assetsPalletEventTransferred }
  | { tag: "Burned"; value: IcPallet_assetsPalletEventBurned }
  | { tag: "TeamChanged"; value: IcPallet_assetsPalletEventTeamChanged }
  | { tag: "OwnerChanged"; value: IcPallet_assetsPalletEventOwnerChanged }
  | { tag: "Frozen"; value: IcPallet_assetsPalletEventFrozen }
  | { tag: "Thawed"; value: IcPallet_assetsPalletEventThawed }
  | { tag: "AssetFrozen"; value: IcPallet_assetsPalletEventAssetFrozen }
  | { tag: "AssetThawed"; value: IcPallet_assetsPalletEventAssetThawed }
  | {
      tag: "AccountsDestroyed"
      value: IcPallet_assetsPalletEventAccountsDestroyed
    }
  | {
      tag: "ApprovalsDestroyed"
      value: IcPallet_assetsPalletEventApprovalsDestroyed
    }
  | {
      tag: "DestructionStarted"
      value: IcPallet_assetsPalletEventDestructionStarted
    }
  | { tag: "Destroyed"; value: IcPallet_assetsPalletEventDestroyed }
  | { tag: "ForceCreated"; value: IcPallet_assetsPalletEventForceCreated }
  | { tag: "MetadataSet"; value: IcPallet_assetsPalletEventMetadataSet }
  | { tag: "MetadataCleared"; value: IcPallet_assetsPalletEventMetadataCleared }
  | {
      tag: "ApprovedTransfer"
      value: IcPallet_assetsPalletEventApprovedTransfer
    }
  | {
      tag: "ApprovalCancelled"
      value: IcPallet_assetsPalletEventApprovalCancelled
    }
  | {
      tag: "TransferredApproved"
      value: IcPallet_assetsPalletEventTransferredApproved
    }
  | {
      tag: "AssetStatusChanged"
      value: IcPallet_assetsPalletEventAssetStatusChanged
    }
  | {
      tag: "AssetMinBalanceChanged"
      value: IcPallet_assetsPalletEventAssetMinBalanceChanged
    }
  | { tag: "Touched"; value: IcPallet_assetsPalletEventTouched }
  | { tag: "Blocked"; value: IcPallet_assetsPalletEventBlocked }
const cPallet_assetsPalletEvent: Codec<IcPallet_assetsPalletEvent> = Enum({
  Created: cPallet_assetsPalletEventCreated,
  Issued: cPallet_assetsPalletEventIssued,
  Transferred: cPallet_assetsPalletEventTransferred,
  Burned: cPallet_assetsPalletEventBurned,
  TeamChanged: cPallet_assetsPalletEventTeamChanged,
  OwnerChanged: cPallet_assetsPalletEventOwnerChanged,
  Frozen: cPallet_assetsPalletEventFrozen,
  Thawed: cPallet_assetsPalletEventThawed,
  AssetFrozen: cPallet_assetsPalletEventAssetFrozen,
  AssetThawed: cPallet_assetsPalletEventAssetThawed,
  AccountsDestroyed: cPallet_assetsPalletEventAccountsDestroyed,
  ApprovalsDestroyed: cPallet_assetsPalletEventApprovalsDestroyed,
  DestructionStarted: cPallet_assetsPalletEventDestructionStarted,
  Destroyed: cPallet_assetsPalletEventDestroyed,
  ForceCreated: cPallet_assetsPalletEventForceCreated,
  MetadataSet: cPallet_assetsPalletEventMetadataSet,
  MetadataCleared: cPallet_assetsPalletEventMetadataCleared,
  ApprovedTransfer: cPallet_assetsPalletEventApprovedTransfer,
  ApprovalCancelled: cPallet_assetsPalletEventApprovalCancelled,
  TransferredApproved: cPallet_assetsPalletEventTransferredApproved,
  AssetStatusChanged: cPallet_assetsPalletEventAssetStatusChanged,
  AssetMinBalanceChanged: cPallet_assetsPalletEventAssetMinBalanceChanged,
  Touched: cPallet_assetsPalletEventTouched,
  Blocked: cPallet_assetsPalletEventBlocked,
})

type IcMoonbeam_runtimeRuntimeEventAssets = IcPallet_assetsPalletEvent
const cMoonbeam_runtimeRuntimeEventAssets: Codec<IcMoonbeam_runtimeRuntimeEventAssets> =
  cPallet_assetsPalletEvent

type IcMoonbeam_runtimeXcm_configAssetTypeXcm =
  IcXcmV3MultilocationMultiLocation
const cMoonbeam_runtimeXcm_configAssetTypeXcm: Codec<IcMoonbeam_runtimeXcm_configAssetTypeXcm> =
  cXcmV3MultilocationMultiLocation

type IcMoonbeam_runtimeXcm_configAssetType = {
  tag: "Xcm"
  value: IcMoonbeam_runtimeXcm_configAssetTypeXcm
}
const cMoonbeam_runtimeXcm_configAssetType: Codec<IcMoonbeam_runtimeXcm_configAssetType> =
  Enum({ Xcm: cMoonbeam_runtimeXcm_configAssetTypeXcm })

type IcMoonbeam_runtimeAsset_configAssetRegistrarMetadata = {
  name: I_bytesSeq
  symbol: I_bytesSeq
  decimals: number
  is_frozen: boolean
}
const cMoonbeam_runtimeAsset_configAssetRegistrarMetadata: Codec<IcMoonbeam_runtimeAsset_configAssetRegistrarMetadata> =
  Struct({ name: _bytesSeq, symbol: _bytesSeq, decimals: u8, is_frozen: bool })

type IcPallet_asset_managerPalletEventForeignAssetRegistered = {
  asset_id: bigint
  asset: IcMoonbeam_runtimeXcm_configAssetType
  metadata: IcMoonbeam_runtimeAsset_configAssetRegistrarMetadata
}
const cPallet_asset_managerPalletEventForeignAssetRegistered: Codec<IcPallet_asset_managerPalletEventForeignAssetRegistered> =
  Struct({
    asset_id: u128,
    asset: cMoonbeam_runtimeXcm_configAssetType,
    metadata: cMoonbeam_runtimeAsset_configAssetRegistrarMetadata,
  })

type IcPallet_asset_managerPalletEventUnitsPerSecondChanged = {
  asset_type: IcMoonbeam_runtimeXcm_configAssetType
  units_per_second: bigint
}
const cPallet_asset_managerPalletEventUnitsPerSecondChanged: Codec<IcPallet_asset_managerPalletEventUnitsPerSecondChanged> =
  Struct({
    asset_type: cMoonbeam_runtimeXcm_configAssetType,
    units_per_second: u128,
  })

type IcPallet_asset_managerPalletEventForeignAssetTypeChanged = {
  asset_id: bigint
  new_asset_type: IcMoonbeam_runtimeXcm_configAssetType
}
const cPallet_asset_managerPalletEventForeignAssetTypeChanged: Codec<IcPallet_asset_managerPalletEventForeignAssetTypeChanged> =
  Struct({
    asset_id: u128,
    new_asset_type: cMoonbeam_runtimeXcm_configAssetType,
  })

type IcPallet_asset_managerPalletEventForeignAssetRemoved = {
  asset_id: bigint
  asset_type: IcMoonbeam_runtimeXcm_configAssetType
}
const cPallet_asset_managerPalletEventForeignAssetRemoved: Codec<IcPallet_asset_managerPalletEventForeignAssetRemoved> =
  Struct({ asset_id: u128, asset_type: cMoonbeam_runtimeXcm_configAssetType })

type IcPallet_asset_managerPalletEventSupportedAssetRemoved = {
  asset_type: IcMoonbeam_runtimeXcm_configAssetType
}
const cPallet_asset_managerPalletEventSupportedAssetRemoved: Codec<IcPallet_asset_managerPalletEventSupportedAssetRemoved> =
  Struct({ asset_type: cMoonbeam_runtimeXcm_configAssetType })

type IcPallet_asset_managerPalletEventLocalAssetRegistered = {
  asset_id: bigint
  creator: Icdc1
  owner: Icdc1
}
const cPallet_asset_managerPalletEventLocalAssetRegistered: Codec<IcPallet_asset_managerPalletEventLocalAssetRegistered> =
  Struct({ asset_id: u128, creator: cdc1, owner: cdc1 })

type IcPallet_asset_managerPalletEventForeignAssetDestroyed = {
  asset_id: bigint
  asset_type: IcMoonbeam_runtimeXcm_configAssetType
}
const cPallet_asset_managerPalletEventForeignAssetDestroyed: Codec<IcPallet_asset_managerPalletEventForeignAssetDestroyed> =
  Struct({ asset_id: u128, asset_type: cMoonbeam_runtimeXcm_configAssetType })

type IcPallet_asset_managerPalletEventLocalAssetDestroyed = { asset_id: bigint }
const cPallet_asset_managerPalletEventLocalAssetDestroyed: Codec<IcPallet_asset_managerPalletEventLocalAssetDestroyed> =
  Struct({ asset_id: u128 })

type IcPallet_asset_managerPalletEvent =
  | {
      tag: "ForeignAssetRegistered"
      value: IcPallet_asset_managerPalletEventForeignAssetRegistered
    }
  | {
      tag: "UnitsPerSecondChanged"
      value: IcPallet_asset_managerPalletEventUnitsPerSecondChanged
    }
  | {
      tag: "ForeignAssetTypeChanged"
      value: IcPallet_asset_managerPalletEventForeignAssetTypeChanged
    }
  | {
      tag: "ForeignAssetRemoved"
      value: IcPallet_asset_managerPalletEventForeignAssetRemoved
    }
  | {
      tag: "SupportedAssetRemoved"
      value: IcPallet_asset_managerPalletEventSupportedAssetRemoved
    }
  | {
      tag: "LocalAssetRegistered"
      value: IcPallet_asset_managerPalletEventLocalAssetRegistered
    }
  | {
      tag: "ForeignAssetDestroyed"
      value: IcPallet_asset_managerPalletEventForeignAssetDestroyed
    }
  | {
      tag: "LocalAssetDestroyed"
      value: IcPallet_asset_managerPalletEventLocalAssetDestroyed
    }
const cPallet_asset_managerPalletEvent: Codec<IcPallet_asset_managerPalletEvent> =
  Enum({
    ForeignAssetRegistered:
      cPallet_asset_managerPalletEventForeignAssetRegistered,
    UnitsPerSecondChanged:
      cPallet_asset_managerPalletEventUnitsPerSecondChanged,
    ForeignAssetTypeChanged:
      cPallet_asset_managerPalletEventForeignAssetTypeChanged,
    ForeignAssetRemoved: cPallet_asset_managerPalletEventForeignAssetRemoved,
    SupportedAssetRemoved:
      cPallet_asset_managerPalletEventSupportedAssetRemoved,
    LocalAssetRegistered: cPallet_asset_managerPalletEventLocalAssetRegistered,
    ForeignAssetDestroyed:
      cPallet_asset_managerPalletEventForeignAssetDestroyed,
    LocalAssetDestroyed: cPallet_asset_managerPalletEventLocalAssetDestroyed,
  })

type IcMoonbeam_runtimeRuntimeEventAssetManager =
  IcPallet_asset_managerPalletEvent
const cMoonbeam_runtimeRuntimeEventAssetManager: Codec<IcMoonbeam_runtimeRuntimeEventAssetManager> =
  cPallet_asset_managerPalletEvent

type IcOrml_xtokensModuleEventTransferredMultiAssets = {
  sender: Icdc1
  assets: Icdc267
  fee: IcXcmV3MultiassetMultiAsset
  dest: IcXcmV3MultilocationMultiLocation
}
const cOrml_xtokensModuleEventTransferredMultiAssets: Codec<IcOrml_xtokensModuleEventTransferredMultiAssets> =
  Struct({
    sender: cdc1,
    assets: cdc267,
    fee: cXcmV3MultiassetMultiAsset,
    dest: cXcmV3MultilocationMultiLocation,
  })

type IcOrml_xtokensModuleEvent = {
  tag: "TransferredMultiAssets"
  value: IcOrml_xtokensModuleEventTransferredMultiAssets
}
const cOrml_xtokensModuleEvent: Codec<IcOrml_xtokensModuleEvent> = Enum({
  TransferredMultiAssets: cOrml_xtokensModuleEventTransferredMultiAssets,
})

type IcMoonbeam_runtimeRuntimeEventXTokens = IcOrml_xtokensModuleEvent
const cMoonbeam_runtimeRuntimeEventXTokens: Codec<IcMoonbeam_runtimeRuntimeEventXTokens> =
  cOrml_xtokensModuleEvent

type IcPallet_xcm_transactorPalletEventTransactedDerivative = {
  account_id: Icdc1
  dest: IcXcmV3MultilocationMultiLocation
  call: I_bytesSeq
  index: number
}
const cPallet_xcm_transactorPalletEventTransactedDerivative: Codec<IcPallet_xcm_transactorPalletEventTransactedDerivative> =
  Struct({
    account_id: cdc1,
    dest: cXcmV3MultilocationMultiLocation,
    call: _bytesSeq,
    index: u16,
  })

type IcPallet_xcm_transactorPalletEventTransactedSovereign = {
  fee_payer: Icdc1
  dest: IcXcmV3MultilocationMultiLocation
  call: I_bytesSeq
}
const cPallet_xcm_transactorPalletEventTransactedSovereign: Codec<IcPallet_xcm_transactorPalletEventTransactedSovereign> =
  Struct({
    fee_payer: cdc1,
    dest: cXcmV3MultilocationMultiLocation,
    call: _bytesSeq,
  })

type IcPallet_xcm_transactorPalletEventTransactedSigned = {
  fee_payer: Icdc1
  dest: IcXcmV3MultilocationMultiLocation
  call: I_bytesSeq
}
const cPallet_xcm_transactorPalletEventTransactedSigned: Codec<IcPallet_xcm_transactorPalletEventTransactedSigned> =
  Struct({
    fee_payer: cdc1,
    dest: cXcmV3MultilocationMultiLocation,
    call: _bytesSeq,
  })

type IcPallet_xcm_transactorPalletEventRegisteredDerivative = {
  account_id: Icdc1
  index: number
}
const cPallet_xcm_transactorPalletEventRegisteredDerivative: Codec<IcPallet_xcm_transactorPalletEventRegisteredDerivative> =
  Struct({ account_id: cdc1, index: u16 })

type IcPallet_xcm_transactorPalletEventDeRegisteredDerivative = {
  index: number
}
const cPallet_xcm_transactorPalletEventDeRegisteredDerivative: Codec<IcPallet_xcm_transactorPalletEventDeRegisteredDerivative> =
  Struct({ index: u16 })

type IcPallet_xcm_transactorPalletEventTransactFailed = {
  error: IcXcmV3TraitsError
}
const cPallet_xcm_transactorPalletEventTransactFailed: Codec<IcPallet_xcm_transactorPalletEventTransactFailed> =
  Struct({ error: cXcmV3TraitsError })

type IcPallet_xcm_transactorPalletRemoteTransactInfoWithMaxWeight = {
  transact_extra_weight: IcSp_weightsWeight_v2Weight
  max_weight: IcSp_weightsWeight_v2Weight
  transact_extra_weight_signed: IcOption
}
const cPallet_xcm_transactorPalletRemoteTransactInfoWithMaxWeight: Codec<IcPallet_xcm_transactorPalletRemoteTransactInfoWithMaxWeight> =
  Struct({
    transact_extra_weight: cSp_weightsWeight_v2Weight,
    max_weight: cSp_weightsWeight_v2Weight,
    transact_extra_weight_signed: cOption,
  })

type IcPallet_xcm_transactorPalletEventTransactInfoChanged = {
  location: IcXcmV3MultilocationMultiLocation
  remote_info: IcPallet_xcm_transactorPalletRemoteTransactInfoWithMaxWeight
}
const cPallet_xcm_transactorPalletEventTransactInfoChanged: Codec<IcPallet_xcm_transactorPalletEventTransactInfoChanged> =
  Struct({
    location: cXcmV3MultilocationMultiLocation,
    remote_info: cPallet_xcm_transactorPalletRemoteTransactInfoWithMaxWeight,
  })

type IcPallet_xcm_transactorPalletEventTransactInfoRemoved = {
  location: IcXcmV3MultilocationMultiLocation
}
const cPallet_xcm_transactorPalletEventTransactInfoRemoved: Codec<IcPallet_xcm_transactorPalletEventTransactInfoRemoved> =
  Struct({ location: cXcmV3MultilocationMultiLocation })

type IcPallet_xcm_transactorPalletEventDestFeePerSecondChanged = {
  location: IcXcmV3MultilocationMultiLocation
  fee_per_second: bigint
}
const cPallet_xcm_transactorPalletEventDestFeePerSecondChanged: Codec<IcPallet_xcm_transactorPalletEventDestFeePerSecondChanged> =
  Struct({ location: cXcmV3MultilocationMultiLocation, fee_per_second: u128 })

type IcPallet_xcm_transactorPalletEventDestFeePerSecondRemoved = {
  location: IcXcmV3MultilocationMultiLocation
}
const cPallet_xcm_transactorPalletEventDestFeePerSecondRemoved: Codec<IcPallet_xcm_transactorPalletEventDestFeePerSecondRemoved> =
  Struct({ location: cXcmV3MultilocationMultiLocation })

type IcPallet_xcm_transactorPalletHrmpInitParams = {
  para_id: number
  proposed_max_capacity: number
  proposed_max_message_size: number
}
const cPallet_xcm_transactorPalletHrmpInitParams: Codec<IcPallet_xcm_transactorPalletHrmpInitParams> =
  Struct({
    para_id: u32,
    proposed_max_capacity: u32,
    proposed_max_message_size: u32,
  })

type IcPallet_xcm_transactorPalletHrmpOperationInitOpen =
  IcPallet_xcm_transactorPalletHrmpInitParams
const cPallet_xcm_transactorPalletHrmpOperationInitOpen: Codec<IcPallet_xcm_transactorPalletHrmpOperationInitOpen> =
  cPallet_xcm_transactorPalletHrmpInitParams

type IcPallet_xcm_transactorPalletHrmpOperationAccept = { para_id: number }
const cPallet_xcm_transactorPalletHrmpOperationAccept: Codec<IcPallet_xcm_transactorPalletHrmpOperationAccept> =
  Struct({ para_id: u32 })

type IcPolkadot_parachainPrimitivesHrmpChannelId = {
  sender: number
  recipient: number
}
const cPolkadot_parachainPrimitivesHrmpChannelId: Codec<IcPolkadot_parachainPrimitivesHrmpChannelId> =
  Struct({ sender: u32, recipient: u32 })

type IcPallet_xcm_transactorPalletHrmpOperationClose =
  IcPolkadot_parachainPrimitivesHrmpChannelId
const cPallet_xcm_transactorPalletHrmpOperationClose: Codec<IcPallet_xcm_transactorPalletHrmpOperationClose> =
  cPolkadot_parachainPrimitivesHrmpChannelId

type IcPallet_xcm_transactorPalletHrmpOperationCancel = {
  channel_id: IcPolkadot_parachainPrimitivesHrmpChannelId
  open_requests: number
}
const cPallet_xcm_transactorPalletHrmpOperationCancel: Codec<IcPallet_xcm_transactorPalletHrmpOperationCancel> =
  Struct({
    channel_id: cPolkadot_parachainPrimitivesHrmpChannelId,
    open_requests: u32,
  })

type IcPallet_xcm_transactorPalletHrmpOperation =
  | {
      tag: "InitOpen"
      value: IcPallet_xcm_transactorPalletHrmpOperationInitOpen
    }
  | { tag: "Accept"; value: IcPallet_xcm_transactorPalletHrmpOperationAccept }
  | { tag: "Close"; value: IcPallet_xcm_transactorPalletHrmpOperationClose }
  | { tag: "Cancel"; value: IcPallet_xcm_transactorPalletHrmpOperationCancel }
const cPallet_xcm_transactorPalletHrmpOperation: Codec<IcPallet_xcm_transactorPalletHrmpOperation> =
  Enum({
    InitOpen: cPallet_xcm_transactorPalletHrmpOperationInitOpen,
    Accept: cPallet_xcm_transactorPalletHrmpOperationAccept,
    Close: cPallet_xcm_transactorPalletHrmpOperationClose,
    Cancel: cPallet_xcm_transactorPalletHrmpOperationCancel,
  })

type IcPallet_xcm_transactorPalletEventHrmpManagementSent = {
  action: IcPallet_xcm_transactorPalletHrmpOperation
}
const cPallet_xcm_transactorPalletEventHrmpManagementSent: Codec<IcPallet_xcm_transactorPalletEventHrmpManagementSent> =
  Struct({ action: cPallet_xcm_transactorPalletHrmpOperation })

type IcPallet_xcm_transactorPalletEvent =
  | {
      tag: "TransactedDerivative"
      value: IcPallet_xcm_transactorPalletEventTransactedDerivative
    }
  | {
      tag: "TransactedSovereign"
      value: IcPallet_xcm_transactorPalletEventTransactedSovereign
    }
  | {
      tag: "TransactedSigned"
      value: IcPallet_xcm_transactorPalletEventTransactedSigned
    }
  | {
      tag: "RegisteredDerivative"
      value: IcPallet_xcm_transactorPalletEventRegisteredDerivative
    }
  | {
      tag: "DeRegisteredDerivative"
      value: IcPallet_xcm_transactorPalletEventDeRegisteredDerivative
    }
  | {
      tag: "TransactFailed"
      value: IcPallet_xcm_transactorPalletEventTransactFailed
    }
  | {
      tag: "TransactInfoChanged"
      value: IcPallet_xcm_transactorPalletEventTransactInfoChanged
    }
  | {
      tag: "TransactInfoRemoved"
      value: IcPallet_xcm_transactorPalletEventTransactInfoRemoved
    }
  | {
      tag: "DestFeePerSecondChanged"
      value: IcPallet_xcm_transactorPalletEventDestFeePerSecondChanged
    }
  | {
      tag: "DestFeePerSecondRemoved"
      value: IcPallet_xcm_transactorPalletEventDestFeePerSecondRemoved
    }
  | {
      tag: "HrmpManagementSent"
      value: IcPallet_xcm_transactorPalletEventHrmpManagementSent
    }
const cPallet_xcm_transactorPalletEvent: Codec<IcPallet_xcm_transactorPalletEvent> =
  Enum({
    TransactedDerivative: cPallet_xcm_transactorPalletEventTransactedDerivative,
    TransactedSovereign: cPallet_xcm_transactorPalletEventTransactedSovereign,
    TransactedSigned: cPallet_xcm_transactorPalletEventTransactedSigned,
    RegisteredDerivative: cPallet_xcm_transactorPalletEventRegisteredDerivative,
    DeRegisteredDerivative:
      cPallet_xcm_transactorPalletEventDeRegisteredDerivative,
    TransactFailed: cPallet_xcm_transactorPalletEventTransactFailed,
    TransactInfoChanged: cPallet_xcm_transactorPalletEventTransactInfoChanged,
    TransactInfoRemoved: cPallet_xcm_transactorPalletEventTransactInfoRemoved,
    DestFeePerSecondChanged:
      cPallet_xcm_transactorPalletEventDestFeePerSecondChanged,
    DestFeePerSecondRemoved:
      cPallet_xcm_transactorPalletEventDestFeePerSecondRemoved,
    HrmpManagementSent: cPallet_xcm_transactorPalletEventHrmpManagementSent,
  })

type IcMoonbeam_runtimeRuntimeEventXcmTransactor =
  IcPallet_xcm_transactorPalletEvent
const cMoonbeam_runtimeRuntimeEventXcmTransactor: Codec<IcMoonbeam_runtimeRuntimeEventXcmTransactor> =
  cPallet_xcm_transactorPalletEvent

type IcMoonbeam_runtimeRuntimeEventLocalAssets = IcPallet_assetsPalletEvent
const cMoonbeam_runtimeRuntimeEventLocalAssets: Codec<IcMoonbeam_runtimeRuntimeEventLocalAssets> =
  cPallet_assetsPalletEvent

type IcPallet_randomnessPalletEventRandomnessRequestedBabeEpoch = {
  id: bigint
  refund_address: Icdc1
  contract_address: Icdc1
  fee: bigint
  gas_limit: bigint
  num_words: number
  salt: Icdc13
  earliest_epoch: bigint
}
const cPallet_randomnessPalletEventRandomnessRequestedBabeEpoch: Codec<IcPallet_randomnessPalletEventRandomnessRequestedBabeEpoch> =
  Struct({
    id: u64,
    refund_address: cdc1,
    contract_address: cdc1,
    fee: u128,
    gas_limit: u64,
    num_words: u8,
    salt: cdc13,
    earliest_epoch: u64,
  })

type IcPallet_randomnessPalletEventRandomnessRequestedLocal = {
  id: bigint
  refund_address: Icdc1
  contract_address: Icdc1
  fee: bigint
  gas_limit: bigint
  num_words: number
  salt: Icdc13
  earliest_block: number
}
const cPallet_randomnessPalletEventRandomnessRequestedLocal: Codec<IcPallet_randomnessPalletEventRandomnessRequestedLocal> =
  Struct({
    id: u64,
    refund_address: cdc1,
    contract_address: cdc1,
    fee: u128,
    gas_limit: u64,
    num_words: u8,
    salt: cdc13,
    earliest_block: u32,
  })

type IcPallet_randomnessPalletEventRequestFulfilled = { id: bigint }
const cPallet_randomnessPalletEventRequestFulfilled: Codec<IcPallet_randomnessPalletEventRequestFulfilled> =
  Struct({ id: u64 })

type IcPallet_randomnessPalletEventRequestFeeIncreased = {
  id: bigint
  new_fee: bigint
}
const cPallet_randomnessPalletEventRequestFeeIncreased: Codec<IcPallet_randomnessPalletEventRequestFeeIncreased> =
  Struct({ id: u64, new_fee: u128 })

type IcPallet_randomnessPalletEventRequestExpirationExecuted = { id: bigint }
const cPallet_randomnessPalletEventRequestExpirationExecuted: Codec<IcPallet_randomnessPalletEventRequestExpirationExecuted> =
  Struct({ id: u64 })

type IcPallet_randomnessPalletEvent =
  | {
      tag: "RandomnessRequestedBabeEpoch"
      value: IcPallet_randomnessPalletEventRandomnessRequestedBabeEpoch
    }
  | {
      tag: "RandomnessRequestedLocal"
      value: IcPallet_randomnessPalletEventRandomnessRequestedLocal
    }
  | {
      tag: "RequestFulfilled"
      value: IcPallet_randomnessPalletEventRequestFulfilled
    }
  | {
      tag: "RequestFeeIncreased"
      value: IcPallet_randomnessPalletEventRequestFeeIncreased
    }
  | {
      tag: "RequestExpirationExecuted"
      value: IcPallet_randomnessPalletEventRequestExpirationExecuted
    }
const cPallet_randomnessPalletEvent: Codec<IcPallet_randomnessPalletEvent> =
  Enum({
    RandomnessRequestedBabeEpoch:
      cPallet_randomnessPalletEventRandomnessRequestedBabeEpoch,
    RandomnessRequestedLocal:
      cPallet_randomnessPalletEventRandomnessRequestedLocal,
    RequestFulfilled: cPallet_randomnessPalletEventRequestFulfilled,
    RequestFeeIncreased: cPallet_randomnessPalletEventRequestFeeIncreased,
    RequestExpirationExecuted:
      cPallet_randomnessPalletEventRequestExpirationExecuted,
  })

type IcMoonbeam_runtimeRuntimeEventRandomness = IcPallet_randomnessPalletEvent
const cMoonbeam_runtimeRuntimeEventRandomness: Codec<IcMoonbeam_runtimeRuntimeEventRandomness> =
  cPallet_randomnessPalletEvent

type IcMoonbeam_runtimeRuntimeEvent =
  | { tag: "System"; value: IcMoonbeam_runtimeRuntimeEventSystem }
  | {
      tag: "ParachainSystem"
      value: IcMoonbeam_runtimeRuntimeEventParachainSystem
    }
  | { tag: "Balances"; value: IcMoonbeam_runtimeRuntimeEventBalances }
  | {
      tag: "TransactionPayment"
      value: IcMoonbeam_runtimeRuntimeEventTransactionPayment
    }
  | {
      tag: "ParachainStaking"
      value: IcMoonbeam_runtimeRuntimeEventParachainStaking
    }
  | { tag: "AuthorFilter"; value: IcMoonbeam_runtimeRuntimeEventAuthorFilter }
  | { tag: "AuthorMapping"; value: IcMoonbeam_runtimeRuntimeEventAuthorMapping }
  | {
      tag: "MoonbeamOrbiters"
      value: IcMoonbeam_runtimeRuntimeEventMoonbeamOrbiters
    }
  | { tag: "Utility"; value: IcMoonbeam_runtimeRuntimeEventUtility }
  | { tag: "Proxy"; value: IcMoonbeam_runtimeRuntimeEventProxy }
  | {
      tag: "MaintenanceMode"
      value: IcMoonbeam_runtimeRuntimeEventMaintenanceMode
    }
  | { tag: "Identity"; value: IcMoonbeam_runtimeRuntimeEventIdentity }
  | { tag: "Migrations"; value: IcMoonbeam_runtimeRuntimeEventMigrations }
  | { tag: "Multisig"; value: IcMoonbeam_runtimeRuntimeEventMultisig }
  | { tag: "EVM"; value: IcMoonbeam_runtimeRuntimeEventEVM }
  | { tag: "Ethereum"; value: IcMoonbeam_runtimeRuntimeEventEthereum }
  | { tag: "Scheduler"; value: IcMoonbeam_runtimeRuntimeEventScheduler }
  | { tag: "Democracy"; value: IcMoonbeam_runtimeRuntimeEventDemocracy }
  | { tag: "Preimage"; value: IcMoonbeam_runtimeRuntimeEventPreimage }
  | {
      tag: "ConvictionVoting"
      value: IcMoonbeam_runtimeRuntimeEventConvictionVoting
    }
  | { tag: "Referenda"; value: IcMoonbeam_runtimeRuntimeEventReferenda }
  | { tag: "Whitelist"; value: IcMoonbeam_runtimeRuntimeEventWhitelist }
  | {
      tag: "CouncilCollective"
      value: IcMoonbeam_runtimeRuntimeEventCouncilCollective
    }
  | {
      tag: "TechCommitteeCollective"
      value: IcMoonbeam_runtimeRuntimeEventTechCommitteeCollective
    }
  | {
      tag: "TreasuryCouncilCollective"
      value: IcMoonbeam_runtimeRuntimeEventTreasuryCouncilCollective
    }
  | {
      tag: "OpenTechCommitteeCollective"
      value: IcMoonbeam_runtimeRuntimeEventOpenTechCommitteeCollective
    }
  | { tag: "Treasury"; value: IcMoonbeam_runtimeRuntimeEventTreasury }
  | {
      tag: "CrowdloanRewards"
      value: IcMoonbeam_runtimeRuntimeEventCrowdloanRewards
    }
  | { tag: "XcmpQueue"; value: IcMoonbeam_runtimeRuntimeEventXcmpQueue }
  | { tag: "CumulusXcm"; value: IcMoonbeam_runtimeRuntimeEventCumulusXcm }
  | { tag: "DmpQueue"; value: IcMoonbeam_runtimeRuntimeEventDmpQueue }
  | { tag: "PolkadotXcm"; value: IcMoonbeam_runtimeRuntimeEventPolkadotXcm }
  | { tag: "Assets"; value: IcMoonbeam_runtimeRuntimeEventAssets }
  | { tag: "AssetManager"; value: IcMoonbeam_runtimeRuntimeEventAssetManager }
  | { tag: "XTokens"; value: IcMoonbeam_runtimeRuntimeEventXTokens }
  | { tag: "XcmTransactor"; value: IcMoonbeam_runtimeRuntimeEventXcmTransactor }
  | { tag: "LocalAssets"; value: IcMoonbeam_runtimeRuntimeEventLocalAssets }
  | { tag: "Randomness"; value: IcMoonbeam_runtimeRuntimeEventRandomness }
const cMoonbeam_runtimeRuntimeEvent: Codec<IcMoonbeam_runtimeRuntimeEvent> =
  Enum(
    {
      System: cMoonbeam_runtimeRuntimeEventSystem,
      ParachainSystem: cMoonbeam_runtimeRuntimeEventParachainSystem,
      Balances: cMoonbeam_runtimeRuntimeEventBalances,
      TransactionPayment: cMoonbeam_runtimeRuntimeEventTransactionPayment,
      ParachainStaking: cMoonbeam_runtimeRuntimeEventParachainStaking,
      AuthorFilter: cMoonbeam_runtimeRuntimeEventAuthorFilter,
      AuthorMapping: cMoonbeam_runtimeRuntimeEventAuthorMapping,
      MoonbeamOrbiters: cMoonbeam_runtimeRuntimeEventMoonbeamOrbiters,
      Utility: cMoonbeam_runtimeRuntimeEventUtility,
      Proxy: cMoonbeam_runtimeRuntimeEventProxy,
      MaintenanceMode: cMoonbeam_runtimeRuntimeEventMaintenanceMode,
      Identity: cMoonbeam_runtimeRuntimeEventIdentity,
      Migrations: cMoonbeam_runtimeRuntimeEventMigrations,
      Multisig: cMoonbeam_runtimeRuntimeEventMultisig,
      EVM: cMoonbeam_runtimeRuntimeEventEVM,
      Ethereum: cMoonbeam_runtimeRuntimeEventEthereum,
      Scheduler: cMoonbeam_runtimeRuntimeEventScheduler,
      Democracy: cMoonbeam_runtimeRuntimeEventDemocracy,
      Preimage: cMoonbeam_runtimeRuntimeEventPreimage,
      ConvictionVoting: cMoonbeam_runtimeRuntimeEventConvictionVoting,
      Referenda: cMoonbeam_runtimeRuntimeEventReferenda,
      Whitelist: cMoonbeam_runtimeRuntimeEventWhitelist,
      CouncilCollective: cMoonbeam_runtimeRuntimeEventCouncilCollective,
      TechCommitteeCollective:
        cMoonbeam_runtimeRuntimeEventTechCommitteeCollective,
      TreasuryCouncilCollective:
        cMoonbeam_runtimeRuntimeEventTreasuryCouncilCollective,
      OpenTechCommitteeCollective:
        cMoonbeam_runtimeRuntimeEventOpenTechCommitteeCollective,
      Treasury: cMoonbeam_runtimeRuntimeEventTreasury,
      CrowdloanRewards: cMoonbeam_runtimeRuntimeEventCrowdloanRewards,
      XcmpQueue: cMoonbeam_runtimeRuntimeEventXcmpQueue,
      CumulusXcm: cMoonbeam_runtimeRuntimeEventCumulusXcm,
      DmpQueue: cMoonbeam_runtimeRuntimeEventDmpQueue,
      PolkadotXcm: cMoonbeam_runtimeRuntimeEventPolkadotXcm,
      Assets: cMoonbeam_runtimeRuntimeEventAssets,
      AssetManager: cMoonbeam_runtimeRuntimeEventAssetManager,
      XTokens: cMoonbeam_runtimeRuntimeEventXTokens,
      XcmTransactor: cMoonbeam_runtimeRuntimeEventXcmTransactor,
      LocalAssets: cMoonbeam_runtimeRuntimeEventLocalAssets,
      Randomness: cMoonbeam_runtimeRuntimeEventRandomness,
    },
    [
      0, 1, 10, 11, 20, 22, 23, 24, 30, 31, 32, 33, 34, 36, 51, 52, 60, 61, 62,
      63, 64, 66, 70, 71, 72, 73, 80, 90, 100, 101, 102, 103, 104, 105, 106,
      107, 108, 120,
    ],
  )

type IcFrame_systemEventRecord = {
  phase: IcFrame_systemPhase
  event: IcMoonbeam_runtimeRuntimeEvent
  topics: Icdc65
}
const cFrame_systemEventRecord: Codec<IcFrame_systemEventRecord> = Struct({
  phase: cFrame_systemPhase,
  event: cMoonbeam_runtimeRuntimeEvent,
  topics: cdc65,
})

type Icdc19 = Array<IcFrame_systemEventRecord>
const cdc19: Codec<Icdc19> = Vector(cFrame_systemEventRecord)

type Icdc351 = Array<Icdc76>
const cdc351: Codec<Icdc351> = Vector(cdc76)

type IcPrimitive_typesH256Tupled = [Key: Icdc13]
const cPrimitive_typesH256Tupled: Codec<IcPrimitive_typesH256Tupled> =
  Tuple(cdc13)

type IcFrame_systemLastRuntimeUpgradeInfo = {
  spec_version: number
  spec_name: string
}
const cFrame_systemLastRuntimeUpgradeInfo: Codec<IcFrame_systemLastRuntimeUpgradeInfo> =
  Struct({ spec_version: compactNumber, spec_name: str })

type IcFrame_systemPalletCallRemarkTupled = [Remark: I_bytesSeq]
const cFrame_systemPalletCallRemarkTupled: Codec<IcFrame_systemPalletCallRemarkTupled> =
  Tuple(_bytesSeq)

type IcFrame_systemPalletCallSet_heap_pagesTupled = [Pages: bigint]
const cFrame_systemPalletCallSet_heap_pagesTupled: Codec<IcFrame_systemPalletCallSet_heap_pagesTupled> =
  Tuple(u64)

type IcFrame_systemPalletCallSet_codeTupled = [Code: I_bytesSeq]
const cFrame_systemPalletCallSet_codeTupled: Codec<IcFrame_systemPalletCallSet_codeTupled> =
  Tuple(_bytesSeq)

type IcFrame_systemPalletCallSet_code_without_checksTupled = [Code: I_bytesSeq]
const cFrame_systemPalletCallSet_code_without_checksTupled: Codec<IcFrame_systemPalletCallSet_code_without_checksTupled> =
  Tuple(_bytesSeq)

type Icdc89 = [I_bytesSeq, I_bytesSeq]
const cdc89: Codec<Icdc89> = Tuple(_bytesSeq, _bytesSeq)

type Icdc88 = Array<Icdc89>
const cdc88: Codec<Icdc88> = Vector(cdc89)

type IcFrame_systemPalletCallSet_storageTupled = [Items: Icdc88]
const cFrame_systemPalletCallSet_storageTupled: Codec<IcFrame_systemPalletCallSet_storageTupled> =
  Tuple(cdc88)

type Icdc90 = Array<I_bytesSeq>
const cdc90: Codec<Icdc90> = Vector(_bytesSeq)

type IcFrame_systemPalletCallKill_storageTupled = [Keys: Icdc90]
const cFrame_systemPalletCallKill_storageTupled: Codec<IcFrame_systemPalletCallKill_storageTupled> =
  Tuple(cdc90)

type IcFrame_systemPalletCallKill_prefixTupled = [
  Prefix: I_bytesSeq,
  Subkeys: number,
]
const cFrame_systemPalletCallKill_prefixTupled: Codec<IcFrame_systemPalletCallKill_prefixTupled> =
  Tuple(_bytesSeq, u32)

type IcFrame_systemPalletCallRemark_with_eventTupled = [Remark: I_bytesSeq]
const cFrame_systemPalletCallRemark_with_eventTupled: Codec<IcFrame_systemPalletCallRemark_with_eventTupled> =
  Tuple(_bytesSeq)

type IcFrame_systemPalletError =
  | { tag: "InvalidSpecName"; value: undefined }
  | { tag: "SpecVersionNeedsToIncrease"; value: undefined }
  | { tag: "FailedToExtractRuntimeVersion"; value: undefined }
  | { tag: "NonDefaultComposite"; value: undefined }
  | { tag: "NonZeroRefCount"; value: undefined }
  | { tag: "CallFiltered"; value: undefined }
const cFrame_systemPalletError: Codec<IcFrame_systemPalletError> = Enum({
  InvalidSpecName: _void,
  SpecVersionNeedsToIncrease: _void,
  FailedToExtractRuntimeVersion: _void,
  NonDefaultComposite: _void,
  NonZeroRefCount: _void,
  CallFiltered: _void,
})

type IcFrame_systemPalletErrorInvalidSpecName = undefined
const cFrame_systemPalletErrorInvalidSpecName: Codec<IcFrame_systemPalletErrorInvalidSpecName> =
  _void

type IcFrame_systemPalletErrorSpecVersionNeedsToIncrease = undefined
const cFrame_systemPalletErrorSpecVersionNeedsToIncrease: Codec<IcFrame_systemPalletErrorSpecVersionNeedsToIncrease> =
  _void

type IcFrame_systemPalletErrorFailedToExtractRuntimeVersion = undefined
const cFrame_systemPalletErrorFailedToExtractRuntimeVersion: Codec<IcFrame_systemPalletErrorFailedToExtractRuntimeVersion> =
  _void

type IcFrame_systemPalletErrorNonDefaultComposite = undefined
const cFrame_systemPalletErrorNonDefaultComposite: Codec<IcFrame_systemPalletErrorNonDefaultComposite> =
  _void

type IcFrame_systemPalletErrorNonZeroRefCount = undefined
const cFrame_systemPalletErrorNonZeroRefCount: Codec<IcFrame_systemPalletErrorNonZeroRefCount> =
  _void

type IcFrame_systemPalletErrorCallFiltered = undefined
const cFrame_systemPalletErrorCallFiltered: Codec<IcFrame_systemPalletErrorCallFiltered> =
  _void

type IcFrame_systemPalletEventCodeUpdated = undefined
const cFrame_systemPalletEventCodeUpdated: Codec<IcFrame_systemPalletEventCodeUpdated> =
  _void

type IcFrame_systemLimitsBlockWeights = {
  base_block: IcSp_weightsWeight_v2Weight
  max_block: IcSp_weightsWeight_v2Weight
  per_class: IcFrame_supportDispatchPerDispatchClass
}
const cFrame_systemLimitsBlockWeights: Codec<IcFrame_systemLimitsBlockWeights> =
  Struct({
    base_block: cSp_weightsWeight_v2Weight,
    max_block: cSp_weightsWeight_v2Weight,
    per_class: cFrame_supportDispatchPerDispatchClass,
  })

type IcSp_weightsRuntimeDbWeight = { read: bigint; write: bigint }
const cSp_weightsRuntimeDbWeight: Codec<IcSp_weightsRuntimeDbWeight> = Struct({
  read: u64,
  write: u64,
})

type Icdc362 = [Icdc154, number]
const cdc362: Codec<Icdc362> = Tuple(cdc154, u32)

type Icdc361 = Array<Icdc362>
const cdc361: Codec<Icdc361> = Vector(cdc362)

type IcSp_versionRuntimeVersion = {
  spec_name: string
  impl_name: string
  authoring_version: number
  spec_version: number
  impl_version: number
  apis: Icdc361
  transaction_version: number
  state_version: number
}
const cSp_versionRuntimeVersion: Codec<IcSp_versionRuntimeVersion> = Struct({
  spec_name: str,
  impl_name: str,
  authoring_version: u32,
  spec_version: u32,
  impl_version: u32,
  apis: cdc361,
  transaction_version: u32,
  state_version: u8,
})

type IcPolkadot_primitivesV4PersistedValidationData = {
  parent_head: I_bytesSeq
  relay_parent_number: number
  relay_parent_storage_root: Icdc13
  max_pov_size: number
}
const cPolkadot_primitivesV4PersistedValidationData: Codec<IcPolkadot_primitivesV4PersistedValidationData> =
  Struct({
    parent_head: _bytesSeq,
    relay_parent_number: u32,
    relay_parent_storage_root: cdc13,
    max_pov_size: u32,
  })

type IcCumulus_pallet_parachain_systemRelay_state_snapshotRelayDispachQueueSize =
  { remaining_count: number; remaining_size: number }
const cCumulus_pallet_parachain_systemRelay_state_snapshotRelayDispachQueueSize: Codec<IcCumulus_pallet_parachain_systemRelay_state_snapshotRelayDispachQueueSize> =
  Struct({ remaining_count: u32, remaining_size: u32 })

type IcPolkadot_primitivesV4AbridgedHrmpChannel = {
  max_capacity: number
  max_total_size: number
  max_message_size: number
  msg_count: number
  total_size: number
  mqc_head: IcOption
}
const cPolkadot_primitivesV4AbridgedHrmpChannel: Codec<IcPolkadot_primitivesV4AbridgedHrmpChannel> =
  Struct({
    max_capacity: u32,
    max_total_size: u32,
    max_message_size: u32,
    msg_count: u32,
    total_size: u32,
    mqc_head: cOption,
  })

type Icdc369 = [number, IcPolkadot_primitivesV4AbridgedHrmpChannel]
const cdc369: Codec<Icdc369> = Tuple(
  u32,
  cPolkadot_primitivesV4AbridgedHrmpChannel,
)

type Icdc368 = Array<Icdc369>
const cdc368: Codec<Icdc368> = Vector(cdc369)

type IcCumulus_pallet_parachain_systemRelay_state_snapshotMessagingStateSnapshot =
  {
    dmq_mqc_head: Icdc13
    relay_dispatch_queue_size: IcCumulus_pallet_parachain_systemRelay_state_snapshotRelayDispachQueueSize
    ingress_channels: Icdc368
    egress_channels: Icdc368
  }
const cCumulus_pallet_parachain_systemRelay_state_snapshotMessagingStateSnapshot: Codec<IcCumulus_pallet_parachain_systemRelay_state_snapshotMessagingStateSnapshot> =
  Struct({
    dmq_mqc_head: cdc13,
    relay_dispatch_queue_size:
      cCumulus_pallet_parachain_systemRelay_state_snapshotRelayDispachQueueSize,
    ingress_channels: cdc368,
    egress_channels: cdc368,
  })

type IcPolkadot_primitivesV4AbridgedHostConfiguration = {
  max_code_size: number
  max_head_data_size: number
  max_upward_queue_count: number
  max_upward_queue_size: number
  max_upward_message_size: number
  max_upward_message_num_per_candidate: number
  hrmp_max_message_num_per_candidate: number
  validation_upgrade_cooldown: number
  validation_upgrade_delay: number
}
const cPolkadot_primitivesV4AbridgedHostConfiguration: Codec<IcPolkadot_primitivesV4AbridgedHostConfiguration> =
  Struct({
    max_code_size: u32,
    max_head_data_size: u32,
    max_upward_queue_count: u32,
    max_upward_queue_size: u32,
    max_upward_message_size: u32,
    max_upward_message_num_per_candidate: u32,
    hrmp_max_message_num_per_candidate: u32,
    validation_upgrade_cooldown: u32,
    validation_upgrade_delay: u32,
  })

type Icdc375 = [number, Icdc13]
const cdc375: Codec<Icdc375> = Tuple(u32, cdc13)

type Icdc374 = Array<Icdc375>
const cdc374: Codec<Icdc374> = Vector(cdc375)

type IcPolkadot_core_primitivesOutboundHrmpMessage = {
  recipient: number
  data: I_bytesSeq
}
const cPolkadot_core_primitivesOutboundHrmpMessage: Codec<IcPolkadot_core_primitivesOutboundHrmpMessage> =
  Struct({ recipient: u32, data: _bytesSeq })

type Icdc376 = Array<IcPolkadot_core_primitivesOutboundHrmpMessage>
const cdc376: Codec<Icdc376> = Vector(
  cPolkadot_core_primitivesOutboundHrmpMessage,
)

type IcCumulus_pallet_parachain_systemCodeUpgradeAuthorization = {
  code_hash: Icdc13
  check_version: boolean
}
const cCumulus_pallet_parachain_systemCodeUpgradeAuthorization: Codec<IcCumulus_pallet_parachain_systemCodeUpgradeAuthorization> =
  Struct({ code_hash: cdc13, check_version: bool })

type IcPolkadot_core_primitivesInboundDownwardMessage = {
  sent_at: number
  msg: I_bytesSeq
}
const cPolkadot_core_primitivesInboundDownwardMessage: Codec<IcPolkadot_core_primitivesInboundDownwardMessage> =
  Struct({ sent_at: u32, msg: _bytesSeq })

type Icdc97 = Array<IcPolkadot_core_primitivesInboundDownwardMessage>
const cdc97: Codec<Icdc97> = Vector(
  cPolkadot_core_primitivesInboundDownwardMessage,
)

type IcPolkadot_core_primitivesInboundHrmpMessage = {
  sent_at: number
  data: I_bytesSeq
}
const cPolkadot_core_primitivesInboundHrmpMessage: Codec<IcPolkadot_core_primitivesInboundHrmpMessage> =
  Struct({ sent_at: u32, data: _bytesSeq })

type Icdc101 = Array<IcPolkadot_core_primitivesInboundHrmpMessage>
const cdc101: Codec<Icdc101> = Vector(
  cPolkadot_core_primitivesInboundHrmpMessage,
)

type Icdc104 = [number, Icdc101]
const cdc104: Codec<Icdc104> = Tuple(u32, cdc101)

type Icdc103 = Array<Icdc104>
const cdc103: Codec<Icdc103> = Vector(cdc104)

type IcCumulus_primitives_parachain_inherentParachainInherentData = {
  validation_data: IcPolkadot_primitivesV4PersistedValidationData
  relay_chain_state: Icdc90
  downward_messages: Icdc97
  horizontal_messages: Icdc103
}
const cCumulus_primitives_parachain_inherentParachainInherentData: Codec<IcCumulus_primitives_parachain_inherentParachainInherentData> =
  Struct({
    validation_data: cPolkadot_primitivesV4PersistedValidationData,
    relay_chain_state: cdc90,
    downward_messages: cdc97,
    horizontal_messages: cdc103,
  })

type IcCumulus_pallet_parachain_systemPalletCallSet_validation_dataTupled = [
  Data: IcCumulus_primitives_parachain_inherentParachainInherentData,
]
const cCumulus_pallet_parachain_systemPalletCallSet_validation_dataTupled: Codec<IcCumulus_pallet_parachain_systemPalletCallSet_validation_dataTupled> =
  Tuple(cCumulus_primitives_parachain_inherentParachainInherentData)

type IcCumulus_pallet_parachain_systemPalletCallSudo_send_upward_messageTupled =
  [Message: I_bytesSeq]
const cCumulus_pallet_parachain_systemPalletCallSudo_send_upward_messageTupled: Codec<IcCumulus_pallet_parachain_systemPalletCallSudo_send_upward_messageTupled> =
  Tuple(_bytesSeq)

type IcCumulus_pallet_parachain_systemPalletCallAuthorize_upgradeTupled = [
  Code_hash: Icdc13,
  Check_version: boolean,
]
const cCumulus_pallet_parachain_systemPalletCallAuthorize_upgradeTupled: Codec<IcCumulus_pallet_parachain_systemPalletCallAuthorize_upgradeTupled> =
  Tuple(cdc13, bool)

type IcCumulus_pallet_parachain_systemPalletCallEnact_authorized_upgradeTupled =
  [Code: I_bytesSeq]
const cCumulus_pallet_parachain_systemPalletCallEnact_authorized_upgradeTupled: Codec<IcCumulus_pallet_parachain_systemPalletCallEnact_authorized_upgradeTupled> =
  Tuple(_bytesSeq)

type IcCumulus_pallet_parachain_systemPalletError =
  | { tag: "OverlappingUpgrades"; value: undefined }
  | { tag: "ProhibitedByPolkadot"; value: undefined }
  | { tag: "TooBig"; value: undefined }
  | { tag: "ValidationDataNotAvailable"; value: undefined }
  | { tag: "HostConfigurationNotAvailable"; value: undefined }
  | { tag: "NotScheduled"; value: undefined }
  | { tag: "NothingAuthorized"; value: undefined }
  | { tag: "Unauthorized"; value: undefined }
const cCumulus_pallet_parachain_systemPalletError: Codec<IcCumulus_pallet_parachain_systemPalletError> =
  Enum({
    OverlappingUpgrades: _void,
    ProhibitedByPolkadot: _void,
    TooBig: _void,
    ValidationDataNotAvailable: _void,
    HostConfigurationNotAvailable: _void,
    NotScheduled: _void,
    NothingAuthorized: _void,
    Unauthorized: _void,
  })

type IcCumulus_pallet_parachain_systemPalletErrorOverlappingUpgrades = undefined
const cCumulus_pallet_parachain_systemPalletErrorOverlappingUpgrades: Codec<IcCumulus_pallet_parachain_systemPalletErrorOverlappingUpgrades> =
  _void

type IcCumulus_pallet_parachain_systemPalletErrorProhibitedByPolkadot =
  undefined
const cCumulus_pallet_parachain_systemPalletErrorProhibitedByPolkadot: Codec<IcCumulus_pallet_parachain_systemPalletErrorProhibitedByPolkadot> =
  _void

type IcCumulus_pallet_parachain_systemPalletErrorTooBig = undefined
const cCumulus_pallet_parachain_systemPalletErrorTooBig: Codec<IcCumulus_pallet_parachain_systemPalletErrorTooBig> =
  _void

type IcCumulus_pallet_parachain_systemPalletErrorValidationDataNotAvailable =
  undefined
const cCumulus_pallet_parachain_systemPalletErrorValidationDataNotAvailable: Codec<IcCumulus_pallet_parachain_systemPalletErrorValidationDataNotAvailable> =
  _void

type IcCumulus_pallet_parachain_systemPalletErrorHostConfigurationNotAvailable =
  undefined
const cCumulus_pallet_parachain_systemPalletErrorHostConfigurationNotAvailable: Codec<IcCumulus_pallet_parachain_systemPalletErrorHostConfigurationNotAvailable> =
  _void

type IcCumulus_pallet_parachain_systemPalletErrorNotScheduled = undefined
const cCumulus_pallet_parachain_systemPalletErrorNotScheduled: Codec<IcCumulus_pallet_parachain_systemPalletErrorNotScheduled> =
  _void

type IcCumulus_pallet_parachain_systemPalletErrorNothingAuthorized = undefined
const cCumulus_pallet_parachain_systemPalletErrorNothingAuthorized: Codec<IcCumulus_pallet_parachain_systemPalletErrorNothingAuthorized> =
  _void

type IcCumulus_pallet_parachain_systemPalletErrorUnauthorized = undefined
const cCumulus_pallet_parachain_systemPalletErrorUnauthorized: Codec<IcCumulus_pallet_parachain_systemPalletErrorUnauthorized> =
  _void

type IcCumulus_pallet_parachain_systemPalletEventValidationFunctionStored =
  undefined
const cCumulus_pallet_parachain_systemPalletEventValidationFunctionStored: Codec<IcCumulus_pallet_parachain_systemPalletEventValidationFunctionStored> =
  _void

type IcCumulus_pallet_parachain_systemPalletEventValidationFunctionDiscarded =
  undefined
const cCumulus_pallet_parachain_systemPalletEventValidationFunctionDiscarded: Codec<IcCumulus_pallet_parachain_systemPalletEventValidationFunctionDiscarded> =
  _void

type IcPallet_timestampPalletCallSetTupled = [Now: bigint]
const cPallet_timestampPalletCallSetTupled: Codec<IcPallet_timestampPalletCallSetTupled> =
  Tuple(compactBn)

type IcPallet_root_testingPalletCallFill_blockTupled = [Ratio: number]
const cPallet_root_testingPalletCallFill_blockTupled: Codec<IcPallet_root_testingPalletCallFill_blockTupled> =
  Tuple(u32)

type IcPallet_balancesTypesReasons =
  | { tag: "Fee"; value: undefined }
  | { tag: "Misc"; value: undefined }
  | { tag: "All"; value: undefined }
const cPallet_balancesTypesReasons: Codec<IcPallet_balancesTypesReasons> = Enum(
  { Fee: _void, Misc: _void, All: _void },
)

type IcPallet_balancesTypesBalanceLock = {
  id: Icdc154
  amount: bigint
  reasons: IcPallet_balancesTypesReasons
}
const cPallet_balancesTypesBalanceLock: Codec<IcPallet_balancesTypesBalanceLock> =
  Struct({ id: cdc154, amount: u128, reasons: cPallet_balancesTypesReasons })

type Icdc383 = Array<IcPallet_balancesTypesBalanceLock>
const cdc383: Codec<Icdc383> = Vector(cPallet_balancesTypesBalanceLock)

type IcPallet_balancesTypesReserveData = { id: Icdc18; amount: bigint }
const cPallet_balancesTypesReserveData: Codec<IcPallet_balancesTypesReserveData> =
  Struct({ id: cdc18, amount: u128 })

type Icdc386 = Array<IcPallet_balancesTypesReserveData>
const cdc386: Codec<Icdc386> = Vector(cPallet_balancesTypesReserveData)

type IcPallet_balancesTypesIdAmount = { id: undefined; amount: bigint }
const cPallet_balancesTypesIdAmount: Codec<IcPallet_balancesTypesIdAmount> =
  Struct({ id: _void, amount: u128 })

type Icdc389 = Array<IcPallet_balancesTypesIdAmount>
const cdc389: Codec<Icdc389> = Vector(cPallet_balancesTypesIdAmount)

type IcPallet_balancesPalletCallTransfer_allow_deathTupled = [
  Dest: Icdc1,
  Value: bigint,
]
const cPallet_balancesPalletCallTransfer_allow_deathTupled: Codec<IcPallet_balancesPalletCallTransfer_allow_deathTupled> =
  Tuple(cdc1, compactBn)

type IcPallet_balancesPalletCallSet_balance_deprecatedTupled = [
  Who: Icdc1,
  New_free: bigint,
  Old_reserved: bigint,
]
const cPallet_balancesPalletCallSet_balance_deprecatedTupled: Codec<IcPallet_balancesPalletCallSet_balance_deprecatedTupled> =
  Tuple(cdc1, compactBn, compactBn)

type IcPallet_balancesPalletCallForce_transferTupled = [
  Source: Icdc1,
  Dest: Icdc1,
  Value: bigint,
]
const cPallet_balancesPalletCallForce_transferTupled: Codec<IcPallet_balancesPalletCallForce_transferTupled> =
  Tuple(cdc1, cdc1, compactBn)

type IcPallet_balancesPalletCallTransfer_keep_aliveTupled = [
  Dest: Icdc1,
  Value: bigint,
]
const cPallet_balancesPalletCallTransfer_keep_aliveTupled: Codec<IcPallet_balancesPalletCallTransfer_keep_aliveTupled> =
  Tuple(cdc1, compactBn)

type IcPallet_balancesPalletCallTransfer_allTupled = [
  Dest: Icdc1,
  Keep_alive: boolean,
]
const cPallet_balancesPalletCallTransfer_allTupled: Codec<IcPallet_balancesPalletCallTransfer_allTupled> =
  Tuple(cdc1, bool)

type IcPallet_balancesPalletCallForce_unreserveTupled = [
  Who: Icdc1,
  Amount: bigint,
]
const cPallet_balancesPalletCallForce_unreserveTupled: Codec<IcPallet_balancesPalletCallForce_unreserveTupled> =
  Tuple(cdc1, u128)

type Icdc109 = Array<Icdc1>
const cdc109: Codec<Icdc109> = Vector(cdc1)

type IcPallet_balancesPalletCallUpgrade_accountsTupled = [Who: Icdc109]
const cPallet_balancesPalletCallUpgrade_accountsTupled: Codec<IcPallet_balancesPalletCallUpgrade_accountsTupled> =
  Tuple(cdc109)

type IcPallet_balancesPalletCallTransferTupled = [Dest: Icdc1, Value: bigint]
const cPallet_balancesPalletCallTransferTupled: Codec<IcPallet_balancesPalletCallTransferTupled> =
  Tuple(cdc1, compactBn)

type IcPallet_balancesPalletCallForce_set_balanceTupled = [
  Who: Icdc1,
  New_free: bigint,
]
const cPallet_balancesPalletCallForce_set_balanceTupled: Codec<IcPallet_balancesPalletCallForce_set_balanceTupled> =
  Tuple(cdc1, compactBn)

type IcPallet_balancesPalletError =
  | { tag: "VestingBalance"; value: undefined }
  | { tag: "LiquidityRestrictions"; value: undefined }
  | { tag: "InsufficientBalance"; value: undefined }
  | { tag: "ExistentialDeposit"; value: undefined }
  | { tag: "Expendability"; value: undefined }
  | { tag: "ExistingVestingSchedule"; value: undefined }
  | { tag: "DeadAccount"; value: undefined }
  | { tag: "TooManyReserves"; value: undefined }
  | { tag: "TooManyHolds"; value: undefined }
  | { tag: "TooManyFreezes"; value: undefined }
const cPallet_balancesPalletError: Codec<IcPallet_balancesPalletError> = Enum({
  VestingBalance: _void,
  LiquidityRestrictions: _void,
  InsufficientBalance: _void,
  ExistentialDeposit: _void,
  Expendability: _void,
  ExistingVestingSchedule: _void,
  DeadAccount: _void,
  TooManyReserves: _void,
  TooManyHolds: _void,
  TooManyFreezes: _void,
})

type IcPallet_balancesPalletErrorVestingBalance = undefined
const cPallet_balancesPalletErrorVestingBalance: Codec<IcPallet_balancesPalletErrorVestingBalance> =
  _void

type IcPallet_balancesPalletErrorLiquidityRestrictions = undefined
const cPallet_balancesPalletErrorLiquidityRestrictions: Codec<IcPallet_balancesPalletErrorLiquidityRestrictions> =
  _void

type IcPallet_balancesPalletErrorInsufficientBalance = undefined
const cPallet_balancesPalletErrorInsufficientBalance: Codec<IcPallet_balancesPalletErrorInsufficientBalance> =
  _void

type IcPallet_balancesPalletErrorExistentialDeposit = undefined
const cPallet_balancesPalletErrorExistentialDeposit: Codec<IcPallet_balancesPalletErrorExistentialDeposit> =
  _void

type IcPallet_balancesPalletErrorExpendability = undefined
const cPallet_balancesPalletErrorExpendability: Codec<IcPallet_balancesPalletErrorExpendability> =
  _void

type IcPallet_balancesPalletErrorExistingVestingSchedule = undefined
const cPallet_balancesPalletErrorExistingVestingSchedule: Codec<IcPallet_balancesPalletErrorExistingVestingSchedule> =
  _void

type IcPallet_balancesPalletErrorDeadAccount = undefined
const cPallet_balancesPalletErrorDeadAccount: Codec<IcPallet_balancesPalletErrorDeadAccount> =
  _void

type IcPallet_balancesPalletErrorTooManyReserves = undefined
const cPallet_balancesPalletErrorTooManyReserves: Codec<IcPallet_balancesPalletErrorTooManyReserves> =
  _void

type IcPallet_balancesPalletErrorTooManyHolds = undefined
const cPallet_balancesPalletErrorTooManyHolds: Codec<IcPallet_balancesPalletErrorTooManyHolds> =
  _void

type IcPallet_balancesPalletErrorTooManyFreezes = undefined
const cPallet_balancesPalletErrorTooManyFreezes: Codec<IcPallet_balancesPalletErrorTooManyFreezes> =
  _void

type IcPallet_transaction_paymentReleases =
  | { tag: "V1Ancient"; value: undefined }
  | { tag: "V2"; value: undefined }
const cPallet_transaction_paymentReleases: Codec<IcPallet_transaction_paymentReleases> =
  Enum({ V1Ancient: _void, V2: _void })

type IcPallet_parachain_stakingTypesParachainBondConfig = {
  account: Icdc1
  percent: number
}
const cPallet_parachain_stakingTypesParachainBondConfig: Codec<IcPallet_parachain_stakingTypesParachainBondConfig> =
  Struct({ account: cdc1, percent: u8 })

type IcPallet_parachain_stakingTypesRoundInfo = {
  current: number
  first: number
  length: number
}
const cPallet_parachain_stakingTypesRoundInfo: Codec<IcPallet_parachain_stakingTypesRoundInfo> =
  Struct({ current: u32, first: u32, length: u32 })

type IcPallet_parachain_stakingTypesBond = { owner: Icdc1; amount: bigint }
const cPallet_parachain_stakingTypesBond: Codec<IcPallet_parachain_stakingTypesBond> =
  Struct({ owner: cdc1, amount: u128 })

type Icdc398 = Array<IcPallet_parachain_stakingTypesBond>
const cdc398: Codec<Icdc398> = Vector(cPallet_parachain_stakingTypesBond)

type IcPallet_parachain_stakingTypesDelegatorStatusLeaving = number
const cPallet_parachain_stakingTypesDelegatorStatusLeaving: Codec<IcPallet_parachain_stakingTypesDelegatorStatusLeaving> =
  u32

type IcPallet_parachain_stakingTypesDelegatorStatus =
  | { tag: "Active"; value: undefined }
  | {
      tag: "Leaving"
      value: IcPallet_parachain_stakingTypesDelegatorStatusLeaving
    }
const cPallet_parachain_stakingTypesDelegatorStatus: Codec<IcPallet_parachain_stakingTypesDelegatorStatus> =
  Enum({
    Active: _void,
    Leaving: cPallet_parachain_stakingTypesDelegatorStatusLeaving,
  })

type IcPallet_parachain_stakingTypesDelegator = {
  id: Icdc1
  delegations: Icdc398
  total: bigint
  less_total: bigint
  status: IcPallet_parachain_stakingTypesDelegatorStatus
}
const cPallet_parachain_stakingTypesDelegator: Codec<IcPallet_parachain_stakingTypesDelegator> =
  Struct({
    id: cdc1,
    delegations: cdc398,
    total: u128,
    less_total: u128,
    status: cPallet_parachain_stakingTypesDelegatorStatus,
  })

type IcPallet_parachain_stakingTypesCapacityStatus =
  | { tag: "Full"; value: undefined }
  | { tag: "Empty"; value: undefined }
  | { tag: "Partial"; value: undefined }
const cPallet_parachain_stakingTypesCapacityStatus: Codec<IcPallet_parachain_stakingTypesCapacityStatus> =
  Enum({ Full: _void, Empty: _void, Partial: _void })

type IcPallet_parachain_stakingTypesCollatorStatusLeaving = number
const cPallet_parachain_stakingTypesCollatorStatusLeaving: Codec<IcPallet_parachain_stakingTypesCollatorStatusLeaving> =
  u32

type IcPallet_parachain_stakingTypesCollatorStatus =
  | { tag: "Active"; value: undefined }
  | { tag: "Idle"; value: undefined }
  | {
      tag: "Leaving"
      value: IcPallet_parachain_stakingTypesCollatorStatusLeaving
    }
const cPallet_parachain_stakingTypesCollatorStatus: Codec<IcPallet_parachain_stakingTypesCollatorStatus> =
  Enum({
    Active: _void,
    Idle: _void,
    Leaving: cPallet_parachain_stakingTypesCollatorStatusLeaving,
  })

type IcPallet_parachain_stakingTypesCandidateMetadata = {
  bond: bigint
  delegation_count: number
  total_counted: bigint
  lowest_top_delegation_amount: bigint
  highest_bottom_delegation_amount: bigint
  lowest_bottom_delegation_amount: bigint
  top_capacity: IcPallet_parachain_stakingTypesCapacityStatus
  bottom_capacity: IcPallet_parachain_stakingTypesCapacityStatus
  request: IcOption
  status: IcPallet_parachain_stakingTypesCollatorStatus
}
const cPallet_parachain_stakingTypesCandidateMetadata: Codec<IcPallet_parachain_stakingTypesCandidateMetadata> =
  Struct({
    bond: u128,
    delegation_count: u32,
    total_counted: u128,
    lowest_top_delegation_amount: u128,
    highest_bottom_delegation_amount: u128,
    lowest_bottom_delegation_amount: u128,
    top_capacity: cPallet_parachain_stakingTypesCapacityStatus,
    bottom_capacity: cPallet_parachain_stakingTypesCapacityStatus,
    request: cOption,
    status: cPallet_parachain_stakingTypesCollatorStatus,
  })

type IcPallet_parachain_stakingDelegation_requestsScheduledRequest = {
  delegator: Icdc1
  when_executable: number
  action: IcPallet_parachain_stakingDelegation_requestsDelegationAction
}
const cPallet_parachain_stakingDelegation_requestsScheduledRequest: Codec<IcPallet_parachain_stakingDelegation_requestsScheduledRequest> =
  Struct({
    delegator: cdc1,
    when_executable: u32,
    action: cPallet_parachain_stakingDelegation_requestsDelegationAction,
  })

type Icdc407 =
  Array<IcPallet_parachain_stakingDelegation_requestsScheduledRequest>
const cdc407: Codec<Icdc407> = Vector(
  cPallet_parachain_stakingDelegation_requestsScheduledRequest,
)

type IcPallet_parachain_stakingAuto_compoundAutoCompoundConfig = {
  delegator: Icdc1
  value: number
}
const cPallet_parachain_stakingAuto_compoundAutoCompoundConfig: Codec<IcPallet_parachain_stakingAuto_compoundAutoCompoundConfig> =
  Struct({ delegator: cdc1, value: u8 })

type Icdc410 = Array<IcPallet_parachain_stakingAuto_compoundAutoCompoundConfig>
const cdc410: Codec<Icdc410> = Vector(
  cPallet_parachain_stakingAuto_compoundAutoCompoundConfig,
)

type IcPallet_parachain_stakingTypesDelegations = {
  delegations: Icdc398
  total: bigint
}
const cPallet_parachain_stakingTypesDelegations: Codec<IcPallet_parachain_stakingTypesDelegations> =
  Struct({ delegations: cdc398, total: u128 })

type IcPallet_parachain_stakingTypesBondWithAutoCompound = {
  owner: Icdc1
  amount: bigint
  auto_compound: number
}
const cPallet_parachain_stakingTypesBondWithAutoCompound: Codec<IcPallet_parachain_stakingTypesBondWithAutoCompound> =
  Struct({ owner: cdc1, amount: u128, auto_compound: u8 })

type Icdc417 = Array<IcPallet_parachain_stakingTypesBondWithAutoCompound>
const cdc417: Codec<Icdc417> = Vector(
  cPallet_parachain_stakingTypesBondWithAutoCompound,
)

type IcPallet_parachain_stakingTypesCollatorSnapshot = {
  bond: bigint
  delegations: Icdc417
  total: bigint
}
const cPallet_parachain_stakingTypesCollatorSnapshot: Codec<IcPallet_parachain_stakingTypesCollatorSnapshot> =
  Struct({ bond: u128, delegations: cdc417, total: u128 })

type Icdc415 = [number, Icdc1]
const cdc415: Codec<Icdc415> = Tuple(u32, cdc1)

type IcPallet_parachain_stakingTypesDelayedPayout = {
  round_issuance: bigint
  total_staking_reward: bigint
  collator_commission: number
}
const cPallet_parachain_stakingTypesDelayedPayout: Codec<IcPallet_parachain_stakingTypesDelayedPayout> =
  Struct({
    round_issuance: u128,
    total_staking_reward: u128,
    collator_commission: u32,
  })

type IcPallet_parachain_stakingInflationRange = {
  min: bigint
  ideal: bigint
  max: bigint
}
const cPallet_parachain_stakingInflationRange: Codec<IcPallet_parachain_stakingInflationRange> =
  Struct({ min: u128, ideal: u128, max: u128 })

type IcPallet_parachain_stakingInflationInflationInfo = {
  expect: IcPallet_parachain_stakingInflationRange
  annual: IcPallet_parachain_stakingInflationRange
  round: IcPallet_parachain_stakingInflationRange
}
const cPallet_parachain_stakingInflationInflationInfo: Codec<IcPallet_parachain_stakingInflationInflationInfo> =
  Struct({
    expect: cPallet_parachain_stakingInflationRange,
    annual: cPallet_parachain_stakingInflationRange,
    round: cPallet_parachain_stakingInflationRange,
  })

type IcPallet_parachain_stakingPalletCallSet_staking_expectationsTupled = [
  Expectations: IcPallet_parachain_stakingInflationRange,
]
const cPallet_parachain_stakingPalletCallSet_staking_expectationsTupled: Codec<IcPallet_parachain_stakingPalletCallSet_staking_expectationsTupled> =
  Tuple(cPallet_parachain_stakingInflationRange)

type IcPallet_parachain_stakingPalletCallSet_inflationTupled = [
  Schedule: IcPallet_parachain_stakingInflationRange,
]
const cPallet_parachain_stakingPalletCallSet_inflationTupled: Codec<IcPallet_parachain_stakingPalletCallSet_inflationTupled> =
  Tuple(cPallet_parachain_stakingInflationRange)

type IcPallet_parachain_stakingPalletCallSet_parachain_bond_accountTupled = [
  New: Icdc1,
]
const cPallet_parachain_stakingPalletCallSet_parachain_bond_accountTupled: Codec<IcPallet_parachain_stakingPalletCallSet_parachain_bond_accountTupled> =
  Tuple(cdc1)

type IcPallet_parachain_stakingPalletCallSet_parachain_bond_reserve_percentTupled =
  [New: number]
const cPallet_parachain_stakingPalletCallSet_parachain_bond_reserve_percentTupled: Codec<IcPallet_parachain_stakingPalletCallSet_parachain_bond_reserve_percentTupled> =
  Tuple(u8)

type IcPallet_parachain_stakingPalletCallSet_total_selectedTupled = [
  New: number,
]
const cPallet_parachain_stakingPalletCallSet_total_selectedTupled: Codec<IcPallet_parachain_stakingPalletCallSet_total_selectedTupled> =
  Tuple(u32)

type IcPallet_parachain_stakingPalletCallSet_collator_commissionTupled = [
  New: number,
]
const cPallet_parachain_stakingPalletCallSet_collator_commissionTupled: Codec<IcPallet_parachain_stakingPalletCallSet_collator_commissionTupled> =
  Tuple(u32)

type IcPallet_parachain_stakingPalletCallSet_blocks_per_roundTupled = [
  New: number,
]
const cPallet_parachain_stakingPalletCallSet_blocks_per_roundTupled: Codec<IcPallet_parachain_stakingPalletCallSet_blocks_per_roundTupled> =
  Tuple(u32)

type IcPallet_parachain_stakingPalletCallJoin_candidatesTupled = [
  Bond: bigint,
  Candidate_count: number,
]
const cPallet_parachain_stakingPalletCallJoin_candidatesTupled: Codec<IcPallet_parachain_stakingPalletCallJoin_candidatesTupled> =
  Tuple(u128, u32)

type IcPallet_parachain_stakingPalletCallSchedule_leave_candidatesTupled = [
  Candidate_count: number,
]
const cPallet_parachain_stakingPalletCallSchedule_leave_candidatesTupled: Codec<IcPallet_parachain_stakingPalletCallSchedule_leave_candidatesTupled> =
  Tuple(u32)

type IcPallet_parachain_stakingPalletCallExecute_leave_candidatesTupled = [
  Candidate: Icdc1,
  Candidate_delegation_count: number,
]
const cPallet_parachain_stakingPalletCallExecute_leave_candidatesTupled: Codec<IcPallet_parachain_stakingPalletCallExecute_leave_candidatesTupled> =
  Tuple(cdc1, u32)

type IcPallet_parachain_stakingPalletCallCancel_leave_candidatesTupled = [
  Candidate_count: number,
]
const cPallet_parachain_stakingPalletCallCancel_leave_candidatesTupled: Codec<IcPallet_parachain_stakingPalletCallCancel_leave_candidatesTupled> =
  Tuple(u32)

type IcPallet_parachain_stakingPalletCallCandidate_bond_moreTupled = [
  More: bigint,
]
const cPallet_parachain_stakingPalletCallCandidate_bond_moreTupled: Codec<IcPallet_parachain_stakingPalletCallCandidate_bond_moreTupled> =
  Tuple(u128)

type IcPallet_parachain_stakingPalletCallSchedule_candidate_bond_lessTupled = [
  Less: bigint,
]
const cPallet_parachain_stakingPalletCallSchedule_candidate_bond_lessTupled: Codec<IcPallet_parachain_stakingPalletCallSchedule_candidate_bond_lessTupled> =
  Tuple(u128)

type IcPallet_parachain_stakingPalletCallExecute_candidate_bond_lessTupled = [
  Candidate: Icdc1,
]
const cPallet_parachain_stakingPalletCallExecute_candidate_bond_lessTupled: Codec<IcPallet_parachain_stakingPalletCallExecute_candidate_bond_lessTupled> =
  Tuple(cdc1)

type IcPallet_parachain_stakingPalletCallDelegateTupled = [
  Candidate: Icdc1,
  Amount: bigint,
  Candidate_delegation_count: number,
  Delegation_count: number,
]
const cPallet_parachain_stakingPalletCallDelegateTupled: Codec<IcPallet_parachain_stakingPalletCallDelegateTupled> =
  Tuple(cdc1, u128, u32, u32)

type IcPallet_parachain_stakingPalletCallDelegate_with_auto_compoundTupled = [
  Candidate: Icdc1,
  Amount: bigint,
  Auto_compound: number,
  Candidate_delegation_count: number,
  Candidate_auto_compounding_delegation_count: number,
  Delegation_count: number,
]
const cPallet_parachain_stakingPalletCallDelegate_with_auto_compoundTupled: Codec<IcPallet_parachain_stakingPalletCallDelegate_with_auto_compoundTupled> =
  Tuple(cdc1, u128, u8, u32, u32, u32)

type IcPallet_parachain_stakingPalletCallSchedule_revoke_delegationTupled = [
  Collator: Icdc1,
]
const cPallet_parachain_stakingPalletCallSchedule_revoke_delegationTupled: Codec<IcPallet_parachain_stakingPalletCallSchedule_revoke_delegationTupled> =
  Tuple(cdc1)

type IcPallet_parachain_stakingPalletCallDelegator_bond_moreTupled = [
  Candidate: Icdc1,
  More: bigint,
]
const cPallet_parachain_stakingPalletCallDelegator_bond_moreTupled: Codec<IcPallet_parachain_stakingPalletCallDelegator_bond_moreTupled> =
  Tuple(cdc1, u128)

type IcPallet_parachain_stakingPalletCallSchedule_delegator_bond_lessTupled = [
  Candidate: Icdc1,
  Less: bigint,
]
const cPallet_parachain_stakingPalletCallSchedule_delegator_bond_lessTupled: Codec<IcPallet_parachain_stakingPalletCallSchedule_delegator_bond_lessTupled> =
  Tuple(cdc1, u128)

type IcPallet_parachain_stakingPalletCallExecute_delegation_requestTupled = [
  Delegator: Icdc1,
  Candidate: Icdc1,
]
const cPallet_parachain_stakingPalletCallExecute_delegation_requestTupled: Codec<IcPallet_parachain_stakingPalletCallExecute_delegation_requestTupled> =
  Tuple(cdc1, cdc1)

type IcPallet_parachain_stakingPalletCallCancel_delegation_requestTupled = [
  Candidate: Icdc1,
]
const cPallet_parachain_stakingPalletCallCancel_delegation_requestTupled: Codec<IcPallet_parachain_stakingPalletCallCancel_delegation_requestTupled> =
  Tuple(cdc1)

type IcPallet_parachain_stakingPalletCallSet_auto_compoundTupled = [
  Candidate: Icdc1,
  Value: number,
  Candidate_auto_compounding_delegation_count_hint: number,
  Delegation_count_hint: number,
]
const cPallet_parachain_stakingPalletCallSet_auto_compoundTupled: Codec<IcPallet_parachain_stakingPalletCallSet_auto_compoundTupled> =
  Tuple(cdc1, u8, u32, u32)

type IcPallet_parachain_stakingPalletCallHotfix_remove_delegation_requests_exited_candidatesTupled =
  [Candidates: Icdc109]
const cPallet_parachain_stakingPalletCallHotfix_remove_delegation_requests_exited_candidatesTupled: Codec<IcPallet_parachain_stakingPalletCallHotfix_remove_delegation_requests_exited_candidatesTupled> =
  Tuple(cdc109)

type IcPallet_parachain_stakingPalletError =
  | { tag: "DelegatorDNE"; value: undefined }
  | { tag: "DelegatorDNEinTopNorBottom"; value: undefined }
  | { tag: "DelegatorDNEInDelegatorSet"; value: undefined }
  | { tag: "CandidateDNE"; value: undefined }
  | { tag: "DelegationDNE"; value: undefined }
  | { tag: "DelegatorExists"; value: undefined }
  | { tag: "CandidateExists"; value: undefined }
  | { tag: "CandidateBondBelowMin"; value: undefined }
  | { tag: "InsufficientBalance"; value: undefined }
  | { tag: "DelegatorBondBelowMin"; value: undefined }
  | { tag: "DelegationBelowMin"; value: undefined }
  | { tag: "AlreadyOffline"; value: undefined }
  | { tag: "AlreadyActive"; value: undefined }
  | { tag: "DelegatorAlreadyLeaving"; value: undefined }
  | { tag: "DelegatorNotLeaving"; value: undefined }
  | { tag: "DelegatorCannotLeaveYet"; value: undefined }
  | { tag: "CannotDelegateIfLeaving"; value: undefined }
  | { tag: "CandidateAlreadyLeaving"; value: undefined }
  | { tag: "CandidateNotLeaving"; value: undefined }
  | { tag: "CandidateCannotLeaveYet"; value: undefined }
  | { tag: "CannotGoOnlineIfLeaving"; value: undefined }
  | { tag: "ExceedMaxDelegationsPerDelegator"; value: undefined }
  | { tag: "AlreadyDelegatedCandidate"; value: undefined }
  | { tag: "InvalidSchedule"; value: undefined }
  | { tag: "CannotSetBelowMin"; value: undefined }
  | {
      tag: "RoundLengthMustBeGreaterThanTotalSelectedCollators"
      value: undefined
    }
  | { tag: "NoWritingSameValue"; value: undefined }
  | { tag: "TooLowCandidateCountWeightHintJoinCandidates"; value: undefined }
  | {
      tag: "TooLowCandidateCountWeightHintCancelLeaveCandidates"
      value: undefined
    }
  | { tag: "TooLowCandidateCountToLeaveCandidates"; value: undefined }
  | { tag: "TooLowDelegationCountToDelegate"; value: undefined }
  | { tag: "TooLowCandidateDelegationCountToDelegate"; value: undefined }
  | { tag: "TooLowCandidateDelegationCountToLeaveCandidates"; value: undefined }
  | { tag: "TooLowDelegationCountToLeaveDelegators"; value: undefined }
  | { tag: "PendingCandidateRequestsDNE"; value: undefined }
  | { tag: "PendingCandidateRequestAlreadyExists"; value: undefined }
  | { tag: "PendingCandidateRequestNotDueYet"; value: undefined }
  | { tag: "PendingDelegationRequestDNE"; value: undefined }
  | { tag: "PendingDelegationRequestAlreadyExists"; value: undefined }
  | { tag: "PendingDelegationRequestNotDueYet"; value: undefined }
  | {
      tag: "CannotDelegateLessThanOrEqualToLowestBottomWhenFull"
      value: undefined
    }
  | { tag: "PendingDelegationRevoke"; value: undefined }
  | { tag: "TooLowDelegationCountToAutoCompound"; value: undefined }
  | {
      tag: "TooLowCandidateAutoCompoundingDelegationCountToAutoCompound"
      value: undefined
    }
  | {
      tag: "TooLowCandidateAutoCompoundingDelegationCountToDelegate"
      value: undefined
    }
  | {
      tag: "TooLowCandidateAutoCompoundingDelegationCountToLeaveCandidates"
      value: undefined
    }
  | { tag: "TooLowCandidateCountWeightHint"; value: undefined }
  | { tag: "TooLowCandidateCountWeightHintGoOffline"; value: undefined }
  | { tag: "CandidateLimitReached"; value: undefined }
  | { tag: "CannotSetAboveMaxCandidates"; value: undefined }
  | { tag: "RemovedCall"; value: undefined }
const cPallet_parachain_stakingPalletError: Codec<IcPallet_parachain_stakingPalletError> =
  Enum({
    DelegatorDNE: _void,
    DelegatorDNEinTopNorBottom: _void,
    DelegatorDNEInDelegatorSet: _void,
    CandidateDNE: _void,
    DelegationDNE: _void,
    DelegatorExists: _void,
    CandidateExists: _void,
    CandidateBondBelowMin: _void,
    InsufficientBalance: _void,
    DelegatorBondBelowMin: _void,
    DelegationBelowMin: _void,
    AlreadyOffline: _void,
    AlreadyActive: _void,
    DelegatorAlreadyLeaving: _void,
    DelegatorNotLeaving: _void,
    DelegatorCannotLeaveYet: _void,
    CannotDelegateIfLeaving: _void,
    CandidateAlreadyLeaving: _void,
    CandidateNotLeaving: _void,
    CandidateCannotLeaveYet: _void,
    CannotGoOnlineIfLeaving: _void,
    ExceedMaxDelegationsPerDelegator: _void,
    AlreadyDelegatedCandidate: _void,
    InvalidSchedule: _void,
    CannotSetBelowMin: _void,
    RoundLengthMustBeGreaterThanTotalSelectedCollators: _void,
    NoWritingSameValue: _void,
    TooLowCandidateCountWeightHintJoinCandidates: _void,
    TooLowCandidateCountWeightHintCancelLeaveCandidates: _void,
    TooLowCandidateCountToLeaveCandidates: _void,
    TooLowDelegationCountToDelegate: _void,
    TooLowCandidateDelegationCountToDelegate: _void,
    TooLowCandidateDelegationCountToLeaveCandidates: _void,
    TooLowDelegationCountToLeaveDelegators: _void,
    PendingCandidateRequestsDNE: _void,
    PendingCandidateRequestAlreadyExists: _void,
    PendingCandidateRequestNotDueYet: _void,
    PendingDelegationRequestDNE: _void,
    PendingDelegationRequestAlreadyExists: _void,
    PendingDelegationRequestNotDueYet: _void,
    CannotDelegateLessThanOrEqualToLowestBottomWhenFull: _void,
    PendingDelegationRevoke: _void,
    TooLowDelegationCountToAutoCompound: _void,
    TooLowCandidateAutoCompoundingDelegationCountToAutoCompound: _void,
    TooLowCandidateAutoCompoundingDelegationCountToDelegate: _void,
    TooLowCandidateAutoCompoundingDelegationCountToLeaveCandidates: _void,
    TooLowCandidateCountWeightHint: _void,
    TooLowCandidateCountWeightHintGoOffline: _void,
    CandidateLimitReached: _void,
    CannotSetAboveMaxCandidates: _void,
    RemovedCall: _void,
  })

type IcPallet_parachain_stakingPalletErrorDelegatorDNE = undefined
const cPallet_parachain_stakingPalletErrorDelegatorDNE: Codec<IcPallet_parachain_stakingPalletErrorDelegatorDNE> =
  _void

type IcPallet_parachain_stakingPalletErrorDelegatorDNEinTopNorBottom = undefined
const cPallet_parachain_stakingPalletErrorDelegatorDNEinTopNorBottom: Codec<IcPallet_parachain_stakingPalletErrorDelegatorDNEinTopNorBottom> =
  _void

type IcPallet_parachain_stakingPalletErrorDelegatorDNEInDelegatorSet = undefined
const cPallet_parachain_stakingPalletErrorDelegatorDNEInDelegatorSet: Codec<IcPallet_parachain_stakingPalletErrorDelegatorDNEInDelegatorSet> =
  _void

type IcPallet_parachain_stakingPalletErrorCandidateDNE = undefined
const cPallet_parachain_stakingPalletErrorCandidateDNE: Codec<IcPallet_parachain_stakingPalletErrorCandidateDNE> =
  _void

type IcPallet_parachain_stakingPalletErrorDelegationDNE = undefined
const cPallet_parachain_stakingPalletErrorDelegationDNE: Codec<IcPallet_parachain_stakingPalletErrorDelegationDNE> =
  _void

type IcPallet_parachain_stakingPalletErrorDelegatorExists = undefined
const cPallet_parachain_stakingPalletErrorDelegatorExists: Codec<IcPallet_parachain_stakingPalletErrorDelegatorExists> =
  _void

type IcPallet_parachain_stakingPalletErrorCandidateExists = undefined
const cPallet_parachain_stakingPalletErrorCandidateExists: Codec<IcPallet_parachain_stakingPalletErrorCandidateExists> =
  _void

type IcPallet_parachain_stakingPalletErrorCandidateBondBelowMin = undefined
const cPallet_parachain_stakingPalletErrorCandidateBondBelowMin: Codec<IcPallet_parachain_stakingPalletErrorCandidateBondBelowMin> =
  _void

type IcPallet_parachain_stakingPalletErrorInsufficientBalance = undefined
const cPallet_parachain_stakingPalletErrorInsufficientBalance: Codec<IcPallet_parachain_stakingPalletErrorInsufficientBalance> =
  _void

type IcPallet_parachain_stakingPalletErrorDelegatorBondBelowMin = undefined
const cPallet_parachain_stakingPalletErrorDelegatorBondBelowMin: Codec<IcPallet_parachain_stakingPalletErrorDelegatorBondBelowMin> =
  _void

type IcPallet_parachain_stakingPalletErrorDelegationBelowMin = undefined
const cPallet_parachain_stakingPalletErrorDelegationBelowMin: Codec<IcPallet_parachain_stakingPalletErrorDelegationBelowMin> =
  _void

type IcPallet_parachain_stakingPalletErrorAlreadyOffline = undefined
const cPallet_parachain_stakingPalletErrorAlreadyOffline: Codec<IcPallet_parachain_stakingPalletErrorAlreadyOffline> =
  _void

type IcPallet_parachain_stakingPalletErrorAlreadyActive = undefined
const cPallet_parachain_stakingPalletErrorAlreadyActive: Codec<IcPallet_parachain_stakingPalletErrorAlreadyActive> =
  _void

type IcPallet_parachain_stakingPalletErrorDelegatorAlreadyLeaving = undefined
const cPallet_parachain_stakingPalletErrorDelegatorAlreadyLeaving: Codec<IcPallet_parachain_stakingPalletErrorDelegatorAlreadyLeaving> =
  _void

type IcPallet_parachain_stakingPalletErrorDelegatorNotLeaving = undefined
const cPallet_parachain_stakingPalletErrorDelegatorNotLeaving: Codec<IcPallet_parachain_stakingPalletErrorDelegatorNotLeaving> =
  _void

type IcPallet_parachain_stakingPalletErrorDelegatorCannotLeaveYet = undefined
const cPallet_parachain_stakingPalletErrorDelegatorCannotLeaveYet: Codec<IcPallet_parachain_stakingPalletErrorDelegatorCannotLeaveYet> =
  _void

type IcPallet_parachain_stakingPalletErrorCannotDelegateIfLeaving = undefined
const cPallet_parachain_stakingPalletErrorCannotDelegateIfLeaving: Codec<IcPallet_parachain_stakingPalletErrorCannotDelegateIfLeaving> =
  _void

type IcPallet_parachain_stakingPalletErrorCandidateAlreadyLeaving = undefined
const cPallet_parachain_stakingPalletErrorCandidateAlreadyLeaving: Codec<IcPallet_parachain_stakingPalletErrorCandidateAlreadyLeaving> =
  _void

type IcPallet_parachain_stakingPalletErrorCandidateNotLeaving = undefined
const cPallet_parachain_stakingPalletErrorCandidateNotLeaving: Codec<IcPallet_parachain_stakingPalletErrorCandidateNotLeaving> =
  _void

type IcPallet_parachain_stakingPalletErrorCandidateCannotLeaveYet = undefined
const cPallet_parachain_stakingPalletErrorCandidateCannotLeaveYet: Codec<IcPallet_parachain_stakingPalletErrorCandidateCannotLeaveYet> =
  _void

type IcPallet_parachain_stakingPalletErrorCannotGoOnlineIfLeaving = undefined
const cPallet_parachain_stakingPalletErrorCannotGoOnlineIfLeaving: Codec<IcPallet_parachain_stakingPalletErrorCannotGoOnlineIfLeaving> =
  _void

type IcPallet_parachain_stakingPalletErrorExceedMaxDelegationsPerDelegator =
  undefined
const cPallet_parachain_stakingPalletErrorExceedMaxDelegationsPerDelegator: Codec<IcPallet_parachain_stakingPalletErrorExceedMaxDelegationsPerDelegator> =
  _void

type IcPallet_parachain_stakingPalletErrorAlreadyDelegatedCandidate = undefined
const cPallet_parachain_stakingPalletErrorAlreadyDelegatedCandidate: Codec<IcPallet_parachain_stakingPalletErrorAlreadyDelegatedCandidate> =
  _void

type IcPallet_parachain_stakingPalletErrorInvalidSchedule = undefined
const cPallet_parachain_stakingPalletErrorInvalidSchedule: Codec<IcPallet_parachain_stakingPalletErrorInvalidSchedule> =
  _void

type IcPallet_parachain_stakingPalletErrorCannotSetBelowMin = undefined
const cPallet_parachain_stakingPalletErrorCannotSetBelowMin: Codec<IcPallet_parachain_stakingPalletErrorCannotSetBelowMin> =
  _void

type IcPallet_parachain_stakingPalletErrorRoundLengthMustBeGreaterThanTotalSelectedCollators =
  undefined
const cPallet_parachain_stakingPalletErrorRoundLengthMustBeGreaterThanTotalSelectedCollators: Codec<IcPallet_parachain_stakingPalletErrorRoundLengthMustBeGreaterThanTotalSelectedCollators> =
  _void

type IcPallet_parachain_stakingPalletErrorNoWritingSameValue = undefined
const cPallet_parachain_stakingPalletErrorNoWritingSameValue: Codec<IcPallet_parachain_stakingPalletErrorNoWritingSameValue> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowCandidateCountWeightHintJoinCandidates =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowCandidateCountWeightHintJoinCandidates: Codec<IcPallet_parachain_stakingPalletErrorTooLowCandidateCountWeightHintJoinCandidates> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowCandidateCountWeightHintCancelLeaveCandidates =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowCandidateCountWeightHintCancelLeaveCandidates: Codec<IcPallet_parachain_stakingPalletErrorTooLowCandidateCountWeightHintCancelLeaveCandidates> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowCandidateCountToLeaveCandidates =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowCandidateCountToLeaveCandidates: Codec<IcPallet_parachain_stakingPalletErrorTooLowCandidateCountToLeaveCandidates> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowDelegationCountToDelegate =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowDelegationCountToDelegate: Codec<IcPallet_parachain_stakingPalletErrorTooLowDelegationCountToDelegate> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowCandidateDelegationCountToDelegate =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowCandidateDelegationCountToDelegate: Codec<IcPallet_parachain_stakingPalletErrorTooLowCandidateDelegationCountToDelegate> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowCandidateDelegationCountToLeaveCandidates =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowCandidateDelegationCountToLeaveCandidates: Codec<IcPallet_parachain_stakingPalletErrorTooLowCandidateDelegationCountToLeaveCandidates> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowDelegationCountToLeaveDelegators =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowDelegationCountToLeaveDelegators: Codec<IcPallet_parachain_stakingPalletErrorTooLowDelegationCountToLeaveDelegators> =
  _void

type IcPallet_parachain_stakingPalletErrorPendingCandidateRequestsDNE =
  undefined
const cPallet_parachain_stakingPalletErrorPendingCandidateRequestsDNE: Codec<IcPallet_parachain_stakingPalletErrorPendingCandidateRequestsDNE> =
  _void

type IcPallet_parachain_stakingPalletErrorPendingCandidateRequestAlreadyExists =
  undefined
const cPallet_parachain_stakingPalletErrorPendingCandidateRequestAlreadyExists: Codec<IcPallet_parachain_stakingPalletErrorPendingCandidateRequestAlreadyExists> =
  _void

type IcPallet_parachain_stakingPalletErrorPendingCandidateRequestNotDueYet =
  undefined
const cPallet_parachain_stakingPalletErrorPendingCandidateRequestNotDueYet: Codec<IcPallet_parachain_stakingPalletErrorPendingCandidateRequestNotDueYet> =
  _void

type IcPallet_parachain_stakingPalletErrorPendingDelegationRequestDNE =
  undefined
const cPallet_parachain_stakingPalletErrorPendingDelegationRequestDNE: Codec<IcPallet_parachain_stakingPalletErrorPendingDelegationRequestDNE> =
  _void

type IcPallet_parachain_stakingPalletErrorPendingDelegationRequestAlreadyExists =
  undefined
const cPallet_parachain_stakingPalletErrorPendingDelegationRequestAlreadyExists: Codec<IcPallet_parachain_stakingPalletErrorPendingDelegationRequestAlreadyExists> =
  _void

type IcPallet_parachain_stakingPalletErrorPendingDelegationRequestNotDueYet =
  undefined
const cPallet_parachain_stakingPalletErrorPendingDelegationRequestNotDueYet: Codec<IcPallet_parachain_stakingPalletErrorPendingDelegationRequestNotDueYet> =
  _void

type IcPallet_parachain_stakingPalletErrorCannotDelegateLessThanOrEqualToLowestBottomWhenFull =
  undefined
const cPallet_parachain_stakingPalletErrorCannotDelegateLessThanOrEqualToLowestBottomWhenFull: Codec<IcPallet_parachain_stakingPalletErrorCannotDelegateLessThanOrEqualToLowestBottomWhenFull> =
  _void

type IcPallet_parachain_stakingPalletErrorPendingDelegationRevoke = undefined
const cPallet_parachain_stakingPalletErrorPendingDelegationRevoke: Codec<IcPallet_parachain_stakingPalletErrorPendingDelegationRevoke> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowDelegationCountToAutoCompound =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowDelegationCountToAutoCompound: Codec<IcPallet_parachain_stakingPalletErrorTooLowDelegationCountToAutoCompound> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowCandidateAutoCompoundingDelegationCountToAutoCompound =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowCandidateAutoCompoundingDelegationCountToAutoCompound: Codec<IcPallet_parachain_stakingPalletErrorTooLowCandidateAutoCompoundingDelegationCountToAutoCompound> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowCandidateAutoCompoundingDelegationCountToDelegate =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowCandidateAutoCompoundingDelegationCountToDelegate: Codec<IcPallet_parachain_stakingPalletErrorTooLowCandidateAutoCompoundingDelegationCountToDelegate> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowCandidateAutoCompoundingDelegationCountToLeaveCandidates =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowCandidateAutoCompoundingDelegationCountToLeaveCandidates: Codec<IcPallet_parachain_stakingPalletErrorTooLowCandidateAutoCompoundingDelegationCountToLeaveCandidates> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowCandidateCountWeightHint =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowCandidateCountWeightHint: Codec<IcPallet_parachain_stakingPalletErrorTooLowCandidateCountWeightHint> =
  _void

type IcPallet_parachain_stakingPalletErrorTooLowCandidateCountWeightHintGoOffline =
  undefined
const cPallet_parachain_stakingPalletErrorTooLowCandidateCountWeightHintGoOffline: Codec<IcPallet_parachain_stakingPalletErrorTooLowCandidateCountWeightHintGoOffline> =
  _void

type IcPallet_parachain_stakingPalletErrorCandidateLimitReached = undefined
const cPallet_parachain_stakingPalletErrorCandidateLimitReached: Codec<IcPallet_parachain_stakingPalletErrorCandidateLimitReached> =
  _void

type IcPallet_parachain_stakingPalletErrorCannotSetAboveMaxCandidates =
  undefined
const cPallet_parachain_stakingPalletErrorCannotSetAboveMaxCandidates: Codec<IcPallet_parachain_stakingPalletErrorCannotSetAboveMaxCandidates> =
  _void

type IcPallet_parachain_stakingPalletErrorRemovedCall = undefined
const cPallet_parachain_stakingPalletErrorRemovedCall: Codec<IcPallet_parachain_stakingPalletErrorRemovedCall> =
  _void

type IcPallet_author_inherentPalletError =
  | { tag: "AuthorAlreadySet"; value: undefined }
  | { tag: "NoAccountId"; value: undefined }
  | { tag: "CannotBeAuthor"; value: undefined }
const cPallet_author_inherentPalletError: Codec<IcPallet_author_inherentPalletError> =
  Enum({ AuthorAlreadySet: _void, NoAccountId: _void, CannotBeAuthor: _void })

type IcPallet_author_inherentPalletErrorAuthorAlreadySet = undefined
const cPallet_author_inherentPalletErrorAuthorAlreadySet: Codec<IcPallet_author_inherentPalletErrorAuthorAlreadySet> =
  _void

type IcPallet_author_inherentPalletErrorNoAccountId = undefined
const cPallet_author_inherentPalletErrorNoAccountId: Codec<IcPallet_author_inherentPalletErrorNoAccountId> =
  _void

type IcPallet_author_inherentPalletErrorCannotBeAuthor = undefined
const cPallet_author_inherentPalletErrorCannotBeAuthor: Codec<IcPallet_author_inherentPalletErrorCannotBeAuthor> =
  _void

type IcPallet_author_slot_filterPalletCallSet_eligibleTupled = [New: number]
const cPallet_author_slot_filterPalletCallSet_eligibleTupled: Codec<IcPallet_author_slot_filterPalletCallSet_eligibleTupled> =
  Tuple(u32)

type IcPallet_author_mappingPalletRegistrationInfo = {
  account: Icdc1
  deposit: bigint
  keys: Icdc13
}
const cPallet_author_mappingPalletRegistrationInfo: Codec<IcPallet_author_mappingPalletRegistrationInfo> =
  Struct({ account: cdc1, deposit: u128, keys: cdc13 })

type IcNimbus_primitivesNimbus_cryptoPublicTupled = [Key: Icdc13]
const cNimbus_primitivesNimbus_cryptoPublicTupled: Codec<IcNimbus_primitivesNimbus_cryptoPublicTupled> =
  Tuple(cdc13)

type IcPallet_author_mappingPalletCallAdd_associationTupled = [
  Nimbus_id: Icdc13,
]
const cPallet_author_mappingPalletCallAdd_associationTupled: Codec<IcPallet_author_mappingPalletCallAdd_associationTupled> =
  Tuple(cdc13)

type IcPallet_author_mappingPalletCallUpdate_associationTupled = [
  Old_nimbus_id: Icdc13,
  New_nimbus_id: Icdc13,
]
const cPallet_author_mappingPalletCallUpdate_associationTupled: Codec<IcPallet_author_mappingPalletCallUpdate_associationTupled> =
  Tuple(cdc13, cdc13)

type IcPallet_author_mappingPalletCallClear_associationTupled = [
  Nimbus_id: Icdc13,
]
const cPallet_author_mappingPalletCallClear_associationTupled: Codec<IcPallet_author_mappingPalletCallClear_associationTupled> =
  Tuple(cdc13)

type IcPallet_author_mappingPalletCallSet_keysTupled = [Keys: I_bytesSeq]
const cPallet_author_mappingPalletCallSet_keysTupled: Codec<IcPallet_author_mappingPalletCallSet_keysTupled> =
  Tuple(_bytesSeq)

type IcPallet_author_mappingPalletError =
  | { tag: "AssociationNotFound"; value: undefined }
  | { tag: "NotYourAssociation"; value: undefined }
  | { tag: "CannotAffordSecurityDeposit"; value: undefined }
  | { tag: "AlreadyAssociated"; value: undefined }
  | { tag: "OldAuthorIdNotFound"; value: undefined }
  | { tag: "WrongKeySize"; value: undefined }
  | { tag: "DecodeNimbusFailed"; value: undefined }
  | { tag: "DecodeKeysFailed"; value: undefined }
const cPallet_author_mappingPalletError: Codec<IcPallet_author_mappingPalletError> =
  Enum({
    AssociationNotFound: _void,
    NotYourAssociation: _void,
    CannotAffordSecurityDeposit: _void,
    AlreadyAssociated: _void,
    OldAuthorIdNotFound: _void,
    WrongKeySize: _void,
    DecodeNimbusFailed: _void,
    DecodeKeysFailed: _void,
  })

type IcPallet_author_mappingPalletErrorAssociationNotFound = undefined
const cPallet_author_mappingPalletErrorAssociationNotFound: Codec<IcPallet_author_mappingPalletErrorAssociationNotFound> =
  _void

type IcPallet_author_mappingPalletErrorNotYourAssociation = undefined
const cPallet_author_mappingPalletErrorNotYourAssociation: Codec<IcPallet_author_mappingPalletErrorNotYourAssociation> =
  _void

type IcPallet_author_mappingPalletErrorCannotAffordSecurityDeposit = undefined
const cPallet_author_mappingPalletErrorCannotAffordSecurityDeposit: Codec<IcPallet_author_mappingPalletErrorCannotAffordSecurityDeposit> =
  _void

type IcPallet_author_mappingPalletErrorAlreadyAssociated = undefined
const cPallet_author_mappingPalletErrorAlreadyAssociated: Codec<IcPallet_author_mappingPalletErrorAlreadyAssociated> =
  _void

type IcPallet_author_mappingPalletErrorOldAuthorIdNotFound = undefined
const cPallet_author_mappingPalletErrorOldAuthorIdNotFound: Codec<IcPallet_author_mappingPalletErrorOldAuthorIdNotFound> =
  _void

type IcPallet_author_mappingPalletErrorWrongKeySize = undefined
const cPallet_author_mappingPalletErrorWrongKeySize: Codec<IcPallet_author_mappingPalletErrorWrongKeySize> =
  _void

type IcPallet_author_mappingPalletErrorDecodeNimbusFailed = undefined
const cPallet_author_mappingPalletErrorDecodeNimbusFailed: Codec<IcPallet_author_mappingPalletErrorDecodeNimbusFailed> =
  _void

type IcPallet_author_mappingPalletErrorDecodeKeysFailed = undefined
const cPallet_author_mappingPalletErrorDecodeKeysFailed: Codec<IcPallet_author_mappingPalletErrorDecodeKeysFailed> =
  _void

type IcPallet_moonbeam_orbitersTypesCollatorPoolInfo = {
  orbiters: Icdc109
  maybe_current_orbiter: IcOption
  next_orbiter: number
}
const cPallet_moonbeam_orbitersTypesCollatorPoolInfo: Codec<IcPallet_moonbeam_orbitersTypesCollatorPoolInfo> =
  Struct({
    orbiters: cdc109,
    maybe_current_orbiter: cOption,
    next_orbiter: u32,
  })

type IcPallet_moonbeam_orbitersPalletCallCollator_add_orbiterTupled = [
  Orbiter: Icdc1,
]
const cPallet_moonbeam_orbitersPalletCallCollator_add_orbiterTupled: Codec<IcPallet_moonbeam_orbitersPalletCallCollator_add_orbiterTupled> =
  Tuple(cdc1)

type IcPallet_moonbeam_orbitersPalletCallCollator_remove_orbiterTupled = [
  Orbiter: Icdc1,
]
const cPallet_moonbeam_orbitersPalletCallCollator_remove_orbiterTupled: Codec<IcPallet_moonbeam_orbitersPalletCallCollator_remove_orbiterTupled> =
  Tuple(cdc1)

type IcPallet_moonbeam_orbitersPalletCallOrbiter_leave_collator_poolTupled = [
  Collator: Icdc1,
]
const cPallet_moonbeam_orbitersPalletCallOrbiter_leave_collator_poolTupled: Codec<IcPallet_moonbeam_orbitersPalletCallOrbiter_leave_collator_poolTupled> =
  Tuple(cdc1)

type IcPallet_moonbeam_orbitersPalletCallOrbiter_unregisterTupled = [
  Collators_pool_count: number,
]
const cPallet_moonbeam_orbitersPalletCallOrbiter_unregisterTupled: Codec<IcPallet_moonbeam_orbitersPalletCallOrbiter_unregisterTupled> =
  Tuple(u32)

type IcPallet_moonbeam_orbitersPalletCallAdd_collatorTupled = [Collator: Icdc1]
const cPallet_moonbeam_orbitersPalletCallAdd_collatorTupled: Codec<IcPallet_moonbeam_orbitersPalletCallAdd_collatorTupled> =
  Tuple(cdc1)

type IcPallet_moonbeam_orbitersPalletCallRemove_collatorTupled = [
  Collator: Icdc1,
]
const cPallet_moonbeam_orbitersPalletCallRemove_collatorTupled: Codec<IcPallet_moonbeam_orbitersPalletCallRemove_collatorTupled> =
  Tuple(cdc1)

type IcPallet_moonbeam_orbitersPalletError =
  | { tag: "CollatorAlreadyAdded"; value: undefined }
  | { tag: "CollatorNotFound"; value: undefined }
  | { tag: "CollatorPoolTooLarge"; value: undefined }
  | { tag: "CollatorsPoolCountTooLow"; value: undefined }
  | { tag: "MinOrbiterDepositNotSet"; value: undefined }
  | { tag: "OrbiterAlreadyInPool"; value: undefined }
  | { tag: "OrbiterDepositNotFound"; value: undefined }
  | { tag: "OrbiterNotFound"; value: undefined }
  | { tag: "OrbiterStillInAPool"; value: undefined }
const cPallet_moonbeam_orbitersPalletError: Codec<IcPallet_moonbeam_orbitersPalletError> =
  Enum({
    CollatorAlreadyAdded: _void,
    CollatorNotFound: _void,
    CollatorPoolTooLarge: _void,
    CollatorsPoolCountTooLow: _void,
    MinOrbiterDepositNotSet: _void,
    OrbiterAlreadyInPool: _void,
    OrbiterDepositNotFound: _void,
    OrbiterNotFound: _void,
    OrbiterStillInAPool: _void,
  })

type IcPallet_moonbeam_orbitersPalletErrorCollatorAlreadyAdded = undefined
const cPallet_moonbeam_orbitersPalletErrorCollatorAlreadyAdded: Codec<IcPallet_moonbeam_orbitersPalletErrorCollatorAlreadyAdded> =
  _void

type IcPallet_moonbeam_orbitersPalletErrorCollatorNotFound = undefined
const cPallet_moonbeam_orbitersPalletErrorCollatorNotFound: Codec<IcPallet_moonbeam_orbitersPalletErrorCollatorNotFound> =
  _void

type IcPallet_moonbeam_orbitersPalletErrorCollatorPoolTooLarge = undefined
const cPallet_moonbeam_orbitersPalletErrorCollatorPoolTooLarge: Codec<IcPallet_moonbeam_orbitersPalletErrorCollatorPoolTooLarge> =
  _void

type IcPallet_moonbeam_orbitersPalletErrorCollatorsPoolCountTooLow = undefined
const cPallet_moonbeam_orbitersPalletErrorCollatorsPoolCountTooLow: Codec<IcPallet_moonbeam_orbitersPalletErrorCollatorsPoolCountTooLow> =
  _void

type IcPallet_moonbeam_orbitersPalletErrorMinOrbiterDepositNotSet = undefined
const cPallet_moonbeam_orbitersPalletErrorMinOrbiterDepositNotSet: Codec<IcPallet_moonbeam_orbitersPalletErrorMinOrbiterDepositNotSet> =
  _void

type IcPallet_moonbeam_orbitersPalletErrorOrbiterAlreadyInPool = undefined
const cPallet_moonbeam_orbitersPalletErrorOrbiterAlreadyInPool: Codec<IcPallet_moonbeam_orbitersPalletErrorOrbiterAlreadyInPool> =
  _void

type IcPallet_moonbeam_orbitersPalletErrorOrbiterDepositNotFound = undefined
const cPallet_moonbeam_orbitersPalletErrorOrbiterDepositNotFound: Codec<IcPallet_moonbeam_orbitersPalletErrorOrbiterDepositNotFound> =
  _void

type IcPallet_moonbeam_orbitersPalletErrorOrbiterNotFound = undefined
const cPallet_moonbeam_orbitersPalletErrorOrbiterNotFound: Codec<IcPallet_moonbeam_orbitersPalletErrorOrbiterNotFound> =
  _void

type IcPallet_moonbeam_orbitersPalletErrorOrbiterStillInAPool = undefined
const cPallet_moonbeam_orbitersPalletErrorOrbiterStillInAPool: Codec<IcPallet_moonbeam_orbitersPalletErrorOrbiterStillInAPool> =
  _void

type IcFrame_systemPalletCallRemark = { remark: I_bytesSeq }
const cFrame_systemPalletCallRemark: Codec<IcFrame_systemPalletCallRemark> =
  Struct({ remark: _bytesSeq })

type IcFrame_systemPalletCallSet_heap_pages = { pages: bigint }
const cFrame_systemPalletCallSet_heap_pages: Codec<IcFrame_systemPalletCallSet_heap_pages> =
  Struct({ pages: u64 })

type IcFrame_systemPalletCallSet_code = { code: I_bytesSeq }
const cFrame_systemPalletCallSet_code: Codec<IcFrame_systemPalletCallSet_code> =
  Struct({ code: _bytesSeq })

type IcFrame_systemPalletCallSet_code_without_checks = { code: I_bytesSeq }
const cFrame_systemPalletCallSet_code_without_checks: Codec<IcFrame_systemPalletCallSet_code_without_checks> =
  Struct({ code: _bytesSeq })

type IcFrame_systemPalletCallSet_storage = { items: Icdc88 }
const cFrame_systemPalletCallSet_storage: Codec<IcFrame_systemPalletCallSet_storage> =
  Struct({ items: cdc88 })

type IcFrame_systemPalletCallKill_storage = { keys: Icdc90 }
const cFrame_systemPalletCallKill_storage: Codec<IcFrame_systemPalletCallKill_storage> =
  Struct({ keys: cdc90 })

type IcFrame_systemPalletCallKill_prefix = {
  prefix: I_bytesSeq
  subkeys: number
}
const cFrame_systemPalletCallKill_prefix: Codec<IcFrame_systemPalletCallKill_prefix> =
  Struct({ prefix: _bytesSeq, subkeys: u32 })

type IcFrame_systemPalletCallRemark_with_event = { remark: I_bytesSeq }
const cFrame_systemPalletCallRemark_with_event: Codec<IcFrame_systemPalletCallRemark_with_event> =
  Struct({ remark: _bytesSeq })

type IcFrame_systemPalletCall =
  | { tag: "remark"; value: IcFrame_systemPalletCallRemark }
  | { tag: "set_heap_pages"; value: IcFrame_systemPalletCallSet_heap_pages }
  | { tag: "set_code"; value: IcFrame_systemPalletCallSet_code }
  | {
      tag: "set_code_without_checks"
      value: IcFrame_systemPalletCallSet_code_without_checks
    }
  | { tag: "set_storage"; value: IcFrame_systemPalletCallSet_storage }
  | { tag: "kill_storage"; value: IcFrame_systemPalletCallKill_storage }
  | { tag: "kill_prefix"; value: IcFrame_systemPalletCallKill_prefix }
  | {
      tag: "remark_with_event"
      value: IcFrame_systemPalletCallRemark_with_event
    }
const cFrame_systemPalletCall: Codec<IcFrame_systemPalletCall> = Enum({
  remark: cFrame_systemPalletCallRemark,
  set_heap_pages: cFrame_systemPalletCallSet_heap_pages,
  set_code: cFrame_systemPalletCallSet_code,
  set_code_without_checks: cFrame_systemPalletCallSet_code_without_checks,
  set_storage: cFrame_systemPalletCallSet_storage,
  kill_storage: cFrame_systemPalletCallKill_storage,
  kill_prefix: cFrame_systemPalletCallKill_prefix,
  remark_with_event: cFrame_systemPalletCallRemark_with_event,
})

type IcMoonbeam_runtimeRuntimeCallSystem = IcFrame_systemPalletCall
const cMoonbeam_runtimeRuntimeCallSystem: Codec<IcMoonbeam_runtimeRuntimeCallSystem> =
  cFrame_systemPalletCall

type IcCumulus_pallet_parachain_systemPalletCallSet_validation_data = {
  data: IcCumulus_primitives_parachain_inherentParachainInherentData
}
const cCumulus_pallet_parachain_systemPalletCallSet_validation_data: Codec<IcCumulus_pallet_parachain_systemPalletCallSet_validation_data> =
  Struct({ data: cCumulus_primitives_parachain_inherentParachainInherentData })

type IcCumulus_pallet_parachain_systemPalletCallSudo_send_upward_message = {
  message: I_bytesSeq
}
const cCumulus_pallet_parachain_systemPalletCallSudo_send_upward_message: Codec<IcCumulus_pallet_parachain_systemPalletCallSudo_send_upward_message> =
  Struct({ message: _bytesSeq })

type IcCumulus_pallet_parachain_systemPalletCallAuthorize_upgrade = {
  code_hash: Icdc13
  check_version: boolean
}
const cCumulus_pallet_parachain_systemPalletCallAuthorize_upgrade: Codec<IcCumulus_pallet_parachain_systemPalletCallAuthorize_upgrade> =
  Struct({ code_hash: cdc13, check_version: bool })

type IcCumulus_pallet_parachain_systemPalletCallEnact_authorized_upgrade = {
  code: I_bytesSeq
}
const cCumulus_pallet_parachain_systemPalletCallEnact_authorized_upgrade: Codec<IcCumulus_pallet_parachain_systemPalletCallEnact_authorized_upgrade> =
  Struct({ code: _bytesSeq })

type IcCumulus_pallet_parachain_systemPalletCall =
  | {
      tag: "set_validation_data"
      value: IcCumulus_pallet_parachain_systemPalletCallSet_validation_data
    }
  | {
      tag: "sudo_send_upward_message"
      value: IcCumulus_pallet_parachain_systemPalletCallSudo_send_upward_message
    }
  | {
      tag: "authorize_upgrade"
      value: IcCumulus_pallet_parachain_systemPalletCallAuthorize_upgrade
    }
  | {
      tag: "enact_authorized_upgrade"
      value: IcCumulus_pallet_parachain_systemPalletCallEnact_authorized_upgrade
    }
const cCumulus_pallet_parachain_systemPalletCall: Codec<IcCumulus_pallet_parachain_systemPalletCall> =
  Enum({
    set_validation_data:
      cCumulus_pallet_parachain_systemPalletCallSet_validation_data,
    sudo_send_upward_message:
      cCumulus_pallet_parachain_systemPalletCallSudo_send_upward_message,
    authorize_upgrade:
      cCumulus_pallet_parachain_systemPalletCallAuthorize_upgrade,
    enact_authorized_upgrade:
      cCumulus_pallet_parachain_systemPalletCallEnact_authorized_upgrade,
  })

type IcMoonbeam_runtimeRuntimeCallParachainSystem =
  IcCumulus_pallet_parachain_systemPalletCall
const cMoonbeam_runtimeRuntimeCallParachainSystem: Codec<IcMoonbeam_runtimeRuntimeCallParachainSystem> =
  cCumulus_pallet_parachain_systemPalletCall

type IcPallet_timestampPalletCallSet = { now: bigint }
const cPallet_timestampPalletCallSet: Codec<IcPallet_timestampPalletCallSet> =
  Struct({ now: compactBn })

type IcPallet_timestampPalletCall = {
  tag: "set"
  value: IcPallet_timestampPalletCallSet
}
const cPallet_timestampPalletCall: Codec<IcPallet_timestampPalletCall> = Enum({
  set: cPallet_timestampPalletCallSet,
})

type IcMoonbeam_runtimeRuntimeCallTimestamp = IcPallet_timestampPalletCall
const cMoonbeam_runtimeRuntimeCallTimestamp: Codec<IcMoonbeam_runtimeRuntimeCallTimestamp> =
  cPallet_timestampPalletCall

type IcPallet_root_testingPalletCallFill_block = { ratio: number }
const cPallet_root_testingPalletCallFill_block: Codec<IcPallet_root_testingPalletCallFill_block> =
  Struct({ ratio: u32 })

type IcPallet_root_testingPalletCall = {
  tag: "fill_block"
  value: IcPallet_root_testingPalletCallFill_block
}
const cPallet_root_testingPalletCall: Codec<IcPallet_root_testingPalletCall> =
  Enum({ fill_block: cPallet_root_testingPalletCallFill_block })

type IcMoonbeam_runtimeRuntimeCallRootTesting = IcPallet_root_testingPalletCall
const cMoonbeam_runtimeRuntimeCallRootTesting: Codec<IcMoonbeam_runtimeRuntimeCallRootTesting> =
  cPallet_root_testingPalletCall

type IcPallet_balancesPalletCallTransfer_allow_death = {
  dest: Icdc1
  value: bigint
}
const cPallet_balancesPalletCallTransfer_allow_death: Codec<IcPallet_balancesPalletCallTransfer_allow_death> =
  Struct({ dest: cdc1, value: compactBn })

type IcPallet_balancesPalletCallSet_balance_deprecated = {
  who: Icdc1
  new_free: bigint
  old_reserved: bigint
}
const cPallet_balancesPalletCallSet_balance_deprecated: Codec<IcPallet_balancesPalletCallSet_balance_deprecated> =
  Struct({ who: cdc1, new_free: compactBn, old_reserved: compactBn })

type IcPallet_balancesPalletCallForce_transfer = {
  source: Icdc1
  dest: Icdc1
  value: bigint
}
const cPallet_balancesPalletCallForce_transfer: Codec<IcPallet_balancesPalletCallForce_transfer> =
  Struct({ source: cdc1, dest: cdc1, value: compactBn })

type IcPallet_balancesPalletCallTransfer_keep_alive = {
  dest: Icdc1
  value: bigint
}
const cPallet_balancesPalletCallTransfer_keep_alive: Codec<IcPallet_balancesPalletCallTransfer_keep_alive> =
  Struct({ dest: cdc1, value: compactBn })

type IcPallet_balancesPalletCallTransfer_all = {
  dest: Icdc1
  keep_alive: boolean
}
const cPallet_balancesPalletCallTransfer_all: Codec<IcPallet_balancesPalletCallTransfer_all> =
  Struct({ dest: cdc1, keep_alive: bool })

type IcPallet_balancesPalletCallForce_unreserve = { who: Icdc1; amount: bigint }
const cPallet_balancesPalletCallForce_unreserve: Codec<IcPallet_balancesPalletCallForce_unreserve> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_balancesPalletCallUpgrade_accounts = { who: Icdc109 }
const cPallet_balancesPalletCallUpgrade_accounts: Codec<IcPallet_balancesPalletCallUpgrade_accounts> =
  Struct({ who: cdc109 })

type IcPallet_balancesPalletCallTransfer = { dest: Icdc1; value: bigint }
const cPallet_balancesPalletCallTransfer: Codec<IcPallet_balancesPalletCallTransfer> =
  Struct({ dest: cdc1, value: compactBn })

type IcPallet_balancesPalletCallForce_set_balance = {
  who: Icdc1
  new_free: bigint
}
const cPallet_balancesPalletCallForce_set_balance: Codec<IcPallet_balancesPalletCallForce_set_balance> =
  Struct({ who: cdc1, new_free: compactBn })

type IcPallet_balancesPalletCall =
  | {
      tag: "transfer_allow_death"
      value: IcPallet_balancesPalletCallTransfer_allow_death
    }
  | {
      tag: "set_balance_deprecated"
      value: IcPallet_balancesPalletCallSet_balance_deprecated
    }
  | { tag: "force_transfer"; value: IcPallet_balancesPalletCallForce_transfer }
  | {
      tag: "transfer_keep_alive"
      value: IcPallet_balancesPalletCallTransfer_keep_alive
    }
  | { tag: "transfer_all"; value: IcPallet_balancesPalletCallTransfer_all }
  | {
      tag: "force_unreserve"
      value: IcPallet_balancesPalletCallForce_unreserve
    }
  | {
      tag: "upgrade_accounts"
      value: IcPallet_balancesPalletCallUpgrade_accounts
    }
  | { tag: "transfer"; value: IcPallet_balancesPalletCallTransfer }
  | {
      tag: "force_set_balance"
      value: IcPallet_balancesPalletCallForce_set_balance
    }
const cPallet_balancesPalletCall: Codec<IcPallet_balancesPalletCall> = Enum({
  transfer_allow_death: cPallet_balancesPalletCallTransfer_allow_death,
  set_balance_deprecated: cPallet_balancesPalletCallSet_balance_deprecated,
  force_transfer: cPallet_balancesPalletCallForce_transfer,
  transfer_keep_alive: cPallet_balancesPalletCallTransfer_keep_alive,
  transfer_all: cPallet_balancesPalletCallTransfer_all,
  force_unreserve: cPallet_balancesPalletCallForce_unreserve,
  upgrade_accounts: cPallet_balancesPalletCallUpgrade_accounts,
  transfer: cPallet_balancesPalletCallTransfer,
  force_set_balance: cPallet_balancesPalletCallForce_set_balance,
})

type IcMoonbeam_runtimeRuntimeCallBalances = IcPallet_balancesPalletCall
const cMoonbeam_runtimeRuntimeCallBalances: Codec<IcMoonbeam_runtimeRuntimeCallBalances> =
  cPallet_balancesPalletCall

type IcPallet_parachain_stakingPalletCallSet_staking_expectations = {
  expectations: IcPallet_parachain_stakingInflationRange
}
const cPallet_parachain_stakingPalletCallSet_staking_expectations: Codec<IcPallet_parachain_stakingPalletCallSet_staking_expectations> =
  Struct({ expectations: cPallet_parachain_stakingInflationRange })

type IcPallet_parachain_stakingPalletCallSet_inflation = {
  schedule: IcPallet_parachain_stakingInflationRange
}
const cPallet_parachain_stakingPalletCallSet_inflation: Codec<IcPallet_parachain_stakingPalletCallSet_inflation> =
  Struct({ schedule: cPallet_parachain_stakingInflationRange })

type IcPallet_parachain_stakingPalletCallSet_parachain_bond_account = {
  new: Icdc1
}
const cPallet_parachain_stakingPalletCallSet_parachain_bond_account: Codec<IcPallet_parachain_stakingPalletCallSet_parachain_bond_account> =
  Struct({ new: cdc1 })

type IcPallet_parachain_stakingPalletCallSet_parachain_bond_reserve_percent = {
  new: number
}
const cPallet_parachain_stakingPalletCallSet_parachain_bond_reserve_percent: Codec<IcPallet_parachain_stakingPalletCallSet_parachain_bond_reserve_percent> =
  Struct({ new: u8 })

type IcPallet_parachain_stakingPalletCallSet_total_selected = { new: number }
const cPallet_parachain_stakingPalletCallSet_total_selected: Codec<IcPallet_parachain_stakingPalletCallSet_total_selected> =
  Struct({ new: u32 })

type IcPallet_parachain_stakingPalletCallSet_collator_commission = {
  new: number
}
const cPallet_parachain_stakingPalletCallSet_collator_commission: Codec<IcPallet_parachain_stakingPalletCallSet_collator_commission> =
  Struct({ new: u32 })

type IcPallet_parachain_stakingPalletCallSet_blocks_per_round = { new: number }
const cPallet_parachain_stakingPalletCallSet_blocks_per_round: Codec<IcPallet_parachain_stakingPalletCallSet_blocks_per_round> =
  Struct({ new: u32 })

type IcPallet_parachain_stakingPalletCallJoin_candidates = {
  bond: bigint
  candidate_count: number
}
const cPallet_parachain_stakingPalletCallJoin_candidates: Codec<IcPallet_parachain_stakingPalletCallJoin_candidates> =
  Struct({ bond: u128, candidate_count: u32 })

type IcPallet_parachain_stakingPalletCallSchedule_leave_candidates = {
  candidate_count: number
}
const cPallet_parachain_stakingPalletCallSchedule_leave_candidates: Codec<IcPallet_parachain_stakingPalletCallSchedule_leave_candidates> =
  Struct({ candidate_count: u32 })

type IcPallet_parachain_stakingPalletCallExecute_leave_candidates = {
  candidate: Icdc1
  candidate_delegation_count: number
}
const cPallet_parachain_stakingPalletCallExecute_leave_candidates: Codec<IcPallet_parachain_stakingPalletCallExecute_leave_candidates> =
  Struct({ candidate: cdc1, candidate_delegation_count: u32 })

type IcPallet_parachain_stakingPalletCallCancel_leave_candidates = {
  candidate_count: number
}
const cPallet_parachain_stakingPalletCallCancel_leave_candidates: Codec<IcPallet_parachain_stakingPalletCallCancel_leave_candidates> =
  Struct({ candidate_count: u32 })

type IcPallet_parachain_stakingPalletCallCandidate_bond_more = { more: bigint }
const cPallet_parachain_stakingPalletCallCandidate_bond_more: Codec<IcPallet_parachain_stakingPalletCallCandidate_bond_more> =
  Struct({ more: u128 })

type IcPallet_parachain_stakingPalletCallSchedule_candidate_bond_less = {
  less: bigint
}
const cPallet_parachain_stakingPalletCallSchedule_candidate_bond_less: Codec<IcPallet_parachain_stakingPalletCallSchedule_candidate_bond_less> =
  Struct({ less: u128 })

type IcPallet_parachain_stakingPalletCallExecute_candidate_bond_less = {
  candidate: Icdc1
}
const cPallet_parachain_stakingPalletCallExecute_candidate_bond_less: Codec<IcPallet_parachain_stakingPalletCallExecute_candidate_bond_less> =
  Struct({ candidate: cdc1 })

type IcPallet_parachain_stakingPalletCallDelegate = {
  candidate: Icdc1
  amount: bigint
  candidate_delegation_count: number
  delegation_count: number
}
const cPallet_parachain_stakingPalletCallDelegate: Codec<IcPallet_parachain_stakingPalletCallDelegate> =
  Struct({
    candidate: cdc1,
    amount: u128,
    candidate_delegation_count: u32,
    delegation_count: u32,
  })

type IcPallet_parachain_stakingPalletCallDelegate_with_auto_compound = {
  candidate: Icdc1
  amount: bigint
  auto_compound: number
  candidate_delegation_count: number
  candidate_auto_compounding_delegation_count: number
  delegation_count: number
}
const cPallet_parachain_stakingPalletCallDelegate_with_auto_compound: Codec<IcPallet_parachain_stakingPalletCallDelegate_with_auto_compound> =
  Struct({
    candidate: cdc1,
    amount: u128,
    auto_compound: u8,
    candidate_delegation_count: u32,
    candidate_auto_compounding_delegation_count: u32,
    delegation_count: u32,
  })

type IcPallet_parachain_stakingPalletCallSchedule_revoke_delegation = {
  collator: Icdc1
}
const cPallet_parachain_stakingPalletCallSchedule_revoke_delegation: Codec<IcPallet_parachain_stakingPalletCallSchedule_revoke_delegation> =
  Struct({ collator: cdc1 })

type IcPallet_parachain_stakingPalletCallDelegator_bond_more = {
  candidate: Icdc1
  more: bigint
}
const cPallet_parachain_stakingPalletCallDelegator_bond_more: Codec<IcPallet_parachain_stakingPalletCallDelegator_bond_more> =
  Struct({ candidate: cdc1, more: u128 })

type IcPallet_parachain_stakingPalletCallSchedule_delegator_bond_less = {
  candidate: Icdc1
  less: bigint
}
const cPallet_parachain_stakingPalletCallSchedule_delegator_bond_less: Codec<IcPallet_parachain_stakingPalletCallSchedule_delegator_bond_less> =
  Struct({ candidate: cdc1, less: u128 })

type IcPallet_parachain_stakingPalletCallExecute_delegation_request = {
  delegator: Icdc1
  candidate: Icdc1
}
const cPallet_parachain_stakingPalletCallExecute_delegation_request: Codec<IcPallet_parachain_stakingPalletCallExecute_delegation_request> =
  Struct({ delegator: cdc1, candidate: cdc1 })

type IcPallet_parachain_stakingPalletCallCancel_delegation_request = {
  candidate: Icdc1
}
const cPallet_parachain_stakingPalletCallCancel_delegation_request: Codec<IcPallet_parachain_stakingPalletCallCancel_delegation_request> =
  Struct({ candidate: cdc1 })

type IcPallet_parachain_stakingPalletCallSet_auto_compound = {
  candidate: Icdc1
  value: number
  candidate_auto_compounding_delegation_count_hint: number
  delegation_count_hint: number
}
const cPallet_parachain_stakingPalletCallSet_auto_compound: Codec<IcPallet_parachain_stakingPalletCallSet_auto_compound> =
  Struct({
    candidate: cdc1,
    value: u8,
    candidate_auto_compounding_delegation_count_hint: u32,
    delegation_count_hint: u32,
  })

type IcPallet_parachain_stakingPalletCallHotfix_remove_delegation_requests_exited_candidates =
  { candidates: Icdc109 }
const cPallet_parachain_stakingPalletCallHotfix_remove_delegation_requests_exited_candidates: Codec<IcPallet_parachain_stakingPalletCallHotfix_remove_delegation_requests_exited_candidates> =
  Struct({ candidates: cdc109 })

type IcPallet_parachain_stakingPalletCall =
  | {
      tag: "set_staking_expectations"
      value: IcPallet_parachain_stakingPalletCallSet_staking_expectations
    }
  | {
      tag: "set_inflation"
      value: IcPallet_parachain_stakingPalletCallSet_inflation
    }
  | {
      tag: "set_parachain_bond_account"
      value: IcPallet_parachain_stakingPalletCallSet_parachain_bond_account
    }
  | {
      tag: "set_parachain_bond_reserve_percent"
      value: IcPallet_parachain_stakingPalletCallSet_parachain_bond_reserve_percent
    }
  | {
      tag: "set_total_selected"
      value: IcPallet_parachain_stakingPalletCallSet_total_selected
    }
  | {
      tag: "set_collator_commission"
      value: IcPallet_parachain_stakingPalletCallSet_collator_commission
    }
  | {
      tag: "set_blocks_per_round"
      value: IcPallet_parachain_stakingPalletCallSet_blocks_per_round
    }
  | {
      tag: "join_candidates"
      value: IcPallet_parachain_stakingPalletCallJoin_candidates
    }
  | {
      tag: "schedule_leave_candidates"
      value: IcPallet_parachain_stakingPalletCallSchedule_leave_candidates
    }
  | {
      tag: "execute_leave_candidates"
      value: IcPallet_parachain_stakingPalletCallExecute_leave_candidates
    }
  | {
      tag: "cancel_leave_candidates"
      value: IcPallet_parachain_stakingPalletCallCancel_leave_candidates
    }
  | { tag: "go_offline"; value: undefined }
  | { tag: "go_online"; value: undefined }
  | {
      tag: "candidate_bond_more"
      value: IcPallet_parachain_stakingPalletCallCandidate_bond_more
    }
  | {
      tag: "schedule_candidate_bond_less"
      value: IcPallet_parachain_stakingPalletCallSchedule_candidate_bond_less
    }
  | {
      tag: "execute_candidate_bond_less"
      value: IcPallet_parachain_stakingPalletCallExecute_candidate_bond_less
    }
  | { tag: "cancel_candidate_bond_less"; value: undefined }
  | { tag: "delegate"; value: IcPallet_parachain_stakingPalletCallDelegate }
  | {
      tag: "delegate_with_auto_compound"
      value: IcPallet_parachain_stakingPalletCallDelegate_with_auto_compound
    }
  | { tag: "removed_call_19"; value: undefined }
  | { tag: "removed_call_20"; value: undefined }
  | { tag: "removed_call_21"; value: undefined }
  | {
      tag: "schedule_revoke_delegation"
      value: IcPallet_parachain_stakingPalletCallSchedule_revoke_delegation
    }
  | {
      tag: "delegator_bond_more"
      value: IcPallet_parachain_stakingPalletCallDelegator_bond_more
    }
  | {
      tag: "schedule_delegator_bond_less"
      value: IcPallet_parachain_stakingPalletCallSchedule_delegator_bond_less
    }
  | {
      tag: "execute_delegation_request"
      value: IcPallet_parachain_stakingPalletCallExecute_delegation_request
    }
  | {
      tag: "cancel_delegation_request"
      value: IcPallet_parachain_stakingPalletCallCancel_delegation_request
    }
  | {
      tag: "set_auto_compound"
      value: IcPallet_parachain_stakingPalletCallSet_auto_compound
    }
  | {
      tag: "hotfix_remove_delegation_requests_exited_candidates"
      value: IcPallet_parachain_stakingPalletCallHotfix_remove_delegation_requests_exited_candidates
    }
const cPallet_parachain_stakingPalletCall: Codec<IcPallet_parachain_stakingPalletCall> =
  Enum({
    set_staking_expectations:
      cPallet_parachain_stakingPalletCallSet_staking_expectations,
    set_inflation: cPallet_parachain_stakingPalletCallSet_inflation,
    set_parachain_bond_account:
      cPallet_parachain_stakingPalletCallSet_parachain_bond_account,
    set_parachain_bond_reserve_percent:
      cPallet_parachain_stakingPalletCallSet_parachain_bond_reserve_percent,
    set_total_selected: cPallet_parachain_stakingPalletCallSet_total_selected,
    set_collator_commission:
      cPallet_parachain_stakingPalletCallSet_collator_commission,
    set_blocks_per_round:
      cPallet_parachain_stakingPalletCallSet_blocks_per_round,
    join_candidates: cPallet_parachain_stakingPalletCallJoin_candidates,
    schedule_leave_candidates:
      cPallet_parachain_stakingPalletCallSchedule_leave_candidates,
    execute_leave_candidates:
      cPallet_parachain_stakingPalletCallExecute_leave_candidates,
    cancel_leave_candidates:
      cPallet_parachain_stakingPalletCallCancel_leave_candidates,
    go_offline: _void,
    go_online: _void,
    candidate_bond_more: cPallet_parachain_stakingPalletCallCandidate_bond_more,
    schedule_candidate_bond_less:
      cPallet_parachain_stakingPalletCallSchedule_candidate_bond_less,
    execute_candidate_bond_less:
      cPallet_parachain_stakingPalletCallExecute_candidate_bond_less,
    cancel_candidate_bond_less: _void,
    delegate: cPallet_parachain_stakingPalletCallDelegate,
    delegate_with_auto_compound:
      cPallet_parachain_stakingPalletCallDelegate_with_auto_compound,
    removed_call_19: _void,
    removed_call_20: _void,
    removed_call_21: _void,
    schedule_revoke_delegation:
      cPallet_parachain_stakingPalletCallSchedule_revoke_delegation,
    delegator_bond_more: cPallet_parachain_stakingPalletCallDelegator_bond_more,
    schedule_delegator_bond_less:
      cPallet_parachain_stakingPalletCallSchedule_delegator_bond_less,
    execute_delegation_request:
      cPallet_parachain_stakingPalletCallExecute_delegation_request,
    cancel_delegation_request:
      cPallet_parachain_stakingPalletCallCancel_delegation_request,
    set_auto_compound: cPallet_parachain_stakingPalletCallSet_auto_compound,
    hotfix_remove_delegation_requests_exited_candidates:
      cPallet_parachain_stakingPalletCallHotfix_remove_delegation_requests_exited_candidates,
  })

type IcMoonbeam_runtimeRuntimeCallParachainStaking =
  IcPallet_parachain_stakingPalletCall
const cMoonbeam_runtimeRuntimeCallParachainStaking: Codec<IcMoonbeam_runtimeRuntimeCallParachainStaking> =
  cPallet_parachain_stakingPalletCall

type IcPallet_author_inherentPalletCall = {
  tag: "kick_off_authorship_validation"
  value: undefined
}
const cPallet_author_inherentPalletCall: Codec<IcPallet_author_inherentPalletCall> =
  Enum({ kick_off_authorship_validation: _void })

type IcMoonbeam_runtimeRuntimeCallAuthorInherent =
  IcPallet_author_inherentPalletCall
const cMoonbeam_runtimeRuntimeCallAuthorInherent: Codec<IcMoonbeam_runtimeRuntimeCallAuthorInherent> =
  cPallet_author_inherentPalletCall

type IcPallet_author_slot_filterPalletCallSet_eligible = { new: number }
const cPallet_author_slot_filterPalletCallSet_eligible: Codec<IcPallet_author_slot_filterPalletCallSet_eligible> =
  Struct({ new: u32 })

type IcPallet_author_slot_filterPalletCall = {
  tag: "set_eligible"
  value: IcPallet_author_slot_filterPalletCallSet_eligible
}
const cPallet_author_slot_filterPalletCall: Codec<IcPallet_author_slot_filterPalletCall> =
  Enum({ set_eligible: cPallet_author_slot_filterPalletCallSet_eligible })

type IcMoonbeam_runtimeRuntimeCallAuthorFilter =
  IcPallet_author_slot_filterPalletCall
const cMoonbeam_runtimeRuntimeCallAuthorFilter: Codec<IcMoonbeam_runtimeRuntimeCallAuthorFilter> =
  cPallet_author_slot_filterPalletCall

type IcPallet_author_mappingPalletCallAdd_association = { nimbus_id: Icdc13 }
const cPallet_author_mappingPalletCallAdd_association: Codec<IcPallet_author_mappingPalletCallAdd_association> =
  Struct({ nimbus_id: cdc13 })

type IcPallet_author_mappingPalletCallUpdate_association = {
  old_nimbus_id: Icdc13
  new_nimbus_id: Icdc13
}
const cPallet_author_mappingPalletCallUpdate_association: Codec<IcPallet_author_mappingPalletCallUpdate_association> =
  Struct({ old_nimbus_id: cdc13, new_nimbus_id: cdc13 })

type IcPallet_author_mappingPalletCallClear_association = { nimbus_id: Icdc13 }
const cPallet_author_mappingPalletCallClear_association: Codec<IcPallet_author_mappingPalletCallClear_association> =
  Struct({ nimbus_id: cdc13 })

type IcPallet_author_mappingPalletCallSet_keys = { keys: I_bytesSeq }
const cPallet_author_mappingPalletCallSet_keys: Codec<IcPallet_author_mappingPalletCallSet_keys> =
  Struct({ keys: _bytesSeq })

type IcPallet_author_mappingPalletCall =
  | {
      tag: "add_association"
      value: IcPallet_author_mappingPalletCallAdd_association
    }
  | {
      tag: "update_association"
      value: IcPallet_author_mappingPalletCallUpdate_association
    }
  | {
      tag: "clear_association"
      value: IcPallet_author_mappingPalletCallClear_association
    }
  | { tag: "remove_keys"; value: undefined }
  | { tag: "set_keys"; value: IcPallet_author_mappingPalletCallSet_keys }
const cPallet_author_mappingPalletCall: Codec<IcPallet_author_mappingPalletCall> =
  Enum({
    add_association: cPallet_author_mappingPalletCallAdd_association,
    update_association: cPallet_author_mappingPalletCallUpdate_association,
    clear_association: cPallet_author_mappingPalletCallClear_association,
    remove_keys: _void,
    set_keys: cPallet_author_mappingPalletCallSet_keys,
  })

type IcMoonbeam_runtimeRuntimeCallAuthorMapping =
  IcPallet_author_mappingPalletCall
const cMoonbeam_runtimeRuntimeCallAuthorMapping: Codec<IcMoonbeam_runtimeRuntimeCallAuthorMapping> =
  cPallet_author_mappingPalletCall

type IcPallet_moonbeam_orbitersPalletCallCollator_add_orbiter = {
  orbiter: Icdc1
}
const cPallet_moonbeam_orbitersPalletCallCollator_add_orbiter: Codec<IcPallet_moonbeam_orbitersPalletCallCollator_add_orbiter> =
  Struct({ orbiter: cdc1 })

type IcPallet_moonbeam_orbitersPalletCallCollator_remove_orbiter = {
  orbiter: Icdc1
}
const cPallet_moonbeam_orbitersPalletCallCollator_remove_orbiter: Codec<IcPallet_moonbeam_orbitersPalletCallCollator_remove_orbiter> =
  Struct({ orbiter: cdc1 })

type IcPallet_moonbeam_orbitersPalletCallOrbiter_leave_collator_pool = {
  collator: Icdc1
}
const cPallet_moonbeam_orbitersPalletCallOrbiter_leave_collator_pool: Codec<IcPallet_moonbeam_orbitersPalletCallOrbiter_leave_collator_pool> =
  Struct({ collator: cdc1 })

type IcPallet_moonbeam_orbitersPalletCallOrbiter_unregister = {
  collators_pool_count: number
}
const cPallet_moonbeam_orbitersPalletCallOrbiter_unregister: Codec<IcPallet_moonbeam_orbitersPalletCallOrbiter_unregister> =
  Struct({ collators_pool_count: u32 })

type IcPallet_moonbeam_orbitersPalletCallAdd_collator = { collator: Icdc1 }
const cPallet_moonbeam_orbitersPalletCallAdd_collator: Codec<IcPallet_moonbeam_orbitersPalletCallAdd_collator> =
  Struct({ collator: cdc1 })

type IcPallet_moonbeam_orbitersPalletCallRemove_collator = { collator: Icdc1 }
const cPallet_moonbeam_orbitersPalletCallRemove_collator: Codec<IcPallet_moonbeam_orbitersPalletCallRemove_collator> =
  Struct({ collator: cdc1 })

type IcPallet_moonbeam_orbitersPalletCall =
  | {
      tag: "collator_add_orbiter"
      value: IcPallet_moonbeam_orbitersPalletCallCollator_add_orbiter
    }
  | {
      tag: "collator_remove_orbiter"
      value: IcPallet_moonbeam_orbitersPalletCallCollator_remove_orbiter
    }
  | {
      tag: "orbiter_leave_collator_pool"
      value: IcPallet_moonbeam_orbitersPalletCallOrbiter_leave_collator_pool
    }
  | { tag: "orbiter_register"; value: undefined }
  | {
      tag: "orbiter_unregister"
      value: IcPallet_moonbeam_orbitersPalletCallOrbiter_unregister
    }
  | {
      tag: "add_collator"
      value: IcPallet_moonbeam_orbitersPalletCallAdd_collator
    }
  | {
      tag: "remove_collator"
      value: IcPallet_moonbeam_orbitersPalletCallRemove_collator
    }
const cPallet_moonbeam_orbitersPalletCall: Codec<IcPallet_moonbeam_orbitersPalletCall> =
  Enum({
    collator_add_orbiter:
      cPallet_moonbeam_orbitersPalletCallCollator_add_orbiter,
    collator_remove_orbiter:
      cPallet_moonbeam_orbitersPalletCallCollator_remove_orbiter,
    orbiter_leave_collator_pool:
      cPallet_moonbeam_orbitersPalletCallOrbiter_leave_collator_pool,
    orbiter_register: _void,
    orbiter_unregister: cPallet_moonbeam_orbitersPalletCallOrbiter_unregister,
    add_collator: cPallet_moonbeam_orbitersPalletCallAdd_collator,
    remove_collator: cPallet_moonbeam_orbitersPalletCallRemove_collator,
  })

type IcMoonbeam_runtimeRuntimeCallMoonbeamOrbiters =
  IcPallet_moonbeam_orbitersPalletCall
const cMoonbeam_runtimeRuntimeCallMoonbeamOrbiters: Codec<IcMoonbeam_runtimeRuntimeCallMoonbeamOrbiters> =
  cPallet_moonbeam_orbitersPalletCall

type Icdc118Circular = Icdc118
const cdc118Circular: Codec<Icdc118Circular> = Self(() => cdc118)

type IcPallet_utilityPalletCallBatch = { calls: Icdc118Circular }
const cPallet_utilityPalletCallBatch: Codec<IcPallet_utilityPalletCallBatch> =
  Struct({ calls: cdc118Circular })

type IcMoonbeam_runtimeRuntimeCallCircular = IcMoonbeam_runtimeRuntimeCall
const cMoonbeam_runtimeRuntimeCallCircular: Codec<IcMoonbeam_runtimeRuntimeCallCircular> =
  Self(() => cMoonbeam_runtimeRuntimeCall)

type IcPallet_utilityPalletCallAs_derivative = {
  index: number
  call: IcMoonbeam_runtimeRuntimeCallCircular
}
const cPallet_utilityPalletCallAs_derivative: Codec<IcPallet_utilityPalletCallAs_derivative> =
  Struct({ index: u16, call: cMoonbeam_runtimeRuntimeCallCircular })

type IcPallet_utilityPalletCallBatch_all = { calls: Icdc118Circular }
const cPallet_utilityPalletCallBatch_all: Codec<IcPallet_utilityPalletCallBatch_all> =
  Struct({ calls: cdc118Circular })

type IcFrame_supportDispatchRawOriginSigned = Icdc1
const cFrame_supportDispatchRawOriginSigned: Codec<IcFrame_supportDispatchRawOriginSigned> =
  cdc1

type IcFrame_supportDispatchRawOrigin =
  | { tag: "Root"; value: undefined }
  | { tag: "Signed"; value: IcFrame_supportDispatchRawOriginSigned }
  | { tag: "None"; value: undefined }
const cFrame_supportDispatchRawOrigin: Codec<IcFrame_supportDispatchRawOrigin> =
  Enum({
    Root: _void,
    Signed: cFrame_supportDispatchRawOriginSigned,
    None: _void,
  })

type IcMoonbeam_runtimeOriginCallerSystem = IcFrame_supportDispatchRawOrigin
const cMoonbeam_runtimeOriginCallerSystem: Codec<IcMoonbeam_runtimeOriginCallerSystem> =
  cFrame_supportDispatchRawOrigin

type IcPallet_ethereumRawOriginEthereumTransaction = Icdc1
const cPallet_ethereumRawOriginEthereumTransaction: Codec<IcPallet_ethereumRawOriginEthereumTransaction> =
  cdc1

type IcPallet_ethereumRawOrigin = {
  tag: "EthereumTransaction"
  value: IcPallet_ethereumRawOriginEthereumTransaction
}
const cPallet_ethereumRawOrigin: Codec<IcPallet_ethereumRawOrigin> = Enum({
  EthereumTransaction: cPallet_ethereumRawOriginEthereumTransaction,
})

type IcMoonbeam_runtimeOriginCallerEthereum = IcPallet_ethereumRawOrigin
const cMoonbeam_runtimeOriginCallerEthereum: Codec<IcMoonbeam_runtimeOriginCallerEthereum> =
  cPallet_ethereumRawOrigin

type IcMoonbeam_runtimeGovernanceOriginsCustom_originsOrigin =
  | { tag: "WhitelistedCaller"; value: undefined }
  | { tag: "GeneralAdmin"; value: undefined }
  | { tag: "ReferendumCanceller"; value: undefined }
  | { tag: "ReferendumKiller"; value: undefined }
const cMoonbeam_runtimeGovernanceOriginsCustom_originsOrigin: Codec<IcMoonbeam_runtimeGovernanceOriginsCustom_originsOrigin> =
  Enum({
    WhitelistedCaller: _void,
    GeneralAdmin: _void,
    ReferendumCanceller: _void,
    ReferendumKiller: _void,
  })

type IcMoonbeam_runtimeOriginCallerOrigins =
  IcMoonbeam_runtimeGovernanceOriginsCustom_originsOrigin
const cMoonbeam_runtimeOriginCallerOrigins: Codec<IcMoonbeam_runtimeOriginCallerOrigins> =
  cMoonbeam_runtimeGovernanceOriginsCustom_originsOrigin

type IcPallet_collectiveRawOriginMembers = [number, number]
const cPallet_collectiveRawOriginMembers: Codec<IcPallet_collectiveRawOriginMembers> =
  Tuple(u32, u32)

type IcPallet_collectiveRawOriginMember = Icdc1
const cPallet_collectiveRawOriginMember: Codec<IcPallet_collectiveRawOriginMember> =
  cdc1

type IcPallet_collectiveRawOrigin =
  | { tag: "Members"; value: IcPallet_collectiveRawOriginMembers }
  | { tag: "Member"; value: IcPallet_collectiveRawOriginMember }
  | { tag: "_Phantom"; value: undefined }
const cPallet_collectiveRawOrigin: Codec<IcPallet_collectiveRawOrigin> = Enum({
  Members: cPallet_collectiveRawOriginMembers,
  Member: cPallet_collectiveRawOriginMember,
  _Phantom: _void,
})

type IcMoonbeam_runtimeOriginCallerCouncilCollective =
  IcPallet_collectiveRawOrigin
const cMoonbeam_runtimeOriginCallerCouncilCollective: Codec<IcMoonbeam_runtimeOriginCallerCouncilCollective> =
  cPallet_collectiveRawOrigin

type IcMoonbeam_runtimeOriginCallerTechCommitteeCollective =
  IcPallet_collectiveRawOrigin
const cMoonbeam_runtimeOriginCallerTechCommitteeCollective: Codec<IcMoonbeam_runtimeOriginCallerTechCommitteeCollective> =
  cPallet_collectiveRawOrigin

type IcMoonbeam_runtimeOriginCallerTreasuryCouncilCollective =
  IcPallet_collectiveRawOrigin
const cMoonbeam_runtimeOriginCallerTreasuryCouncilCollective: Codec<IcMoonbeam_runtimeOriginCallerTreasuryCouncilCollective> =
  cPallet_collectiveRawOrigin

type IcMoonbeam_runtimeOriginCallerOpenTechCommitteeCollective =
  IcPallet_collectiveRawOrigin
const cMoonbeam_runtimeOriginCallerOpenTechCommitteeCollective: Codec<IcMoonbeam_runtimeOriginCallerOpenTechCommitteeCollective> =
  cPallet_collectiveRawOrigin

type IcCumulus_pallet_xcmPalletOriginSiblingParachain = number
const cCumulus_pallet_xcmPalletOriginSiblingParachain: Codec<IcCumulus_pallet_xcmPalletOriginSiblingParachain> =
  u32

type IcCumulus_pallet_xcmPalletOrigin =
  | { tag: "Relay"; value: undefined }
  | {
      tag: "SiblingParachain"
      value: IcCumulus_pallet_xcmPalletOriginSiblingParachain
    }
const cCumulus_pallet_xcmPalletOrigin: Codec<IcCumulus_pallet_xcmPalletOrigin> =
  Enum({
    Relay: _void,
    SiblingParachain: cCumulus_pallet_xcmPalletOriginSiblingParachain,
  })

type IcMoonbeam_runtimeOriginCallerCumulusXcm = IcCumulus_pallet_xcmPalletOrigin
const cMoonbeam_runtimeOriginCallerCumulusXcm: Codec<IcMoonbeam_runtimeOriginCallerCumulusXcm> =
  cCumulus_pallet_xcmPalletOrigin

type IcPallet_xcmPalletOriginXcm = IcXcmV3MultilocationMultiLocation
const cPallet_xcmPalletOriginXcm: Codec<IcPallet_xcmPalletOriginXcm> =
  cXcmV3MultilocationMultiLocation

type IcPallet_xcmPalletOriginResponse = IcXcmV3MultilocationMultiLocation
const cPallet_xcmPalletOriginResponse: Codec<IcPallet_xcmPalletOriginResponse> =
  cXcmV3MultilocationMultiLocation

type IcPallet_xcmPalletOrigin =
  | { tag: "Xcm"; value: IcPallet_xcmPalletOriginXcm }
  | { tag: "Response"; value: IcPallet_xcmPalletOriginResponse }
const cPallet_xcmPalletOrigin: Codec<IcPallet_xcmPalletOrigin> = Enum({
  Xcm: cPallet_xcmPalletOriginXcm,
  Response: cPallet_xcmPalletOriginResponse,
})

type IcMoonbeam_runtimeOriginCallerPolkadotXcm = IcPallet_xcmPalletOrigin
const cMoonbeam_runtimeOriginCallerPolkadotXcm: Codec<IcMoonbeam_runtimeOriginCallerPolkadotXcm> =
  cPallet_xcmPalletOrigin

type IcPallet_ethereum_xcmRawOriginXcmEthereumTransaction = Icdc1
const cPallet_ethereum_xcmRawOriginXcmEthereumTransaction: Codec<IcPallet_ethereum_xcmRawOriginXcmEthereumTransaction> =
  cdc1

type IcPallet_ethereum_xcmRawOrigin = {
  tag: "XcmEthereumTransaction"
  value: IcPallet_ethereum_xcmRawOriginXcmEthereumTransaction
}
const cPallet_ethereum_xcmRawOrigin: Codec<IcPallet_ethereum_xcmRawOrigin> =
  Enum({
    XcmEthereumTransaction: cPallet_ethereum_xcmRawOriginXcmEthereumTransaction,
  })

type IcMoonbeam_runtimeOriginCallerEthereumXcm = IcPallet_ethereum_xcmRawOrigin
const cMoonbeam_runtimeOriginCallerEthereumXcm: Codec<IcMoonbeam_runtimeOriginCallerEthereumXcm> =
  cPallet_ethereum_xcmRawOrigin

type IcMoonbeam_runtimeOriginCallerVoid = undefined
const cMoonbeam_runtimeOriginCallerVoid: Codec<IcMoonbeam_runtimeOriginCallerVoid> =
  _void

type IcMoonbeam_runtimeOriginCaller =
  | { tag: "system"; value: IcMoonbeam_runtimeOriginCallerSystem }
  | { tag: "Ethereum"; value: IcMoonbeam_runtimeOriginCallerEthereum }
  | { tag: "Origins"; value: IcMoonbeam_runtimeOriginCallerOrigins }
  | {
      tag: "CouncilCollective"
      value: IcMoonbeam_runtimeOriginCallerCouncilCollective
    }
  | {
      tag: "TechCommitteeCollective"
      value: IcMoonbeam_runtimeOriginCallerTechCommitteeCollective
    }
  | {
      tag: "TreasuryCouncilCollective"
      value: IcMoonbeam_runtimeOriginCallerTreasuryCouncilCollective
    }
  | {
      tag: "OpenTechCommitteeCollective"
      value: IcMoonbeam_runtimeOriginCallerOpenTechCommitteeCollective
    }
  | { tag: "CumulusXcm"; value: IcMoonbeam_runtimeOriginCallerCumulusXcm }
  | { tag: "PolkadotXcm"; value: IcMoonbeam_runtimeOriginCallerPolkadotXcm }
  | { tag: "EthereumXcm"; value: IcMoonbeam_runtimeOriginCallerEthereumXcm }
  | { tag: "Void"; value: IcMoonbeam_runtimeOriginCallerVoid }
const cMoonbeam_runtimeOriginCaller: Codec<IcMoonbeam_runtimeOriginCaller> =
  Enum(
    {
      system: cMoonbeam_runtimeOriginCallerSystem,
      Ethereum: cMoonbeam_runtimeOriginCallerEthereum,
      Origins: cMoonbeam_runtimeOriginCallerOrigins,
      CouncilCollective: cMoonbeam_runtimeOriginCallerCouncilCollective,
      TechCommitteeCollective:
        cMoonbeam_runtimeOriginCallerTechCommitteeCollective,
      TreasuryCouncilCollective:
        cMoonbeam_runtimeOriginCallerTreasuryCouncilCollective,
      OpenTechCommitteeCollective:
        cMoonbeam_runtimeOriginCallerOpenTechCommitteeCollective,
      CumulusXcm: cMoonbeam_runtimeOriginCallerCumulusXcm,
      PolkadotXcm: cMoonbeam_runtimeOriginCallerPolkadotXcm,
      EthereumXcm: cMoonbeam_runtimeOriginCallerEthereumXcm,
      Void: cMoonbeam_runtimeOriginCallerVoid,
    },
    [0, 52, 65, 70, 71, 72, 73, 101, 103, 109, 10],
  )

type IcPallet_utilityPalletCallDispatch_as = {
  as_origin: IcMoonbeam_runtimeOriginCaller
  call: IcMoonbeam_runtimeRuntimeCallCircular
}
const cPallet_utilityPalletCallDispatch_as: Codec<IcPallet_utilityPalletCallDispatch_as> =
  Struct({
    as_origin: cMoonbeam_runtimeOriginCaller,
    call: cMoonbeam_runtimeRuntimeCallCircular,
  })

type IcPallet_utilityPalletCallForce_batch = { calls: Icdc118Circular }
const cPallet_utilityPalletCallForce_batch: Codec<IcPallet_utilityPalletCallForce_batch> =
  Struct({ calls: cdc118Circular })

type IcPallet_utilityPalletCallWith_weight = {
  call: IcMoonbeam_runtimeRuntimeCallCircular
  weight: IcSp_weightsWeight_v2Weight
}
const cPallet_utilityPalletCallWith_weight: Codec<IcPallet_utilityPalletCallWith_weight> =
  Struct({
    call: cMoonbeam_runtimeRuntimeCallCircular,
    weight: cSp_weightsWeight_v2Weight,
  })

type IcPallet_utilityPalletCall =
  | { tag: "batch"; value: IcPallet_utilityPalletCallBatch }
  | { tag: "as_derivative"; value: IcPallet_utilityPalletCallAs_derivative }
  | { tag: "batch_all"; value: IcPallet_utilityPalletCallBatch_all }
  | { tag: "dispatch_as"; value: IcPallet_utilityPalletCallDispatch_as }
  | { tag: "force_batch"; value: IcPallet_utilityPalletCallForce_batch }
  | { tag: "with_weight"; value: IcPallet_utilityPalletCallWith_weight }
const cPallet_utilityPalletCall: Codec<IcPallet_utilityPalletCall> = Enum({
  batch: cPallet_utilityPalletCallBatch,
  as_derivative: cPallet_utilityPalletCallAs_derivative,
  batch_all: cPallet_utilityPalletCallBatch_all,
  dispatch_as: cPallet_utilityPalletCallDispatch_as,
  force_batch: cPallet_utilityPalletCallForce_batch,
  with_weight: cPallet_utilityPalletCallWith_weight,
})

type IcMoonbeam_runtimeRuntimeCallUtility = IcPallet_utilityPalletCall
const cMoonbeam_runtimeRuntimeCallUtility: Codec<IcMoonbeam_runtimeRuntimeCallUtility> =
  cPallet_utilityPalletCall

type IcPallet_proxyPalletCallProxy = {
  real: Icdc1
  force_proxy_type: IcOption
  call: IcMoonbeam_runtimeRuntimeCallCircular
}
const cPallet_proxyPalletCallProxy: Codec<IcPallet_proxyPalletCallProxy> =
  Struct({
    real: cdc1,
    force_proxy_type: cOption,
    call: cMoonbeam_runtimeRuntimeCallCircular,
  })

type IcPallet_proxyPalletCallAdd_proxy = {
  delegate: Icdc1
  proxy_type: IcMoonbeam_runtimeProxyType
  delay: number
}
const cPallet_proxyPalletCallAdd_proxy: Codec<IcPallet_proxyPalletCallAdd_proxy> =
  Struct({ delegate: cdc1, proxy_type: cMoonbeam_runtimeProxyType, delay: u32 })

type IcPallet_proxyPalletCallRemove_proxy = {
  delegate: Icdc1
  proxy_type: IcMoonbeam_runtimeProxyType
  delay: number
}
const cPallet_proxyPalletCallRemove_proxy: Codec<IcPallet_proxyPalletCallRemove_proxy> =
  Struct({ delegate: cdc1, proxy_type: cMoonbeam_runtimeProxyType, delay: u32 })

type IcPallet_proxyPalletCallCreate_pure = {
  proxy_type: IcMoonbeam_runtimeProxyType
  delay: number
  index: number
}
const cPallet_proxyPalletCallCreate_pure: Codec<IcPallet_proxyPalletCallCreate_pure> =
  Struct({ proxy_type: cMoonbeam_runtimeProxyType, delay: u32, index: u16 })

type IcPallet_proxyPalletCallKill_pure = {
  spawner: Icdc1
  proxy_type: IcMoonbeam_runtimeProxyType
  index: number
  height: number
  ext_index: number
}
const cPallet_proxyPalletCallKill_pure: Codec<IcPallet_proxyPalletCallKill_pure> =
  Struct({
    spawner: cdc1,
    proxy_type: cMoonbeam_runtimeProxyType,
    index: u16,
    height: compactNumber,
    ext_index: compactNumber,
  })

type IcPallet_proxyPalletCallAnnounce = { real: Icdc1; call_hash: Icdc13 }
const cPallet_proxyPalletCallAnnounce: Codec<IcPallet_proxyPalletCallAnnounce> =
  Struct({ real: cdc1, call_hash: cdc13 })

type IcPallet_proxyPalletCallRemove_announcement = {
  real: Icdc1
  call_hash: Icdc13
}
const cPallet_proxyPalletCallRemove_announcement: Codec<IcPallet_proxyPalletCallRemove_announcement> =
  Struct({ real: cdc1, call_hash: cdc13 })

type IcPallet_proxyPalletCallReject_announcement = {
  delegate: Icdc1
  call_hash: Icdc13
}
const cPallet_proxyPalletCallReject_announcement: Codec<IcPallet_proxyPalletCallReject_announcement> =
  Struct({ delegate: cdc1, call_hash: cdc13 })

type IcPallet_proxyPalletCallProxy_announced = {
  delegate: Icdc1
  real: Icdc1
  force_proxy_type: IcOption
  call: IcMoonbeam_runtimeRuntimeCallCircular
}
const cPallet_proxyPalletCallProxy_announced: Codec<IcPallet_proxyPalletCallProxy_announced> =
  Struct({
    delegate: cdc1,
    real: cdc1,
    force_proxy_type: cOption,
    call: cMoonbeam_runtimeRuntimeCallCircular,
  })

type IcPallet_proxyPalletCall =
  | { tag: "proxy"; value: IcPallet_proxyPalletCallProxy }
  | { tag: "add_proxy"; value: IcPallet_proxyPalletCallAdd_proxy }
  | { tag: "remove_proxy"; value: IcPallet_proxyPalletCallRemove_proxy }
  | { tag: "remove_proxies"; value: undefined }
  | { tag: "create_pure"; value: IcPallet_proxyPalletCallCreate_pure }
  | { tag: "kill_pure"; value: IcPallet_proxyPalletCallKill_pure }
  | { tag: "announce"; value: IcPallet_proxyPalletCallAnnounce }
  | {
      tag: "remove_announcement"
      value: IcPallet_proxyPalletCallRemove_announcement
    }
  | {
      tag: "reject_announcement"
      value: IcPallet_proxyPalletCallReject_announcement
    }
  | { tag: "proxy_announced"; value: IcPallet_proxyPalletCallProxy_announced }
const cPallet_proxyPalletCall: Codec<IcPallet_proxyPalletCall> = Enum({
  proxy: cPallet_proxyPalletCallProxy,
  add_proxy: cPallet_proxyPalletCallAdd_proxy,
  remove_proxy: cPallet_proxyPalletCallRemove_proxy,
  remove_proxies: _void,
  create_pure: cPallet_proxyPalletCallCreate_pure,
  kill_pure: cPallet_proxyPalletCallKill_pure,
  announce: cPallet_proxyPalletCallAnnounce,
  remove_announcement: cPallet_proxyPalletCallRemove_announcement,
  reject_announcement: cPallet_proxyPalletCallReject_announcement,
  proxy_announced: cPallet_proxyPalletCallProxy_announced,
})

type IcMoonbeam_runtimeRuntimeCallProxy = IcPallet_proxyPalletCall
const cMoonbeam_runtimeRuntimeCallProxy: Codec<IcMoonbeam_runtimeRuntimeCallProxy> =
  cPallet_proxyPalletCall

type IcPallet_maintenance_modePalletCall =
  | { tag: "enter_maintenance_mode"; value: undefined }
  | { tag: "resume_normal_operation"; value: undefined }
const cPallet_maintenance_modePalletCall: Codec<IcPallet_maintenance_modePalletCall> =
  Enum({ enter_maintenance_mode: _void, resume_normal_operation: _void })

type IcMoonbeam_runtimeRuntimeCallMaintenanceMode =
  IcPallet_maintenance_modePalletCall
const cMoonbeam_runtimeRuntimeCallMaintenanceMode: Codec<IcMoonbeam_runtimeRuntimeCallMaintenanceMode> =
  cPallet_maintenance_modePalletCall

type IcPallet_identityPalletCallAdd_registrar = { account: Icdc1 }
const cPallet_identityPalletCallAdd_registrar: Codec<IcPallet_identityPalletCallAdd_registrar> =
  Struct({ account: cdc1 })

type I_fixedStr0 = string
const _fixedStr0: Codec<I_fixedStr0> = fixedStr(0)

type IcPallet_identityTypesDataRaw0 = I_fixedStr0
const cPallet_identityTypesDataRaw0: Codec<IcPallet_identityTypesDataRaw0> =
  _fixedStr0

type I_fixedStr1 = string
const _fixedStr1: Codec<I_fixedStr1> = fixedStr(1)

type IcPallet_identityTypesDataRaw1 = I_fixedStr1
const cPallet_identityTypesDataRaw1: Codec<IcPallet_identityTypesDataRaw1> =
  _fixedStr1

type I_fixedStr2 = string
const _fixedStr2: Codec<I_fixedStr2> = fixedStr(2)

type IcPallet_identityTypesDataRaw2 = I_fixedStr2
const cPallet_identityTypesDataRaw2: Codec<IcPallet_identityTypesDataRaw2> =
  _fixedStr2

type I_fixedStr3 = string
const _fixedStr3: Codec<I_fixedStr3> = fixedStr(3)

type IcPallet_identityTypesDataRaw3 = I_fixedStr3
const cPallet_identityTypesDataRaw3: Codec<IcPallet_identityTypesDataRaw3> =
  _fixedStr3

type I_fixedStr4 = string
const _fixedStr4: Codec<I_fixedStr4> = fixedStr(4)

type IcPallet_identityTypesDataRaw4 = I_fixedStr4
const cPallet_identityTypesDataRaw4: Codec<IcPallet_identityTypesDataRaw4> =
  _fixedStr4

type I_fixedStr5 = string
const _fixedStr5: Codec<I_fixedStr5> = fixedStr(5)

type IcPallet_identityTypesDataRaw5 = I_fixedStr5
const cPallet_identityTypesDataRaw5: Codec<IcPallet_identityTypesDataRaw5> =
  _fixedStr5

type I_fixedStr6 = string
const _fixedStr6: Codec<I_fixedStr6> = fixedStr(6)

type IcPallet_identityTypesDataRaw6 = I_fixedStr6
const cPallet_identityTypesDataRaw6: Codec<IcPallet_identityTypesDataRaw6> =
  _fixedStr6

type I_fixedStr7 = string
const _fixedStr7: Codec<I_fixedStr7> = fixedStr(7)

type IcPallet_identityTypesDataRaw7 = I_fixedStr7
const cPallet_identityTypesDataRaw7: Codec<IcPallet_identityTypesDataRaw7> =
  _fixedStr7

type I_fixedStr8 = string
const _fixedStr8: Codec<I_fixedStr8> = fixedStr(8)

type IcPallet_identityTypesDataRaw8 = I_fixedStr8
const cPallet_identityTypesDataRaw8: Codec<IcPallet_identityTypesDataRaw8> =
  _fixedStr8

type I_fixedStr9 = string
const _fixedStr9: Codec<I_fixedStr9> = fixedStr(9)

type IcPallet_identityTypesDataRaw9 = I_fixedStr9
const cPallet_identityTypesDataRaw9: Codec<IcPallet_identityTypesDataRaw9> =
  _fixedStr9

type I_fixedStr10 = string
const _fixedStr10: Codec<I_fixedStr10> = fixedStr(10)

type IcPallet_identityTypesDataRaw10 = I_fixedStr10
const cPallet_identityTypesDataRaw10: Codec<IcPallet_identityTypesDataRaw10> =
  _fixedStr10

type I_fixedStr11 = string
const _fixedStr11: Codec<I_fixedStr11> = fixedStr(11)

type IcPallet_identityTypesDataRaw11 = I_fixedStr11
const cPallet_identityTypesDataRaw11: Codec<IcPallet_identityTypesDataRaw11> =
  _fixedStr11

type I_fixedStr12 = string
const _fixedStr12: Codec<I_fixedStr12> = fixedStr(12)

type IcPallet_identityTypesDataRaw12 = I_fixedStr12
const cPallet_identityTypesDataRaw12: Codec<IcPallet_identityTypesDataRaw12> =
  _fixedStr12

type I_fixedStr13 = string
const _fixedStr13: Codec<I_fixedStr13> = fixedStr(13)

type IcPallet_identityTypesDataRaw13 = I_fixedStr13
const cPallet_identityTypesDataRaw13: Codec<IcPallet_identityTypesDataRaw13> =
  _fixedStr13

type I_fixedStr14 = string
const _fixedStr14: Codec<I_fixedStr14> = fixedStr(14)

type IcPallet_identityTypesDataRaw14 = I_fixedStr14
const cPallet_identityTypesDataRaw14: Codec<IcPallet_identityTypesDataRaw14> =
  _fixedStr14

type I_fixedStr15 = string
const _fixedStr15: Codec<I_fixedStr15> = fixedStr(15)

type IcPallet_identityTypesDataRaw15 = I_fixedStr15
const cPallet_identityTypesDataRaw15: Codec<IcPallet_identityTypesDataRaw15> =
  _fixedStr15

type I_fixedStr16 = string
const _fixedStr16: Codec<I_fixedStr16> = fixedStr(16)

type IcPallet_identityTypesDataRaw16 = I_fixedStr16
const cPallet_identityTypesDataRaw16: Codec<IcPallet_identityTypesDataRaw16> =
  _fixedStr16

type I_fixedStr17 = string
const _fixedStr17: Codec<I_fixedStr17> = fixedStr(17)

type IcPallet_identityTypesDataRaw17 = I_fixedStr17
const cPallet_identityTypesDataRaw17: Codec<IcPallet_identityTypesDataRaw17> =
  _fixedStr17

type I_fixedStr18 = string
const _fixedStr18: Codec<I_fixedStr18> = fixedStr(18)

type IcPallet_identityTypesDataRaw18 = I_fixedStr18
const cPallet_identityTypesDataRaw18: Codec<IcPallet_identityTypesDataRaw18> =
  _fixedStr18

type I_fixedStr19 = string
const _fixedStr19: Codec<I_fixedStr19> = fixedStr(19)

type IcPallet_identityTypesDataRaw19 = I_fixedStr19
const cPallet_identityTypesDataRaw19: Codec<IcPallet_identityTypesDataRaw19> =
  _fixedStr19

type I_fixedStr20 = string
const _fixedStr20: Codec<I_fixedStr20> = fixedStr(20)

type IcPallet_identityTypesDataRaw20 = I_fixedStr20
const cPallet_identityTypesDataRaw20: Codec<IcPallet_identityTypesDataRaw20> =
  _fixedStr20

type I_fixedStr21 = string
const _fixedStr21: Codec<I_fixedStr21> = fixedStr(21)

type IcPallet_identityTypesDataRaw21 = I_fixedStr21
const cPallet_identityTypesDataRaw21: Codec<IcPallet_identityTypesDataRaw21> =
  _fixedStr21

type I_fixedStr22 = string
const _fixedStr22: Codec<I_fixedStr22> = fixedStr(22)

type IcPallet_identityTypesDataRaw22 = I_fixedStr22
const cPallet_identityTypesDataRaw22: Codec<IcPallet_identityTypesDataRaw22> =
  _fixedStr22

type I_fixedStr23 = string
const _fixedStr23: Codec<I_fixedStr23> = fixedStr(23)

type IcPallet_identityTypesDataRaw23 = I_fixedStr23
const cPallet_identityTypesDataRaw23: Codec<IcPallet_identityTypesDataRaw23> =
  _fixedStr23

type I_fixedStr24 = string
const _fixedStr24: Codec<I_fixedStr24> = fixedStr(24)

type IcPallet_identityTypesDataRaw24 = I_fixedStr24
const cPallet_identityTypesDataRaw24: Codec<IcPallet_identityTypesDataRaw24> =
  _fixedStr24

type I_fixedStr25 = string
const _fixedStr25: Codec<I_fixedStr25> = fixedStr(25)

type IcPallet_identityTypesDataRaw25 = I_fixedStr25
const cPallet_identityTypesDataRaw25: Codec<IcPallet_identityTypesDataRaw25> =
  _fixedStr25

type I_fixedStr26 = string
const _fixedStr26: Codec<I_fixedStr26> = fixedStr(26)

type IcPallet_identityTypesDataRaw26 = I_fixedStr26
const cPallet_identityTypesDataRaw26: Codec<IcPallet_identityTypesDataRaw26> =
  _fixedStr26

type I_fixedStr27 = string
const _fixedStr27: Codec<I_fixedStr27> = fixedStr(27)

type IcPallet_identityTypesDataRaw27 = I_fixedStr27
const cPallet_identityTypesDataRaw27: Codec<IcPallet_identityTypesDataRaw27> =
  _fixedStr27

type I_fixedStr28 = string
const _fixedStr28: Codec<I_fixedStr28> = fixedStr(28)

type IcPallet_identityTypesDataRaw28 = I_fixedStr28
const cPallet_identityTypesDataRaw28: Codec<IcPallet_identityTypesDataRaw28> =
  _fixedStr28

type I_fixedStr29 = string
const _fixedStr29: Codec<I_fixedStr29> = fixedStr(29)

type IcPallet_identityTypesDataRaw29 = I_fixedStr29
const cPallet_identityTypesDataRaw29: Codec<IcPallet_identityTypesDataRaw29> =
  _fixedStr29

type I_fixedStr30 = string
const _fixedStr30: Codec<I_fixedStr30> = fixedStr(30)

type IcPallet_identityTypesDataRaw30 = I_fixedStr30
const cPallet_identityTypesDataRaw30: Codec<IcPallet_identityTypesDataRaw30> =
  _fixedStr30

type I_fixedStr31 = string
const _fixedStr31: Codec<I_fixedStr31> = fixedStr(31)

type IcPallet_identityTypesDataRaw31 = I_fixedStr31
const cPallet_identityTypesDataRaw31: Codec<IcPallet_identityTypesDataRaw31> =
  _fixedStr31

type I_fixedStr32 = string
const _fixedStr32: Codec<I_fixedStr32> = fixedStr(32)

type IcPallet_identityTypesDataRaw32 = I_fixedStr32
const cPallet_identityTypesDataRaw32: Codec<IcPallet_identityTypesDataRaw32> =
  _fixedStr32

type IcPallet_identityTypesDataBlakeTwo256 = Icdc13
const cPallet_identityTypesDataBlakeTwo256: Codec<IcPallet_identityTypesDataBlakeTwo256> =
  cdc13

type IcPallet_identityTypesDataSha256 = Icdc13
const cPallet_identityTypesDataSha256: Codec<IcPallet_identityTypesDataSha256> =
  cdc13

type IcPallet_identityTypesDataKeccak256 = Icdc13
const cPallet_identityTypesDataKeccak256: Codec<IcPallet_identityTypesDataKeccak256> =
  cdc13

type IcPallet_identityTypesDataShaThree256 = Icdc13
const cPallet_identityTypesDataShaThree256: Codec<IcPallet_identityTypesDataShaThree256> =
  cdc13

type IcPallet_identityTypesData =
  | { tag: "None"; value: undefined }
  | { tag: "Raw0"; value: IcPallet_identityTypesDataRaw0 }
  | { tag: "Raw1"; value: IcPallet_identityTypesDataRaw1 }
  | { tag: "Raw2"; value: IcPallet_identityTypesDataRaw2 }
  | { tag: "Raw3"; value: IcPallet_identityTypesDataRaw3 }
  | { tag: "Raw4"; value: IcPallet_identityTypesDataRaw4 }
  | { tag: "Raw5"; value: IcPallet_identityTypesDataRaw5 }
  | { tag: "Raw6"; value: IcPallet_identityTypesDataRaw6 }
  | { tag: "Raw7"; value: IcPallet_identityTypesDataRaw7 }
  | { tag: "Raw8"; value: IcPallet_identityTypesDataRaw8 }
  | { tag: "Raw9"; value: IcPallet_identityTypesDataRaw9 }
  | { tag: "Raw10"; value: IcPallet_identityTypesDataRaw10 }
  | { tag: "Raw11"; value: IcPallet_identityTypesDataRaw11 }
  | { tag: "Raw12"; value: IcPallet_identityTypesDataRaw12 }
  | { tag: "Raw13"; value: IcPallet_identityTypesDataRaw13 }
  | { tag: "Raw14"; value: IcPallet_identityTypesDataRaw14 }
  | { tag: "Raw15"; value: IcPallet_identityTypesDataRaw15 }
  | { tag: "Raw16"; value: IcPallet_identityTypesDataRaw16 }
  | { tag: "Raw17"; value: IcPallet_identityTypesDataRaw17 }
  | { tag: "Raw18"; value: IcPallet_identityTypesDataRaw18 }
  | { tag: "Raw19"; value: IcPallet_identityTypesDataRaw19 }
  | { tag: "Raw20"; value: IcPallet_identityTypesDataRaw20 }
  | { tag: "Raw21"; value: IcPallet_identityTypesDataRaw21 }
  | { tag: "Raw22"; value: IcPallet_identityTypesDataRaw22 }
  | { tag: "Raw23"; value: IcPallet_identityTypesDataRaw23 }
  | { tag: "Raw24"; value: IcPallet_identityTypesDataRaw24 }
  | { tag: "Raw25"; value: IcPallet_identityTypesDataRaw25 }
  | { tag: "Raw26"; value: IcPallet_identityTypesDataRaw26 }
  | { tag: "Raw27"; value: IcPallet_identityTypesDataRaw27 }
  | { tag: "Raw28"; value: IcPallet_identityTypesDataRaw28 }
  | { tag: "Raw29"; value: IcPallet_identityTypesDataRaw29 }
  | { tag: "Raw30"; value: IcPallet_identityTypesDataRaw30 }
  | { tag: "Raw31"; value: IcPallet_identityTypesDataRaw31 }
  | { tag: "Raw32"; value: IcPallet_identityTypesDataRaw32 }
  | { tag: "BlakeTwo256"; value: IcPallet_identityTypesDataBlakeTwo256 }
  | { tag: "Sha256"; value: IcPallet_identityTypesDataSha256 }
  | { tag: "Keccak256"; value: IcPallet_identityTypesDataKeccak256 }
  | { tag: "ShaThree256"; value: IcPallet_identityTypesDataShaThree256 }
const cPallet_identityTypesData: Codec<IcPallet_identityTypesData> = Enum({
  None: _void,
  Raw0: cPallet_identityTypesDataRaw0,
  Raw1: cPallet_identityTypesDataRaw1,
  Raw2: cPallet_identityTypesDataRaw2,
  Raw3: cPallet_identityTypesDataRaw3,
  Raw4: cPallet_identityTypesDataRaw4,
  Raw5: cPallet_identityTypesDataRaw5,
  Raw6: cPallet_identityTypesDataRaw6,
  Raw7: cPallet_identityTypesDataRaw7,
  Raw8: cPallet_identityTypesDataRaw8,
  Raw9: cPallet_identityTypesDataRaw9,
  Raw10: cPallet_identityTypesDataRaw10,
  Raw11: cPallet_identityTypesDataRaw11,
  Raw12: cPallet_identityTypesDataRaw12,
  Raw13: cPallet_identityTypesDataRaw13,
  Raw14: cPallet_identityTypesDataRaw14,
  Raw15: cPallet_identityTypesDataRaw15,
  Raw16: cPallet_identityTypesDataRaw16,
  Raw17: cPallet_identityTypesDataRaw17,
  Raw18: cPallet_identityTypesDataRaw18,
  Raw19: cPallet_identityTypesDataRaw19,
  Raw20: cPallet_identityTypesDataRaw20,
  Raw21: cPallet_identityTypesDataRaw21,
  Raw22: cPallet_identityTypesDataRaw22,
  Raw23: cPallet_identityTypesDataRaw23,
  Raw24: cPallet_identityTypesDataRaw24,
  Raw25: cPallet_identityTypesDataRaw25,
  Raw26: cPallet_identityTypesDataRaw26,
  Raw27: cPallet_identityTypesDataRaw27,
  Raw28: cPallet_identityTypesDataRaw28,
  Raw29: cPallet_identityTypesDataRaw29,
  Raw30: cPallet_identityTypesDataRaw30,
  Raw31: cPallet_identityTypesDataRaw31,
  Raw32: cPallet_identityTypesDataRaw32,
  BlakeTwo256: cPallet_identityTypesDataBlakeTwo256,
  Sha256: cPallet_identityTypesDataSha256,
  Keccak256: cPallet_identityTypesDataKeccak256,
  ShaThree256: cPallet_identityTypesDataShaThree256,
})

type Icdc145 = [IcPallet_identityTypesData, IcPallet_identityTypesData]
const cdc145: Codec<Icdc145> = Tuple(
  cPallet_identityTypesData,
  cPallet_identityTypesData,
)

type Icdc177 = Array<Icdc145>
const cdc177: Codec<Icdc177> = Vector(cdc145)

type IcPallet_identityTypesIdentityInfo = {
  additional: Icdc177
  display: IcPallet_identityTypesData
  legal: IcPallet_identityTypesData
  web: IcPallet_identityTypesData
  riot: IcPallet_identityTypesData
  email: IcPallet_identityTypesData
  pgp_fingerprint: IcOption
  image: IcPallet_identityTypesData
  twitter: IcPallet_identityTypesData
}
const cPallet_identityTypesIdentityInfo: Codec<IcPallet_identityTypesIdentityInfo> =
  Struct({
    additional: cdc177,
    display: cPallet_identityTypesData,
    legal: cPallet_identityTypesData,
    web: cPallet_identityTypesData,
    riot: cPallet_identityTypesData,
    email: cPallet_identityTypesData,
    pgp_fingerprint: cOption,
    image: cPallet_identityTypesData,
    twitter: cPallet_identityTypesData,
  })

type IcPallet_identityPalletCallSet_identity = {
  info: IcPallet_identityTypesIdentityInfo
}
const cPallet_identityPalletCallSet_identity: Codec<IcPallet_identityPalletCallSet_identity> =
  Struct({ info: cPallet_identityTypesIdentityInfo })

type Icdc180 = [Icdc1, IcPallet_identityTypesData]
const cdc180: Codec<Icdc180> = Tuple(cdc1, cPallet_identityTypesData)

type Icdc179 = Array<Icdc180>
const cdc179: Codec<Icdc179> = Vector(cdc180)

type IcPallet_identityPalletCallSet_subs = { subs: Icdc179 }
const cPallet_identityPalletCallSet_subs: Codec<IcPallet_identityPalletCallSet_subs> =
  Struct({ subs: cdc179 })

type IcPallet_identityPalletCallRequest_judgement = {
  reg_index: number
  max_fee: bigint
}
const cPallet_identityPalletCallRequest_judgement: Codec<IcPallet_identityPalletCallRequest_judgement> =
  Struct({ reg_index: compactNumber, max_fee: compactBn })

type IcPallet_identityPalletCallCancel_request = { reg_index: number }
const cPallet_identityPalletCallCancel_request: Codec<IcPallet_identityPalletCallCancel_request> =
  Struct({ reg_index: u32 })

type IcPallet_identityPalletCallSet_fee = { index: number; fee: bigint }
const cPallet_identityPalletCallSet_fee: Codec<IcPallet_identityPalletCallSet_fee> =
  Struct({ index: compactNumber, fee: compactBn })

type IcPallet_identityPalletCallSet_account_id = { index: number; new: Icdc1 }
const cPallet_identityPalletCallSet_account_id: Codec<IcPallet_identityPalletCallSet_account_id> =
  Struct({ index: compactNumber, new: cdc1 })

type IcPallet_identityPalletCallSet_fields = { index: number; fields: bigint }
const cPallet_identityPalletCallSet_fields: Codec<IcPallet_identityPalletCallSet_fields> =
  Struct({ index: compactNumber, fields: u64 })

type IcPallet_identityTypesJudgementFeePaid = bigint
const cPallet_identityTypesJudgementFeePaid: Codec<IcPallet_identityTypesJudgementFeePaid> =
  u128

type IcPallet_identityTypesJudgement =
  | { tag: "Unknown"; value: undefined }
  | { tag: "FeePaid"; value: IcPallet_identityTypesJudgementFeePaid }
  | { tag: "Reasonable"; value: undefined }
  | { tag: "KnownGood"; value: undefined }
  | { tag: "OutOfDate"; value: undefined }
  | { tag: "LowQuality"; value: undefined }
  | { tag: "Erroneous"; value: undefined }
const cPallet_identityTypesJudgement: Codec<IcPallet_identityTypesJudgement> =
  Enum({
    Unknown: _void,
    FeePaid: cPallet_identityTypesJudgementFeePaid,
    Reasonable: _void,
    KnownGood: _void,
    OutOfDate: _void,
    LowQuality: _void,
    Erroneous: _void,
  })

type IcPallet_identityPalletCallProvide_judgement = {
  reg_index: number
  target: Icdc1
  judgement: IcPallet_identityTypesJudgement
  identity: Icdc13
}
const cPallet_identityPalletCallProvide_judgement: Codec<IcPallet_identityPalletCallProvide_judgement> =
  Struct({
    reg_index: compactNumber,
    target: cdc1,
    judgement: cPallet_identityTypesJudgement,
    identity: cdc13,
  })

type IcPallet_identityPalletCallKill_identity = { target: Icdc1 }
const cPallet_identityPalletCallKill_identity: Codec<IcPallet_identityPalletCallKill_identity> =
  Struct({ target: cdc1 })

type IcPallet_identityPalletCallAdd_sub = {
  sub: Icdc1
  data: IcPallet_identityTypesData
}
const cPallet_identityPalletCallAdd_sub: Codec<IcPallet_identityPalletCallAdd_sub> =
  Struct({ sub: cdc1, data: cPallet_identityTypesData })

type IcPallet_identityPalletCallRename_sub = {
  sub: Icdc1
  data: IcPallet_identityTypesData
}
const cPallet_identityPalletCallRename_sub: Codec<IcPallet_identityPalletCallRename_sub> =
  Struct({ sub: cdc1, data: cPallet_identityTypesData })

type IcPallet_identityPalletCallRemove_sub = { sub: Icdc1 }
const cPallet_identityPalletCallRemove_sub: Codec<IcPallet_identityPalletCallRemove_sub> =
  Struct({ sub: cdc1 })

type IcPallet_identityPalletCall =
  | { tag: "add_registrar"; value: IcPallet_identityPalletCallAdd_registrar }
  | { tag: "set_identity"; value: IcPallet_identityPalletCallSet_identity }
  | { tag: "set_subs"; value: IcPallet_identityPalletCallSet_subs }
  | { tag: "clear_identity"; value: undefined }
  | {
      tag: "request_judgement"
      value: IcPallet_identityPalletCallRequest_judgement
    }
  | { tag: "cancel_request"; value: IcPallet_identityPalletCallCancel_request }
  | { tag: "set_fee"; value: IcPallet_identityPalletCallSet_fee }
  | { tag: "set_account_id"; value: IcPallet_identityPalletCallSet_account_id }
  | { tag: "set_fields"; value: IcPallet_identityPalletCallSet_fields }
  | {
      tag: "provide_judgement"
      value: IcPallet_identityPalletCallProvide_judgement
    }
  | { tag: "kill_identity"; value: IcPallet_identityPalletCallKill_identity }
  | { tag: "add_sub"; value: IcPallet_identityPalletCallAdd_sub }
  | { tag: "rename_sub"; value: IcPallet_identityPalletCallRename_sub }
  | { tag: "remove_sub"; value: IcPallet_identityPalletCallRemove_sub }
  | { tag: "quit_sub"; value: undefined }
const cPallet_identityPalletCall: Codec<IcPallet_identityPalletCall> = Enum({
  add_registrar: cPallet_identityPalletCallAdd_registrar,
  set_identity: cPallet_identityPalletCallSet_identity,
  set_subs: cPallet_identityPalletCallSet_subs,
  clear_identity: _void,
  request_judgement: cPallet_identityPalletCallRequest_judgement,
  cancel_request: cPallet_identityPalletCallCancel_request,
  set_fee: cPallet_identityPalletCallSet_fee,
  set_account_id: cPallet_identityPalletCallSet_account_id,
  set_fields: cPallet_identityPalletCallSet_fields,
  provide_judgement: cPallet_identityPalletCallProvide_judgement,
  kill_identity: cPallet_identityPalletCallKill_identity,
  add_sub: cPallet_identityPalletCallAdd_sub,
  rename_sub: cPallet_identityPalletCallRename_sub,
  remove_sub: cPallet_identityPalletCallRemove_sub,
  quit_sub: _void,
})

type IcMoonbeam_runtimeRuntimeCallIdentity = IcPallet_identityPalletCall
const cMoonbeam_runtimeRuntimeCallIdentity: Codec<IcMoonbeam_runtimeRuntimeCallIdentity> =
  cPallet_identityPalletCall

type IcPallet_multisigPalletCallAs_multi_threshold_1 = {
  other_signatories: Icdc109
  call: IcMoonbeam_runtimeRuntimeCallCircular
}
const cPallet_multisigPalletCallAs_multi_threshold_1: Codec<IcPallet_multisigPalletCallAs_multi_threshold_1> =
  Struct({
    other_signatories: cdc109,
    call: cMoonbeam_runtimeRuntimeCallCircular,
  })

type IcPallet_multisigPalletCallAs_multi = {
  threshold: number
  other_signatories: Icdc109
  maybe_timepoint: IcOption
  call: IcMoonbeam_runtimeRuntimeCallCircular
  max_weight: IcSp_weightsWeight_v2Weight
}
const cPallet_multisigPalletCallAs_multi: Codec<IcPallet_multisigPalletCallAs_multi> =
  Struct({
    threshold: u16,
    other_signatories: cdc109,
    maybe_timepoint: cOption,
    call: cMoonbeam_runtimeRuntimeCallCircular,
    max_weight: cSp_weightsWeight_v2Weight,
  })

type IcPallet_multisigPalletCallApprove_as_multi = {
  threshold: number
  other_signatories: Icdc109
  maybe_timepoint: IcOption
  call_hash: Icdc13
  max_weight: IcSp_weightsWeight_v2Weight
}
const cPallet_multisigPalletCallApprove_as_multi: Codec<IcPallet_multisigPalletCallApprove_as_multi> =
  Struct({
    threshold: u16,
    other_signatories: cdc109,
    maybe_timepoint: cOption,
    call_hash: cdc13,
    max_weight: cSp_weightsWeight_v2Weight,
  })

type IcPallet_multisigPalletCallCancel_as_multi = {
  threshold: number
  other_signatories: Icdc109
  timepoint: IcPallet_multisigTimepoint
  call_hash: Icdc13
}
const cPallet_multisigPalletCallCancel_as_multi: Codec<IcPallet_multisigPalletCallCancel_as_multi> =
  Struct({
    threshold: u16,
    other_signatories: cdc109,
    timepoint: cPallet_multisigTimepoint,
    call_hash: cdc13,
  })

type IcPallet_multisigPalletCall =
  | {
      tag: "as_multi_threshold_1"
      value: IcPallet_multisigPalletCallAs_multi_threshold_1
    }
  | { tag: "as_multi"; value: IcPallet_multisigPalletCallAs_multi }
  | {
      tag: "approve_as_multi"
      value: IcPallet_multisigPalletCallApprove_as_multi
    }
  | {
      tag: "cancel_as_multi"
      value: IcPallet_multisigPalletCallCancel_as_multi
    }
const cPallet_multisigPalletCall: Codec<IcPallet_multisigPalletCall> = Enum({
  as_multi_threshold_1: cPallet_multisigPalletCallAs_multi_threshold_1,
  as_multi: cPallet_multisigPalletCallAs_multi,
  approve_as_multi: cPallet_multisigPalletCallApprove_as_multi,
  cancel_as_multi: cPallet_multisigPalletCallCancel_as_multi,
})

type IcMoonbeam_runtimeRuntimeCallMultisig = IcPallet_multisigPalletCall
const cMoonbeam_runtimeRuntimeCallMultisig: Codec<IcMoonbeam_runtimeRuntimeCallMultisig> =
  cPallet_multisigPalletCall

type IcPallet_evmPalletCallWithdraw = { address: Icdc1; value: bigint }
const cPallet_evmPalletCallWithdraw: Codec<IcPallet_evmPalletCallWithdraw> =
  Struct({ address: cdc1, value: u128 })

type Icdc188 = Array<bigint>
const cdc188: Codec<Icdc188> = Vector(u64, 4)

type Icdc191 = [Icdc1, Icdc65]
const cdc191: Codec<Icdc191> = Tuple(cdc1, cdc65)

type Icdc190 = Array<Icdc191>
const cdc190: Codec<Icdc190> = Vector(cdc191)

type IcPallet_evmPalletCallCall = {
  source: Icdc1
  target: Icdc1
  input: I_bytesSeq
  value: Icdc188
  gas_limit: bigint
  max_fee_per_gas: Icdc188
  max_priority_fee_per_gas: IcOption
  nonce: IcOption
  access_list: Icdc190
}
const cPallet_evmPalletCallCall: Codec<IcPallet_evmPalletCallCall> = Struct({
  source: cdc1,
  target: cdc1,
  input: _bytesSeq,
  value: cdc188,
  gas_limit: u64,
  max_fee_per_gas: cdc188,
  max_priority_fee_per_gas: cOption,
  nonce: cOption,
  access_list: cdc190,
})

type IcPallet_evmPalletCallCreate = {
  source: Icdc1
  init: I_bytesSeq
  value: Icdc188
  gas_limit: bigint
  max_fee_per_gas: Icdc188
  max_priority_fee_per_gas: IcOption
  nonce: IcOption
  access_list: Icdc190
}
const cPallet_evmPalletCallCreate: Codec<IcPallet_evmPalletCallCreate> = Struct(
  {
    source: cdc1,
    init: _bytesSeq,
    value: cdc188,
    gas_limit: u64,
    max_fee_per_gas: cdc188,
    max_priority_fee_per_gas: cOption,
    nonce: cOption,
    access_list: cdc190,
  },
)

type IcPallet_evmPalletCallCreate2 = {
  source: Icdc1
  init: I_bytesSeq
  salt: Icdc13
  value: Icdc188
  gas_limit: bigint
  max_fee_per_gas: Icdc188
  max_priority_fee_per_gas: IcOption
  nonce: IcOption
  access_list: Icdc190
}
const cPallet_evmPalletCallCreate2: Codec<IcPallet_evmPalletCallCreate2> =
  Struct({
    source: cdc1,
    init: _bytesSeq,
    salt: cdc13,
    value: cdc188,
    gas_limit: u64,
    max_fee_per_gas: cdc188,
    max_priority_fee_per_gas: cOption,
    nonce: cOption,
    access_list: cdc190,
  })

type IcPallet_evmPalletCall =
  | { tag: "withdraw"; value: IcPallet_evmPalletCallWithdraw }
  | { tag: "call"; value: IcPallet_evmPalletCallCall }
  | { tag: "create"; value: IcPallet_evmPalletCallCreate }
  | { tag: "create2"; value: IcPallet_evmPalletCallCreate2 }
const cPallet_evmPalletCall: Codec<IcPallet_evmPalletCall> = Enum({
  withdraw: cPallet_evmPalletCallWithdraw,
  call: cPallet_evmPalletCallCall,
  create: cPallet_evmPalletCallCreate,
  create2: cPallet_evmPalletCallCreate2,
})

type IcMoonbeam_runtimeRuntimeCallEVM = IcPallet_evmPalletCall
const cMoonbeam_runtimeRuntimeCallEVM: Codec<IcMoonbeam_runtimeRuntimeCallEVM> =
  cPallet_evmPalletCall

type IcEthereumTransactionTransactionActionCall = Icdc1
const cEthereumTransactionTransactionActionCall: Codec<IcEthereumTransactionTransactionActionCall> =
  cdc1

type IcEthereumTransactionTransactionAction =
  | { tag: "Call"; value: IcEthereumTransactionTransactionActionCall }
  | { tag: "Create"; value: undefined }
const cEthereumTransactionTransactionAction: Codec<IcEthereumTransactionTransactionAction> =
  Enum({ Call: cEthereumTransactionTransactionActionCall, Create: _void })

type IcEthereumTransactionTransactionSignature = {
  v: bigint
  r: Icdc13
  s: Icdc13
}
const cEthereumTransactionTransactionSignature: Codec<IcEthereumTransactionTransactionSignature> =
  Struct({ v: u64, r: cdc13, s: cdc13 })

type IcEthereumTransactionLegacyTransaction = {
  nonce: Icdc188
  gas_price: Icdc188
  gas_limit: Icdc188
  action: IcEthereumTransactionTransactionAction
  value: Icdc188
  input: I_bytesSeq
  signature: IcEthereumTransactionTransactionSignature
}
const cEthereumTransactionLegacyTransaction: Codec<IcEthereumTransactionLegacyTransaction> =
  Struct({
    nonce: cdc188,
    gas_price: cdc188,
    gas_limit: cdc188,
    action: cEthereumTransactionTransactionAction,
    value: cdc188,
    input: _bytesSeq,
    signature: cEthereumTransactionTransactionSignature,
  })

type IcEthereumTransactionTransactionV2Legacy =
  IcEthereumTransactionLegacyTransaction
const cEthereumTransactionTransactionV2Legacy: Codec<IcEthereumTransactionTransactionV2Legacy> =
  cEthereumTransactionLegacyTransaction

type IcEthereumTransactionAccessListItem = {
  address: Icdc1
  storage_keys: Icdc65
}
const cEthereumTransactionAccessListItem: Codec<IcEthereumTransactionAccessListItem> =
  Struct({ address: cdc1, storage_keys: cdc65 })

type Icdc199 = Array<IcEthereumTransactionAccessListItem>
const cdc199: Codec<Icdc199> = Vector(cEthereumTransactionAccessListItem)

type IcEthereumTransactionEIP2930Transaction = {
  chain_id: bigint
  nonce: Icdc188
  gas_price: Icdc188
  gas_limit: Icdc188
  action: IcEthereumTransactionTransactionAction
  value: Icdc188
  input: I_bytesSeq
  access_list: Icdc199
  odd_y_parity: boolean
  r: Icdc13
  s: Icdc13
}
const cEthereumTransactionEIP2930Transaction: Codec<IcEthereumTransactionEIP2930Transaction> =
  Struct({
    chain_id: u64,
    nonce: cdc188,
    gas_price: cdc188,
    gas_limit: cdc188,
    action: cEthereumTransactionTransactionAction,
    value: cdc188,
    input: _bytesSeq,
    access_list: cdc199,
    odd_y_parity: bool,
    r: cdc13,
    s: cdc13,
  })

type IcEthereumTransactionTransactionV2EIP2930 =
  IcEthereumTransactionEIP2930Transaction
const cEthereumTransactionTransactionV2EIP2930: Codec<IcEthereumTransactionTransactionV2EIP2930> =
  cEthereumTransactionEIP2930Transaction

type IcEthereumTransactionEIP1559Transaction = {
  chain_id: bigint
  nonce: Icdc188
  max_priority_fee_per_gas: Icdc188
  max_fee_per_gas: Icdc188
  gas_limit: Icdc188
  action: IcEthereumTransactionTransactionAction
  value: Icdc188
  input: I_bytesSeq
  access_list: Icdc199
  odd_y_parity: boolean
  r: Icdc13
  s: Icdc13
}
const cEthereumTransactionEIP1559Transaction: Codec<IcEthereumTransactionEIP1559Transaction> =
  Struct({
    chain_id: u64,
    nonce: cdc188,
    max_priority_fee_per_gas: cdc188,
    max_fee_per_gas: cdc188,
    gas_limit: cdc188,
    action: cEthereumTransactionTransactionAction,
    value: cdc188,
    input: _bytesSeq,
    access_list: cdc199,
    odd_y_parity: bool,
    r: cdc13,
    s: cdc13,
  })

type IcEthereumTransactionTransactionV2EIP1559 =
  IcEthereumTransactionEIP1559Transaction
const cEthereumTransactionTransactionV2EIP1559: Codec<IcEthereumTransactionTransactionV2EIP1559> =
  cEthereumTransactionEIP1559Transaction

type IcEthereumTransactionTransactionV2 =
  | { tag: "Legacy"; value: IcEthereumTransactionTransactionV2Legacy }
  | { tag: "EIP2930"; value: IcEthereumTransactionTransactionV2EIP2930 }
  | { tag: "EIP1559"; value: IcEthereumTransactionTransactionV2EIP1559 }
const cEthereumTransactionTransactionV2: Codec<IcEthereumTransactionTransactionV2> =
  Enum({
    Legacy: cEthereumTransactionTransactionV2Legacy,
    EIP2930: cEthereumTransactionTransactionV2EIP2930,
    EIP1559: cEthereumTransactionTransactionV2EIP1559,
  })

type IcPallet_ethereumPalletCallTransact = {
  transaction: IcEthereumTransactionTransactionV2
}
const cPallet_ethereumPalletCallTransact: Codec<IcPallet_ethereumPalletCallTransact> =
  Struct({ transaction: cEthereumTransactionTransactionV2 })

type IcPallet_ethereumPalletCall = {
  tag: "transact"
  value: IcPallet_ethereumPalletCallTransact
}
const cPallet_ethereumPalletCall: Codec<IcPallet_ethereumPalletCall> = Enum({
  transact: cPallet_ethereumPalletCallTransact,
})

type IcMoonbeam_runtimeRuntimeCallEthereum = IcPallet_ethereumPalletCall
const cMoonbeam_runtimeRuntimeCallEthereum: Codec<IcMoonbeam_runtimeRuntimeCallEthereum> =
  cPallet_ethereumPalletCall

type IcPallet_schedulerPalletCallSchedule = {
  when: number
  maybe_periodic: IcOption
  priority: number
  call: IcMoonbeam_runtimeRuntimeCallCircular
}
const cPallet_schedulerPalletCallSchedule: Codec<IcPallet_schedulerPalletCallSchedule> =
  Struct({
    when: u32,
    maybe_periodic: cOption,
    priority: u8,
    call: cMoonbeam_runtimeRuntimeCallCircular,
  })

type IcPallet_schedulerPalletCallCancel = { when: number; index: number }
const cPallet_schedulerPalletCallCancel: Codec<IcPallet_schedulerPalletCallCancel> =
  Struct({ when: u32, index: u32 })

type IcPallet_schedulerPalletCallSchedule_named = {
  id: Icdc13
  when: number
  maybe_periodic: IcOption
  priority: number
  call: IcMoonbeam_runtimeRuntimeCallCircular
}
const cPallet_schedulerPalletCallSchedule_named: Codec<IcPallet_schedulerPalletCallSchedule_named> =
  Struct({
    id: cdc13,
    when: u32,
    maybe_periodic: cOption,
    priority: u8,
    call: cMoonbeam_runtimeRuntimeCallCircular,
  })

type IcPallet_schedulerPalletCallCancel_named = { id: Icdc13 }
const cPallet_schedulerPalletCallCancel_named: Codec<IcPallet_schedulerPalletCallCancel_named> =
  Struct({ id: cdc13 })

type IcPallet_schedulerPalletCallSchedule_after = {
  after: number
  maybe_periodic: IcOption
  priority: number
  call: IcMoonbeam_runtimeRuntimeCallCircular
}
const cPallet_schedulerPalletCallSchedule_after: Codec<IcPallet_schedulerPalletCallSchedule_after> =
  Struct({
    after: u32,
    maybe_periodic: cOption,
    priority: u8,
    call: cMoonbeam_runtimeRuntimeCallCircular,
  })

type IcPallet_schedulerPalletCallSchedule_named_after = {
  id: Icdc13
  after: number
  maybe_periodic: IcOption
  priority: number
  call: IcMoonbeam_runtimeRuntimeCallCircular
}
const cPallet_schedulerPalletCallSchedule_named_after: Codec<IcPallet_schedulerPalletCallSchedule_named_after> =
  Struct({
    id: cdc13,
    after: u32,
    maybe_periodic: cOption,
    priority: u8,
    call: cMoonbeam_runtimeRuntimeCallCircular,
  })

type IcPallet_schedulerPalletCall =
  | { tag: "schedule"; value: IcPallet_schedulerPalletCallSchedule }
  | { tag: "cancel"; value: IcPallet_schedulerPalletCallCancel }
  | { tag: "schedule_named"; value: IcPallet_schedulerPalletCallSchedule_named }
  | { tag: "cancel_named"; value: IcPallet_schedulerPalletCallCancel_named }
  | { tag: "schedule_after"; value: IcPallet_schedulerPalletCallSchedule_after }
  | {
      tag: "schedule_named_after"
      value: IcPallet_schedulerPalletCallSchedule_named_after
    }
const cPallet_schedulerPalletCall: Codec<IcPallet_schedulerPalletCall> = Enum({
  schedule: cPallet_schedulerPalletCallSchedule,
  cancel: cPallet_schedulerPalletCallCancel,
  schedule_named: cPallet_schedulerPalletCallSchedule_named,
  cancel_named: cPallet_schedulerPalletCallCancel_named,
  schedule_after: cPallet_schedulerPalletCallSchedule_after,
  schedule_named_after: cPallet_schedulerPalletCallSchedule_named_after,
})

type IcMoonbeam_runtimeRuntimeCallScheduler = IcPallet_schedulerPalletCall
const cMoonbeam_runtimeRuntimeCallScheduler: Codec<IcMoonbeam_runtimeRuntimeCallScheduler> =
  cPallet_schedulerPalletCall

type IcPallet_democracyPalletCallPropose = {
  proposal: IcFrame_supportTraitsPreimagesBounded
  value: bigint
}
const cPallet_democracyPalletCallPropose: Codec<IcPallet_democracyPalletCallPropose> =
  Struct({ proposal: cFrame_supportTraitsPreimagesBounded, value: compactBn })

type IcPallet_democracyPalletCallSecond = { proposal: number }
const cPallet_democracyPalletCallSecond: Codec<IcPallet_democracyPalletCallSecond> =
  Struct({ proposal: compactNumber })

type IcPallet_democracyPalletCallVote = {
  ref_index: number
  vote: IcPallet_democracyVoteAccountVote
}
const cPallet_democracyPalletCallVote: Codec<IcPallet_democracyPalletCallVote> =
  Struct({ ref_index: compactNumber, vote: cPallet_democracyVoteAccountVote })

type IcPallet_democracyPalletCallEmergency_cancel = { ref_index: number }
const cPallet_democracyPalletCallEmergency_cancel: Codec<IcPallet_democracyPalletCallEmergency_cancel> =
  Struct({ ref_index: u32 })

type IcPallet_democracyPalletCallExternal_propose = {
  proposal: IcFrame_supportTraitsPreimagesBounded
}
const cPallet_democracyPalletCallExternal_propose: Codec<IcPallet_democracyPalletCallExternal_propose> =
  Struct({ proposal: cFrame_supportTraitsPreimagesBounded })

type IcPallet_democracyPalletCallExternal_propose_majority = {
  proposal: IcFrame_supportTraitsPreimagesBounded
}
const cPallet_democracyPalletCallExternal_propose_majority: Codec<IcPallet_democracyPalletCallExternal_propose_majority> =
  Struct({ proposal: cFrame_supportTraitsPreimagesBounded })

type IcPallet_democracyPalletCallExternal_propose_default = {
  proposal: IcFrame_supportTraitsPreimagesBounded
}
const cPallet_democracyPalletCallExternal_propose_default: Codec<IcPallet_democracyPalletCallExternal_propose_default> =
  Struct({ proposal: cFrame_supportTraitsPreimagesBounded })

type IcPallet_democracyPalletCallFast_track = {
  proposal_hash: Icdc13
  voting_period: number
  delay: number
}
const cPallet_democracyPalletCallFast_track: Codec<IcPallet_democracyPalletCallFast_track> =
  Struct({ proposal_hash: cdc13, voting_period: u32, delay: u32 })

type IcPallet_democracyPalletCallVeto_external = { proposal_hash: Icdc13 }
const cPallet_democracyPalletCallVeto_external: Codec<IcPallet_democracyPalletCallVeto_external> =
  Struct({ proposal_hash: cdc13 })

type IcPallet_democracyPalletCallCancel_referendum = { ref_index: number }
const cPallet_democracyPalletCallCancel_referendum: Codec<IcPallet_democracyPalletCallCancel_referendum> =
  Struct({ ref_index: compactNumber })

type IcPallet_democracyConvictionConviction =
  | { tag: "None"; value: undefined }
  | { tag: "Locked1x"; value: undefined }
  | { tag: "Locked2x"; value: undefined }
  | { tag: "Locked3x"; value: undefined }
  | { tag: "Locked4x"; value: undefined }
  | { tag: "Locked5x"; value: undefined }
  | { tag: "Locked6x"; value: undefined }
const cPallet_democracyConvictionConviction: Codec<IcPallet_democracyConvictionConviction> =
  Enum({
    None: _void,
    Locked1x: _void,
    Locked2x: _void,
    Locked3x: _void,
    Locked4x: _void,
    Locked5x: _void,
    Locked6x: _void,
  })

type IcPallet_democracyPalletCallDelegate = {
  to: Icdc1
  conviction: IcPallet_democracyConvictionConviction
  balance: bigint
}
const cPallet_democracyPalletCallDelegate: Codec<IcPallet_democracyPalletCallDelegate> =
  Struct({
    to: cdc1,
    conviction: cPallet_democracyConvictionConviction,
    balance: u128,
  })

type IcPallet_democracyPalletCallUnlock = { target: Icdc1 }
const cPallet_democracyPalletCallUnlock: Codec<IcPallet_democracyPalletCallUnlock> =
  Struct({ target: cdc1 })

type IcPallet_democracyPalletCallRemove_vote = { index: number }
const cPallet_democracyPalletCallRemove_vote: Codec<IcPallet_democracyPalletCallRemove_vote> =
  Struct({ index: u32 })

type IcPallet_democracyPalletCallRemove_other_vote = {
  target: Icdc1
  index: number
}
const cPallet_democracyPalletCallRemove_other_vote: Codec<IcPallet_democracyPalletCallRemove_other_vote> =
  Struct({ target: cdc1, index: u32 })

type IcPallet_democracyPalletCallBlacklist = {
  proposal_hash: Icdc13
  maybe_ref_index: IcOption
}
const cPallet_democracyPalletCallBlacklist: Codec<IcPallet_democracyPalletCallBlacklist> =
  Struct({ proposal_hash: cdc13, maybe_ref_index: cOption })

type IcPallet_democracyPalletCallCancel_proposal = { prop_index: number }
const cPallet_democracyPalletCallCancel_proposal: Codec<IcPallet_democracyPalletCallCancel_proposal> =
  Struct({ prop_index: compactNumber })

type IcPallet_democracyPalletCallSet_metadata = {
  owner: IcPallet_democracyTypesMetadataOwner
  maybe_hash: IcOption
}
const cPallet_democracyPalletCallSet_metadata: Codec<IcPallet_democracyPalletCallSet_metadata> =
  Struct({ owner: cPallet_democracyTypesMetadataOwner, maybe_hash: cOption })

type IcPallet_democracyPalletCall =
  | { tag: "propose"; value: IcPallet_democracyPalletCallPropose }
  | { tag: "second"; value: IcPallet_democracyPalletCallSecond }
  | { tag: "vote"; value: IcPallet_democracyPalletCallVote }
  | {
      tag: "emergency_cancel"
      value: IcPallet_democracyPalletCallEmergency_cancel
    }
  | {
      tag: "external_propose"
      value: IcPallet_democracyPalletCallExternal_propose
    }
  | {
      tag: "external_propose_majority"
      value: IcPallet_democracyPalletCallExternal_propose_majority
    }
  | {
      tag: "external_propose_default"
      value: IcPallet_democracyPalletCallExternal_propose_default
    }
  | { tag: "fast_track"; value: IcPallet_democracyPalletCallFast_track }
  | { tag: "veto_external"; value: IcPallet_democracyPalletCallVeto_external }
  | {
      tag: "cancel_referendum"
      value: IcPallet_democracyPalletCallCancel_referendum
    }
  | { tag: "delegate"; value: IcPallet_democracyPalletCallDelegate }
  | { tag: "undelegate"; value: undefined }
  | { tag: "clear_public_proposals"; value: undefined }
  | { tag: "unlock"; value: IcPallet_democracyPalletCallUnlock }
  | { tag: "remove_vote"; value: IcPallet_democracyPalletCallRemove_vote }
  | {
      tag: "remove_other_vote"
      value: IcPallet_democracyPalletCallRemove_other_vote
    }
  | { tag: "blacklist"; value: IcPallet_democracyPalletCallBlacklist }
  | {
      tag: "cancel_proposal"
      value: IcPallet_democracyPalletCallCancel_proposal
    }
  | { tag: "set_metadata"; value: IcPallet_democracyPalletCallSet_metadata }
const cPallet_democracyPalletCall: Codec<IcPallet_democracyPalletCall> = Enum({
  propose: cPallet_democracyPalletCallPropose,
  second: cPallet_democracyPalletCallSecond,
  vote: cPallet_democracyPalletCallVote,
  emergency_cancel: cPallet_democracyPalletCallEmergency_cancel,
  external_propose: cPallet_democracyPalletCallExternal_propose,
  external_propose_majority:
    cPallet_democracyPalletCallExternal_propose_majority,
  external_propose_default: cPallet_democracyPalletCallExternal_propose_default,
  fast_track: cPallet_democracyPalletCallFast_track,
  veto_external: cPallet_democracyPalletCallVeto_external,
  cancel_referendum: cPallet_democracyPalletCallCancel_referendum,
  delegate: cPallet_democracyPalletCallDelegate,
  undelegate: _void,
  clear_public_proposals: _void,
  unlock: cPallet_democracyPalletCallUnlock,
  remove_vote: cPallet_democracyPalletCallRemove_vote,
  remove_other_vote: cPallet_democracyPalletCallRemove_other_vote,
  blacklist: cPallet_democracyPalletCallBlacklist,
  cancel_proposal: cPallet_democracyPalletCallCancel_proposal,
  set_metadata: cPallet_democracyPalletCallSet_metadata,
})

type IcMoonbeam_runtimeRuntimeCallDemocracy = IcPallet_democracyPalletCall
const cMoonbeam_runtimeRuntimeCallDemocracy: Codec<IcMoonbeam_runtimeRuntimeCallDemocracy> =
  cPallet_democracyPalletCall

type IcPallet_preimagePalletCallNote_preimage = { bytes: I_bytesSeq }
const cPallet_preimagePalletCallNote_preimage: Codec<IcPallet_preimagePalletCallNote_preimage> =
  Struct({ bytes: _bytesSeq })

type IcPallet_preimagePalletCallUnnote_preimage = { hash: Icdc13 }
const cPallet_preimagePalletCallUnnote_preimage: Codec<IcPallet_preimagePalletCallUnnote_preimage> =
  Struct({ hash: cdc13 })

type IcPallet_preimagePalletCallRequest_preimage = { hash: Icdc13 }
const cPallet_preimagePalletCallRequest_preimage: Codec<IcPallet_preimagePalletCallRequest_preimage> =
  Struct({ hash: cdc13 })

type IcPallet_preimagePalletCallUnrequest_preimage = { hash: Icdc13 }
const cPallet_preimagePalletCallUnrequest_preimage: Codec<IcPallet_preimagePalletCallUnrequest_preimage> =
  Struct({ hash: cdc13 })

type IcPallet_preimagePalletCall =
  | { tag: "note_preimage"; value: IcPallet_preimagePalletCallNote_preimage }
  | {
      tag: "unnote_preimage"
      value: IcPallet_preimagePalletCallUnnote_preimage
    }
  | {
      tag: "request_preimage"
      value: IcPallet_preimagePalletCallRequest_preimage
    }
  | {
      tag: "unrequest_preimage"
      value: IcPallet_preimagePalletCallUnrequest_preimage
    }
const cPallet_preimagePalletCall: Codec<IcPallet_preimagePalletCall> = Enum({
  note_preimage: cPallet_preimagePalletCallNote_preimage,
  unnote_preimage: cPallet_preimagePalletCallUnnote_preimage,
  request_preimage: cPallet_preimagePalletCallRequest_preimage,
  unrequest_preimage: cPallet_preimagePalletCallUnrequest_preimage,
})

type IcMoonbeam_runtimeRuntimeCallPreimage = IcPallet_preimagePalletCall
const cMoonbeam_runtimeRuntimeCallPreimage: Codec<IcMoonbeam_runtimeRuntimeCallPreimage> =
  cPallet_preimagePalletCall

type IcPallet_conviction_votingVoteAccountVoteStandard = {
  vote: number
  balance: bigint
}
const cPallet_conviction_votingVoteAccountVoteStandard: Codec<IcPallet_conviction_votingVoteAccountVoteStandard> =
  Struct({ vote: u8, balance: u128 })

type IcPallet_conviction_votingVoteAccountVoteSplit = {
  aye: bigint
  nay: bigint
}
const cPallet_conviction_votingVoteAccountVoteSplit: Codec<IcPallet_conviction_votingVoteAccountVoteSplit> =
  Struct({ aye: u128, nay: u128 })

type IcPallet_conviction_votingVoteAccountVoteSplitAbstain = {
  aye: bigint
  nay: bigint
  abstain: bigint
}
const cPallet_conviction_votingVoteAccountVoteSplitAbstain: Codec<IcPallet_conviction_votingVoteAccountVoteSplitAbstain> =
  Struct({ aye: u128, nay: u128, abstain: u128 })

type IcPallet_conviction_votingVoteAccountVote =
  | {
      tag: "Standard"
      value: IcPallet_conviction_votingVoteAccountVoteStandard
    }
  | { tag: "Split"; value: IcPallet_conviction_votingVoteAccountVoteSplit }
  | {
      tag: "SplitAbstain"
      value: IcPallet_conviction_votingVoteAccountVoteSplitAbstain
    }
const cPallet_conviction_votingVoteAccountVote: Codec<IcPallet_conviction_votingVoteAccountVote> =
  Enum({
    Standard: cPallet_conviction_votingVoteAccountVoteStandard,
    Split: cPallet_conviction_votingVoteAccountVoteSplit,
    SplitAbstain: cPallet_conviction_votingVoteAccountVoteSplitAbstain,
  })

type IcPallet_conviction_votingPalletCallVote = {
  poll_index: number
  vote: IcPallet_conviction_votingVoteAccountVote
}
const cPallet_conviction_votingPalletCallVote: Codec<IcPallet_conviction_votingPalletCallVote> =
  Struct({
    poll_index: compactNumber,
    vote: cPallet_conviction_votingVoteAccountVote,
  })

type IcPallet_conviction_votingConvictionConviction =
  | { tag: "None"; value: undefined }
  | { tag: "Locked1x"; value: undefined }
  | { tag: "Locked2x"; value: undefined }
  | { tag: "Locked3x"; value: undefined }
  | { tag: "Locked4x"; value: undefined }
  | { tag: "Locked5x"; value: undefined }
  | { tag: "Locked6x"; value: undefined }
const cPallet_conviction_votingConvictionConviction: Codec<IcPallet_conviction_votingConvictionConviction> =
  Enum({
    None: _void,
    Locked1x: _void,
    Locked2x: _void,
    Locked3x: _void,
    Locked4x: _void,
    Locked5x: _void,
    Locked6x: _void,
  })

type IcPallet_conviction_votingPalletCallDelegate = {
  class: number
  to: Icdc1
  conviction: IcPallet_conviction_votingConvictionConviction
  balance: bigint
}
const cPallet_conviction_votingPalletCallDelegate: Codec<IcPallet_conviction_votingPalletCallDelegate> =
  Struct({
    class: u16,
    to: cdc1,
    conviction: cPallet_conviction_votingConvictionConviction,
    balance: u128,
  })

type IcPallet_conviction_votingPalletCallUndelegate = { class: number }
const cPallet_conviction_votingPalletCallUndelegate: Codec<IcPallet_conviction_votingPalletCallUndelegate> =
  Struct({ class: u16 })

type IcPallet_conviction_votingPalletCallUnlock = {
  class: number
  target: Icdc1
}
const cPallet_conviction_votingPalletCallUnlock: Codec<IcPallet_conviction_votingPalletCallUnlock> =
  Struct({ class: u16, target: cdc1 })

type IcPallet_conviction_votingPalletCallRemove_vote = {
  class: IcOption
  index: number
}
const cPallet_conviction_votingPalletCallRemove_vote: Codec<IcPallet_conviction_votingPalletCallRemove_vote> =
  Struct({ class: cOption, index: u32 })

type IcPallet_conviction_votingPalletCallRemove_other_vote = {
  target: Icdc1
  class: number
  index: number
}
const cPallet_conviction_votingPalletCallRemove_other_vote: Codec<IcPallet_conviction_votingPalletCallRemove_other_vote> =
  Struct({ target: cdc1, class: u16, index: u32 })

type IcPallet_conviction_votingPalletCall =
  | { tag: "vote"; value: IcPallet_conviction_votingPalletCallVote }
  | { tag: "delegate"; value: IcPallet_conviction_votingPalletCallDelegate }
  | { tag: "undelegate"; value: IcPallet_conviction_votingPalletCallUndelegate }
  | { tag: "unlock"; value: IcPallet_conviction_votingPalletCallUnlock }
  | {
      tag: "remove_vote"
      value: IcPallet_conviction_votingPalletCallRemove_vote
    }
  | {
      tag: "remove_other_vote"
      value: IcPallet_conviction_votingPalletCallRemove_other_vote
    }
const cPallet_conviction_votingPalletCall: Codec<IcPallet_conviction_votingPalletCall> =
  Enum({
    vote: cPallet_conviction_votingPalletCallVote,
    delegate: cPallet_conviction_votingPalletCallDelegate,
    undelegate: cPallet_conviction_votingPalletCallUndelegate,
    unlock: cPallet_conviction_votingPalletCallUnlock,
    remove_vote: cPallet_conviction_votingPalletCallRemove_vote,
    remove_other_vote: cPallet_conviction_votingPalletCallRemove_other_vote,
  })

type IcMoonbeam_runtimeRuntimeCallConvictionVoting =
  IcPallet_conviction_votingPalletCall
const cMoonbeam_runtimeRuntimeCallConvictionVoting: Codec<IcMoonbeam_runtimeRuntimeCallConvictionVoting> =
  cPallet_conviction_votingPalletCall

type IcFrame_supportTraitsScheduleDispatchTimeAt = number
const cFrame_supportTraitsScheduleDispatchTimeAt: Codec<IcFrame_supportTraitsScheduleDispatchTimeAt> =
  u32

type IcFrame_supportTraitsScheduleDispatchTimeAfter = number
const cFrame_supportTraitsScheduleDispatchTimeAfter: Codec<IcFrame_supportTraitsScheduleDispatchTimeAfter> =
  u32

type IcFrame_supportTraitsScheduleDispatchTime =
  | { tag: "At"; value: IcFrame_supportTraitsScheduleDispatchTimeAt }
  | { tag: "After"; value: IcFrame_supportTraitsScheduleDispatchTimeAfter }
const cFrame_supportTraitsScheduleDispatchTime: Codec<IcFrame_supportTraitsScheduleDispatchTime> =
  Enum({
    At: cFrame_supportTraitsScheduleDispatchTimeAt,
    After: cFrame_supportTraitsScheduleDispatchTimeAfter,
  })

type IcPallet_referendaPalletCallSubmit = {
  proposal_origin: IcMoonbeam_runtimeOriginCaller
  proposal: IcFrame_supportTraitsPreimagesBounded
  enactment_moment: IcFrame_supportTraitsScheduleDispatchTime
}
const cPallet_referendaPalletCallSubmit: Codec<IcPallet_referendaPalletCallSubmit> =
  Struct({
    proposal_origin: cMoonbeam_runtimeOriginCaller,
    proposal: cFrame_supportTraitsPreimagesBounded,
    enactment_moment: cFrame_supportTraitsScheduleDispatchTime,
  })

type IcPallet_referendaPalletCallPlace_decision_deposit = { index: number }
const cPallet_referendaPalletCallPlace_decision_deposit: Codec<IcPallet_referendaPalletCallPlace_decision_deposit> =
  Struct({ index: u32 })

type IcPallet_referendaPalletCallRefund_decision_deposit = { index: number }
const cPallet_referendaPalletCallRefund_decision_deposit: Codec<IcPallet_referendaPalletCallRefund_decision_deposit> =
  Struct({ index: u32 })

type IcPallet_referendaPalletCallCancel = { index: number }
const cPallet_referendaPalletCallCancel: Codec<IcPallet_referendaPalletCallCancel> =
  Struct({ index: u32 })

type IcPallet_referendaPalletCallKill = { index: number }
const cPallet_referendaPalletCallKill: Codec<IcPallet_referendaPalletCallKill> =
  Struct({ index: u32 })

type IcPallet_referendaPalletCallNudge_referendum = { index: number }
const cPallet_referendaPalletCallNudge_referendum: Codec<IcPallet_referendaPalletCallNudge_referendum> =
  Struct({ index: u32 })

type IcPallet_referendaPalletCallOne_fewer_deciding = { track: number }
const cPallet_referendaPalletCallOne_fewer_deciding: Codec<IcPallet_referendaPalletCallOne_fewer_deciding> =
  Struct({ track: u16 })

type IcPallet_referendaPalletCallRefund_submission_deposit = { index: number }
const cPallet_referendaPalletCallRefund_submission_deposit: Codec<IcPallet_referendaPalletCallRefund_submission_deposit> =
  Struct({ index: u32 })

type IcPallet_referendaPalletCallSet_metadata = {
  index: number
  maybe_hash: IcOption
}
const cPallet_referendaPalletCallSet_metadata: Codec<IcPallet_referendaPalletCallSet_metadata> =
  Struct({ index: u32, maybe_hash: cOption })

type IcPallet_referendaPalletCall =
  | { tag: "submit"; value: IcPallet_referendaPalletCallSubmit }
  | {
      tag: "place_decision_deposit"
      value: IcPallet_referendaPalletCallPlace_decision_deposit
    }
  | {
      tag: "refund_decision_deposit"
      value: IcPallet_referendaPalletCallRefund_decision_deposit
    }
  | { tag: "cancel"; value: IcPallet_referendaPalletCallCancel }
  | { tag: "kill"; value: IcPallet_referendaPalletCallKill }
  | {
      tag: "nudge_referendum"
      value: IcPallet_referendaPalletCallNudge_referendum
    }
  | {
      tag: "one_fewer_deciding"
      value: IcPallet_referendaPalletCallOne_fewer_deciding
    }
  | {
      tag: "refund_submission_deposit"
      value: IcPallet_referendaPalletCallRefund_submission_deposit
    }
  | { tag: "set_metadata"; value: IcPallet_referendaPalletCallSet_metadata }
const cPallet_referendaPalletCall: Codec<IcPallet_referendaPalletCall> = Enum({
  submit: cPallet_referendaPalletCallSubmit,
  place_decision_deposit: cPallet_referendaPalletCallPlace_decision_deposit,
  refund_decision_deposit: cPallet_referendaPalletCallRefund_decision_deposit,
  cancel: cPallet_referendaPalletCallCancel,
  kill: cPallet_referendaPalletCallKill,
  nudge_referendum: cPallet_referendaPalletCallNudge_referendum,
  one_fewer_deciding: cPallet_referendaPalletCallOne_fewer_deciding,
  refund_submission_deposit:
    cPallet_referendaPalletCallRefund_submission_deposit,
  set_metadata: cPallet_referendaPalletCallSet_metadata,
})

type IcMoonbeam_runtimeRuntimeCallReferenda = IcPallet_referendaPalletCall
const cMoonbeam_runtimeRuntimeCallReferenda: Codec<IcMoonbeam_runtimeRuntimeCallReferenda> =
  cPallet_referendaPalletCall

type IcPallet_whitelistPalletCallWhitelist_call = { call_hash: Icdc13 }
const cPallet_whitelistPalletCallWhitelist_call: Codec<IcPallet_whitelistPalletCallWhitelist_call> =
  Struct({ call_hash: cdc13 })

type IcPallet_whitelistPalletCallRemove_whitelisted_call = { call_hash: Icdc13 }
const cPallet_whitelistPalletCallRemove_whitelisted_call: Codec<IcPallet_whitelistPalletCallRemove_whitelisted_call> =
  Struct({ call_hash: cdc13 })

type IcPallet_whitelistPalletCallDispatch_whitelisted_call = {
  call_hash: Icdc13
  call_encoded_len: number
  call_weight_witness: IcSp_weightsWeight_v2Weight
}
const cPallet_whitelistPalletCallDispatch_whitelisted_call: Codec<IcPallet_whitelistPalletCallDispatch_whitelisted_call> =
  Struct({
    call_hash: cdc13,
    call_encoded_len: u32,
    call_weight_witness: cSp_weightsWeight_v2Weight,
  })

type IcPallet_whitelistPalletCallDispatch_whitelisted_call_with_preimage = {
  call: IcMoonbeam_runtimeRuntimeCallCircular
}
const cPallet_whitelistPalletCallDispatch_whitelisted_call_with_preimage: Codec<IcPallet_whitelistPalletCallDispatch_whitelisted_call_with_preimage> =
  Struct({ call: cMoonbeam_runtimeRuntimeCallCircular })

type IcPallet_whitelistPalletCall =
  | { tag: "whitelist_call"; value: IcPallet_whitelistPalletCallWhitelist_call }
  | {
      tag: "remove_whitelisted_call"
      value: IcPallet_whitelistPalletCallRemove_whitelisted_call
    }
  | {
      tag: "dispatch_whitelisted_call"
      value: IcPallet_whitelistPalletCallDispatch_whitelisted_call
    }
  | {
      tag: "dispatch_whitelisted_call_with_preimage"
      value: IcPallet_whitelistPalletCallDispatch_whitelisted_call_with_preimage
    }
const cPallet_whitelistPalletCall: Codec<IcPallet_whitelistPalletCall> = Enum({
  whitelist_call: cPallet_whitelistPalletCallWhitelist_call,
  remove_whitelisted_call: cPallet_whitelistPalletCallRemove_whitelisted_call,
  dispatch_whitelisted_call:
    cPallet_whitelistPalletCallDispatch_whitelisted_call,
  dispatch_whitelisted_call_with_preimage:
    cPallet_whitelistPalletCallDispatch_whitelisted_call_with_preimage,
})

type IcMoonbeam_runtimeRuntimeCallWhitelist = IcPallet_whitelistPalletCall
const cMoonbeam_runtimeRuntimeCallWhitelist: Codec<IcMoonbeam_runtimeRuntimeCallWhitelist> =
  cPallet_whitelistPalletCall

type IcPallet_collectivePalletCallSet_members = {
  new_members: Icdc109
  prime: IcOption
  old_count: number
}
const cPallet_collectivePalletCallSet_members: Codec<IcPallet_collectivePalletCallSet_members> =
  Struct({ new_members: cdc109, prime: cOption, old_count: u32 })

type IcPallet_collectivePalletCallExecute = {
  proposal: IcMoonbeam_runtimeRuntimeCallCircular
  length_bound: number
}
const cPallet_collectivePalletCallExecute: Codec<IcPallet_collectivePalletCallExecute> =
  Struct({
    proposal: cMoonbeam_runtimeRuntimeCallCircular,
    length_bound: compactNumber,
  })

type IcPallet_collectivePalletCallPropose = {
  threshold: number
  proposal: IcMoonbeam_runtimeRuntimeCallCircular
  length_bound: number
}
const cPallet_collectivePalletCallPropose: Codec<IcPallet_collectivePalletCallPropose> =
  Struct({
    threshold: compactNumber,
    proposal: cMoonbeam_runtimeRuntimeCallCircular,
    length_bound: compactNumber,
  })

type IcPallet_collectivePalletCallVote = {
  proposal: Icdc13
  index: number
  approve: boolean
}
const cPallet_collectivePalletCallVote: Codec<IcPallet_collectivePalletCallVote> =
  Struct({ proposal: cdc13, index: compactNumber, approve: bool })

type IcPallet_collectivePalletCallDisapprove_proposal = {
  proposal_hash: Icdc13
}
const cPallet_collectivePalletCallDisapprove_proposal: Codec<IcPallet_collectivePalletCallDisapprove_proposal> =
  Struct({ proposal_hash: cdc13 })

type IcPallet_collectivePalletCallClose = {
  proposal_hash: Icdc13
  index: number
  proposal_weight_bound: IcSp_weightsWeight_v2Weight
  length_bound: number
}
const cPallet_collectivePalletCallClose: Codec<IcPallet_collectivePalletCallClose> =
  Struct({
    proposal_hash: cdc13,
    index: compactNumber,
    proposal_weight_bound: cSp_weightsWeight_v2Weight,
    length_bound: compactNumber,
  })

type IcPallet_collectivePalletCall =
  | { tag: "set_members"; value: IcPallet_collectivePalletCallSet_members }
  | { tag: "execute"; value: IcPallet_collectivePalletCallExecute }
  | { tag: "propose"; value: IcPallet_collectivePalletCallPropose }
  | { tag: "vote"; value: IcPallet_collectivePalletCallVote }
  | {
      tag: "disapprove_proposal"
      value: IcPallet_collectivePalletCallDisapprove_proposal
    }
  | { tag: "close"; value: IcPallet_collectivePalletCallClose }
const cPallet_collectivePalletCall: Codec<IcPallet_collectivePalletCall> = Enum(
  {
    set_members: cPallet_collectivePalletCallSet_members,
    execute: cPallet_collectivePalletCallExecute,
    propose: cPallet_collectivePalletCallPropose,
    vote: cPallet_collectivePalletCallVote,
    disapprove_proposal: cPallet_collectivePalletCallDisapprove_proposal,
    close: cPallet_collectivePalletCallClose,
  },
  [0, 1, 2, 3, 5, 6],
)

type IcMoonbeam_runtimeRuntimeCallCouncilCollective =
  IcPallet_collectivePalletCall
const cMoonbeam_runtimeRuntimeCallCouncilCollective: Codec<IcMoonbeam_runtimeRuntimeCallCouncilCollective> =
  cPallet_collectivePalletCall

type IcMoonbeam_runtimeRuntimeCallTechCommitteeCollective =
  IcPallet_collectivePalletCall
const cMoonbeam_runtimeRuntimeCallTechCommitteeCollective: Codec<IcMoonbeam_runtimeRuntimeCallTechCommitteeCollective> =
  cPallet_collectivePalletCall

type IcMoonbeam_runtimeRuntimeCallTreasuryCouncilCollective =
  IcPallet_collectivePalletCall
const cMoonbeam_runtimeRuntimeCallTreasuryCouncilCollective: Codec<IcMoonbeam_runtimeRuntimeCallTreasuryCouncilCollective> =
  cPallet_collectivePalletCall

type IcMoonbeam_runtimeRuntimeCallOpenTechCommitteeCollective =
  IcPallet_collectivePalletCall
const cMoonbeam_runtimeRuntimeCallOpenTechCommitteeCollective: Codec<IcMoonbeam_runtimeRuntimeCallOpenTechCommitteeCollective> =
  cPallet_collectivePalletCall

type IcPallet_treasuryPalletCallPropose_spend = {
  value: bigint
  beneficiary: Icdc1
}
const cPallet_treasuryPalletCallPropose_spend: Codec<IcPallet_treasuryPalletCallPropose_spend> =
  Struct({ value: compactBn, beneficiary: cdc1 })

type IcPallet_treasuryPalletCallReject_proposal = { proposal_id: number }
const cPallet_treasuryPalletCallReject_proposal: Codec<IcPallet_treasuryPalletCallReject_proposal> =
  Struct({ proposal_id: compactNumber })

type IcPallet_treasuryPalletCallApprove_proposal = { proposal_id: number }
const cPallet_treasuryPalletCallApprove_proposal: Codec<IcPallet_treasuryPalletCallApprove_proposal> =
  Struct({ proposal_id: compactNumber })

type IcPallet_treasuryPalletCallSpend = { amount: bigint; beneficiary: Icdc1 }
const cPallet_treasuryPalletCallSpend: Codec<IcPallet_treasuryPalletCallSpend> =
  Struct({ amount: compactBn, beneficiary: cdc1 })

type IcPallet_treasuryPalletCallRemove_approval = { proposal_id: number }
const cPallet_treasuryPalletCallRemove_approval: Codec<IcPallet_treasuryPalletCallRemove_approval> =
  Struct({ proposal_id: compactNumber })

type IcPallet_treasuryPalletCall =
  | { tag: "propose_spend"; value: IcPallet_treasuryPalletCallPropose_spend }
  | {
      tag: "reject_proposal"
      value: IcPallet_treasuryPalletCallReject_proposal
    }
  | {
      tag: "approve_proposal"
      value: IcPallet_treasuryPalletCallApprove_proposal
    }
  | { tag: "spend"; value: IcPallet_treasuryPalletCallSpend }
  | {
      tag: "remove_approval"
      value: IcPallet_treasuryPalletCallRemove_approval
    }
const cPallet_treasuryPalletCall: Codec<IcPallet_treasuryPalletCall> = Enum({
  propose_spend: cPallet_treasuryPalletCallPropose_spend,
  reject_proposal: cPallet_treasuryPalletCallReject_proposal,
  approve_proposal: cPallet_treasuryPalletCallApprove_proposal,
  spend: cPallet_treasuryPalletCallSpend,
  remove_approval: cPallet_treasuryPalletCallRemove_approval,
})

type IcMoonbeam_runtimeRuntimeCallTreasury = IcPallet_treasuryPalletCall
const cMoonbeam_runtimeRuntimeCallTreasury: Codec<IcMoonbeam_runtimeRuntimeCallTreasury> =
  cPallet_treasuryPalletCall

type Icdc225 = HexString
const cdc225: Codec<Icdc225> = Hex(64)

type IcSp_runtimeMultiSignatureEd25519 = Icdc225
const cSp_runtimeMultiSignatureEd25519: Codec<IcSp_runtimeMultiSignatureEd25519> =
  cdc225

type IcSp_runtimeMultiSignatureSr25519 = Icdc225
const cSp_runtimeMultiSignatureSr25519: Codec<IcSp_runtimeMultiSignatureSr25519> =
  cdc225

type Icdc228 = HexString
const cdc228: Codec<Icdc228> = Hex(65)

type IcSp_runtimeMultiSignatureEcdsa = Icdc228
const cSp_runtimeMultiSignatureEcdsa: Codec<IcSp_runtimeMultiSignatureEcdsa> =
  cdc228

type IcSp_runtimeMultiSignature =
  | { tag: "Ed25519"; value: IcSp_runtimeMultiSignatureEd25519 }
  | { tag: "Sr25519"; value: IcSp_runtimeMultiSignatureSr25519 }
  | { tag: "Ecdsa"; value: IcSp_runtimeMultiSignatureEcdsa }
const cSp_runtimeMultiSignature: Codec<IcSp_runtimeMultiSignature> = Enum({
  Ed25519: cSp_runtimeMultiSignatureEd25519,
  Sr25519: cSp_runtimeMultiSignatureSr25519,
  Ecdsa: cSp_runtimeMultiSignatureEcdsa,
})

type IcPallet_crowdloan_rewardsPalletCallAssociate_native_identity = {
  reward_account: Icdc1
  relay_account: Icdc13
  proof: IcSp_runtimeMultiSignature
}
const cPallet_crowdloan_rewardsPalletCallAssociate_native_identity: Codec<IcPallet_crowdloan_rewardsPalletCallAssociate_native_identity> =
  Struct({
    reward_account: cdc1,
    relay_account: cdc13,
    proof: cSp_runtimeMultiSignature,
  })

type Icdc230 = [Icdc13, IcSp_runtimeMultiSignature]
const cdc230: Codec<Icdc230> = Tuple(cdc13, cSp_runtimeMultiSignature)

type Icdc229 = Array<Icdc230>
const cdc229: Codec<Icdc229> = Vector(cdc230)

type IcPallet_crowdloan_rewardsPalletCallChange_association_with_relay_keys = {
  reward_account: Icdc1
  previous_account: Icdc1
  proofs: Icdc229
}
const cPallet_crowdloan_rewardsPalletCallChange_association_with_relay_keys: Codec<IcPallet_crowdloan_rewardsPalletCallChange_association_with_relay_keys> =
  Struct({ reward_account: cdc1, previous_account: cdc1, proofs: cdc229 })

type IcPallet_crowdloan_rewardsPalletCallUpdate_reward_address = {
  new_reward_account: Icdc1
}
const cPallet_crowdloan_rewardsPalletCallUpdate_reward_address: Codec<IcPallet_crowdloan_rewardsPalletCallUpdate_reward_address> =
  Struct({ new_reward_account: cdc1 })

type IcPallet_crowdloan_rewardsPalletCallComplete_initialization = {
  lease_ending_block: number
}
const cPallet_crowdloan_rewardsPalletCallComplete_initialization: Codec<IcPallet_crowdloan_rewardsPalletCallComplete_initialization> =
  Struct({ lease_ending_block: u32 })

type Icdc232 = [Icdc13, IcOption, bigint]
const cdc232: Codec<Icdc232> = Tuple(cdc13, cOption, u128)

type Icdc231 = Array<Icdc232>
const cdc231: Codec<Icdc231> = Vector(cdc232)

type IcPallet_crowdloan_rewardsPalletCallInitialize_reward_vec = {
  rewards: Icdc231
}
const cPallet_crowdloan_rewardsPalletCallInitialize_reward_vec: Codec<IcPallet_crowdloan_rewardsPalletCallInitialize_reward_vec> =
  Struct({ rewards: cdc231 })

type IcPallet_crowdloan_rewardsPalletCall =
  | {
      tag: "associate_native_identity"
      value: IcPallet_crowdloan_rewardsPalletCallAssociate_native_identity
    }
  | {
      tag: "change_association_with_relay_keys"
      value: IcPallet_crowdloan_rewardsPalletCallChange_association_with_relay_keys
    }
  | { tag: "claim"; value: undefined }
  | {
      tag: "update_reward_address"
      value: IcPallet_crowdloan_rewardsPalletCallUpdate_reward_address
    }
  | {
      tag: "complete_initialization"
      value: IcPallet_crowdloan_rewardsPalletCallComplete_initialization
    }
  | {
      tag: "initialize_reward_vec"
      value: IcPallet_crowdloan_rewardsPalletCallInitialize_reward_vec
    }
const cPallet_crowdloan_rewardsPalletCall: Codec<IcPallet_crowdloan_rewardsPalletCall> =
  Enum({
    associate_native_identity:
      cPallet_crowdloan_rewardsPalletCallAssociate_native_identity,
    change_association_with_relay_keys:
      cPallet_crowdloan_rewardsPalletCallChange_association_with_relay_keys,
    claim: _void,
    update_reward_address:
      cPallet_crowdloan_rewardsPalletCallUpdate_reward_address,
    complete_initialization:
      cPallet_crowdloan_rewardsPalletCallComplete_initialization,
    initialize_reward_vec:
      cPallet_crowdloan_rewardsPalletCallInitialize_reward_vec,
  })

type IcMoonbeam_runtimeRuntimeCallCrowdloanRewards =
  IcPallet_crowdloan_rewardsPalletCall
const cMoonbeam_runtimeRuntimeCallCrowdloanRewards: Codec<IcMoonbeam_runtimeRuntimeCallCrowdloanRewards> =
  cPallet_crowdloan_rewardsPalletCall

type IcCumulus_pallet_dmp_queuePalletCallService_overweight = {
  index: bigint
  weight_limit: IcSp_weightsWeight_v2Weight
}
const cCumulus_pallet_dmp_queuePalletCallService_overweight: Codec<IcCumulus_pallet_dmp_queuePalletCallService_overweight> =
  Struct({ index: u64, weight_limit: cSp_weightsWeight_v2Weight })

type IcCumulus_pallet_dmp_queuePalletCall = {
  tag: "service_overweight"
  value: IcCumulus_pallet_dmp_queuePalletCallService_overweight
}
const cCumulus_pallet_dmp_queuePalletCall: Codec<IcCumulus_pallet_dmp_queuePalletCall> =
  Enum({
    service_overweight: cCumulus_pallet_dmp_queuePalletCallService_overweight,
  })

type IcMoonbeam_runtimeRuntimeCallDmpQueue =
  IcCumulus_pallet_dmp_queuePalletCall
const cMoonbeam_runtimeRuntimeCallDmpQueue: Codec<IcMoonbeam_runtimeRuntimeCallDmpQueue> =
  cCumulus_pallet_dmp_queuePalletCall

type IcXcmV2InstructionWithdrawAsset = Icdc248
const cXcmV2InstructionWithdrawAsset: Codec<IcXcmV2InstructionWithdrawAsset> =
  cdc248

type IcXcmV2InstructionReserveAssetDeposited = Icdc248
const cXcmV2InstructionReserveAssetDeposited: Codec<IcXcmV2InstructionReserveAssetDeposited> =
  cdc248

type IcXcmV2InstructionReceiveTeleportedAsset = Icdc248
const cXcmV2InstructionReceiveTeleportedAsset: Codec<IcXcmV2InstructionReceiveTeleportedAsset> =
  cdc248

type IcXcmV2ResponseAssets = Icdc248
const cXcmV2ResponseAssets: Codec<IcXcmV2ResponseAssets> = cdc248

type IcXcmV2ResponseExecutionResult = IcOption
const cXcmV2ResponseExecutionResult: Codec<IcXcmV2ResponseExecutionResult> =
  cOption

type IcXcmV2ResponseVersion = number
const cXcmV2ResponseVersion: Codec<IcXcmV2ResponseVersion> = u32

type IcXcmV2Response =
  | { tag: "Null"; value: undefined }
  | { tag: "Assets"; value: IcXcmV2ResponseAssets }
  | { tag: "ExecutionResult"; value: IcXcmV2ResponseExecutionResult }
  | { tag: "Version"; value: IcXcmV2ResponseVersion }
const cXcmV2Response: Codec<IcXcmV2Response> = Enum({
  Null: _void,
  Assets: cXcmV2ResponseAssets,
  ExecutionResult: cXcmV2ResponseExecutionResult,
  Version: cXcmV2ResponseVersion,
})

type IcXcmV2InstructionQueryResponse = {
  query_id: bigint
  response: IcXcmV2Response
  max_weight: bigint
}
const cXcmV2InstructionQueryResponse: Codec<IcXcmV2InstructionQueryResponse> =
  Struct({
    query_id: compactBn,
    response: cXcmV2Response,
    max_weight: compactBn,
  })

type IcXcmV2InstructionTransferAsset = {
  assets: Icdc248
  beneficiary: IcXcmV2MultilocationMultiLocation
}
const cXcmV2InstructionTransferAsset: Codec<IcXcmV2InstructionTransferAsset> =
  Struct({ assets: cdc248, beneficiary: cXcmV2MultilocationMultiLocation })

type Icdc245Circular = Icdc245
const cdc245Circular: Codec<Icdc245Circular> = Self(() => cdc245)

type IcXcmV2InstructionTransferReserveAsset = {
  assets: Icdc248
  dest: IcXcmV2MultilocationMultiLocation
  xcm: Icdc245Circular
}
const cXcmV2InstructionTransferReserveAsset: Codec<IcXcmV2InstructionTransferReserveAsset> =
  Struct({
    assets: cdc248,
    dest: cXcmV2MultilocationMultiLocation,
    xcm: cdc245Circular,
  })

type IcXcmV2InstructionTransact = {
  origin_type: IcXcmV2OriginKind
  require_weight_at_most: bigint
  call: I_bytesSeq
}
const cXcmV2InstructionTransact: Codec<IcXcmV2InstructionTransact> = Struct({
  origin_type: cXcmV2OriginKind,
  require_weight_at_most: compactBn,
  call: _bytesSeq,
})

type IcXcmV2InstructionHrmpNewChannelOpenRequest = {
  sender: number
  max_message_size: number
  max_capacity: number
}
const cXcmV2InstructionHrmpNewChannelOpenRequest: Codec<IcXcmV2InstructionHrmpNewChannelOpenRequest> =
  Struct({
    sender: compactNumber,
    max_message_size: compactNumber,
    max_capacity: compactNumber,
  })

type IcXcmV2InstructionHrmpChannelAccepted = { recipient: number }
const cXcmV2InstructionHrmpChannelAccepted: Codec<IcXcmV2InstructionHrmpChannelAccepted> =
  Struct({ recipient: compactNumber })

type IcXcmV2InstructionHrmpChannelClosing = {
  initiator: number
  sender: number
  recipient: number
}
const cXcmV2InstructionHrmpChannelClosing: Codec<IcXcmV2InstructionHrmpChannelClosing> =
  Struct({
    initiator: compactNumber,
    sender: compactNumber,
    recipient: compactNumber,
  })

type IcXcmV2InstructionDescendOrigin = IcXcmV2MultilocationJunctions
const cXcmV2InstructionDescendOrigin: Codec<IcXcmV2InstructionDescendOrigin> =
  cXcmV2MultilocationJunctions

type IcXcmV2InstructionReportError = {
  query_id: bigint
  dest: IcXcmV2MultilocationMultiLocation
  max_response_weight: bigint
}
const cXcmV2InstructionReportError: Codec<IcXcmV2InstructionReportError> =
  Struct({
    query_id: compactBn,
    dest: cXcmV2MultilocationMultiLocation,
    max_response_weight: compactBn,
  })

type IcXcmV2MultiassetMultiAssetFilterDefinite = Icdc248
const cXcmV2MultiassetMultiAssetFilterDefinite: Codec<IcXcmV2MultiassetMultiAssetFilterDefinite> =
  cdc248

type IcXcmV2MultiassetWildFungibility =
  | { tag: "Fungible"; value: undefined }
  | { tag: "NonFungible"; value: undefined }
const cXcmV2MultiassetWildFungibility: Codec<IcXcmV2MultiassetWildFungibility> =
  Enum({ Fungible: _void, NonFungible: _void })

type IcXcmV2MultiassetWildMultiAssetAllOf = {
  id: IcXcmV2MultiassetAssetId
  fun: IcXcmV2MultiassetWildFungibility
}
const cXcmV2MultiassetWildMultiAssetAllOf: Codec<IcXcmV2MultiassetWildMultiAssetAllOf> =
  Struct({ id: cXcmV2MultiassetAssetId, fun: cXcmV2MultiassetWildFungibility })

type IcXcmV2MultiassetWildMultiAsset =
  | { tag: "All"; value: undefined }
  | { tag: "AllOf"; value: IcXcmV2MultiassetWildMultiAssetAllOf }
const cXcmV2MultiassetWildMultiAsset: Codec<IcXcmV2MultiassetWildMultiAsset> =
  Enum({ All: _void, AllOf: cXcmV2MultiassetWildMultiAssetAllOf })

type IcXcmV2MultiassetMultiAssetFilterWild = IcXcmV2MultiassetWildMultiAsset
const cXcmV2MultiassetMultiAssetFilterWild: Codec<IcXcmV2MultiassetMultiAssetFilterWild> =
  cXcmV2MultiassetWildMultiAsset

type IcXcmV2MultiassetMultiAssetFilter =
  | { tag: "Definite"; value: IcXcmV2MultiassetMultiAssetFilterDefinite }
  | { tag: "Wild"; value: IcXcmV2MultiassetMultiAssetFilterWild }
const cXcmV2MultiassetMultiAssetFilter: Codec<IcXcmV2MultiassetMultiAssetFilter> =
  Enum({
    Definite: cXcmV2MultiassetMultiAssetFilterDefinite,
    Wild: cXcmV2MultiassetMultiAssetFilterWild,
  })

type IcXcmV2InstructionDepositAsset = {
  assets: IcXcmV2MultiassetMultiAssetFilter
  max_assets: number
  beneficiary: IcXcmV2MultilocationMultiLocation
}
const cXcmV2InstructionDepositAsset: Codec<IcXcmV2InstructionDepositAsset> =
  Struct({
    assets: cXcmV2MultiassetMultiAssetFilter,
    max_assets: compactNumber,
    beneficiary: cXcmV2MultilocationMultiLocation,
  })

type IcXcmV2InstructionDepositReserveAsset = {
  assets: IcXcmV2MultiassetMultiAssetFilter
  max_assets: number
  dest: IcXcmV2MultilocationMultiLocation
  xcm: Icdc245Circular
}
const cXcmV2InstructionDepositReserveAsset: Codec<IcXcmV2InstructionDepositReserveAsset> =
  Struct({
    assets: cXcmV2MultiassetMultiAssetFilter,
    max_assets: compactNumber,
    dest: cXcmV2MultilocationMultiLocation,
    xcm: cdc245Circular,
  })

type IcXcmV2InstructionExchangeAsset = {
  give: IcXcmV2MultiassetMultiAssetFilter
  receive: Icdc248
}
const cXcmV2InstructionExchangeAsset: Codec<IcXcmV2InstructionExchangeAsset> =
  Struct({ give: cXcmV2MultiassetMultiAssetFilter, receive: cdc248 })

type IcXcmV2InstructionInitiateReserveWithdraw = {
  assets: IcXcmV2MultiassetMultiAssetFilter
  reserve: IcXcmV2MultilocationMultiLocation
  xcm: Icdc245Circular
}
const cXcmV2InstructionInitiateReserveWithdraw: Codec<IcXcmV2InstructionInitiateReserveWithdraw> =
  Struct({
    assets: cXcmV2MultiassetMultiAssetFilter,
    reserve: cXcmV2MultilocationMultiLocation,
    xcm: cdc245Circular,
  })

type IcXcmV2InstructionInitiateTeleport = {
  assets: IcXcmV2MultiassetMultiAssetFilter
  dest: IcXcmV2MultilocationMultiLocation
  xcm: Icdc245Circular
}
const cXcmV2InstructionInitiateTeleport: Codec<IcXcmV2InstructionInitiateTeleport> =
  Struct({
    assets: cXcmV2MultiassetMultiAssetFilter,
    dest: cXcmV2MultilocationMultiLocation,
    xcm: cdc245Circular,
  })

type IcXcmV2InstructionQueryHolding = {
  query_id: bigint
  dest: IcXcmV2MultilocationMultiLocation
  assets: IcXcmV2MultiassetMultiAssetFilter
  max_response_weight: bigint
}
const cXcmV2InstructionQueryHolding: Codec<IcXcmV2InstructionQueryHolding> =
  Struct({
    query_id: compactBn,
    dest: cXcmV2MultilocationMultiLocation,
    assets: cXcmV2MultiassetMultiAssetFilter,
    max_response_weight: compactBn,
  })

type IcXcmV2WeightLimitLimited = bigint
const cXcmV2WeightLimitLimited: Codec<IcXcmV2WeightLimitLimited> = compactBn

type IcXcmV2WeightLimit =
  | { tag: "Unlimited"; value: undefined }
  | { tag: "Limited"; value: IcXcmV2WeightLimitLimited }
const cXcmV2WeightLimit: Codec<IcXcmV2WeightLimit> = Enum({
  Unlimited: _void,
  Limited: cXcmV2WeightLimitLimited,
})

type IcXcmV2InstructionBuyExecution = {
  fees: IcXcmV2MultiassetMultiAsset
  weight_limit: IcXcmV2WeightLimit
}
const cXcmV2InstructionBuyExecution: Codec<IcXcmV2InstructionBuyExecution> =
  Struct({ fees: cXcmV2MultiassetMultiAsset, weight_limit: cXcmV2WeightLimit })

type IcXcmV2InstructionSetErrorHandler = Icdc245Circular
const cXcmV2InstructionSetErrorHandler: Codec<IcXcmV2InstructionSetErrorHandler> =
  cdc245Circular

type IcXcmV2InstructionSetAppendix = Icdc245Circular
const cXcmV2InstructionSetAppendix: Codec<IcXcmV2InstructionSetAppendix> =
  cdc245Circular

type IcXcmV2InstructionClaimAsset = {
  assets: Icdc248
  ticket: IcXcmV2MultilocationMultiLocation
}
const cXcmV2InstructionClaimAsset: Codec<IcXcmV2InstructionClaimAsset> = Struct(
  { assets: cdc248, ticket: cXcmV2MultilocationMultiLocation },
)

type IcXcmV2InstructionTrap = bigint
const cXcmV2InstructionTrap: Codec<IcXcmV2InstructionTrap> = compactBn

type IcXcmV2InstructionSubscribeVersion = {
  query_id: bigint
  max_response_weight: bigint
}
const cXcmV2InstructionSubscribeVersion: Codec<IcXcmV2InstructionSubscribeVersion> =
  Struct({ query_id: compactBn, max_response_weight: compactBn })

type IcXcmV2Instruction =
  | { tag: "WithdrawAsset"; value: IcXcmV2InstructionWithdrawAsset }
  | {
      tag: "ReserveAssetDeposited"
      value: IcXcmV2InstructionReserveAssetDeposited
    }
  | {
      tag: "ReceiveTeleportedAsset"
      value: IcXcmV2InstructionReceiveTeleportedAsset
    }
  | { tag: "QueryResponse"; value: IcXcmV2InstructionQueryResponse }
  | { tag: "TransferAsset"; value: IcXcmV2InstructionTransferAsset }
  | {
      tag: "TransferReserveAsset"
      value: IcXcmV2InstructionTransferReserveAsset
    }
  | { tag: "Transact"; value: IcXcmV2InstructionTransact }
  | {
      tag: "HrmpNewChannelOpenRequest"
      value: IcXcmV2InstructionHrmpNewChannelOpenRequest
    }
  | { tag: "HrmpChannelAccepted"; value: IcXcmV2InstructionHrmpChannelAccepted }
  | { tag: "HrmpChannelClosing"; value: IcXcmV2InstructionHrmpChannelClosing }
  | { tag: "ClearOrigin"; value: undefined }
  | { tag: "DescendOrigin"; value: IcXcmV2InstructionDescendOrigin }
  | { tag: "ReportError"; value: IcXcmV2InstructionReportError }
  | { tag: "DepositAsset"; value: IcXcmV2InstructionDepositAsset }
  | { tag: "DepositReserveAsset"; value: IcXcmV2InstructionDepositReserveAsset }
  | { tag: "ExchangeAsset"; value: IcXcmV2InstructionExchangeAsset }
  | {
      tag: "InitiateReserveWithdraw"
      value: IcXcmV2InstructionInitiateReserveWithdraw
    }
  | { tag: "InitiateTeleport"; value: IcXcmV2InstructionInitiateTeleport }
  | { tag: "QueryHolding"; value: IcXcmV2InstructionQueryHolding }
  | { tag: "BuyExecution"; value: IcXcmV2InstructionBuyExecution }
  | { tag: "RefundSurplus"; value: undefined }
  | { tag: "SetErrorHandler"; value: IcXcmV2InstructionSetErrorHandler }
  | { tag: "SetAppendix"; value: IcXcmV2InstructionSetAppendix }
  | { tag: "ClearError"; value: undefined }
  | { tag: "ClaimAsset"; value: IcXcmV2InstructionClaimAsset }
  | { tag: "Trap"; value: IcXcmV2InstructionTrap }
  | { tag: "SubscribeVersion"; value: IcXcmV2InstructionSubscribeVersion }
  | { tag: "UnsubscribeVersion"; value: undefined }
const cXcmV2Instruction: Codec<IcXcmV2Instruction> = Enum({
  WithdrawAsset: cXcmV2InstructionWithdrawAsset,
  ReserveAssetDeposited: cXcmV2InstructionReserveAssetDeposited,
  ReceiveTeleportedAsset: cXcmV2InstructionReceiveTeleportedAsset,
  QueryResponse: cXcmV2InstructionQueryResponse,
  TransferAsset: cXcmV2InstructionTransferAsset,
  TransferReserveAsset: cXcmV2InstructionTransferReserveAsset,
  Transact: cXcmV2InstructionTransact,
  HrmpNewChannelOpenRequest: cXcmV2InstructionHrmpNewChannelOpenRequest,
  HrmpChannelAccepted: cXcmV2InstructionHrmpChannelAccepted,
  HrmpChannelClosing: cXcmV2InstructionHrmpChannelClosing,
  ClearOrigin: _void,
  DescendOrigin: cXcmV2InstructionDescendOrigin,
  ReportError: cXcmV2InstructionReportError,
  DepositAsset: cXcmV2InstructionDepositAsset,
  DepositReserveAsset: cXcmV2InstructionDepositReserveAsset,
  ExchangeAsset: cXcmV2InstructionExchangeAsset,
  InitiateReserveWithdraw: cXcmV2InstructionInitiateReserveWithdraw,
  InitiateTeleport: cXcmV2InstructionInitiateTeleport,
  QueryHolding: cXcmV2InstructionQueryHolding,
  BuyExecution: cXcmV2InstructionBuyExecution,
  RefundSurplus: _void,
  SetErrorHandler: cXcmV2InstructionSetErrorHandler,
  SetAppendix: cXcmV2InstructionSetAppendix,
  ClearError: _void,
  ClaimAsset: cXcmV2InstructionClaimAsset,
  Trap: cXcmV2InstructionTrap,
  SubscribeVersion: cXcmV2InstructionSubscribeVersion,
  UnsubscribeVersion: _void,
})

type Icdc245 = Array<IcXcmV2Instruction>
const cdc245: Codec<Icdc245> = Vector(cXcmV2Instruction)

type IcXcmVersionedXcmV2 = Icdc245
const cXcmVersionedXcmV2: Codec<IcXcmVersionedXcmV2> = cdc245

type IcXcmVersionedXcmV3 = Icdc264
const cXcmVersionedXcmV3: Codec<IcXcmVersionedXcmV3> = cdc264

type IcXcmVersionedXcm =
  | { tag: "V2"; value: IcXcmVersionedXcmV2 }
  | { tag: "V3"; value: IcXcmVersionedXcmV3 }
const cXcmVersionedXcm: Codec<IcXcmVersionedXcm> = Enum(
  { V2: cXcmVersionedXcmV2, V3: cXcmVersionedXcmV3 },
  [2, 3],
)

type IcPallet_xcmPalletCallSend = {
  dest: IcXcmVersionedMultiLocation
  message: IcXcmVersionedXcm
}
const cPallet_xcmPalletCallSend: Codec<IcPallet_xcmPalletCallSend> = Struct({
  dest: cXcmVersionedMultiLocation,
  message: cXcmVersionedXcm,
})

type IcPallet_xcmPalletCallTeleport_assets = {
  dest: IcXcmVersionedMultiLocation
  beneficiary: IcXcmVersionedMultiLocation
  assets: IcXcmVersionedMultiAssets
  fee_asset_item: number
}
const cPallet_xcmPalletCallTeleport_assets: Codec<IcPallet_xcmPalletCallTeleport_assets> =
  Struct({
    dest: cXcmVersionedMultiLocation,
    beneficiary: cXcmVersionedMultiLocation,
    assets: cXcmVersionedMultiAssets,
    fee_asset_item: u32,
  })

type IcPallet_xcmPalletCallReserve_transfer_assets = {
  dest: IcXcmVersionedMultiLocation
  beneficiary: IcXcmVersionedMultiLocation
  assets: IcXcmVersionedMultiAssets
  fee_asset_item: number
}
const cPallet_xcmPalletCallReserve_transfer_assets: Codec<IcPallet_xcmPalletCallReserve_transfer_assets> =
  Struct({
    dest: cXcmVersionedMultiLocation,
    beneficiary: cXcmVersionedMultiLocation,
    assets: cXcmVersionedMultiAssets,
    fee_asset_item: u32,
  })

type IcPallet_xcmPalletCallExecute = {
  message: IcXcmVersionedXcm
  max_weight: IcSp_weightsWeight_v2Weight
}
const cPallet_xcmPalletCallExecute: Codec<IcPallet_xcmPalletCallExecute> =
  Struct({ message: cXcmVersionedXcm, max_weight: cSp_weightsWeight_v2Weight })

type IcPallet_xcmPalletCallForce_xcm_version = {
  location: IcXcmV3MultilocationMultiLocation
  xcm_version: number
}
const cPallet_xcmPalletCallForce_xcm_version: Codec<IcPallet_xcmPalletCallForce_xcm_version> =
  Struct({ location: cXcmV3MultilocationMultiLocation, xcm_version: u32 })

type IcPallet_xcmPalletCallForce_default_xcm_version = {
  maybe_xcm_version: IcOption
}
const cPallet_xcmPalletCallForce_default_xcm_version: Codec<IcPallet_xcmPalletCallForce_default_xcm_version> =
  Struct({ maybe_xcm_version: cOption })

type IcPallet_xcmPalletCallForce_subscribe_version_notify = {
  location: IcXcmVersionedMultiLocation
}
const cPallet_xcmPalletCallForce_subscribe_version_notify: Codec<IcPallet_xcmPalletCallForce_subscribe_version_notify> =
  Struct({ location: cXcmVersionedMultiLocation })

type IcPallet_xcmPalletCallForce_unsubscribe_version_notify = {
  location: IcXcmVersionedMultiLocation
}
const cPallet_xcmPalletCallForce_unsubscribe_version_notify: Codec<IcPallet_xcmPalletCallForce_unsubscribe_version_notify> =
  Struct({ location: cXcmVersionedMultiLocation })

type IcPallet_xcmPalletCallLimited_reserve_transfer_assets = {
  dest: IcXcmVersionedMultiLocation
  beneficiary: IcXcmVersionedMultiLocation
  assets: IcXcmVersionedMultiAssets
  fee_asset_item: number
  weight_limit: IcXcmV3WeightLimit
}
const cPallet_xcmPalletCallLimited_reserve_transfer_assets: Codec<IcPallet_xcmPalletCallLimited_reserve_transfer_assets> =
  Struct({
    dest: cXcmVersionedMultiLocation,
    beneficiary: cXcmVersionedMultiLocation,
    assets: cXcmVersionedMultiAssets,
    fee_asset_item: u32,
    weight_limit: cXcmV3WeightLimit,
  })

type IcPallet_xcmPalletCallLimited_teleport_assets = {
  dest: IcXcmVersionedMultiLocation
  beneficiary: IcXcmVersionedMultiLocation
  assets: IcXcmVersionedMultiAssets
  fee_asset_item: number
  weight_limit: IcXcmV3WeightLimit
}
const cPallet_xcmPalletCallLimited_teleport_assets: Codec<IcPallet_xcmPalletCallLimited_teleport_assets> =
  Struct({
    dest: cXcmVersionedMultiLocation,
    beneficiary: cXcmVersionedMultiLocation,
    assets: cXcmVersionedMultiAssets,
    fee_asset_item: u32,
    weight_limit: cXcmV3WeightLimit,
  })

type IcPallet_xcmPalletCallForce_suspension = { suspended: boolean }
const cPallet_xcmPalletCallForce_suspension: Codec<IcPallet_xcmPalletCallForce_suspension> =
  Struct({ suspended: bool })

type IcPallet_xcmPalletCall =
  | { tag: "send"; value: IcPallet_xcmPalletCallSend }
  | { tag: "teleport_assets"; value: IcPallet_xcmPalletCallTeleport_assets }
  | {
      tag: "reserve_transfer_assets"
      value: IcPallet_xcmPalletCallReserve_transfer_assets
    }
  | { tag: "execute"; value: IcPallet_xcmPalletCallExecute }
  | { tag: "force_xcm_version"; value: IcPallet_xcmPalletCallForce_xcm_version }
  | {
      tag: "force_default_xcm_version"
      value: IcPallet_xcmPalletCallForce_default_xcm_version
    }
  | {
      tag: "force_subscribe_version_notify"
      value: IcPallet_xcmPalletCallForce_subscribe_version_notify
    }
  | {
      tag: "force_unsubscribe_version_notify"
      value: IcPallet_xcmPalletCallForce_unsubscribe_version_notify
    }
  | {
      tag: "limited_reserve_transfer_assets"
      value: IcPallet_xcmPalletCallLimited_reserve_transfer_assets
    }
  | {
      tag: "limited_teleport_assets"
      value: IcPallet_xcmPalletCallLimited_teleport_assets
    }
  | { tag: "force_suspension"; value: IcPallet_xcmPalletCallForce_suspension }
const cPallet_xcmPalletCall: Codec<IcPallet_xcmPalletCall> = Enum({
  send: cPallet_xcmPalletCallSend,
  teleport_assets: cPallet_xcmPalletCallTeleport_assets,
  reserve_transfer_assets: cPallet_xcmPalletCallReserve_transfer_assets,
  execute: cPallet_xcmPalletCallExecute,
  force_xcm_version: cPallet_xcmPalletCallForce_xcm_version,
  force_default_xcm_version: cPallet_xcmPalletCallForce_default_xcm_version,
  force_subscribe_version_notify:
    cPallet_xcmPalletCallForce_subscribe_version_notify,
  force_unsubscribe_version_notify:
    cPallet_xcmPalletCallForce_unsubscribe_version_notify,
  limited_reserve_transfer_assets:
    cPallet_xcmPalletCallLimited_reserve_transfer_assets,
  limited_teleport_assets: cPallet_xcmPalletCallLimited_teleport_assets,
  force_suspension: cPallet_xcmPalletCallForce_suspension,
})

type IcMoonbeam_runtimeRuntimeCallPolkadotXcm = IcPallet_xcmPalletCall
const cMoonbeam_runtimeRuntimeCallPolkadotXcm: Codec<IcMoonbeam_runtimeRuntimeCallPolkadotXcm> =
  cPallet_xcmPalletCall

type IcPallet_assetsPalletCallCreate = {
  id: bigint
  admin: Icdc1
  min_balance: bigint
}
const cPallet_assetsPalletCallCreate: Codec<IcPallet_assetsPalletCallCreate> =
  Struct({ id: compactBn, admin: cdc1, min_balance: u128 })

type IcPallet_assetsPalletCallForce_create = {
  id: bigint
  owner: Icdc1
  is_sufficient: boolean
  min_balance: bigint
}
const cPallet_assetsPalletCallForce_create: Codec<IcPallet_assetsPalletCallForce_create> =
  Struct({
    id: compactBn,
    owner: cdc1,
    is_sufficient: bool,
    min_balance: compactBn,
  })

type IcPallet_assetsPalletCallStart_destroy = { id: bigint }
const cPallet_assetsPalletCallStart_destroy: Codec<IcPallet_assetsPalletCallStart_destroy> =
  Struct({ id: compactBn })

type IcPallet_assetsPalletCallDestroy_accounts = { id: bigint }
const cPallet_assetsPalletCallDestroy_accounts: Codec<IcPallet_assetsPalletCallDestroy_accounts> =
  Struct({ id: compactBn })

type IcPallet_assetsPalletCallDestroy_approvals = { id: bigint }
const cPallet_assetsPalletCallDestroy_approvals: Codec<IcPallet_assetsPalletCallDestroy_approvals> =
  Struct({ id: compactBn })

type IcPallet_assetsPalletCallFinish_destroy = { id: bigint }
const cPallet_assetsPalletCallFinish_destroy: Codec<IcPallet_assetsPalletCallFinish_destroy> =
  Struct({ id: compactBn })

type IcPallet_assetsPalletCallMint = {
  id: bigint
  beneficiary: Icdc1
  amount: bigint
}
const cPallet_assetsPalletCallMint: Codec<IcPallet_assetsPalletCallMint> =
  Struct({ id: compactBn, beneficiary: cdc1, amount: compactBn })

type IcPallet_assetsPalletCallBurn = { id: bigint; who: Icdc1; amount: bigint }
const cPallet_assetsPalletCallBurn: Codec<IcPallet_assetsPalletCallBurn> =
  Struct({ id: compactBn, who: cdc1, amount: compactBn })

type IcPallet_assetsPalletCallTransfer = {
  id: bigint
  target: Icdc1
  amount: bigint
}
const cPallet_assetsPalletCallTransfer: Codec<IcPallet_assetsPalletCallTransfer> =
  Struct({ id: compactBn, target: cdc1, amount: compactBn })

type IcPallet_assetsPalletCallTransfer_keep_alive = {
  id: bigint
  target: Icdc1
  amount: bigint
}
const cPallet_assetsPalletCallTransfer_keep_alive: Codec<IcPallet_assetsPalletCallTransfer_keep_alive> =
  Struct({ id: compactBn, target: cdc1, amount: compactBn })

type IcPallet_assetsPalletCallForce_transfer = {
  id: bigint
  source: Icdc1
  dest: Icdc1
  amount: bigint
}
const cPallet_assetsPalletCallForce_transfer: Codec<IcPallet_assetsPalletCallForce_transfer> =
  Struct({ id: compactBn, source: cdc1, dest: cdc1, amount: compactBn })

type IcPallet_assetsPalletCallFreeze = { id: bigint; who: Icdc1 }
const cPallet_assetsPalletCallFreeze: Codec<IcPallet_assetsPalletCallFreeze> =
  Struct({ id: compactBn, who: cdc1 })

type IcPallet_assetsPalletCallThaw = { id: bigint; who: Icdc1 }
const cPallet_assetsPalletCallThaw: Codec<IcPallet_assetsPalletCallThaw> =
  Struct({ id: compactBn, who: cdc1 })

type IcPallet_assetsPalletCallFreeze_asset = { id: bigint }
const cPallet_assetsPalletCallFreeze_asset: Codec<IcPallet_assetsPalletCallFreeze_asset> =
  Struct({ id: compactBn })

type IcPallet_assetsPalletCallThaw_asset = { id: bigint }
const cPallet_assetsPalletCallThaw_asset: Codec<IcPallet_assetsPalletCallThaw_asset> =
  Struct({ id: compactBn })

type IcPallet_assetsPalletCallTransfer_ownership = { id: bigint; owner: Icdc1 }
const cPallet_assetsPalletCallTransfer_ownership: Codec<IcPallet_assetsPalletCallTransfer_ownership> =
  Struct({ id: compactBn, owner: cdc1 })

type IcPallet_assetsPalletCallSet_team = {
  id: bigint
  issuer: Icdc1
  admin: Icdc1
  freezer: Icdc1
}
const cPallet_assetsPalletCallSet_team: Codec<IcPallet_assetsPalletCallSet_team> =
  Struct({ id: compactBn, issuer: cdc1, admin: cdc1, freezer: cdc1 })

type IcPallet_assetsPalletCallSet_metadata = {
  id: bigint
  name: I_bytesSeq
  symbol: I_bytesSeq
  decimals: number
}
const cPallet_assetsPalletCallSet_metadata: Codec<IcPallet_assetsPalletCallSet_metadata> =
  Struct({ id: compactBn, name: _bytesSeq, symbol: _bytesSeq, decimals: u8 })

type IcPallet_assetsPalletCallClear_metadata = { id: bigint }
const cPallet_assetsPalletCallClear_metadata: Codec<IcPallet_assetsPalletCallClear_metadata> =
  Struct({ id: compactBn })

type IcPallet_assetsPalletCallForce_set_metadata = {
  id: bigint
  name: I_bytesSeq
  symbol: I_bytesSeq
  decimals: number
  is_frozen: boolean
}
const cPallet_assetsPalletCallForce_set_metadata: Codec<IcPallet_assetsPalletCallForce_set_metadata> =
  Struct({
    id: compactBn,
    name: _bytesSeq,
    symbol: _bytesSeq,
    decimals: u8,
    is_frozen: bool,
  })

type IcPallet_assetsPalletCallForce_clear_metadata = { id: bigint }
const cPallet_assetsPalletCallForce_clear_metadata: Codec<IcPallet_assetsPalletCallForce_clear_metadata> =
  Struct({ id: compactBn })

type IcPallet_assetsPalletCallForce_asset_status = {
  id: bigint
  owner: Icdc1
  issuer: Icdc1
  admin: Icdc1
  freezer: Icdc1
  min_balance: bigint
  is_sufficient: boolean
  is_frozen: boolean
}
const cPallet_assetsPalletCallForce_asset_status: Codec<IcPallet_assetsPalletCallForce_asset_status> =
  Struct({
    id: compactBn,
    owner: cdc1,
    issuer: cdc1,
    admin: cdc1,
    freezer: cdc1,
    min_balance: compactBn,
    is_sufficient: bool,
    is_frozen: bool,
  })

type IcPallet_assetsPalletCallApprove_transfer = {
  id: bigint
  delegate: Icdc1
  amount: bigint
}
const cPallet_assetsPalletCallApprove_transfer: Codec<IcPallet_assetsPalletCallApprove_transfer> =
  Struct({ id: compactBn, delegate: cdc1, amount: compactBn })

type IcPallet_assetsPalletCallCancel_approval = { id: bigint; delegate: Icdc1 }
const cPallet_assetsPalletCallCancel_approval: Codec<IcPallet_assetsPalletCallCancel_approval> =
  Struct({ id: compactBn, delegate: cdc1 })

type IcPallet_assetsPalletCallForce_cancel_approval = {
  id: bigint
  owner: Icdc1
  delegate: Icdc1
}
const cPallet_assetsPalletCallForce_cancel_approval: Codec<IcPallet_assetsPalletCallForce_cancel_approval> =
  Struct({ id: compactBn, owner: cdc1, delegate: cdc1 })

type IcPallet_assetsPalletCallTransfer_approved = {
  id: bigint
  owner: Icdc1
  destination: Icdc1
  amount: bigint
}
const cPallet_assetsPalletCallTransfer_approved: Codec<IcPallet_assetsPalletCallTransfer_approved> =
  Struct({ id: compactBn, owner: cdc1, destination: cdc1, amount: compactBn })

type IcPallet_assetsPalletCallTouch = { id: bigint }
const cPallet_assetsPalletCallTouch: Codec<IcPallet_assetsPalletCallTouch> =
  Struct({ id: compactBn })

type IcPallet_assetsPalletCallRefund = { id: bigint; allow_burn: boolean }
const cPallet_assetsPalletCallRefund: Codec<IcPallet_assetsPalletCallRefund> =
  Struct({ id: compactBn, allow_burn: bool })

type IcPallet_assetsPalletCallSet_min_balance = {
  id: bigint
  min_balance: bigint
}
const cPallet_assetsPalletCallSet_min_balance: Codec<IcPallet_assetsPalletCallSet_min_balance> =
  Struct({ id: compactBn, min_balance: u128 })

type IcPallet_assetsPalletCallTouch_other = { id: bigint; who: Icdc1 }
const cPallet_assetsPalletCallTouch_other: Codec<IcPallet_assetsPalletCallTouch_other> =
  Struct({ id: compactBn, who: cdc1 })

type IcPallet_assetsPalletCallRefund_other = { id: bigint; who: Icdc1 }
const cPallet_assetsPalletCallRefund_other: Codec<IcPallet_assetsPalletCallRefund_other> =
  Struct({ id: compactBn, who: cdc1 })

type IcPallet_assetsPalletCallBlock = { id: bigint; who: Icdc1 }
const cPallet_assetsPalletCallBlock: Codec<IcPallet_assetsPalletCallBlock> =
  Struct({ id: compactBn, who: cdc1 })

type IcPallet_assetsPalletCall =
  | { tag: "create"; value: IcPallet_assetsPalletCallCreate }
  | { tag: "force_create"; value: IcPallet_assetsPalletCallForce_create }
  | { tag: "start_destroy"; value: IcPallet_assetsPalletCallStart_destroy }
  | {
      tag: "destroy_accounts"
      value: IcPallet_assetsPalletCallDestroy_accounts
    }
  | {
      tag: "destroy_approvals"
      value: IcPallet_assetsPalletCallDestroy_approvals
    }
  | { tag: "finish_destroy"; value: IcPallet_assetsPalletCallFinish_destroy }
  | { tag: "mint"; value: IcPallet_assetsPalletCallMint }
  | { tag: "burn"; value: IcPallet_assetsPalletCallBurn }
  | { tag: "transfer"; value: IcPallet_assetsPalletCallTransfer }
  | {
      tag: "transfer_keep_alive"
      value: IcPallet_assetsPalletCallTransfer_keep_alive
    }
  | { tag: "force_transfer"; value: IcPallet_assetsPalletCallForce_transfer }
  | { tag: "freeze"; value: IcPallet_assetsPalletCallFreeze }
  | { tag: "thaw"; value: IcPallet_assetsPalletCallThaw }
  | { tag: "freeze_asset"; value: IcPallet_assetsPalletCallFreeze_asset }
  | { tag: "thaw_asset"; value: IcPallet_assetsPalletCallThaw_asset }
  | {
      tag: "transfer_ownership"
      value: IcPallet_assetsPalletCallTransfer_ownership
    }
  | { tag: "set_team"; value: IcPallet_assetsPalletCallSet_team }
  | { tag: "set_metadata"; value: IcPallet_assetsPalletCallSet_metadata }
  | { tag: "clear_metadata"; value: IcPallet_assetsPalletCallClear_metadata }
  | {
      tag: "force_set_metadata"
      value: IcPallet_assetsPalletCallForce_set_metadata
    }
  | {
      tag: "force_clear_metadata"
      value: IcPallet_assetsPalletCallForce_clear_metadata
    }
  | {
      tag: "force_asset_status"
      value: IcPallet_assetsPalletCallForce_asset_status
    }
  | {
      tag: "approve_transfer"
      value: IcPallet_assetsPalletCallApprove_transfer
    }
  | { tag: "cancel_approval"; value: IcPallet_assetsPalletCallCancel_approval }
  | {
      tag: "force_cancel_approval"
      value: IcPallet_assetsPalletCallForce_cancel_approval
    }
  | {
      tag: "transfer_approved"
      value: IcPallet_assetsPalletCallTransfer_approved
    }
  | { tag: "touch"; value: IcPallet_assetsPalletCallTouch }
  | { tag: "refund"; value: IcPallet_assetsPalletCallRefund }
  | { tag: "set_min_balance"; value: IcPallet_assetsPalletCallSet_min_balance }
  | { tag: "touch_other"; value: IcPallet_assetsPalletCallTouch_other }
  | { tag: "refund_other"; value: IcPallet_assetsPalletCallRefund_other }
  | { tag: "block"; value: IcPallet_assetsPalletCallBlock }
const cPallet_assetsPalletCall: Codec<IcPallet_assetsPalletCall> = Enum({
  create: cPallet_assetsPalletCallCreate,
  force_create: cPallet_assetsPalletCallForce_create,
  start_destroy: cPallet_assetsPalletCallStart_destroy,
  destroy_accounts: cPallet_assetsPalletCallDestroy_accounts,
  destroy_approvals: cPallet_assetsPalletCallDestroy_approvals,
  finish_destroy: cPallet_assetsPalletCallFinish_destroy,
  mint: cPallet_assetsPalletCallMint,
  burn: cPallet_assetsPalletCallBurn,
  transfer: cPallet_assetsPalletCallTransfer,
  transfer_keep_alive: cPallet_assetsPalletCallTransfer_keep_alive,
  force_transfer: cPallet_assetsPalletCallForce_transfer,
  freeze: cPallet_assetsPalletCallFreeze,
  thaw: cPallet_assetsPalletCallThaw,
  freeze_asset: cPallet_assetsPalletCallFreeze_asset,
  thaw_asset: cPallet_assetsPalletCallThaw_asset,
  transfer_ownership: cPallet_assetsPalletCallTransfer_ownership,
  set_team: cPallet_assetsPalletCallSet_team,
  set_metadata: cPallet_assetsPalletCallSet_metadata,
  clear_metadata: cPallet_assetsPalletCallClear_metadata,
  force_set_metadata: cPallet_assetsPalletCallForce_set_metadata,
  force_clear_metadata: cPallet_assetsPalletCallForce_clear_metadata,
  force_asset_status: cPallet_assetsPalletCallForce_asset_status,
  approve_transfer: cPallet_assetsPalletCallApprove_transfer,
  cancel_approval: cPallet_assetsPalletCallCancel_approval,
  force_cancel_approval: cPallet_assetsPalletCallForce_cancel_approval,
  transfer_approved: cPallet_assetsPalletCallTransfer_approved,
  touch: cPallet_assetsPalletCallTouch,
  refund: cPallet_assetsPalletCallRefund,
  set_min_balance: cPallet_assetsPalletCallSet_min_balance,
  touch_other: cPallet_assetsPalletCallTouch_other,
  refund_other: cPallet_assetsPalletCallRefund_other,
  block: cPallet_assetsPalletCallBlock,
})

type IcMoonbeam_runtimeRuntimeCallAssets = IcPallet_assetsPalletCall
const cMoonbeam_runtimeRuntimeCallAssets: Codec<IcMoonbeam_runtimeRuntimeCallAssets> =
  cPallet_assetsPalletCall

type IcPallet_asset_managerPalletCallRegister_foreign_asset = {
  asset: IcMoonbeam_runtimeXcm_configAssetType
  metadata: IcMoonbeam_runtimeAsset_configAssetRegistrarMetadata
  min_amount: bigint
  is_sufficient: boolean
}
const cPallet_asset_managerPalletCallRegister_foreign_asset: Codec<IcPallet_asset_managerPalletCallRegister_foreign_asset> =
  Struct({
    asset: cMoonbeam_runtimeXcm_configAssetType,
    metadata: cMoonbeam_runtimeAsset_configAssetRegistrarMetadata,
    min_amount: u128,
    is_sufficient: bool,
  })

type IcPallet_asset_managerPalletCallSet_asset_units_per_second = {
  asset_type: IcMoonbeam_runtimeXcm_configAssetType
  units_per_second: bigint
  num_assets_weight_hint: number
}
const cPallet_asset_managerPalletCallSet_asset_units_per_second: Codec<IcPallet_asset_managerPalletCallSet_asset_units_per_second> =
  Struct({
    asset_type: cMoonbeam_runtimeXcm_configAssetType,
    units_per_second: u128,
    num_assets_weight_hint: u32,
  })

type IcPallet_asset_managerPalletCallChange_existing_asset_type = {
  asset_id: bigint
  new_asset_type: IcMoonbeam_runtimeXcm_configAssetType
  num_assets_weight_hint: number
}
const cPallet_asset_managerPalletCallChange_existing_asset_type: Codec<IcPallet_asset_managerPalletCallChange_existing_asset_type> =
  Struct({
    asset_id: u128,
    new_asset_type: cMoonbeam_runtimeXcm_configAssetType,
    num_assets_weight_hint: u32,
  })

type IcPallet_asset_managerPalletCallRemove_supported_asset = {
  asset_type: IcMoonbeam_runtimeXcm_configAssetType
  num_assets_weight_hint: number
}
const cPallet_asset_managerPalletCallRemove_supported_asset: Codec<IcPallet_asset_managerPalletCallRemove_supported_asset> =
  Struct({
    asset_type: cMoonbeam_runtimeXcm_configAssetType,
    num_assets_weight_hint: u32,
  })

type IcPallet_asset_managerPalletCallRemove_existing_asset_type = {
  asset_id: bigint
  num_assets_weight_hint: number
}
const cPallet_asset_managerPalletCallRemove_existing_asset_type: Codec<IcPallet_asset_managerPalletCallRemove_existing_asset_type> =
  Struct({ asset_id: u128, num_assets_weight_hint: u32 })

type IcPallet_asset_managerPalletCallRegister_local_asset = {
  creator: Icdc1
  owner: Icdc1
  is_sufficient: boolean
  min_balance: bigint
}
const cPallet_asset_managerPalletCallRegister_local_asset: Codec<IcPallet_asset_managerPalletCallRegister_local_asset> =
  Struct({ creator: cdc1, owner: cdc1, is_sufficient: bool, min_balance: u128 })

type IcPallet_asset_managerPalletCallDestroy_foreign_asset = {
  asset_id: bigint
  num_assets_weight_hint: number
}
const cPallet_asset_managerPalletCallDestroy_foreign_asset: Codec<IcPallet_asset_managerPalletCallDestroy_foreign_asset> =
  Struct({ asset_id: u128, num_assets_weight_hint: u32 })

type IcPallet_asset_managerPalletCallDestroy_local_asset = { asset_id: bigint }
const cPallet_asset_managerPalletCallDestroy_local_asset: Codec<IcPallet_asset_managerPalletCallDestroy_local_asset> =
  Struct({ asset_id: u128 })

type IcPallet_asset_managerPalletCall =
  | {
      tag: "register_foreign_asset"
      value: IcPallet_asset_managerPalletCallRegister_foreign_asset
    }
  | {
      tag: "set_asset_units_per_second"
      value: IcPallet_asset_managerPalletCallSet_asset_units_per_second
    }
  | {
      tag: "change_existing_asset_type"
      value: IcPallet_asset_managerPalletCallChange_existing_asset_type
    }
  | {
      tag: "remove_supported_asset"
      value: IcPallet_asset_managerPalletCallRemove_supported_asset
    }
  | {
      tag: "remove_existing_asset_type"
      value: IcPallet_asset_managerPalletCallRemove_existing_asset_type
    }
  | {
      tag: "register_local_asset"
      value: IcPallet_asset_managerPalletCallRegister_local_asset
    }
  | {
      tag: "destroy_foreign_asset"
      value: IcPallet_asset_managerPalletCallDestroy_foreign_asset
    }
  | {
      tag: "destroy_local_asset"
      value: IcPallet_asset_managerPalletCallDestroy_local_asset
    }
const cPallet_asset_managerPalletCall: Codec<IcPallet_asset_managerPalletCall> =
  Enum({
    register_foreign_asset:
      cPallet_asset_managerPalletCallRegister_foreign_asset,
    set_asset_units_per_second:
      cPallet_asset_managerPalletCallSet_asset_units_per_second,
    change_existing_asset_type:
      cPallet_asset_managerPalletCallChange_existing_asset_type,
    remove_supported_asset:
      cPallet_asset_managerPalletCallRemove_supported_asset,
    remove_existing_asset_type:
      cPallet_asset_managerPalletCallRemove_existing_asset_type,
    register_local_asset: cPallet_asset_managerPalletCallRegister_local_asset,
    destroy_foreign_asset: cPallet_asset_managerPalletCallDestroy_foreign_asset,
    destroy_local_asset: cPallet_asset_managerPalletCallDestroy_local_asset,
  })

type IcMoonbeam_runtimeRuntimeCallAssetManager =
  IcPallet_asset_managerPalletCall
const cMoonbeam_runtimeRuntimeCallAssetManager: Codec<IcMoonbeam_runtimeRuntimeCallAssetManager> =
  cPallet_asset_managerPalletCall

type IcMoonbeam_runtimeXcm_configCurrencyIdForeignAsset = bigint
const cMoonbeam_runtimeXcm_configCurrencyIdForeignAsset: Codec<IcMoonbeam_runtimeXcm_configCurrencyIdForeignAsset> =
  u128

type IcMoonbeam_runtimeXcm_configCurrencyIdLocalAssetReserve = bigint
const cMoonbeam_runtimeXcm_configCurrencyIdLocalAssetReserve: Codec<IcMoonbeam_runtimeXcm_configCurrencyIdLocalAssetReserve> =
  u128

type IcMoonbeam_runtimeXcm_configCurrencyIdErc20 = { contract_address: Icdc1 }
const cMoonbeam_runtimeXcm_configCurrencyIdErc20: Codec<IcMoonbeam_runtimeXcm_configCurrencyIdErc20> =
  Struct({ contract_address: cdc1 })

type IcMoonbeam_runtimeXcm_configCurrencyId =
  | { tag: "SelfReserve"; value: undefined }
  | {
      tag: "ForeignAsset"
      value: IcMoonbeam_runtimeXcm_configCurrencyIdForeignAsset
    }
  | {
      tag: "LocalAssetReserve"
      value: IcMoonbeam_runtimeXcm_configCurrencyIdLocalAssetReserve
    }
  | { tag: "Erc20"; value: IcMoonbeam_runtimeXcm_configCurrencyIdErc20 }
const cMoonbeam_runtimeXcm_configCurrencyId: Codec<IcMoonbeam_runtimeXcm_configCurrencyId> =
  Enum({
    SelfReserve: _void,
    ForeignAsset: cMoonbeam_runtimeXcm_configCurrencyIdForeignAsset,
    LocalAssetReserve: cMoonbeam_runtimeXcm_configCurrencyIdLocalAssetReserve,
    Erc20: cMoonbeam_runtimeXcm_configCurrencyIdErc20,
  })

type IcOrml_xtokensModuleCallTransfer = {
  currency_id: IcMoonbeam_runtimeXcm_configCurrencyId
  amount: bigint
  dest: IcXcmVersionedMultiLocation
  dest_weight_limit: IcXcmV3WeightLimit
}
const cOrml_xtokensModuleCallTransfer: Codec<IcOrml_xtokensModuleCallTransfer> =
  Struct({
    currency_id: cMoonbeam_runtimeXcm_configCurrencyId,
    amount: u128,
    dest: cXcmVersionedMultiLocation,
    dest_weight_limit: cXcmV3WeightLimit,
  })

type IcXcmVersionedMultiAssetV2 = IcXcmV2MultiassetMultiAsset
const cXcmVersionedMultiAssetV2: Codec<IcXcmVersionedMultiAssetV2> =
  cXcmV2MultiassetMultiAsset

type IcXcmVersionedMultiAssetV3 = IcXcmV3MultiassetMultiAsset
const cXcmVersionedMultiAssetV3: Codec<IcXcmVersionedMultiAssetV3> =
  cXcmV3MultiassetMultiAsset

type IcXcmVersionedMultiAsset =
  | { tag: "V2"; value: IcXcmVersionedMultiAssetV2 }
  | { tag: "V3"; value: IcXcmVersionedMultiAssetV3 }
const cXcmVersionedMultiAsset: Codec<IcXcmVersionedMultiAsset> = Enum(
  { V2: cXcmVersionedMultiAssetV2, V3: cXcmVersionedMultiAssetV3 },
  [1, 3],
)

type IcOrml_xtokensModuleCallTransfer_multiasset = {
  asset: IcXcmVersionedMultiAsset
  dest: IcXcmVersionedMultiLocation
  dest_weight_limit: IcXcmV3WeightLimit
}
const cOrml_xtokensModuleCallTransfer_multiasset: Codec<IcOrml_xtokensModuleCallTransfer_multiasset> =
  Struct({
    asset: cXcmVersionedMultiAsset,
    dest: cXcmVersionedMultiLocation,
    dest_weight_limit: cXcmV3WeightLimit,
  })

type IcOrml_xtokensModuleCallTransfer_with_fee = {
  currency_id: IcMoonbeam_runtimeXcm_configCurrencyId
  amount: bigint
  fee: bigint
  dest: IcXcmVersionedMultiLocation
  dest_weight_limit: IcXcmV3WeightLimit
}
const cOrml_xtokensModuleCallTransfer_with_fee: Codec<IcOrml_xtokensModuleCallTransfer_with_fee> =
  Struct({
    currency_id: cMoonbeam_runtimeXcm_configCurrencyId,
    amount: u128,
    fee: u128,
    dest: cXcmVersionedMultiLocation,
    dest_weight_limit: cXcmV3WeightLimit,
  })

type IcOrml_xtokensModuleCallTransfer_multiasset_with_fee = {
  asset: IcXcmVersionedMultiAsset
  fee: IcXcmVersionedMultiAsset
  dest: IcXcmVersionedMultiLocation
  dest_weight_limit: IcXcmV3WeightLimit
}
const cOrml_xtokensModuleCallTransfer_multiasset_with_fee: Codec<IcOrml_xtokensModuleCallTransfer_multiasset_with_fee> =
  Struct({
    asset: cXcmVersionedMultiAsset,
    fee: cXcmVersionedMultiAsset,
    dest: cXcmVersionedMultiLocation,
    dest_weight_limit: cXcmV3WeightLimit,
  })

type Icdc305 = [IcMoonbeam_runtimeXcm_configCurrencyId, bigint]
const cdc305: Codec<Icdc305> = Tuple(
  cMoonbeam_runtimeXcm_configCurrencyId,
  u128,
)

type Icdc304 = Array<Icdc305>
const cdc304: Codec<Icdc304> = Vector(cdc305)

type IcOrml_xtokensModuleCallTransfer_multicurrencies = {
  currencies: Icdc304
  fee_item: number
  dest: IcXcmVersionedMultiLocation
  dest_weight_limit: IcXcmV3WeightLimit
}
const cOrml_xtokensModuleCallTransfer_multicurrencies: Codec<IcOrml_xtokensModuleCallTransfer_multicurrencies> =
  Struct({
    currencies: cdc304,
    fee_item: u32,
    dest: cXcmVersionedMultiLocation,
    dest_weight_limit: cXcmV3WeightLimit,
  })

type IcOrml_xtokensModuleCallTransfer_multiassets = {
  assets: IcXcmVersionedMultiAssets
  fee_item: number
  dest: IcXcmVersionedMultiLocation
  dest_weight_limit: IcXcmV3WeightLimit
}
const cOrml_xtokensModuleCallTransfer_multiassets: Codec<IcOrml_xtokensModuleCallTransfer_multiassets> =
  Struct({
    assets: cXcmVersionedMultiAssets,
    fee_item: u32,
    dest: cXcmVersionedMultiLocation,
    dest_weight_limit: cXcmV3WeightLimit,
  })

type IcOrml_xtokensModuleCall =
  | { tag: "transfer"; value: IcOrml_xtokensModuleCallTransfer }
  | {
      tag: "transfer_multiasset"
      value: IcOrml_xtokensModuleCallTransfer_multiasset
    }
  | {
      tag: "transfer_with_fee"
      value: IcOrml_xtokensModuleCallTransfer_with_fee
    }
  | {
      tag: "transfer_multiasset_with_fee"
      value: IcOrml_xtokensModuleCallTransfer_multiasset_with_fee
    }
  | {
      tag: "transfer_multicurrencies"
      value: IcOrml_xtokensModuleCallTransfer_multicurrencies
    }
  | {
      tag: "transfer_multiassets"
      value: IcOrml_xtokensModuleCallTransfer_multiassets
    }
const cOrml_xtokensModuleCall: Codec<IcOrml_xtokensModuleCall> = Enum({
  transfer: cOrml_xtokensModuleCallTransfer,
  transfer_multiasset: cOrml_xtokensModuleCallTransfer_multiasset,
  transfer_with_fee: cOrml_xtokensModuleCallTransfer_with_fee,
  transfer_multiasset_with_fee:
    cOrml_xtokensModuleCallTransfer_multiasset_with_fee,
  transfer_multicurrencies: cOrml_xtokensModuleCallTransfer_multicurrencies,
  transfer_multiassets: cOrml_xtokensModuleCallTransfer_multiassets,
})

type IcMoonbeam_runtimeRuntimeCallXTokens = IcOrml_xtokensModuleCall
const cMoonbeam_runtimeRuntimeCallXTokens: Codec<IcMoonbeam_runtimeRuntimeCallXTokens> =
  cOrml_xtokensModuleCall

type IcPallet_xcm_transactorPalletCallRegister = { who: Icdc1; index: number }
const cPallet_xcm_transactorPalletCallRegister: Codec<IcPallet_xcm_transactorPalletCallRegister> =
  Struct({ who: cdc1, index: u16 })

type IcPallet_xcm_transactorPalletCallDeregister = { index: number }
const cPallet_xcm_transactorPalletCallDeregister: Codec<IcPallet_xcm_transactorPalletCallDeregister> =
  Struct({ index: u16 })

type IcMoonbeam_runtimeXcm_configTransactors = {
  tag: "Relay"
  value: undefined
}
const cMoonbeam_runtimeXcm_configTransactors: Codec<IcMoonbeam_runtimeXcm_configTransactors> =
  Enum({ Relay: _void })

type IcPallet_xcm_transactorPalletCurrencyAsCurrencyId =
  IcMoonbeam_runtimeXcm_configCurrencyId
const cPallet_xcm_transactorPalletCurrencyAsCurrencyId: Codec<IcPallet_xcm_transactorPalletCurrencyAsCurrencyId> =
  cMoonbeam_runtimeXcm_configCurrencyId

type IcPallet_xcm_transactorPalletCurrencyAsMultiLocation =
  IcXcmVersionedMultiLocation
const cPallet_xcm_transactorPalletCurrencyAsMultiLocation: Codec<IcPallet_xcm_transactorPalletCurrencyAsMultiLocation> =
  cXcmVersionedMultiLocation

type IcPallet_xcm_transactorPalletCurrency =
  | {
      tag: "AsCurrencyId"
      value: IcPallet_xcm_transactorPalletCurrencyAsCurrencyId
    }
  | {
      tag: "AsMultiLocation"
      value: IcPallet_xcm_transactorPalletCurrencyAsMultiLocation
    }
const cPallet_xcm_transactorPalletCurrency: Codec<IcPallet_xcm_transactorPalletCurrency> =
  Enum({
    AsCurrencyId: cPallet_xcm_transactorPalletCurrencyAsCurrencyId,
    AsMultiLocation: cPallet_xcm_transactorPalletCurrencyAsMultiLocation,
  })

type IcPallet_xcm_transactorPalletCurrencyPayment = {
  currency: IcPallet_xcm_transactorPalletCurrency
  fee_amount: IcOption
}
const cPallet_xcm_transactorPalletCurrencyPayment: Codec<IcPallet_xcm_transactorPalletCurrencyPayment> =
  Struct({
    currency: cPallet_xcm_transactorPalletCurrency,
    fee_amount: cOption,
  })

type IcPallet_xcm_transactorPalletTransactWeights = {
  transact_required_weight_at_most: IcSp_weightsWeight_v2Weight
  overall_weight: IcOption
}
const cPallet_xcm_transactorPalletTransactWeights: Codec<IcPallet_xcm_transactorPalletTransactWeights> =
  Struct({
    transact_required_weight_at_most: cSp_weightsWeight_v2Weight,
    overall_weight: cOption,
  })

type IcPallet_xcm_transactorPalletCallTransact_through_derivative = {
  dest: IcMoonbeam_runtimeXcm_configTransactors
  index: number
  fee: IcPallet_xcm_transactorPalletCurrencyPayment
  inner_call: I_bytesSeq
  weight_info: IcPallet_xcm_transactorPalletTransactWeights
  refund: boolean
}
const cPallet_xcm_transactorPalletCallTransact_through_derivative: Codec<IcPallet_xcm_transactorPalletCallTransact_through_derivative> =
  Struct({
    dest: cMoonbeam_runtimeXcm_configTransactors,
    index: u16,
    fee: cPallet_xcm_transactorPalletCurrencyPayment,
    inner_call: _bytesSeq,
    weight_info: cPallet_xcm_transactorPalletTransactWeights,
    refund: bool,
  })

type IcPallet_xcm_transactorPalletCallTransact_through_sovereign = {
  dest: IcXcmVersionedMultiLocation
  fee_payer: Icdc1
  fee: IcPallet_xcm_transactorPalletCurrencyPayment
  call: I_bytesSeq
  origin_kind: IcXcmV2OriginKind
  weight_info: IcPallet_xcm_transactorPalletTransactWeights
  refund: boolean
}
const cPallet_xcm_transactorPalletCallTransact_through_sovereign: Codec<IcPallet_xcm_transactorPalletCallTransact_through_sovereign> =
  Struct({
    dest: cXcmVersionedMultiLocation,
    fee_payer: cdc1,
    fee: cPallet_xcm_transactorPalletCurrencyPayment,
    call: _bytesSeq,
    origin_kind: cXcmV2OriginKind,
    weight_info: cPallet_xcm_transactorPalletTransactWeights,
    refund: bool,
  })

type IcPallet_xcm_transactorPalletCallSet_transact_info = {
  location: IcXcmVersionedMultiLocation
  transact_extra_weight: IcSp_weightsWeight_v2Weight
  max_weight: IcSp_weightsWeight_v2Weight
  transact_extra_weight_signed: IcOption
}
const cPallet_xcm_transactorPalletCallSet_transact_info: Codec<IcPallet_xcm_transactorPalletCallSet_transact_info> =
  Struct({
    location: cXcmVersionedMultiLocation,
    transact_extra_weight: cSp_weightsWeight_v2Weight,
    max_weight: cSp_weightsWeight_v2Weight,
    transact_extra_weight_signed: cOption,
  })

type IcPallet_xcm_transactorPalletCallRemove_transact_info = {
  location: IcXcmVersionedMultiLocation
}
const cPallet_xcm_transactorPalletCallRemove_transact_info: Codec<IcPallet_xcm_transactorPalletCallRemove_transact_info> =
  Struct({ location: cXcmVersionedMultiLocation })

type IcPallet_xcm_transactorPalletCallTransact_through_signed = {
  dest: IcXcmVersionedMultiLocation
  fee: IcPallet_xcm_transactorPalletCurrencyPayment
  call: I_bytesSeq
  weight_info: IcPallet_xcm_transactorPalletTransactWeights
  refund: boolean
}
const cPallet_xcm_transactorPalletCallTransact_through_signed: Codec<IcPallet_xcm_transactorPalletCallTransact_through_signed> =
  Struct({
    dest: cXcmVersionedMultiLocation,
    fee: cPallet_xcm_transactorPalletCurrencyPayment,
    call: _bytesSeq,
    weight_info: cPallet_xcm_transactorPalletTransactWeights,
    refund: bool,
  })

type IcPallet_xcm_transactorPalletCallSet_fee_per_second = {
  asset_location: IcXcmVersionedMultiLocation
  fee_per_second: bigint
}
const cPallet_xcm_transactorPalletCallSet_fee_per_second: Codec<IcPallet_xcm_transactorPalletCallSet_fee_per_second> =
  Struct({ asset_location: cXcmVersionedMultiLocation, fee_per_second: u128 })

type IcPallet_xcm_transactorPalletCallRemove_fee_per_second = {
  asset_location: IcXcmVersionedMultiLocation
}
const cPallet_xcm_transactorPalletCallRemove_fee_per_second: Codec<IcPallet_xcm_transactorPalletCallRemove_fee_per_second> =
  Struct({ asset_location: cXcmVersionedMultiLocation })

type IcPallet_xcm_transactorPalletCallHrmp_manage = {
  action: IcPallet_xcm_transactorPalletHrmpOperation
  fee: IcPallet_xcm_transactorPalletCurrencyPayment
  weight_info: IcPallet_xcm_transactorPalletTransactWeights
}
const cPallet_xcm_transactorPalletCallHrmp_manage: Codec<IcPallet_xcm_transactorPalletCallHrmp_manage> =
  Struct({
    action: cPallet_xcm_transactorPalletHrmpOperation,
    fee: cPallet_xcm_transactorPalletCurrencyPayment,
    weight_info: cPallet_xcm_transactorPalletTransactWeights,
  })

type IcPallet_xcm_transactorPalletCall =
  | { tag: "register"; value: IcPallet_xcm_transactorPalletCallRegister }
  | { tag: "deregister"; value: IcPallet_xcm_transactorPalletCallDeregister }
  | {
      tag: "transact_through_derivative"
      value: IcPallet_xcm_transactorPalletCallTransact_through_derivative
    }
  | {
      tag: "transact_through_sovereign"
      value: IcPallet_xcm_transactorPalletCallTransact_through_sovereign
    }
  | {
      tag: "set_transact_info"
      value: IcPallet_xcm_transactorPalletCallSet_transact_info
    }
  | {
      tag: "remove_transact_info"
      value: IcPallet_xcm_transactorPalletCallRemove_transact_info
    }
  | {
      tag: "transact_through_signed"
      value: IcPallet_xcm_transactorPalletCallTransact_through_signed
    }
  | {
      tag: "set_fee_per_second"
      value: IcPallet_xcm_transactorPalletCallSet_fee_per_second
    }
  | {
      tag: "remove_fee_per_second"
      value: IcPallet_xcm_transactorPalletCallRemove_fee_per_second
    }
  | { tag: "hrmp_manage"; value: IcPallet_xcm_transactorPalletCallHrmp_manage }
const cPallet_xcm_transactorPalletCall: Codec<IcPallet_xcm_transactorPalletCall> =
  Enum({
    register: cPallet_xcm_transactorPalletCallRegister,
    deregister: cPallet_xcm_transactorPalletCallDeregister,
    transact_through_derivative:
      cPallet_xcm_transactorPalletCallTransact_through_derivative,
    transact_through_sovereign:
      cPallet_xcm_transactorPalletCallTransact_through_sovereign,
    set_transact_info: cPallet_xcm_transactorPalletCallSet_transact_info,
    remove_transact_info: cPallet_xcm_transactorPalletCallRemove_transact_info,
    transact_through_signed:
      cPallet_xcm_transactorPalletCallTransact_through_signed,
    set_fee_per_second: cPallet_xcm_transactorPalletCallSet_fee_per_second,
    remove_fee_per_second:
      cPallet_xcm_transactorPalletCallRemove_fee_per_second,
    hrmp_manage: cPallet_xcm_transactorPalletCallHrmp_manage,
  })

type IcMoonbeam_runtimeRuntimeCallXcmTransactor =
  IcPallet_xcm_transactorPalletCall
const cMoonbeam_runtimeRuntimeCallXcmTransactor: Codec<IcMoonbeam_runtimeRuntimeCallXcmTransactor> =
  cPallet_xcm_transactorPalletCall

type IcMoonbeam_runtimeRuntimeCallLocalAssets = IcPallet_assetsPalletCall
const cMoonbeam_runtimeRuntimeCallLocalAssets: Codec<IcMoonbeam_runtimeRuntimeCallLocalAssets> =
  cPallet_assetsPalletCall

type IcXcm_primitivesEthereum_xcmManualEthereumXcmFee = {
  gas_price: IcOption
  max_fee_per_gas: IcOption
}
const cXcm_primitivesEthereum_xcmManualEthereumXcmFee: Codec<IcXcm_primitivesEthereum_xcmManualEthereumXcmFee> =
  Struct({ gas_price: cOption, max_fee_per_gas: cOption })

type IcXcm_primitivesEthereum_xcmEthereumXcmFeeManual =
  IcXcm_primitivesEthereum_xcmManualEthereumXcmFee
const cXcm_primitivesEthereum_xcmEthereumXcmFeeManual: Codec<IcXcm_primitivesEthereum_xcmEthereumXcmFeeManual> =
  cXcm_primitivesEthereum_xcmManualEthereumXcmFee

type IcXcm_primitivesEthereum_xcmEthereumXcmFee =
  | { tag: "Manual"; value: IcXcm_primitivesEthereum_xcmEthereumXcmFeeManual }
  | { tag: "Auto"; value: undefined }
const cXcm_primitivesEthereum_xcmEthereumXcmFee: Codec<IcXcm_primitivesEthereum_xcmEthereumXcmFee> =
  Enum({ Manual: cXcm_primitivesEthereum_xcmEthereumXcmFeeManual, Auto: _void })

type IcXcm_primitivesEthereum_xcmEthereumXcmTransactionV1 =
  IcXcm_primitivesEthereum_xcmEthereumXcmTransactionV1
const cXcm_primitivesEthereum_xcmEthereumXcmTransactionV1: Codec<IcXcm_primitivesEthereum_xcmEthereumXcmTransactionV1> =
  cXcm_primitivesEthereum_xcmEthereumXcmTransactionV1

type IcXcm_primitivesEthereum_xcmEthereumXcmTransactionV2 =
  IcXcm_primitivesEthereum_xcmEthereumXcmTransactionV2
const cXcm_primitivesEthereum_xcmEthereumXcmTransactionV2: Codec<IcXcm_primitivesEthereum_xcmEthereumXcmTransactionV2> =
  cXcm_primitivesEthereum_xcmEthereumXcmTransactionV2

type IcXcm_primitivesEthereum_xcmEthereumXcmTransaction =
  | { tag: "V1"; value: IcXcm_primitivesEthereum_xcmEthereumXcmTransactionV1 }
  | { tag: "V2"; value: IcXcm_primitivesEthereum_xcmEthereumXcmTransactionV2 }
const cXcm_primitivesEthereum_xcmEthereumXcmTransaction: Codec<IcXcm_primitivesEthereum_xcmEthereumXcmTransaction> =
  Enum({
    V1: cXcm_primitivesEthereum_xcmEthereumXcmTransactionV1,
    V2: cXcm_primitivesEthereum_xcmEthereumXcmTransactionV2,
  })

type IcPallet_ethereum_xcmPalletCallTransact = {
  xcm_transaction: IcXcm_primitivesEthereum_xcmEthereumXcmTransaction
}
const cPallet_ethereum_xcmPalletCallTransact: Codec<IcPallet_ethereum_xcmPalletCallTransact> =
  Struct({ xcm_transaction: cXcm_primitivesEthereum_xcmEthereumXcmTransaction })

type IcPallet_ethereum_xcmPalletCallTransact_through_proxy = {
  transact_as: Icdc1
  xcm_transaction: IcXcm_primitivesEthereum_xcmEthereumXcmTransaction
}
const cPallet_ethereum_xcmPalletCallTransact_through_proxy: Codec<IcPallet_ethereum_xcmPalletCallTransact_through_proxy> =
  Struct({
    transact_as: cdc1,
    xcm_transaction: cXcm_primitivesEthereum_xcmEthereumXcmTransaction,
  })

type IcPallet_ethereum_xcmPalletCall =
  | { tag: "transact"; value: IcPallet_ethereum_xcmPalletCallTransact }
  | {
      tag: "transact_through_proxy"
      value: IcPallet_ethereum_xcmPalletCallTransact_through_proxy
    }
  | { tag: "suspend_ethereum_xcm_execution"; value: undefined }
  | { tag: "resume_ethereum_xcm_execution"; value: undefined }
const cPallet_ethereum_xcmPalletCall: Codec<IcPallet_ethereum_xcmPalletCall> =
  Enum({
    transact: cPallet_ethereum_xcmPalletCallTransact,
    transact_through_proxy:
      cPallet_ethereum_xcmPalletCallTransact_through_proxy,
    suspend_ethereum_xcm_execution: _void,
    resume_ethereum_xcm_execution: _void,
  })

type IcMoonbeam_runtimeRuntimeCallEthereumXcm = IcPallet_ethereum_xcmPalletCall
const cMoonbeam_runtimeRuntimeCallEthereumXcm: Codec<IcMoonbeam_runtimeRuntimeCallEthereumXcm> =
  cPallet_ethereum_xcmPalletCall

type IcPallet_randomnessPalletCall = {
  tag: "set_babe_randomness_results"
  value: undefined
}
const cPallet_randomnessPalletCall: Codec<IcPallet_randomnessPalletCall> = Enum(
  { set_babe_randomness_results: _void },
)

type IcMoonbeam_runtimeRuntimeCallRandomness = IcPallet_randomnessPalletCall
const cMoonbeam_runtimeRuntimeCallRandomness: Codec<IcMoonbeam_runtimeRuntimeCallRandomness> =
  cPallet_randomnessPalletCall

type IcMoonbeam_runtimeRuntimeCall =
  | { tag: "System"; value: IcMoonbeam_runtimeRuntimeCallSystem }
  | {
      tag: "ParachainSystem"
      value: IcMoonbeam_runtimeRuntimeCallParachainSystem
    }
  | { tag: "Timestamp"; value: IcMoonbeam_runtimeRuntimeCallTimestamp }
  | { tag: "RootTesting"; value: IcMoonbeam_runtimeRuntimeCallRootTesting }
  | { tag: "Balances"; value: IcMoonbeam_runtimeRuntimeCallBalances }
  | {
      tag: "ParachainStaking"
      value: IcMoonbeam_runtimeRuntimeCallParachainStaking
    }
  | {
      tag: "AuthorInherent"
      value: IcMoonbeam_runtimeRuntimeCallAuthorInherent
    }
  | { tag: "AuthorFilter"; value: IcMoonbeam_runtimeRuntimeCallAuthorFilter }
  | { tag: "AuthorMapping"; value: IcMoonbeam_runtimeRuntimeCallAuthorMapping }
  | {
      tag: "MoonbeamOrbiters"
      value: IcMoonbeam_runtimeRuntimeCallMoonbeamOrbiters
    }
  | { tag: "Utility"; value: IcMoonbeam_runtimeRuntimeCallUtility }
  | { tag: "Proxy"; value: IcMoonbeam_runtimeRuntimeCallProxy }
  | {
      tag: "MaintenanceMode"
      value: IcMoonbeam_runtimeRuntimeCallMaintenanceMode
    }
  | { tag: "Identity"; value: IcMoonbeam_runtimeRuntimeCallIdentity }
  | { tag: "Multisig"; value: IcMoonbeam_runtimeRuntimeCallMultisig }
  | { tag: "EVM"; value: IcMoonbeam_runtimeRuntimeCallEVM }
  | { tag: "Ethereum"; value: IcMoonbeam_runtimeRuntimeCallEthereum }
  | { tag: "Scheduler"; value: IcMoonbeam_runtimeRuntimeCallScheduler }
  | { tag: "Democracy"; value: IcMoonbeam_runtimeRuntimeCallDemocracy }
  | { tag: "Preimage"; value: IcMoonbeam_runtimeRuntimeCallPreimage }
  | {
      tag: "ConvictionVoting"
      value: IcMoonbeam_runtimeRuntimeCallConvictionVoting
    }
  | { tag: "Referenda"; value: IcMoonbeam_runtimeRuntimeCallReferenda }
  | { tag: "Whitelist"; value: IcMoonbeam_runtimeRuntimeCallWhitelist }
  | {
      tag: "CouncilCollective"
      value: IcMoonbeam_runtimeRuntimeCallCouncilCollective
    }
  | {
      tag: "TechCommitteeCollective"
      value: IcMoonbeam_runtimeRuntimeCallTechCommitteeCollective
    }
  | {
      tag: "TreasuryCouncilCollective"
      value: IcMoonbeam_runtimeRuntimeCallTreasuryCouncilCollective
    }
  | {
      tag: "OpenTechCommitteeCollective"
      value: IcMoonbeam_runtimeRuntimeCallOpenTechCommitteeCollective
    }
  | { tag: "Treasury"; value: IcMoonbeam_runtimeRuntimeCallTreasury }
  | {
      tag: "CrowdloanRewards"
      value: IcMoonbeam_runtimeRuntimeCallCrowdloanRewards
    }
  | { tag: "DmpQueue"; value: IcMoonbeam_runtimeRuntimeCallDmpQueue }
  | { tag: "PolkadotXcm"; value: IcMoonbeam_runtimeRuntimeCallPolkadotXcm }
  | { tag: "Assets"; value: IcMoonbeam_runtimeRuntimeCallAssets }
  | { tag: "AssetManager"; value: IcMoonbeam_runtimeRuntimeCallAssetManager }
  | { tag: "XTokens"; value: IcMoonbeam_runtimeRuntimeCallXTokens }
  | { tag: "XcmTransactor"; value: IcMoonbeam_runtimeRuntimeCallXcmTransactor }
  | { tag: "LocalAssets"; value: IcMoonbeam_runtimeRuntimeCallLocalAssets }
  | { tag: "EthereumXcm"; value: IcMoonbeam_runtimeRuntimeCallEthereumXcm }
  | { tag: "Randomness"; value: IcMoonbeam_runtimeRuntimeCallRandomness }
const cMoonbeam_runtimeRuntimeCall: Codec<IcMoonbeam_runtimeRuntimeCall> = Enum(
  {
    System: cMoonbeam_runtimeRuntimeCallSystem,
    ParachainSystem: cMoonbeam_runtimeRuntimeCallParachainSystem,
    Timestamp: cMoonbeam_runtimeRuntimeCallTimestamp,
    RootTesting: cMoonbeam_runtimeRuntimeCallRootTesting,
    Balances: cMoonbeam_runtimeRuntimeCallBalances,
    ParachainStaking: cMoonbeam_runtimeRuntimeCallParachainStaking,
    AuthorInherent: cMoonbeam_runtimeRuntimeCallAuthorInherent,
    AuthorFilter: cMoonbeam_runtimeRuntimeCallAuthorFilter,
    AuthorMapping: cMoonbeam_runtimeRuntimeCallAuthorMapping,
    MoonbeamOrbiters: cMoonbeam_runtimeRuntimeCallMoonbeamOrbiters,
    Utility: cMoonbeam_runtimeRuntimeCallUtility,
    Proxy: cMoonbeam_runtimeRuntimeCallProxy,
    MaintenanceMode: cMoonbeam_runtimeRuntimeCallMaintenanceMode,
    Identity: cMoonbeam_runtimeRuntimeCallIdentity,
    Multisig: cMoonbeam_runtimeRuntimeCallMultisig,
    EVM: cMoonbeam_runtimeRuntimeCallEVM,
    Ethereum: cMoonbeam_runtimeRuntimeCallEthereum,
    Scheduler: cMoonbeam_runtimeRuntimeCallScheduler,
    Democracy: cMoonbeam_runtimeRuntimeCallDemocracy,
    Preimage: cMoonbeam_runtimeRuntimeCallPreimage,
    ConvictionVoting: cMoonbeam_runtimeRuntimeCallConvictionVoting,
    Referenda: cMoonbeam_runtimeRuntimeCallReferenda,
    Whitelist: cMoonbeam_runtimeRuntimeCallWhitelist,
    CouncilCollective: cMoonbeam_runtimeRuntimeCallCouncilCollective,
    TechCommitteeCollective:
      cMoonbeam_runtimeRuntimeCallTechCommitteeCollective,
    TreasuryCouncilCollective:
      cMoonbeam_runtimeRuntimeCallTreasuryCouncilCollective,
    OpenTechCommitteeCollective:
      cMoonbeam_runtimeRuntimeCallOpenTechCommitteeCollective,
    Treasury: cMoonbeam_runtimeRuntimeCallTreasury,
    CrowdloanRewards: cMoonbeam_runtimeRuntimeCallCrowdloanRewards,
    DmpQueue: cMoonbeam_runtimeRuntimeCallDmpQueue,
    PolkadotXcm: cMoonbeam_runtimeRuntimeCallPolkadotXcm,
    Assets: cMoonbeam_runtimeRuntimeCallAssets,
    AssetManager: cMoonbeam_runtimeRuntimeCallAssetManager,
    XTokens: cMoonbeam_runtimeRuntimeCallXTokens,
    XcmTransactor: cMoonbeam_runtimeRuntimeCallXcmTransactor,
    LocalAssets: cMoonbeam_runtimeRuntimeCallLocalAssets,
    EthereumXcm: cMoonbeam_runtimeRuntimeCallEthereumXcm,
    Randomness: cMoonbeam_runtimeRuntimeCallRandomness,
  },
  [
    0, 1, 3, 5, 10, 20, 21, 22, 23, 24, 30, 31, 32, 33, 36, 51, 52, 60, 61, 62,
    63, 64, 66, 70, 71, 72, 73, 80, 90, 102, 103, 104, 105, 106, 107, 108, 109,
    120,
  ],
)

type Icdc118 = Array<IcMoonbeam_runtimeRuntimeCall>
const cdc118: Codec<Icdc118> = Vector(cMoonbeam_runtimeRuntimeCall)

type IcPallet_utilityPalletCallBatchTupled = [Calls: Icdc118]
const cPallet_utilityPalletCallBatchTupled: Codec<IcPallet_utilityPalletCallBatchTupled> =
  Tuple(cdc118)

type IcPallet_utilityPalletCallAs_derivativeTupled = [
  Index: number,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
const cPallet_utilityPalletCallAs_derivativeTupled: Codec<IcPallet_utilityPalletCallAs_derivativeTupled> =
  Tuple(u16, cMoonbeam_runtimeRuntimeCall)

type IcPallet_utilityPalletCallBatch_allTupled = [Calls: Icdc118]
const cPallet_utilityPalletCallBatch_allTupled: Codec<IcPallet_utilityPalletCallBatch_allTupled> =
  Tuple(cdc118)

type IcPallet_utilityPalletCallDispatch_asTupled = [
  As_origin: IcMoonbeam_runtimeOriginCaller,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
const cPallet_utilityPalletCallDispatch_asTupled: Codec<IcPallet_utilityPalletCallDispatch_asTupled> =
  Tuple(cMoonbeam_runtimeOriginCaller, cMoonbeam_runtimeRuntimeCall)

type IcPallet_utilityPalletCallForce_batchTupled = [Calls: Icdc118]
const cPallet_utilityPalletCallForce_batchTupled: Codec<IcPallet_utilityPalletCallForce_batchTupled> =
  Tuple(cdc118)

type IcPallet_utilityPalletCallWith_weightTupled = [
  Call: IcMoonbeam_runtimeRuntimeCall,
  Weight: IcSp_weightsWeight_v2Weight,
]
const cPallet_utilityPalletCallWith_weightTupled: Codec<IcPallet_utilityPalletCallWith_weightTupled> =
  Tuple(cMoonbeam_runtimeRuntimeCall, cSp_weightsWeight_v2Weight)

type IcPallet_utilityPalletError = { tag: "TooManyCalls"; value: undefined }
const cPallet_utilityPalletError: Codec<IcPallet_utilityPalletError> = Enum({
  TooManyCalls: _void,
})

type IcPallet_utilityPalletErrorTooManyCalls = undefined
const cPallet_utilityPalletErrorTooManyCalls: Codec<IcPallet_utilityPalletErrorTooManyCalls> =
  _void

type IcPallet_utilityPalletEventBatchCompleted = undefined
const cPallet_utilityPalletEventBatchCompleted: Codec<IcPallet_utilityPalletEventBatchCompleted> =
  _void

type IcPallet_utilityPalletEventBatchCompletedWithErrors = undefined
const cPallet_utilityPalletEventBatchCompletedWithErrors: Codec<IcPallet_utilityPalletEventBatchCompletedWithErrors> =
  _void

type IcPallet_utilityPalletEventItemCompleted = undefined
const cPallet_utilityPalletEventItemCompleted: Codec<IcPallet_utilityPalletEventItemCompleted> =
  _void

type IcPallet_proxyProxyDefinition = {
  delegate: Icdc1
  proxy_type: IcMoonbeam_runtimeProxyType
  delay: number
}
const cPallet_proxyProxyDefinition: Codec<IcPallet_proxyProxyDefinition> =
  Struct({ delegate: cdc1, proxy_type: cMoonbeam_runtimeProxyType, delay: u32 })

type Icdc433 = Array<IcPallet_proxyProxyDefinition>
const cdc433: Codec<Icdc433> = Vector(cPallet_proxyProxyDefinition)

type Icdc430 = [Icdc433, bigint]
const cdc430: Codec<Icdc430> = Tuple(cdc433, u128)

type IcPallet_proxyAnnouncement = {
  real: Icdc1
  call_hash: Icdc13
  height: number
}
const cPallet_proxyAnnouncement: Codec<IcPallet_proxyAnnouncement> = Struct({
  real: cdc1,
  call_hash: cdc13,
  height: u32,
})

type Icdc437 = Array<IcPallet_proxyAnnouncement>
const cdc437: Codec<Icdc437> = Vector(cPallet_proxyAnnouncement)

type Icdc434 = [Icdc437, bigint]
const cdc434: Codec<Icdc434> = Tuple(cdc437, u128)

type IcPallet_proxyPalletCallProxyTupled = [
  Real: Icdc1,
  Force_proxy_type: IcOption,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
const cPallet_proxyPalletCallProxyTupled: Codec<IcPallet_proxyPalletCallProxyTupled> =
  Tuple(cdc1, cOption, cMoonbeam_runtimeRuntimeCall)

type IcPallet_proxyPalletCallAdd_proxyTupled = [
  Delegate: Icdc1,
  Proxy_type: IcMoonbeam_runtimeProxyType,
  Delay: number,
]
const cPallet_proxyPalletCallAdd_proxyTupled: Codec<IcPallet_proxyPalletCallAdd_proxyTupled> =
  Tuple(cdc1, cMoonbeam_runtimeProxyType, u32)

type IcPallet_proxyPalletCallRemove_proxyTupled = [
  Delegate: Icdc1,
  Proxy_type: IcMoonbeam_runtimeProxyType,
  Delay: number,
]
const cPallet_proxyPalletCallRemove_proxyTupled: Codec<IcPallet_proxyPalletCallRemove_proxyTupled> =
  Tuple(cdc1, cMoonbeam_runtimeProxyType, u32)

type IcPallet_proxyPalletCallCreate_pureTupled = [
  Proxy_type: IcMoonbeam_runtimeProxyType,
  Delay: number,
  Index: number,
]
const cPallet_proxyPalletCallCreate_pureTupled: Codec<IcPallet_proxyPalletCallCreate_pureTupled> =
  Tuple(cMoonbeam_runtimeProxyType, u32, u16)

type IcPallet_proxyPalletCallKill_pureTupled = [
  Spawner: Icdc1,
  Proxy_type: IcMoonbeam_runtimeProxyType,
  Index: number,
  Height: number,
  Ext_index: number,
]
const cPallet_proxyPalletCallKill_pureTupled: Codec<IcPallet_proxyPalletCallKill_pureTupled> =
  Tuple(cdc1, cMoonbeam_runtimeProxyType, u16, compactNumber, compactNumber)

type IcPallet_proxyPalletCallAnnounceTupled = [Real: Icdc1, Call_hash: Icdc13]
const cPallet_proxyPalletCallAnnounceTupled: Codec<IcPallet_proxyPalletCallAnnounceTupled> =
  Tuple(cdc1, cdc13)

type IcPallet_proxyPalletCallRemove_announcementTupled = [
  Real: Icdc1,
  Call_hash: Icdc13,
]
const cPallet_proxyPalletCallRemove_announcementTupled: Codec<IcPallet_proxyPalletCallRemove_announcementTupled> =
  Tuple(cdc1, cdc13)

type IcPallet_proxyPalletCallReject_announcementTupled = [
  Delegate: Icdc1,
  Call_hash: Icdc13,
]
const cPallet_proxyPalletCallReject_announcementTupled: Codec<IcPallet_proxyPalletCallReject_announcementTupled> =
  Tuple(cdc1, cdc13)

type IcPallet_proxyPalletCallProxy_announcedTupled = [
  Delegate: Icdc1,
  Real: Icdc1,
  Force_proxy_type: IcOption,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
const cPallet_proxyPalletCallProxy_announcedTupled: Codec<IcPallet_proxyPalletCallProxy_announcedTupled> =
  Tuple(cdc1, cdc1, cOption, cMoonbeam_runtimeRuntimeCall)

type IcPallet_proxyPalletError =
  | { tag: "TooMany"; value: undefined }
  | { tag: "NotFound"; value: undefined }
  | { tag: "NotProxy"; value: undefined }
  | { tag: "Unproxyable"; value: undefined }
  | { tag: "Duplicate"; value: undefined }
  | { tag: "NoPermission"; value: undefined }
  | { tag: "Unannounced"; value: undefined }
  | { tag: "NoSelfProxy"; value: undefined }
const cPallet_proxyPalletError: Codec<IcPallet_proxyPalletError> = Enum({
  TooMany: _void,
  NotFound: _void,
  NotProxy: _void,
  Unproxyable: _void,
  Duplicate: _void,
  NoPermission: _void,
  Unannounced: _void,
  NoSelfProxy: _void,
})

type IcPallet_proxyPalletErrorTooMany = undefined
const cPallet_proxyPalletErrorTooMany: Codec<IcPallet_proxyPalletErrorTooMany> =
  _void

type IcPallet_proxyPalletErrorNotFound = undefined
const cPallet_proxyPalletErrorNotFound: Codec<IcPallet_proxyPalletErrorNotFound> =
  _void

type IcPallet_proxyPalletErrorNotProxy = undefined
const cPallet_proxyPalletErrorNotProxy: Codec<IcPallet_proxyPalletErrorNotProxy> =
  _void

type IcPallet_proxyPalletErrorUnproxyable = undefined
const cPallet_proxyPalletErrorUnproxyable: Codec<IcPallet_proxyPalletErrorUnproxyable> =
  _void

type IcPallet_proxyPalletErrorDuplicate = undefined
const cPallet_proxyPalletErrorDuplicate: Codec<IcPallet_proxyPalletErrorDuplicate> =
  _void

type IcPallet_proxyPalletErrorNoPermission = undefined
const cPallet_proxyPalletErrorNoPermission: Codec<IcPallet_proxyPalletErrorNoPermission> =
  _void

type IcPallet_proxyPalletErrorUnannounced = undefined
const cPallet_proxyPalletErrorUnannounced: Codec<IcPallet_proxyPalletErrorUnannounced> =
  _void

type IcPallet_proxyPalletErrorNoSelfProxy = undefined
const cPallet_proxyPalletErrorNoSelfProxy: Codec<IcPallet_proxyPalletErrorNoSelfProxy> =
  _void

type IcPallet_maintenance_modePalletError =
  | { tag: "AlreadyInMaintenanceMode"; value: undefined }
  | { tag: "NotInMaintenanceMode"; value: undefined }
const cPallet_maintenance_modePalletError: Codec<IcPallet_maintenance_modePalletError> =
  Enum({ AlreadyInMaintenanceMode: _void, NotInMaintenanceMode: _void })

type IcPallet_maintenance_modePalletErrorAlreadyInMaintenanceMode = undefined
const cPallet_maintenance_modePalletErrorAlreadyInMaintenanceMode: Codec<IcPallet_maintenance_modePalletErrorAlreadyInMaintenanceMode> =
  _void

type IcPallet_maintenance_modePalletErrorNotInMaintenanceMode = undefined
const cPallet_maintenance_modePalletErrorNotInMaintenanceMode: Codec<IcPallet_maintenance_modePalletErrorNotInMaintenanceMode> =
  _void

type IcPallet_maintenance_modePalletEventEnteredMaintenanceMode = undefined
const cPallet_maintenance_modePalletEventEnteredMaintenanceMode: Codec<IcPallet_maintenance_modePalletEventEnteredMaintenanceMode> =
  _void

type IcPallet_maintenance_modePalletEventNormalOperationResumed = undefined
const cPallet_maintenance_modePalletEventNormalOperationResumed: Codec<IcPallet_maintenance_modePalletEventNormalOperationResumed> =
  _void

type Icdc442 = [number, IcPallet_identityTypesJudgement]
const cdc442: Codec<Icdc442> = Tuple(u32, cPallet_identityTypesJudgement)

type Icdc443 = Array<Icdc442>
const cdc443: Codec<Icdc443> = Vector(cdc442)

type IcPallet_identityTypesRegistration = {
  judgements: Icdc443
  deposit: bigint
  info: IcPallet_identityTypesIdentityInfo
}
const cPallet_identityTypesRegistration: Codec<IcPallet_identityTypesRegistration> =
  Struct({
    judgements: cdc443,
    deposit: u128,
    info: cPallet_identityTypesIdentityInfo,
  })

type Icdc444 = [bigint, Icdc109]
const cdc444: Codec<Icdc444> = Tuple(u128, cdc109)

type Icdc449 = Array<IcOption>
const cdc449: Codec<Icdc449> = Vector(cOption)

type IcPallet_identityPalletCallAdd_registrarTupled = [Account: Icdc1]
const cPallet_identityPalletCallAdd_registrarTupled: Codec<IcPallet_identityPalletCallAdd_registrarTupled> =
  Tuple(cdc1)

type IcPallet_identityPalletCallSet_identityTupled = [
  Info: IcPallet_identityTypesIdentityInfo,
]
const cPallet_identityPalletCallSet_identityTupled: Codec<IcPallet_identityPalletCallSet_identityTupled> =
  Tuple(cPallet_identityTypesIdentityInfo)

type IcPallet_identityPalletCallSet_subsTupled = [Subs: Icdc179]
const cPallet_identityPalletCallSet_subsTupled: Codec<IcPallet_identityPalletCallSet_subsTupled> =
  Tuple(cdc179)

type IcPallet_identityPalletCallRequest_judgementTupled = [
  Reg_index: number,
  Max_fee: bigint,
]
const cPallet_identityPalletCallRequest_judgementTupled: Codec<IcPallet_identityPalletCallRequest_judgementTupled> =
  Tuple(compactNumber, compactBn)

type IcPallet_identityPalletCallCancel_requestTupled = [Reg_index: number]
const cPallet_identityPalletCallCancel_requestTupled: Codec<IcPallet_identityPalletCallCancel_requestTupled> =
  Tuple(u32)

type IcPallet_identityPalletCallSet_feeTupled = [Index: number, Fee: bigint]
const cPallet_identityPalletCallSet_feeTupled: Codec<IcPallet_identityPalletCallSet_feeTupled> =
  Tuple(compactNumber, compactBn)

type IcPallet_identityPalletCallSet_account_idTupled = [
  Index: number,
  New: Icdc1,
]
const cPallet_identityPalletCallSet_account_idTupled: Codec<IcPallet_identityPalletCallSet_account_idTupled> =
  Tuple(compactNumber, cdc1)

type IcPallet_identityPalletCallSet_fieldsTupled = [
  Index: number,
  Fields: bigint,
]
const cPallet_identityPalletCallSet_fieldsTupled: Codec<IcPallet_identityPalletCallSet_fieldsTupled> =
  Tuple(compactNumber, u64)

type IcPallet_identityPalletCallProvide_judgementTupled = [
  Reg_index: number,
  Target: Icdc1,
  Judgement: IcPallet_identityTypesJudgement,
  Identity: Icdc13,
]
const cPallet_identityPalletCallProvide_judgementTupled: Codec<IcPallet_identityPalletCallProvide_judgementTupled> =
  Tuple(compactNumber, cdc1, cPallet_identityTypesJudgement, cdc13)

type IcPallet_identityPalletCallKill_identityTupled = [Target: Icdc1]
const cPallet_identityPalletCallKill_identityTupled: Codec<IcPallet_identityPalletCallKill_identityTupled> =
  Tuple(cdc1)

type IcPallet_identityPalletCallAdd_subTupled = [
  Sub: Icdc1,
  Data: IcPallet_identityTypesData,
]
const cPallet_identityPalletCallAdd_subTupled: Codec<IcPallet_identityPalletCallAdd_subTupled> =
  Tuple(cdc1, cPallet_identityTypesData)

type IcPallet_identityPalletCallRename_subTupled = [
  Sub: Icdc1,
  Data: IcPallet_identityTypesData,
]
const cPallet_identityPalletCallRename_subTupled: Codec<IcPallet_identityPalletCallRename_subTupled> =
  Tuple(cdc1, cPallet_identityTypesData)

type IcPallet_identityPalletCallRemove_subTupled = [Sub: Icdc1]
const cPallet_identityPalletCallRemove_subTupled: Codec<IcPallet_identityPalletCallRemove_subTupled> =
  Tuple(cdc1)

type IcPallet_identityPalletError =
  | { tag: "TooManySubAccounts"; value: undefined }
  | { tag: "NotFound"; value: undefined }
  | { tag: "NotNamed"; value: undefined }
  | { tag: "EmptyIndex"; value: undefined }
  | { tag: "FeeChanged"; value: undefined }
  | { tag: "NoIdentity"; value: undefined }
  | { tag: "StickyJudgement"; value: undefined }
  | { tag: "JudgementGiven"; value: undefined }
  | { tag: "InvalidJudgement"; value: undefined }
  | { tag: "InvalidIndex"; value: undefined }
  | { tag: "InvalidTarget"; value: undefined }
  | { tag: "TooManyFields"; value: undefined }
  | { tag: "TooManyRegistrars"; value: undefined }
  | { tag: "AlreadyClaimed"; value: undefined }
  | { tag: "NotSub"; value: undefined }
  | { tag: "NotOwned"; value: undefined }
  | { tag: "JudgementForDifferentIdentity"; value: undefined }
  | { tag: "JudgementPaymentFailed"; value: undefined }
const cPallet_identityPalletError: Codec<IcPallet_identityPalletError> = Enum({
  TooManySubAccounts: _void,
  NotFound: _void,
  NotNamed: _void,
  EmptyIndex: _void,
  FeeChanged: _void,
  NoIdentity: _void,
  StickyJudgement: _void,
  JudgementGiven: _void,
  InvalidJudgement: _void,
  InvalidIndex: _void,
  InvalidTarget: _void,
  TooManyFields: _void,
  TooManyRegistrars: _void,
  AlreadyClaimed: _void,
  NotSub: _void,
  NotOwned: _void,
  JudgementForDifferentIdentity: _void,
  JudgementPaymentFailed: _void,
})

type IcPallet_identityPalletErrorTooManySubAccounts = undefined
const cPallet_identityPalletErrorTooManySubAccounts: Codec<IcPallet_identityPalletErrorTooManySubAccounts> =
  _void

type IcPallet_identityPalletErrorNotFound = undefined
const cPallet_identityPalletErrorNotFound: Codec<IcPallet_identityPalletErrorNotFound> =
  _void

type IcPallet_identityPalletErrorNotNamed = undefined
const cPallet_identityPalletErrorNotNamed: Codec<IcPallet_identityPalletErrorNotNamed> =
  _void

type IcPallet_identityPalletErrorEmptyIndex = undefined
const cPallet_identityPalletErrorEmptyIndex: Codec<IcPallet_identityPalletErrorEmptyIndex> =
  _void

type IcPallet_identityPalletErrorFeeChanged = undefined
const cPallet_identityPalletErrorFeeChanged: Codec<IcPallet_identityPalletErrorFeeChanged> =
  _void

type IcPallet_identityPalletErrorNoIdentity = undefined
const cPallet_identityPalletErrorNoIdentity: Codec<IcPallet_identityPalletErrorNoIdentity> =
  _void

type IcPallet_identityPalletErrorStickyJudgement = undefined
const cPallet_identityPalletErrorStickyJudgement: Codec<IcPallet_identityPalletErrorStickyJudgement> =
  _void

type IcPallet_identityPalletErrorJudgementGiven = undefined
const cPallet_identityPalletErrorJudgementGiven: Codec<IcPallet_identityPalletErrorJudgementGiven> =
  _void

type IcPallet_identityPalletErrorInvalidJudgement = undefined
const cPallet_identityPalletErrorInvalidJudgement: Codec<IcPallet_identityPalletErrorInvalidJudgement> =
  _void

type IcPallet_identityPalletErrorInvalidIndex = undefined
const cPallet_identityPalletErrorInvalidIndex: Codec<IcPallet_identityPalletErrorInvalidIndex> =
  _void

type IcPallet_identityPalletErrorInvalidTarget = undefined
const cPallet_identityPalletErrorInvalidTarget: Codec<IcPallet_identityPalletErrorInvalidTarget> =
  _void

type IcPallet_identityPalletErrorTooManyFields = undefined
const cPallet_identityPalletErrorTooManyFields: Codec<IcPallet_identityPalletErrorTooManyFields> =
  _void

type IcPallet_identityPalletErrorTooManyRegistrars = undefined
const cPallet_identityPalletErrorTooManyRegistrars: Codec<IcPallet_identityPalletErrorTooManyRegistrars> =
  _void

type IcPallet_identityPalletErrorAlreadyClaimed = undefined
const cPallet_identityPalletErrorAlreadyClaimed: Codec<IcPallet_identityPalletErrorAlreadyClaimed> =
  _void

type IcPallet_identityPalletErrorNotSub = undefined
const cPallet_identityPalletErrorNotSub: Codec<IcPallet_identityPalletErrorNotSub> =
  _void

type IcPallet_identityPalletErrorNotOwned = undefined
const cPallet_identityPalletErrorNotOwned: Codec<IcPallet_identityPalletErrorNotOwned> =
  _void

type IcPallet_identityPalletErrorJudgementForDifferentIdentity = undefined
const cPallet_identityPalletErrorJudgementForDifferentIdentity: Codec<IcPallet_identityPalletErrorJudgementForDifferentIdentity> =
  _void

type IcPallet_identityPalletErrorJudgementPaymentFailed = undefined
const cPallet_identityPalletErrorJudgementPaymentFailed: Codec<IcPallet_identityPalletErrorJudgementPaymentFailed> =
  _void

type Icdc14Tupled = [Key: I_bytesSeq]
const cdc14Tupled: Codec<Icdc14Tupled> = Tuple(_bytesSeq)

type IcPallet_migrationsPalletError =
  | { tag: "PreimageMissing"; value: undefined }
  | { tag: "WrongUpperBound"; value: undefined }
  | { tag: "PreimageIsTooBig"; value: undefined }
  | { tag: "PreimageAlreadyExists"; value: undefined }
const cPallet_migrationsPalletError: Codec<IcPallet_migrationsPalletError> =
  Enum({
    PreimageMissing: _void,
    WrongUpperBound: _void,
    PreimageIsTooBig: _void,
    PreimageAlreadyExists: _void,
  })

type IcPallet_migrationsPalletErrorPreimageMissing = undefined
const cPallet_migrationsPalletErrorPreimageMissing: Codec<IcPallet_migrationsPalletErrorPreimageMissing> =
  _void

type IcPallet_migrationsPalletErrorWrongUpperBound = undefined
const cPallet_migrationsPalletErrorWrongUpperBound: Codec<IcPallet_migrationsPalletErrorWrongUpperBound> =
  _void

type IcPallet_migrationsPalletErrorPreimageIsTooBig = undefined
const cPallet_migrationsPalletErrorPreimageIsTooBig: Codec<IcPallet_migrationsPalletErrorPreimageIsTooBig> =
  _void

type IcPallet_migrationsPalletErrorPreimageAlreadyExists = undefined
const cPallet_migrationsPalletErrorPreimageAlreadyExists: Codec<IcPallet_migrationsPalletErrorPreimageAlreadyExists> =
  _void

type IcPallet_migrationsPalletEventRuntimeUpgradeStarted = undefined
const cPallet_migrationsPalletEventRuntimeUpgradeStarted: Codec<IcPallet_migrationsPalletEventRuntimeUpgradeStarted> =
  _void

type IcPallet_multisigMultisig = {
  when: IcPallet_multisigTimepoint
  deposit: bigint
  depositor: Icdc1
  approvals: Icdc109
}
const cPallet_multisigMultisig: Codec<IcPallet_multisigMultisig> = Struct({
  when: cPallet_multisigTimepoint,
  deposit: u128,
  depositor: cdc1,
  approvals: cdc109,
})

type Icdc452 = [Icdc1, Icdc13]
const cdc452: Codec<Icdc452> = Tuple(cdc1, cdc13)

type IcPallet_multisigPalletCallAs_multi_threshold_1Tupled = [
  Other_signatories: Icdc109,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
const cPallet_multisigPalletCallAs_multi_threshold_1Tupled: Codec<IcPallet_multisigPalletCallAs_multi_threshold_1Tupled> =
  Tuple(cdc109, cMoonbeam_runtimeRuntimeCall)

type IcPallet_multisigPalletCallAs_multiTupled = [
  Threshold: number,
  Other_signatories: Icdc109,
  Maybe_timepoint: IcOption,
  Call: IcMoonbeam_runtimeRuntimeCall,
  Max_weight: IcSp_weightsWeight_v2Weight,
]
const cPallet_multisigPalletCallAs_multiTupled: Codec<IcPallet_multisigPalletCallAs_multiTupled> =
  Tuple(
    u16,
    cdc109,
    cOption,
    cMoonbeam_runtimeRuntimeCall,
    cSp_weightsWeight_v2Weight,
  )

type IcPallet_multisigPalletCallApprove_as_multiTupled = [
  Threshold: number,
  Other_signatories: Icdc109,
  Maybe_timepoint: IcOption,
  Call_hash: Icdc13,
  Max_weight: IcSp_weightsWeight_v2Weight,
]
const cPallet_multisigPalletCallApprove_as_multiTupled: Codec<IcPallet_multisigPalletCallApprove_as_multiTupled> =
  Tuple(u16, cdc109, cOption, cdc13, cSp_weightsWeight_v2Weight)

type IcPallet_multisigPalletCallCancel_as_multiTupled = [
  Threshold: number,
  Other_signatories: Icdc109,
  Timepoint: IcPallet_multisigTimepoint,
  Call_hash: Icdc13,
]
const cPallet_multisigPalletCallCancel_as_multiTupled: Codec<IcPallet_multisigPalletCallCancel_as_multiTupled> =
  Tuple(u16, cdc109, cPallet_multisigTimepoint, cdc13)

type IcPallet_multisigPalletError =
  | { tag: "MinimumThreshold"; value: undefined }
  | { tag: "AlreadyApproved"; value: undefined }
  | { tag: "NoApprovalsNeeded"; value: undefined }
  | { tag: "TooFewSignatories"; value: undefined }
  | { tag: "TooManySignatories"; value: undefined }
  | { tag: "SignatoriesOutOfOrder"; value: undefined }
  | { tag: "SenderInSignatories"; value: undefined }
  | { tag: "NotFound"; value: undefined }
  | { tag: "NotOwner"; value: undefined }
  | { tag: "NoTimepoint"; value: undefined }
  | { tag: "WrongTimepoint"; value: undefined }
  | { tag: "UnexpectedTimepoint"; value: undefined }
  | { tag: "MaxWeightTooLow"; value: undefined }
  | { tag: "AlreadyStored"; value: undefined }
const cPallet_multisigPalletError: Codec<IcPallet_multisigPalletError> = Enum({
  MinimumThreshold: _void,
  AlreadyApproved: _void,
  NoApprovalsNeeded: _void,
  TooFewSignatories: _void,
  TooManySignatories: _void,
  SignatoriesOutOfOrder: _void,
  SenderInSignatories: _void,
  NotFound: _void,
  NotOwner: _void,
  NoTimepoint: _void,
  WrongTimepoint: _void,
  UnexpectedTimepoint: _void,
  MaxWeightTooLow: _void,
  AlreadyStored: _void,
})

type IcPallet_multisigPalletErrorMinimumThreshold = undefined
const cPallet_multisigPalletErrorMinimumThreshold: Codec<IcPallet_multisigPalletErrorMinimumThreshold> =
  _void

type IcPallet_multisigPalletErrorAlreadyApproved = undefined
const cPallet_multisigPalletErrorAlreadyApproved: Codec<IcPallet_multisigPalletErrorAlreadyApproved> =
  _void

type IcPallet_multisigPalletErrorNoApprovalsNeeded = undefined
const cPallet_multisigPalletErrorNoApprovalsNeeded: Codec<IcPallet_multisigPalletErrorNoApprovalsNeeded> =
  _void

type IcPallet_multisigPalletErrorTooFewSignatories = undefined
const cPallet_multisigPalletErrorTooFewSignatories: Codec<IcPallet_multisigPalletErrorTooFewSignatories> =
  _void

type IcPallet_multisigPalletErrorTooManySignatories = undefined
const cPallet_multisigPalletErrorTooManySignatories: Codec<IcPallet_multisigPalletErrorTooManySignatories> =
  _void

type IcPallet_multisigPalletErrorSignatoriesOutOfOrder = undefined
const cPallet_multisigPalletErrorSignatoriesOutOfOrder: Codec<IcPallet_multisigPalletErrorSignatoriesOutOfOrder> =
  _void

type IcPallet_multisigPalletErrorSenderInSignatories = undefined
const cPallet_multisigPalletErrorSenderInSignatories: Codec<IcPallet_multisigPalletErrorSenderInSignatories> =
  _void

type IcPallet_multisigPalletErrorNotFound = undefined
const cPallet_multisigPalletErrorNotFound: Codec<IcPallet_multisigPalletErrorNotFound> =
  _void

type IcPallet_multisigPalletErrorNotOwner = undefined
const cPallet_multisigPalletErrorNotOwner: Codec<IcPallet_multisigPalletErrorNotOwner> =
  _void

type IcPallet_multisigPalletErrorNoTimepoint = undefined
const cPallet_multisigPalletErrorNoTimepoint: Codec<IcPallet_multisigPalletErrorNoTimepoint> =
  _void

type IcPallet_multisigPalletErrorWrongTimepoint = undefined
const cPallet_multisigPalletErrorWrongTimepoint: Codec<IcPallet_multisigPalletErrorWrongTimepoint> =
  _void

type IcPallet_multisigPalletErrorUnexpectedTimepoint = undefined
const cPallet_multisigPalletErrorUnexpectedTimepoint: Codec<IcPallet_multisigPalletErrorUnexpectedTimepoint> =
  _void

type IcPallet_multisigPalletErrorMaxWeightTooLow = undefined
const cPallet_multisigPalletErrorMaxWeightTooLow: Codec<IcPallet_multisigPalletErrorMaxWeightTooLow> =
  _void

type IcPallet_multisigPalletErrorAlreadyStored = undefined
const cPallet_multisigPalletErrorAlreadyStored: Codec<IcPallet_multisigPalletErrorAlreadyStored> =
  _void

type IcPrimitive_typesH160Tupled = [Key: Icdc1]
const cPrimitive_typesH160Tupled: Codec<IcPrimitive_typesH160Tupled> =
  Tuple(cdc1)

type IcPallet_evmCodeMetadata = { size: bigint; hash: Icdc13 }
const cPallet_evmCodeMetadata: Codec<IcPallet_evmCodeMetadata> = Struct({
  size: u64,
  hash: cdc13,
})

type Icdc457 = [Icdc1, Icdc13]
const cdc457: Codec<Icdc457> = Tuple(cdc1, cdc13)

type IcPallet_evmPalletCallWithdrawTupled = [Address: Icdc1, Value: bigint]
const cPallet_evmPalletCallWithdrawTupled: Codec<IcPallet_evmPalletCallWithdrawTupled> =
  Tuple(cdc1, u128)

type IcPallet_evmPalletCallCallTupled = [
  Source: Icdc1,
  Target: Icdc1,
  Input: I_bytesSeq,
  Value: Icdc188,
  Gas_limit: bigint,
  Max_fee_per_gas: Icdc188,
  Max_priority_fee_per_gas: IcOption,
  Nonce: IcOption,
  Access_list: Icdc190,
]
const cPallet_evmPalletCallCallTupled: Codec<IcPallet_evmPalletCallCallTupled> =
  Tuple(cdc1, cdc1, _bytesSeq, cdc188, u64, cdc188, cOption, cOption, cdc190)

type IcPallet_evmPalletCallCreateTupled = [
  Source: Icdc1,
  Init: I_bytesSeq,
  Value: Icdc188,
  Gas_limit: bigint,
  Max_fee_per_gas: Icdc188,
  Max_priority_fee_per_gas: IcOption,
  Nonce: IcOption,
  Access_list: Icdc190,
]
const cPallet_evmPalletCallCreateTupled: Codec<IcPallet_evmPalletCallCreateTupled> =
  Tuple(cdc1, _bytesSeq, cdc188, u64, cdc188, cOption, cOption, cdc190)

type IcPallet_evmPalletCallCreate2Tupled = [
  Source: Icdc1,
  Init: I_bytesSeq,
  Salt: Icdc13,
  Value: Icdc188,
  Gas_limit: bigint,
  Max_fee_per_gas: Icdc188,
  Max_priority_fee_per_gas: IcOption,
  Nonce: IcOption,
  Access_list: Icdc190,
]
const cPallet_evmPalletCallCreate2Tupled: Codec<IcPallet_evmPalletCallCreate2Tupled> =
  Tuple(cdc1, _bytesSeq, cdc13, cdc188, u64, cdc188, cOption, cOption, cdc190)

type IcPallet_evmPalletError =
  | { tag: "BalanceLow"; value: undefined }
  | { tag: "FeeOverflow"; value: undefined }
  | { tag: "PaymentOverflow"; value: undefined }
  | { tag: "WithdrawFailed"; value: undefined }
  | { tag: "GasPriceTooLow"; value: undefined }
  | { tag: "InvalidNonce"; value: undefined }
  | { tag: "GasLimitTooLow"; value: undefined }
  | { tag: "GasLimitTooHigh"; value: undefined }
  | { tag: "Undefined"; value: undefined }
  | { tag: "Reentrancy"; value: undefined }
  | { tag: "TransactionMustComeFromEOA"; value: undefined }
const cPallet_evmPalletError: Codec<IcPallet_evmPalletError> = Enum({
  BalanceLow: _void,
  FeeOverflow: _void,
  PaymentOverflow: _void,
  WithdrawFailed: _void,
  GasPriceTooLow: _void,
  InvalidNonce: _void,
  GasLimitTooLow: _void,
  GasLimitTooHigh: _void,
  Undefined: _void,
  Reentrancy: _void,
  TransactionMustComeFromEOA: _void,
})

type IcPallet_evmPalletErrorBalanceLow = undefined
const cPallet_evmPalletErrorBalanceLow: Codec<IcPallet_evmPalletErrorBalanceLow> =
  _void

type IcPallet_evmPalletErrorFeeOverflow = undefined
const cPallet_evmPalletErrorFeeOverflow: Codec<IcPallet_evmPalletErrorFeeOverflow> =
  _void

type IcPallet_evmPalletErrorPaymentOverflow = undefined
const cPallet_evmPalletErrorPaymentOverflow: Codec<IcPallet_evmPalletErrorPaymentOverflow> =
  _void

type IcPallet_evmPalletErrorWithdrawFailed = undefined
const cPallet_evmPalletErrorWithdrawFailed: Codec<IcPallet_evmPalletErrorWithdrawFailed> =
  _void

type IcPallet_evmPalletErrorGasPriceTooLow = undefined
const cPallet_evmPalletErrorGasPriceTooLow: Codec<IcPallet_evmPalletErrorGasPriceTooLow> =
  _void

type IcPallet_evmPalletErrorInvalidNonce = undefined
const cPallet_evmPalletErrorInvalidNonce: Codec<IcPallet_evmPalletErrorInvalidNonce> =
  _void

type IcPallet_evmPalletErrorGasLimitTooLow = undefined
const cPallet_evmPalletErrorGasLimitTooLow: Codec<IcPallet_evmPalletErrorGasLimitTooLow> =
  _void

type IcPallet_evmPalletErrorGasLimitTooHigh = undefined
const cPallet_evmPalletErrorGasLimitTooHigh: Codec<IcPallet_evmPalletErrorGasLimitTooHigh> =
  _void

type IcPallet_evmPalletErrorUndefined = undefined
const cPallet_evmPalletErrorUndefined: Codec<IcPallet_evmPalletErrorUndefined> =
  _void

type IcPallet_evmPalletErrorReentrancy = undefined
const cPallet_evmPalletErrorReentrancy: Codec<IcPallet_evmPalletErrorReentrancy> =
  _void

type IcPallet_evmPalletErrorTransactionMustComeFromEOA = undefined
const cPallet_evmPalletErrorTransactionMustComeFromEOA: Codec<IcPallet_evmPalletErrorTransactionMustComeFromEOA> =
  _void

type Icdc463 = Array<IcEthereumLogLog>
const cdc463: Codec<Icdc463> = Vector(cEthereumLogLog)

type Icdc465 = HexString
const cdc465: Codec<Icdc465> = Hex(256)

type IcFp_rpcTransactionStatus = {
  transaction_hash: Icdc13
  transaction_index: number
  from: Icdc1
  to: IcOption
  contract_address: IcOption
  logs: Icdc463
  logs_bloom: Icdc465
}
const cFp_rpcTransactionStatus: Codec<IcFp_rpcTransactionStatus> = Struct({
  transaction_hash: cdc13,
  transaction_index: u32,
  from: cdc1,
  to: cOption,
  contract_address: cOption,
  logs: cdc463,
  logs_bloom: cdc465,
})

type IcEthereumReceiptEIP658ReceiptData = {
  status_code: number
  used_gas: Icdc188
  logs_bloom: Icdc465
  logs: Icdc463
}
const cEthereumReceiptEIP658ReceiptData: Codec<IcEthereumReceiptEIP658ReceiptData> =
  Struct({
    status_code: u8,
    used_gas: cdc188,
    logs_bloom: cdc465,
    logs: cdc463,
  })

type IcEthereumReceiptReceiptV3Legacy = IcEthereumReceiptEIP658ReceiptData
const cEthereumReceiptReceiptV3Legacy: Codec<IcEthereumReceiptReceiptV3Legacy> =
  cEthereumReceiptEIP658ReceiptData

type IcEthereumReceiptReceiptV3EIP2930 = IcEthereumReceiptEIP658ReceiptData
const cEthereumReceiptReceiptV3EIP2930: Codec<IcEthereumReceiptReceiptV3EIP2930> =
  cEthereumReceiptEIP658ReceiptData

type IcEthereumReceiptReceiptV3EIP1559 = IcEthereumReceiptEIP658ReceiptData
const cEthereumReceiptReceiptV3EIP1559: Codec<IcEthereumReceiptReceiptV3EIP1559> =
  cEthereumReceiptEIP658ReceiptData

type IcEthereumReceiptReceiptV3 =
  | { tag: "Legacy"; value: IcEthereumReceiptReceiptV3Legacy }
  | { tag: "EIP2930"; value: IcEthereumReceiptReceiptV3EIP2930 }
  | { tag: "EIP1559"; value: IcEthereumReceiptReceiptV3EIP1559 }
const cEthereumReceiptReceiptV3: Codec<IcEthereumReceiptReceiptV3> = Enum({
  Legacy: cEthereumReceiptReceiptV3Legacy,
  EIP2930: cEthereumReceiptReceiptV3EIP2930,
  EIP1559: cEthereumReceiptReceiptV3EIP1559,
})

type Icdc460 = [
  IcEthereumTransactionTransactionV2,
  IcFp_rpcTransactionStatus,
  IcEthereumReceiptReceiptV3,
]
const cdc460: Codec<Icdc460> = Tuple(
  cEthereumTransactionTransactionV2,
  cFp_rpcTransactionStatus,
  cEthereumReceiptReceiptV3,
)

type Icdc459 = Array<Icdc460>
const cdc459: Codec<Icdc459> = Vector(cdc460)

type IcEthereumHeaderHeader = {
  parent_hash: Icdc13
  ommers_hash: Icdc13
  beneficiary: Icdc1
  state_root: Icdc13
  transactions_root: Icdc13
  receipts_root: Icdc13
  logs_bloom: Icdc465
  difficulty: Icdc188
  number: Icdc188
  gas_limit: Icdc188
  gas_used: Icdc188
  timestamp: bigint
  extra_data: I_bytesSeq
  mix_hash: Icdc13
  nonce: Icdc154
}
const cEthereumHeaderHeader: Codec<IcEthereumHeaderHeader> = Struct({
  parent_hash: cdc13,
  ommers_hash: cdc13,
  beneficiary: cdc1,
  state_root: cdc13,
  transactions_root: cdc13,
  receipts_root: cdc13,
  logs_bloom: cdc465,
  difficulty: cdc188,
  number: cdc188,
  gas_limit: cdc188,
  gas_used: cdc188,
  timestamp: u64,
  extra_data: _bytesSeq,
  mix_hash: cdc13,
  nonce: cdc154,
})

type Icdc471 = Array<IcEthereumTransactionTransactionV2>
const cdc471: Codec<Icdc471> = Vector(cEthereumTransactionTransactionV2)

type Icdc472 = Array<IcEthereumHeaderHeader>
const cdc472: Codec<Icdc472> = Vector(cEthereumHeaderHeader)

type IcEthereumBlockBlock = {
  header: IcEthereumHeaderHeader
  transactions: Icdc471
  ommers: Icdc472
}
const cEthereumBlockBlock: Codec<IcEthereumBlockBlock> = Struct({
  header: cEthereumHeaderHeader,
  transactions: cdc471,
  ommers: cdc472,
})

type Icdc473 = Array<IcEthereumReceiptReceiptV3>
const cdc473: Codec<Icdc473> = Vector(cEthereumReceiptReceiptV3)

type Icdc474 = Array<IcFp_rpcTransactionStatus>
const cdc474: Codec<Icdc474> = Vector(cFp_rpcTransactionStatus)

type IcPrimitive_typesU256Tupled = [Key: Icdc188]
const cPrimitive_typesU256Tupled: Codec<IcPrimitive_typesU256Tupled> =
  Tuple(cdc188)

type IcPallet_ethereumPalletCallTransactTupled = [
  Transaction: IcEthereumTransactionTransactionV2,
]
const cPallet_ethereumPalletCallTransactTupled: Codec<IcPallet_ethereumPalletCallTransactTupled> =
  Tuple(cEthereumTransactionTransactionV2)

type IcPallet_ethereumPalletError =
  | { tag: "InvalidSignature"; value: undefined }
  | { tag: "PreLogExists"; value: undefined }
const cPallet_ethereumPalletError: Codec<IcPallet_ethereumPalletError> = Enum({
  InvalidSignature: _void,
  PreLogExists: _void,
})

type IcPallet_ethereumPalletErrorInvalidSignature = undefined
const cPallet_ethereumPalletErrorInvalidSignature: Codec<IcPallet_ethereumPalletErrorInvalidSignature> =
  _void

type IcPallet_ethereumPalletErrorPreLogExists = undefined
const cPallet_ethereumPalletErrorPreLogExists: Codec<IcPallet_ethereumPalletErrorPreLogExists> =
  _void

type Icdc479 = Array<IcOption>
const cdc479: Codec<Icdc479> = Vector(cOption)

type Icdc13Tupled = [Key: Icdc13]
const cdc13Tupled: Codec<Icdc13Tupled> = Tuple(cdc13)

type IcPallet_schedulerPalletCallScheduleTupled = [
  When: number,
  Maybe_periodic: IcOption,
  Priority: number,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
const cPallet_schedulerPalletCallScheduleTupled: Codec<IcPallet_schedulerPalletCallScheduleTupled> =
  Tuple(u32, cOption, u8, cMoonbeam_runtimeRuntimeCall)

type IcPallet_schedulerPalletCallCancelTupled = [When: number, Index: number]
const cPallet_schedulerPalletCallCancelTupled: Codec<IcPallet_schedulerPalletCallCancelTupled> =
  Tuple(u32, u32)

type IcPallet_schedulerPalletCallSchedule_namedTupled = [
  Id: Icdc13,
  When: number,
  Maybe_periodic: IcOption,
  Priority: number,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
const cPallet_schedulerPalletCallSchedule_namedTupled: Codec<IcPallet_schedulerPalletCallSchedule_namedTupled> =
  Tuple(cdc13, u32, cOption, u8, cMoonbeam_runtimeRuntimeCall)

type IcPallet_schedulerPalletCallCancel_namedTupled = [Id: Icdc13]
const cPallet_schedulerPalletCallCancel_namedTupled: Codec<IcPallet_schedulerPalletCallCancel_namedTupled> =
  Tuple(cdc13)

type IcPallet_schedulerPalletCallSchedule_afterTupled = [
  After: number,
  Maybe_periodic: IcOption,
  Priority: number,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
const cPallet_schedulerPalletCallSchedule_afterTupled: Codec<IcPallet_schedulerPalletCallSchedule_afterTupled> =
  Tuple(u32, cOption, u8, cMoonbeam_runtimeRuntimeCall)

type IcPallet_schedulerPalletCallSchedule_named_afterTupled = [
  Id: Icdc13,
  After: number,
  Maybe_periodic: IcOption,
  Priority: number,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
const cPallet_schedulerPalletCallSchedule_named_afterTupled: Codec<IcPallet_schedulerPalletCallSchedule_named_afterTupled> =
  Tuple(cdc13, u32, cOption, u8, cMoonbeam_runtimeRuntimeCall)

type IcPallet_schedulerPalletError =
  | { tag: "FailedToSchedule"; value: undefined }
  | { tag: "NotFound"; value: undefined }
  | { tag: "TargetBlockNumberInPast"; value: undefined }
  | { tag: "RescheduleNoChange"; value: undefined }
  | { tag: "Named"; value: undefined }
const cPallet_schedulerPalletError: Codec<IcPallet_schedulerPalletError> = Enum(
  {
    FailedToSchedule: _void,
    NotFound: _void,
    TargetBlockNumberInPast: _void,
    RescheduleNoChange: _void,
    Named: _void,
  },
)

type IcPallet_schedulerPalletErrorFailedToSchedule = undefined
const cPallet_schedulerPalletErrorFailedToSchedule: Codec<IcPallet_schedulerPalletErrorFailedToSchedule> =
  _void

type IcPallet_schedulerPalletErrorNotFound = undefined
const cPallet_schedulerPalletErrorNotFound: Codec<IcPallet_schedulerPalletErrorNotFound> =
  _void

type IcPallet_schedulerPalletErrorTargetBlockNumberInPast = undefined
const cPallet_schedulerPalletErrorTargetBlockNumberInPast: Codec<IcPallet_schedulerPalletErrorTargetBlockNumberInPast> =
  _void

type IcPallet_schedulerPalletErrorRescheduleNoChange = undefined
const cPallet_schedulerPalletErrorRescheduleNoChange: Codec<IcPallet_schedulerPalletErrorRescheduleNoChange> =
  _void

type IcPallet_schedulerPalletErrorNamed = undefined
const cPallet_schedulerPalletErrorNamed: Codec<IcPallet_schedulerPalletErrorNamed> =
  _void

type Icdc482 = [number, IcFrame_supportTraitsPreimagesBounded, Icdc1]
const cdc482: Codec<Icdc482> = Tuple(
  u32,
  cFrame_supportTraitsPreimagesBounded,
  cdc1,
)

type Icdc483 = Array<Icdc482>
const cdc483: Codec<Icdc483> = Vector(cdc482)

type Icdc484 = [Icdc109, bigint]
const cdc484: Codec<Icdc484> = Tuple(cdc109, u128)

type IcPallet_democracyTypesTally = {
  ayes: bigint
  nays: bigint
  turnout: bigint
}
const cPallet_democracyTypesTally: Codec<IcPallet_democracyTypesTally> = Struct(
  { ayes: u128, nays: u128, turnout: u128 },
)

type IcPallet_democracyTypesReferendumStatus = {
  end: number
  proposal: IcFrame_supportTraitsPreimagesBounded
  threshold: IcPallet_democracyVote_thresholdVoteThreshold
  delay: number
  tally: IcPallet_democracyTypesTally
}
const cPallet_democracyTypesReferendumStatus: Codec<IcPallet_democracyTypesReferendumStatus> =
  Struct({
    end: u32,
    proposal: cFrame_supportTraitsPreimagesBounded,
    threshold: cPallet_democracyVote_thresholdVoteThreshold,
    delay: u32,
    tally: cPallet_democracyTypesTally,
  })

type IcPallet_democracyTypesReferendumInfoOngoing =
  IcPallet_democracyTypesReferendumStatus
const cPallet_democracyTypesReferendumInfoOngoing: Codec<IcPallet_democracyTypesReferendumInfoOngoing> =
  cPallet_democracyTypesReferendumStatus

type IcPallet_democracyTypesReferendumInfoFinished = {
  approved: boolean
  end: number
}
const cPallet_democracyTypesReferendumInfoFinished: Codec<IcPallet_democracyTypesReferendumInfoFinished> =
  Struct({ approved: bool, end: u32 })

type IcPallet_democracyTypesReferendumInfo =
  | { tag: "Ongoing"; value: IcPallet_democracyTypesReferendumInfoOngoing }
  | { tag: "Finished"; value: IcPallet_democracyTypesReferendumInfoFinished }
const cPallet_democracyTypesReferendumInfo: Codec<IcPallet_democracyTypesReferendumInfo> =
  Enum({
    Ongoing: cPallet_democracyTypesReferendumInfoOngoing,
    Finished: cPallet_democracyTypesReferendumInfoFinished,
  })

type Icdc490 = [number, IcPallet_democracyVoteAccountVote]
const cdc490: Codec<Icdc490> = Tuple(u32, cPallet_democracyVoteAccountVote)

type Icdc491 = Array<Icdc490>
const cdc491: Codec<Icdc491> = Vector(cdc490)

type IcPallet_democracyTypesDelegations = { votes: bigint; capital: bigint }
const cPallet_democracyTypesDelegations: Codec<IcPallet_democracyTypesDelegations> =
  Struct({ votes: u128, capital: u128 })

type IcPallet_democracyVotePriorLock = [number, bigint]
const cPallet_democracyVotePriorLock: Codec<IcPallet_democracyVotePriorLock> =
  Tuple(u32, u128)

type IcPallet_democracyVoteVotingDirect = {
  votes: Icdc491
  delegations: IcPallet_democracyTypesDelegations
  prior: IcPallet_democracyVotePriorLock
}
const cPallet_democracyVoteVotingDirect: Codec<IcPallet_democracyVoteVotingDirect> =
  Struct({
    votes: cdc491,
    delegations: cPallet_democracyTypesDelegations,
    prior: cPallet_democracyVotePriorLock,
  })

type IcPallet_democracyVoteVotingDelegating = {
  balance: bigint
  target: Icdc1
  conviction: IcPallet_democracyConvictionConviction
  delegations: IcPallet_democracyTypesDelegations
  prior: IcPallet_democracyVotePriorLock
}
const cPallet_democracyVoteVotingDelegating: Codec<IcPallet_democracyVoteVotingDelegating> =
  Struct({
    balance: u128,
    target: cdc1,
    conviction: cPallet_democracyConvictionConviction,
    delegations: cPallet_democracyTypesDelegations,
    prior: cPallet_democracyVotePriorLock,
  })

type IcPallet_democracyVoteVoting =
  | { tag: "Direct"; value: IcPallet_democracyVoteVotingDirect }
  | { tag: "Delegating"; value: IcPallet_democracyVoteVotingDelegating }
const cPallet_democracyVoteVoting: Codec<IcPallet_democracyVoteVoting> = Enum({
  Direct: cPallet_democracyVoteVotingDirect,
  Delegating: cPallet_democracyVoteVotingDelegating,
})

type Icdc494 = [
  IcFrame_supportTraitsPreimagesBounded,
  IcPallet_democracyVote_thresholdVoteThreshold,
]
const cdc494: Codec<Icdc494> = Tuple(
  cFrame_supportTraitsPreimagesBounded,
  cPallet_democracyVote_thresholdVoteThreshold,
)

type Icdc495 = [number, Icdc109]
const cdc495: Codec<Icdc495> = Tuple(u32, cdc109)

type IcPallet_democracyTypesMetadataOwnerTupled = [
  Key: IcPallet_democracyTypesMetadataOwner,
]
const cPallet_democracyTypesMetadataOwnerTupled: Codec<IcPallet_democracyTypesMetadataOwnerTupled> =
  Tuple(cPallet_democracyTypesMetadataOwner)

type IcPallet_democracyPalletCallProposeTupled = [
  Proposal: IcFrame_supportTraitsPreimagesBounded,
  Value: bigint,
]
const cPallet_democracyPalletCallProposeTupled: Codec<IcPallet_democracyPalletCallProposeTupled> =
  Tuple(cFrame_supportTraitsPreimagesBounded, compactBn)

type IcPallet_democracyPalletCallSecondTupled = [Proposal: number]
const cPallet_democracyPalletCallSecondTupled: Codec<IcPallet_democracyPalletCallSecondTupled> =
  Tuple(compactNumber)

type IcPallet_democracyPalletCallVoteTupled = [
  Ref_index: number,
  Vote: IcPallet_democracyVoteAccountVote,
]
const cPallet_democracyPalletCallVoteTupled: Codec<IcPallet_democracyPalletCallVoteTupled> =
  Tuple(compactNumber, cPallet_democracyVoteAccountVote)

type IcPallet_democracyPalletCallEmergency_cancelTupled = [Ref_index: number]
const cPallet_democracyPalletCallEmergency_cancelTupled: Codec<IcPallet_democracyPalletCallEmergency_cancelTupled> =
  Tuple(u32)

type IcPallet_democracyPalletCallExternal_proposeTupled = [
  Proposal: IcFrame_supportTraitsPreimagesBounded,
]
const cPallet_democracyPalletCallExternal_proposeTupled: Codec<IcPallet_democracyPalletCallExternal_proposeTupled> =
  Tuple(cFrame_supportTraitsPreimagesBounded)

type IcPallet_democracyPalletCallExternal_propose_majorityTupled = [
  Proposal: IcFrame_supportTraitsPreimagesBounded,
]
const cPallet_democracyPalletCallExternal_propose_majorityTupled: Codec<IcPallet_democracyPalletCallExternal_propose_majorityTupled> =
  Tuple(cFrame_supportTraitsPreimagesBounded)

type IcPallet_democracyPalletCallExternal_propose_defaultTupled = [
  Proposal: IcFrame_supportTraitsPreimagesBounded,
]
const cPallet_democracyPalletCallExternal_propose_defaultTupled: Codec<IcPallet_democracyPalletCallExternal_propose_defaultTupled> =
  Tuple(cFrame_supportTraitsPreimagesBounded)

type IcPallet_democracyPalletCallFast_trackTupled = [
  Proposal_hash: Icdc13,
  Voting_period: number,
  Delay: number,
]
const cPallet_democracyPalletCallFast_trackTupled: Codec<IcPallet_democracyPalletCallFast_trackTupled> =
  Tuple(cdc13, u32, u32)

type IcPallet_democracyPalletCallVeto_externalTupled = [Proposal_hash: Icdc13]
const cPallet_democracyPalletCallVeto_externalTupled: Codec<IcPallet_democracyPalletCallVeto_externalTupled> =
  Tuple(cdc13)

type IcPallet_democracyPalletCallCancel_referendumTupled = [Ref_index: number]
const cPallet_democracyPalletCallCancel_referendumTupled: Codec<IcPallet_democracyPalletCallCancel_referendumTupled> =
  Tuple(compactNumber)

type IcPallet_democracyPalletCallDelegateTupled = [
  To: Icdc1,
  Conviction: IcPallet_democracyConvictionConviction,
  Balance: bigint,
]
const cPallet_democracyPalletCallDelegateTupled: Codec<IcPallet_democracyPalletCallDelegateTupled> =
  Tuple(cdc1, cPallet_democracyConvictionConviction, u128)

type IcPallet_democracyPalletCallUnlockTupled = [Target: Icdc1]
const cPallet_democracyPalletCallUnlockTupled: Codec<IcPallet_democracyPalletCallUnlockTupled> =
  Tuple(cdc1)

type IcPallet_democracyPalletCallRemove_voteTupled = [Index: number]
const cPallet_democracyPalletCallRemove_voteTupled: Codec<IcPallet_democracyPalletCallRemove_voteTupled> =
  Tuple(u32)

type IcPallet_democracyPalletCallRemove_other_voteTupled = [
  Target: Icdc1,
  Index: number,
]
const cPallet_democracyPalletCallRemove_other_voteTupled: Codec<IcPallet_democracyPalletCallRemove_other_voteTupled> =
  Tuple(cdc1, u32)

type IcPallet_democracyPalletCallBlacklistTupled = [
  Proposal_hash: Icdc13,
  Maybe_ref_index: IcOption,
]
const cPallet_democracyPalletCallBlacklistTupled: Codec<IcPallet_democracyPalletCallBlacklistTupled> =
  Tuple(cdc13, cOption)

type IcPallet_democracyPalletCallCancel_proposalTupled = [Prop_index: number]
const cPallet_democracyPalletCallCancel_proposalTupled: Codec<IcPallet_democracyPalletCallCancel_proposalTupled> =
  Tuple(compactNumber)

type IcPallet_democracyPalletCallSet_metadataTupled = [
  Owner: IcPallet_democracyTypesMetadataOwner,
  Maybe_hash: IcOption,
]
const cPallet_democracyPalletCallSet_metadataTupled: Codec<IcPallet_democracyPalletCallSet_metadataTupled> =
  Tuple(cPallet_democracyTypesMetadataOwner, cOption)

type IcPallet_democracyPalletError =
  | { tag: "ValueLow"; value: undefined }
  | { tag: "ProposalMissing"; value: undefined }
  | { tag: "AlreadyCanceled"; value: undefined }
  | { tag: "DuplicateProposal"; value: undefined }
  | { tag: "ProposalBlacklisted"; value: undefined }
  | { tag: "NotSimpleMajority"; value: undefined }
  | { tag: "InvalidHash"; value: undefined }
  | { tag: "NoProposal"; value: undefined }
  | { tag: "AlreadyVetoed"; value: undefined }
  | { tag: "ReferendumInvalid"; value: undefined }
  | { tag: "NoneWaiting"; value: undefined }
  | { tag: "NotVoter"; value: undefined }
  | { tag: "NoPermission"; value: undefined }
  | { tag: "AlreadyDelegating"; value: undefined }
  | { tag: "InsufficientFunds"; value: undefined }
  | { tag: "NotDelegating"; value: undefined }
  | { tag: "VotesExist"; value: undefined }
  | { tag: "InstantNotAllowed"; value: undefined }
  | { tag: "Nonsense"; value: undefined }
  | { tag: "WrongUpperBound"; value: undefined }
  | { tag: "MaxVotesReached"; value: undefined }
  | { tag: "TooMany"; value: undefined }
  | { tag: "VotingPeriodLow"; value: undefined }
  | { tag: "PreimageNotExist"; value: undefined }
const cPallet_democracyPalletError: Codec<IcPallet_democracyPalletError> = Enum(
  {
    ValueLow: _void,
    ProposalMissing: _void,
    AlreadyCanceled: _void,
    DuplicateProposal: _void,
    ProposalBlacklisted: _void,
    NotSimpleMajority: _void,
    InvalidHash: _void,
    NoProposal: _void,
    AlreadyVetoed: _void,
    ReferendumInvalid: _void,
    NoneWaiting: _void,
    NotVoter: _void,
    NoPermission: _void,
    AlreadyDelegating: _void,
    InsufficientFunds: _void,
    NotDelegating: _void,
    VotesExist: _void,
    InstantNotAllowed: _void,
    Nonsense: _void,
    WrongUpperBound: _void,
    MaxVotesReached: _void,
    TooMany: _void,
    VotingPeriodLow: _void,
    PreimageNotExist: _void,
  },
)

type IcPallet_democracyPalletErrorValueLow = undefined
const cPallet_democracyPalletErrorValueLow: Codec<IcPallet_democracyPalletErrorValueLow> =
  _void

type IcPallet_democracyPalletErrorProposalMissing = undefined
const cPallet_democracyPalletErrorProposalMissing: Codec<IcPallet_democracyPalletErrorProposalMissing> =
  _void

type IcPallet_democracyPalletErrorAlreadyCanceled = undefined
const cPallet_democracyPalletErrorAlreadyCanceled: Codec<IcPallet_democracyPalletErrorAlreadyCanceled> =
  _void

type IcPallet_democracyPalletErrorDuplicateProposal = undefined
const cPallet_democracyPalletErrorDuplicateProposal: Codec<IcPallet_democracyPalletErrorDuplicateProposal> =
  _void

type IcPallet_democracyPalletErrorProposalBlacklisted = undefined
const cPallet_democracyPalletErrorProposalBlacklisted: Codec<IcPallet_democracyPalletErrorProposalBlacklisted> =
  _void

type IcPallet_democracyPalletErrorNotSimpleMajority = undefined
const cPallet_democracyPalletErrorNotSimpleMajority: Codec<IcPallet_democracyPalletErrorNotSimpleMajority> =
  _void

type IcPallet_democracyPalletErrorInvalidHash = undefined
const cPallet_democracyPalletErrorInvalidHash: Codec<IcPallet_democracyPalletErrorInvalidHash> =
  _void

type IcPallet_democracyPalletErrorNoProposal = undefined
const cPallet_democracyPalletErrorNoProposal: Codec<IcPallet_democracyPalletErrorNoProposal> =
  _void

type IcPallet_democracyPalletErrorAlreadyVetoed = undefined
const cPallet_democracyPalletErrorAlreadyVetoed: Codec<IcPallet_democracyPalletErrorAlreadyVetoed> =
  _void

type IcPallet_democracyPalletErrorReferendumInvalid = undefined
const cPallet_democracyPalletErrorReferendumInvalid: Codec<IcPallet_democracyPalletErrorReferendumInvalid> =
  _void

type IcPallet_democracyPalletErrorNoneWaiting = undefined
const cPallet_democracyPalletErrorNoneWaiting: Codec<IcPallet_democracyPalletErrorNoneWaiting> =
  _void

type IcPallet_democracyPalletErrorNotVoter = undefined
const cPallet_democracyPalletErrorNotVoter: Codec<IcPallet_democracyPalletErrorNotVoter> =
  _void

type IcPallet_democracyPalletErrorNoPermission = undefined
const cPallet_democracyPalletErrorNoPermission: Codec<IcPallet_democracyPalletErrorNoPermission> =
  _void

type IcPallet_democracyPalletErrorAlreadyDelegating = undefined
const cPallet_democracyPalletErrorAlreadyDelegating: Codec<IcPallet_democracyPalletErrorAlreadyDelegating> =
  _void

type IcPallet_democracyPalletErrorInsufficientFunds = undefined
const cPallet_democracyPalletErrorInsufficientFunds: Codec<IcPallet_democracyPalletErrorInsufficientFunds> =
  _void

type IcPallet_democracyPalletErrorNotDelegating = undefined
const cPallet_democracyPalletErrorNotDelegating: Codec<IcPallet_democracyPalletErrorNotDelegating> =
  _void

type IcPallet_democracyPalletErrorVotesExist = undefined
const cPallet_democracyPalletErrorVotesExist: Codec<IcPallet_democracyPalletErrorVotesExist> =
  _void

type IcPallet_democracyPalletErrorInstantNotAllowed = undefined
const cPallet_democracyPalletErrorInstantNotAllowed: Codec<IcPallet_democracyPalletErrorInstantNotAllowed> =
  _void

type IcPallet_democracyPalletErrorNonsense = undefined
const cPallet_democracyPalletErrorNonsense: Codec<IcPallet_democracyPalletErrorNonsense> =
  _void

type IcPallet_democracyPalletErrorWrongUpperBound = undefined
const cPallet_democracyPalletErrorWrongUpperBound: Codec<IcPallet_democracyPalletErrorWrongUpperBound> =
  _void

type IcPallet_democracyPalletErrorMaxVotesReached = undefined
const cPallet_democracyPalletErrorMaxVotesReached: Codec<IcPallet_democracyPalletErrorMaxVotesReached> =
  _void

type IcPallet_democracyPalletErrorTooMany = undefined
const cPallet_democracyPalletErrorTooMany: Codec<IcPallet_democracyPalletErrorTooMany> =
  _void

type IcPallet_democracyPalletErrorVotingPeriodLow = undefined
const cPallet_democracyPalletErrorVotingPeriodLow: Codec<IcPallet_democracyPalletErrorVotingPeriodLow> =
  _void

type IcPallet_democracyPalletErrorPreimageNotExist = undefined
const cPallet_democracyPalletErrorPreimageNotExist: Codec<IcPallet_democracyPalletErrorPreimageNotExist> =
  _void

type IcPallet_democracyPalletEventExternalTabled = undefined
const cPallet_democracyPalletEventExternalTabled: Codec<IcPallet_democracyPalletEventExternalTabled> =
  _void

type Icdc498 = [Icdc1, bigint]
const cdc498: Codec<Icdc498> = Tuple(cdc1, u128)

type IcPallet_preimageRequestStatusUnrequested = {
  deposit: Icdc498
  len: number
}
const cPallet_preimageRequestStatusUnrequested: Codec<IcPallet_preimageRequestStatusUnrequested> =
  Struct({ deposit: cdc498, len: u32 })

type IcPallet_preimageRequestStatusRequested = {
  deposit: IcOption
  count: number
  len: IcOption
}
const cPallet_preimageRequestStatusRequested: Codec<IcPallet_preimageRequestStatusRequested> =
  Struct({ deposit: cOption, count: u32, len: cOption })

type IcPallet_preimageRequestStatus =
  | { tag: "Unrequested"; value: IcPallet_preimageRequestStatusUnrequested }
  | { tag: "Requested"; value: IcPallet_preimageRequestStatusRequested }
const cPallet_preimageRequestStatus: Codec<IcPallet_preimageRequestStatus> =
  Enum({
    Unrequested: cPallet_preimageRequestStatusUnrequested,
    Requested: cPallet_preimageRequestStatusRequested,
  })

type Icdc500 = [Icdc13, number]
const cdc500: Codec<Icdc500> = Tuple(cdc13, u32)

type Icdc500Tupled = [Key: Icdc500]
const cdc500Tupled: Codec<Icdc500Tupled> = Tuple(cdc500)

type IcPallet_preimagePalletCallNote_preimageTupled = [Bytes: I_bytesSeq]
const cPallet_preimagePalletCallNote_preimageTupled: Codec<IcPallet_preimagePalletCallNote_preimageTupled> =
  Tuple(_bytesSeq)

type IcPallet_preimagePalletCallUnnote_preimageTupled = [Hash: Icdc13]
const cPallet_preimagePalletCallUnnote_preimageTupled: Codec<IcPallet_preimagePalletCallUnnote_preimageTupled> =
  Tuple(cdc13)

type IcPallet_preimagePalletCallRequest_preimageTupled = [Hash: Icdc13]
const cPallet_preimagePalletCallRequest_preimageTupled: Codec<IcPallet_preimagePalletCallRequest_preimageTupled> =
  Tuple(cdc13)

type IcPallet_preimagePalletCallUnrequest_preimageTupled = [Hash: Icdc13]
const cPallet_preimagePalletCallUnrequest_preimageTupled: Codec<IcPallet_preimagePalletCallUnrequest_preimageTupled> =
  Tuple(cdc13)

type IcPallet_preimagePalletError =
  | { tag: "TooBig"; value: undefined }
  | { tag: "AlreadyNoted"; value: undefined }
  | { tag: "NotAuthorized"; value: undefined }
  | { tag: "NotNoted"; value: undefined }
  | { tag: "Requested"; value: undefined }
  | { tag: "NotRequested"; value: undefined }
const cPallet_preimagePalletError: Codec<IcPallet_preimagePalletError> = Enum({
  TooBig: _void,
  AlreadyNoted: _void,
  NotAuthorized: _void,
  NotNoted: _void,
  Requested: _void,
  NotRequested: _void,
})

type IcPallet_preimagePalletErrorTooBig = undefined
const cPallet_preimagePalletErrorTooBig: Codec<IcPallet_preimagePalletErrorTooBig> =
  _void

type IcPallet_preimagePalletErrorAlreadyNoted = undefined
const cPallet_preimagePalletErrorAlreadyNoted: Codec<IcPallet_preimagePalletErrorAlreadyNoted> =
  _void

type IcPallet_preimagePalletErrorNotAuthorized = undefined
const cPallet_preimagePalletErrorNotAuthorized: Codec<IcPallet_preimagePalletErrorNotAuthorized> =
  _void

type IcPallet_preimagePalletErrorNotNoted = undefined
const cPallet_preimagePalletErrorNotNoted: Codec<IcPallet_preimagePalletErrorNotNoted> =
  _void

type IcPallet_preimagePalletErrorRequested = undefined
const cPallet_preimagePalletErrorRequested: Codec<IcPallet_preimagePalletErrorRequested> =
  _void

type IcPallet_preimagePalletErrorNotRequested = undefined
const cPallet_preimagePalletErrorNotRequested: Codec<IcPallet_preimagePalletErrorNotRequested> =
  _void

type Icdc507 = [number, IcPallet_conviction_votingVoteAccountVote]
const cdc507: Codec<Icdc507> = Tuple(
  u32,
  cPallet_conviction_votingVoteAccountVote,
)

type Icdc508 = Array<Icdc507>
const cdc508: Codec<Icdc508> = Vector(cdc507)

type IcPallet_conviction_votingTypesDelegations = {
  votes: bigint
  capital: bigint
}
const cPallet_conviction_votingTypesDelegations: Codec<IcPallet_conviction_votingTypesDelegations> =
  Struct({ votes: u128, capital: u128 })

type IcPallet_conviction_votingVotePriorLock = [number, bigint]
const cPallet_conviction_votingVotePriorLock: Codec<IcPallet_conviction_votingVotePriorLock> =
  Tuple(u32, u128)

type IcPallet_conviction_votingVoteCasting = {
  votes: Icdc508
  delegations: IcPallet_conviction_votingTypesDelegations
  prior: IcPallet_conviction_votingVotePriorLock
}
const cPallet_conviction_votingVoteCasting: Codec<IcPallet_conviction_votingVoteCasting> =
  Struct({
    votes: cdc508,
    delegations: cPallet_conviction_votingTypesDelegations,
    prior: cPallet_conviction_votingVotePriorLock,
  })

type IcPallet_conviction_votingVoteVotingCasting =
  IcPallet_conviction_votingVoteCasting
const cPallet_conviction_votingVoteVotingCasting: Codec<IcPallet_conviction_votingVoteVotingCasting> =
  cPallet_conviction_votingVoteCasting

type IcPallet_conviction_votingVoteDelegating = {
  balance: bigint
  target: Icdc1
  conviction: IcPallet_conviction_votingConvictionConviction
  delegations: IcPallet_conviction_votingTypesDelegations
  prior: IcPallet_conviction_votingVotePriorLock
}
const cPallet_conviction_votingVoteDelegating: Codec<IcPallet_conviction_votingVoteDelegating> =
  Struct({
    balance: u128,
    target: cdc1,
    conviction: cPallet_conviction_votingConvictionConviction,
    delegations: cPallet_conviction_votingTypesDelegations,
    prior: cPallet_conviction_votingVotePriorLock,
  })

type IcPallet_conviction_votingVoteVotingDelegating =
  IcPallet_conviction_votingVoteDelegating
const cPallet_conviction_votingVoteVotingDelegating: Codec<IcPallet_conviction_votingVoteVotingDelegating> =
  cPallet_conviction_votingVoteDelegating

type IcPallet_conviction_votingVoteVoting =
  | { tag: "Casting"; value: IcPallet_conviction_votingVoteVotingCasting }
  | { tag: "Delegating"; value: IcPallet_conviction_votingVoteVotingDelegating }
const cPallet_conviction_votingVoteVoting: Codec<IcPallet_conviction_votingVoteVoting> =
  Enum({
    Casting: cPallet_conviction_votingVoteVotingCasting,
    Delegating: cPallet_conviction_votingVoteVotingDelegating,
  })

type Icdc503 = [Icdc1, number]
const cdc503: Codec<Icdc503> = Tuple(cdc1, u16)

type Icdc513 = [number, bigint]
const cdc513: Codec<Icdc513> = Tuple(u16, u128)

type Icdc514 = Array<Icdc513>
const cdc514: Codec<Icdc514> = Vector(cdc513)

type IcPallet_conviction_votingPalletCallVoteTupled = [
  Poll_index: number,
  Vote: IcPallet_conviction_votingVoteAccountVote,
]
const cPallet_conviction_votingPalletCallVoteTupled: Codec<IcPallet_conviction_votingPalletCallVoteTupled> =
  Tuple(compactNumber, cPallet_conviction_votingVoteAccountVote)

type IcPallet_conviction_votingPalletCallDelegateTupled = [
  Class: number,
  To: Icdc1,
  Conviction: IcPallet_conviction_votingConvictionConviction,
  Balance: bigint,
]
const cPallet_conviction_votingPalletCallDelegateTupled: Codec<IcPallet_conviction_votingPalletCallDelegateTupled> =
  Tuple(u16, cdc1, cPallet_conviction_votingConvictionConviction, u128)

type IcPallet_conviction_votingPalletCallUndelegateTupled = [Class: number]
const cPallet_conviction_votingPalletCallUndelegateTupled: Codec<IcPallet_conviction_votingPalletCallUndelegateTupled> =
  Tuple(u16)

type IcPallet_conviction_votingPalletCallUnlockTupled = [
  Class: number,
  Target: Icdc1,
]
const cPallet_conviction_votingPalletCallUnlockTupled: Codec<IcPallet_conviction_votingPalletCallUnlockTupled> =
  Tuple(u16, cdc1)

type IcPallet_conviction_votingPalletCallRemove_voteTupled = [
  Class: IcOption,
  Index: number,
]
const cPallet_conviction_votingPalletCallRemove_voteTupled: Codec<IcPallet_conviction_votingPalletCallRemove_voteTupled> =
  Tuple(cOption, u32)

type IcPallet_conviction_votingPalletCallRemove_other_voteTupled = [
  Target: Icdc1,
  Class: number,
  Index: number,
]
const cPallet_conviction_votingPalletCallRemove_other_voteTupled: Codec<IcPallet_conviction_votingPalletCallRemove_other_voteTupled> =
  Tuple(cdc1, u16, u32)

type IcPallet_conviction_votingPalletError =
  | { tag: "NotOngoing"; value: undefined }
  | { tag: "NotVoter"; value: undefined }
  | { tag: "NoPermission"; value: undefined }
  | { tag: "NoPermissionYet"; value: undefined }
  | { tag: "AlreadyDelegating"; value: undefined }
  | { tag: "AlreadyVoting"; value: undefined }
  | { tag: "InsufficientFunds"; value: undefined }
  | { tag: "NotDelegating"; value: undefined }
  | { tag: "Nonsense"; value: undefined }
  | { tag: "MaxVotesReached"; value: undefined }
  | { tag: "ClassNeeded"; value: undefined }
  | { tag: "BadClass"; value: undefined }
const cPallet_conviction_votingPalletError: Codec<IcPallet_conviction_votingPalletError> =
  Enum({
    NotOngoing: _void,
    NotVoter: _void,
    NoPermission: _void,
    NoPermissionYet: _void,
    AlreadyDelegating: _void,
    AlreadyVoting: _void,
    InsufficientFunds: _void,
    NotDelegating: _void,
    Nonsense: _void,
    MaxVotesReached: _void,
    ClassNeeded: _void,
    BadClass: _void,
  })

type IcPallet_conviction_votingPalletErrorNotOngoing = undefined
const cPallet_conviction_votingPalletErrorNotOngoing: Codec<IcPallet_conviction_votingPalletErrorNotOngoing> =
  _void

type IcPallet_conviction_votingPalletErrorNotVoter = undefined
const cPallet_conviction_votingPalletErrorNotVoter: Codec<IcPallet_conviction_votingPalletErrorNotVoter> =
  _void

type IcPallet_conviction_votingPalletErrorNoPermission = undefined
const cPallet_conviction_votingPalletErrorNoPermission: Codec<IcPallet_conviction_votingPalletErrorNoPermission> =
  _void

type IcPallet_conviction_votingPalletErrorNoPermissionYet = undefined
const cPallet_conviction_votingPalletErrorNoPermissionYet: Codec<IcPallet_conviction_votingPalletErrorNoPermissionYet> =
  _void

type IcPallet_conviction_votingPalletErrorAlreadyDelegating = undefined
const cPallet_conviction_votingPalletErrorAlreadyDelegating: Codec<IcPallet_conviction_votingPalletErrorAlreadyDelegating> =
  _void

type IcPallet_conviction_votingPalletErrorAlreadyVoting = undefined
const cPallet_conviction_votingPalletErrorAlreadyVoting: Codec<IcPallet_conviction_votingPalletErrorAlreadyVoting> =
  _void

type IcPallet_conviction_votingPalletErrorInsufficientFunds = undefined
const cPallet_conviction_votingPalletErrorInsufficientFunds: Codec<IcPallet_conviction_votingPalletErrorInsufficientFunds> =
  _void

type IcPallet_conviction_votingPalletErrorNotDelegating = undefined
const cPallet_conviction_votingPalletErrorNotDelegating: Codec<IcPallet_conviction_votingPalletErrorNotDelegating> =
  _void

type IcPallet_conviction_votingPalletErrorNonsense = undefined
const cPallet_conviction_votingPalletErrorNonsense: Codec<IcPallet_conviction_votingPalletErrorNonsense> =
  _void

type IcPallet_conviction_votingPalletErrorMaxVotesReached = undefined
const cPallet_conviction_votingPalletErrorMaxVotesReached: Codec<IcPallet_conviction_votingPalletErrorMaxVotesReached> =
  _void

type IcPallet_conviction_votingPalletErrorClassNeeded = undefined
const cPallet_conviction_votingPalletErrorClassNeeded: Codec<IcPallet_conviction_votingPalletErrorClassNeeded> =
  _void

type IcPallet_conviction_votingPalletErrorBadClass = undefined
const cPallet_conviction_votingPalletErrorBadClass: Codec<IcPallet_conviction_votingPalletErrorBadClass> =
  _void

type IcPallet_referendaTypesDeposit = { who: Icdc1; amount: bigint }
const cPallet_referendaTypesDeposit: Codec<IcPallet_referendaTypesDeposit> =
  Struct({ who: cdc1, amount: u128 })

type IcPallet_referendaTypesReferendumStatus = {
  track: number
  origin: IcMoonbeam_runtimeOriginCaller
  proposal: IcFrame_supportTraitsPreimagesBounded
  enactment: IcFrame_supportTraitsScheduleDispatchTime
  submitted: number
  submission_deposit: IcPallet_referendaTypesDeposit
  decision_deposit: IcOption
  deciding: IcOption
  tally: IcPallet_conviction_votingTypesTally
  in_queue: boolean
  alarm: IcOption
}
const cPallet_referendaTypesReferendumStatus: Codec<IcPallet_referendaTypesReferendumStatus> =
  Struct({
    track: u16,
    origin: cMoonbeam_runtimeOriginCaller,
    proposal: cFrame_supportTraitsPreimagesBounded,
    enactment: cFrame_supportTraitsScheduleDispatchTime,
    submitted: u32,
    submission_deposit: cPallet_referendaTypesDeposit,
    decision_deposit: cOption,
    deciding: cOption,
    tally: cPallet_conviction_votingTypesTally,
    in_queue: bool,
    alarm: cOption,
  })

type IcPallet_referendaTypesReferendumInfoOngoing =
  IcPallet_referendaTypesReferendumStatus
const cPallet_referendaTypesReferendumInfoOngoing: Codec<IcPallet_referendaTypesReferendumInfoOngoing> =
  cPallet_referendaTypesReferendumStatus

type IcPallet_referendaTypesReferendumInfoApproved = [
  number,
  IcOption,
  IcOption,
]
const cPallet_referendaTypesReferendumInfoApproved: Codec<IcPallet_referendaTypesReferendumInfoApproved> =
  Tuple(u32, cOption, cOption)

type IcPallet_referendaTypesReferendumInfoRejected = [
  number,
  IcOption,
  IcOption,
]
const cPallet_referendaTypesReferendumInfoRejected: Codec<IcPallet_referendaTypesReferendumInfoRejected> =
  Tuple(u32, cOption, cOption)

type IcPallet_referendaTypesReferendumInfoCancelled = [
  number,
  IcOption,
  IcOption,
]
const cPallet_referendaTypesReferendumInfoCancelled: Codec<IcPallet_referendaTypesReferendumInfoCancelled> =
  Tuple(u32, cOption, cOption)

type IcPallet_referendaTypesReferendumInfoTimedOut = [
  number,
  IcOption,
  IcOption,
]
const cPallet_referendaTypesReferendumInfoTimedOut: Codec<IcPallet_referendaTypesReferendumInfoTimedOut> =
  Tuple(u32, cOption, cOption)

type IcPallet_referendaTypesReferendumInfoKilled = number
const cPallet_referendaTypesReferendumInfoKilled: Codec<IcPallet_referendaTypesReferendumInfoKilled> =
  u32

type IcPallet_referendaTypesReferendumInfo =
  | { tag: "Ongoing"; value: IcPallet_referendaTypesReferendumInfoOngoing }
  | { tag: "Approved"; value: IcPallet_referendaTypesReferendumInfoApproved }
  | { tag: "Rejected"; value: IcPallet_referendaTypesReferendumInfoRejected }
  | { tag: "Cancelled"; value: IcPallet_referendaTypesReferendumInfoCancelled }
  | { tag: "TimedOut"; value: IcPallet_referendaTypesReferendumInfoTimedOut }
  | { tag: "Killed"; value: IcPallet_referendaTypesReferendumInfoKilled }
const cPallet_referendaTypesReferendumInfo: Codec<IcPallet_referendaTypesReferendumInfo> =
  Enum({
    Ongoing: cPallet_referendaTypesReferendumInfoOngoing,
    Approved: cPallet_referendaTypesReferendumInfoApproved,
    Rejected: cPallet_referendaTypesReferendumInfoRejected,
    Cancelled: cPallet_referendaTypesReferendumInfoCancelled,
    TimedOut: cPallet_referendaTypesReferendumInfoTimedOut,
    Killed: cPallet_referendaTypesReferendumInfoKilled,
  })

type Icdc525 = [number, bigint]
const cdc525: Codec<Icdc525> = Tuple(u32, u128)

type Icdc526 = Array<Icdc525>
const cdc526: Codec<Icdc526> = Vector(cdc525)

type Icdc56Tupled = [Key: number]
const cdc56Tupled: Codec<Icdc56Tupled> = Tuple(u16)

type IcPallet_referendaPalletCallSubmitTupled = [
  Proposal_origin: IcMoonbeam_runtimeOriginCaller,
  Proposal: IcFrame_supportTraitsPreimagesBounded,
  Enactment_moment: IcFrame_supportTraitsScheduleDispatchTime,
]
const cPallet_referendaPalletCallSubmitTupled: Codec<IcPallet_referendaPalletCallSubmitTupled> =
  Tuple(
    cMoonbeam_runtimeOriginCaller,
    cFrame_supportTraitsPreimagesBounded,
    cFrame_supportTraitsScheduleDispatchTime,
  )

type IcPallet_referendaPalletCallPlace_decision_depositTupled = [Index: number]
const cPallet_referendaPalletCallPlace_decision_depositTupled: Codec<IcPallet_referendaPalletCallPlace_decision_depositTupled> =
  Tuple(u32)

type IcPallet_referendaPalletCallRefund_decision_depositTupled = [Index: number]
const cPallet_referendaPalletCallRefund_decision_depositTupled: Codec<IcPallet_referendaPalletCallRefund_decision_depositTupled> =
  Tuple(u32)

type IcPallet_referendaPalletCallCancelTupled = [Index: number]
const cPallet_referendaPalletCallCancelTupled: Codec<IcPallet_referendaPalletCallCancelTupled> =
  Tuple(u32)

type IcPallet_referendaPalletCallKillTupled = [Index: number]
const cPallet_referendaPalletCallKillTupled: Codec<IcPallet_referendaPalletCallKillTupled> =
  Tuple(u32)

type IcPallet_referendaPalletCallNudge_referendumTupled = [Index: number]
const cPallet_referendaPalletCallNudge_referendumTupled: Codec<IcPallet_referendaPalletCallNudge_referendumTupled> =
  Tuple(u32)

type IcPallet_referendaPalletCallOne_fewer_decidingTupled = [Track: number]
const cPallet_referendaPalletCallOne_fewer_decidingTupled: Codec<IcPallet_referendaPalletCallOne_fewer_decidingTupled> =
  Tuple(u16)

type IcPallet_referendaPalletCallRefund_submission_depositTupled = [
  Index: number,
]
const cPallet_referendaPalletCallRefund_submission_depositTupled: Codec<IcPallet_referendaPalletCallRefund_submission_depositTupled> =
  Tuple(u32)

type IcPallet_referendaPalletCallSet_metadataTupled = [
  Index: number,
  Maybe_hash: IcOption,
]
const cPallet_referendaPalletCallSet_metadataTupled: Codec<IcPallet_referendaPalletCallSet_metadataTupled> =
  Tuple(u32, cOption)

type IcPallet_referendaPalletError =
  | { tag: "NotOngoing"; value: undefined }
  | { tag: "HasDeposit"; value: undefined }
  | { tag: "BadTrack"; value: undefined }
  | { tag: "Full"; value: undefined }
  | { tag: "QueueEmpty"; value: undefined }
  | { tag: "BadReferendum"; value: undefined }
  | { tag: "NothingToDo"; value: undefined }
  | { tag: "NoTrack"; value: undefined }
  | { tag: "Unfinished"; value: undefined }
  | { tag: "NoPermission"; value: undefined }
  | { tag: "NoDeposit"; value: undefined }
  | { tag: "BadStatus"; value: undefined }
  | { tag: "PreimageNotExist"; value: undefined }
const cPallet_referendaPalletError: Codec<IcPallet_referendaPalletError> = Enum(
  {
    NotOngoing: _void,
    HasDeposit: _void,
    BadTrack: _void,
    Full: _void,
    QueueEmpty: _void,
    BadReferendum: _void,
    NothingToDo: _void,
    NoTrack: _void,
    Unfinished: _void,
    NoPermission: _void,
    NoDeposit: _void,
    BadStatus: _void,
    PreimageNotExist: _void,
  },
)

type IcPallet_referendaPalletErrorNotOngoing = undefined
const cPallet_referendaPalletErrorNotOngoing: Codec<IcPallet_referendaPalletErrorNotOngoing> =
  _void

type IcPallet_referendaPalletErrorHasDeposit = undefined
const cPallet_referendaPalletErrorHasDeposit: Codec<IcPallet_referendaPalletErrorHasDeposit> =
  _void

type IcPallet_referendaPalletErrorBadTrack = undefined
const cPallet_referendaPalletErrorBadTrack: Codec<IcPallet_referendaPalletErrorBadTrack> =
  _void

type IcPallet_referendaPalletErrorFull = undefined
const cPallet_referendaPalletErrorFull: Codec<IcPallet_referendaPalletErrorFull> =
  _void

type IcPallet_referendaPalletErrorQueueEmpty = undefined
const cPallet_referendaPalletErrorQueueEmpty: Codec<IcPallet_referendaPalletErrorQueueEmpty> =
  _void

type IcPallet_referendaPalletErrorBadReferendum = undefined
const cPallet_referendaPalletErrorBadReferendum: Codec<IcPallet_referendaPalletErrorBadReferendum> =
  _void

type IcPallet_referendaPalletErrorNothingToDo = undefined
const cPallet_referendaPalletErrorNothingToDo: Codec<IcPallet_referendaPalletErrorNothingToDo> =
  _void

type IcPallet_referendaPalletErrorNoTrack = undefined
const cPallet_referendaPalletErrorNoTrack: Codec<IcPallet_referendaPalletErrorNoTrack> =
  _void

type IcPallet_referendaPalletErrorUnfinished = undefined
const cPallet_referendaPalletErrorUnfinished: Codec<IcPallet_referendaPalletErrorUnfinished> =
  _void

type IcPallet_referendaPalletErrorNoPermission = undefined
const cPallet_referendaPalletErrorNoPermission: Codec<IcPallet_referendaPalletErrorNoPermission> =
  _void

type IcPallet_referendaPalletErrorNoDeposit = undefined
const cPallet_referendaPalletErrorNoDeposit: Codec<IcPallet_referendaPalletErrorNoDeposit> =
  _void

type IcPallet_referendaPalletErrorBadStatus = undefined
const cPallet_referendaPalletErrorBadStatus: Codec<IcPallet_referendaPalletErrorBadStatus> =
  _void

type IcPallet_referendaPalletErrorPreimageNotExist = undefined
const cPallet_referendaPalletErrorPreimageNotExist: Codec<IcPallet_referendaPalletErrorPreimageNotExist> =
  _void

type IcPallet_referendaTypesCurveLinearDecreasing = {
  length: number
  floor: number
  ceil: number
}
const cPallet_referendaTypesCurveLinearDecreasing: Codec<IcPallet_referendaTypesCurveLinearDecreasing> =
  Struct({ length: u32, floor: u32, ceil: u32 })

type IcPallet_referendaTypesCurveSteppedDecreasing = {
  begin: number
  end: number
  step: number
  period: number
}
const cPallet_referendaTypesCurveSteppedDecreasing: Codec<IcPallet_referendaTypesCurveSteppedDecreasing> =
  Struct({ begin: u32, end: u32, step: u32, period: u32 })

type IcPallet_referendaTypesCurveReciprocal = {
  factor: bigint
  x_offset: bigint
  y_offset: bigint
}
const cPallet_referendaTypesCurveReciprocal: Codec<IcPallet_referendaTypesCurveReciprocal> =
  Struct({ factor: i64, x_offset: i64, y_offset: i64 })

type IcPallet_referendaTypesCurve =
  | {
      tag: "LinearDecreasing"
      value: IcPallet_referendaTypesCurveLinearDecreasing
    }
  | {
      tag: "SteppedDecreasing"
      value: IcPallet_referendaTypesCurveSteppedDecreasing
    }
  | { tag: "Reciprocal"; value: IcPallet_referendaTypesCurveReciprocal }
const cPallet_referendaTypesCurve: Codec<IcPallet_referendaTypesCurve> = Enum({
  LinearDecreasing: cPallet_referendaTypesCurveLinearDecreasing,
  SteppedDecreasing: cPallet_referendaTypesCurveSteppedDecreasing,
  Reciprocal: cPallet_referendaTypesCurveReciprocal,
})

type IcPallet_referendaTypesTrackInfo = {
  name: string
  max_deciding: number
  decision_deposit: bigint
  prepare_period: number
  decision_period: number
  confirm_period: number
  min_enactment_period: number
  min_approval: IcPallet_referendaTypesCurve
  min_support: IcPallet_referendaTypesCurve
}
const cPallet_referendaTypesTrackInfo: Codec<IcPallet_referendaTypesTrackInfo> =
  Struct({
    name: str,
    max_deciding: u32,
    decision_deposit: u128,
    prepare_period: u32,
    decision_period: u32,
    confirm_period: u32,
    min_enactment_period: u32,
    min_approval: cPallet_referendaTypesCurve,
    min_support: cPallet_referendaTypesCurve,
  })

type Icdc528 = [number, IcPallet_referendaTypesTrackInfo]
const cdc528: Codec<Icdc528> = Tuple(u16, cPallet_referendaTypesTrackInfo)

type Icdc527 = Array<Icdc528>
const cdc527: Codec<Icdc527> = Vector(cdc528)

type IcPallet_whitelistPalletCallWhitelist_callTupled = [Call_hash: Icdc13]
const cPallet_whitelistPalletCallWhitelist_callTupled: Codec<IcPallet_whitelistPalletCallWhitelist_callTupled> =
  Tuple(cdc13)

type IcPallet_whitelistPalletCallRemove_whitelisted_callTupled = [
  Call_hash: Icdc13,
]
const cPallet_whitelistPalletCallRemove_whitelisted_callTupled: Codec<IcPallet_whitelistPalletCallRemove_whitelisted_callTupled> =
  Tuple(cdc13)

type IcPallet_whitelistPalletCallDispatch_whitelisted_callTupled = [
  Call_hash: Icdc13,
  Call_encoded_len: number,
  Call_weight_witness: IcSp_weightsWeight_v2Weight,
]
const cPallet_whitelistPalletCallDispatch_whitelisted_callTupled: Codec<IcPallet_whitelistPalletCallDispatch_whitelisted_callTupled> =
  Tuple(cdc13, u32, cSp_weightsWeight_v2Weight)

type IcPallet_whitelistPalletCallDispatch_whitelisted_call_with_preimageTupled =
  [Call: IcMoonbeam_runtimeRuntimeCall]
const cPallet_whitelistPalletCallDispatch_whitelisted_call_with_preimageTupled: Codec<IcPallet_whitelistPalletCallDispatch_whitelisted_call_with_preimageTupled> =
  Tuple(cMoonbeam_runtimeRuntimeCall)

type IcPallet_whitelistPalletError =
  | { tag: "UnavailablePreImage"; value: undefined }
  | { tag: "UndecodableCall"; value: undefined }
  | { tag: "InvalidCallWeightWitness"; value: undefined }
  | { tag: "CallIsNotWhitelisted"; value: undefined }
  | { tag: "CallAlreadyWhitelisted"; value: undefined }
const cPallet_whitelistPalletError: Codec<IcPallet_whitelistPalletError> = Enum(
  {
    UnavailablePreImage: _void,
    UndecodableCall: _void,
    InvalidCallWeightWitness: _void,
    CallIsNotWhitelisted: _void,
    CallAlreadyWhitelisted: _void,
  },
)

type IcPallet_whitelistPalletErrorUnavailablePreImage = undefined
const cPallet_whitelistPalletErrorUnavailablePreImage: Codec<IcPallet_whitelistPalletErrorUnavailablePreImage> =
  _void

type IcPallet_whitelistPalletErrorUndecodableCall = undefined
const cPallet_whitelistPalletErrorUndecodableCall: Codec<IcPallet_whitelistPalletErrorUndecodableCall> =
  _void

type IcPallet_whitelistPalletErrorInvalidCallWeightWitness = undefined
const cPallet_whitelistPalletErrorInvalidCallWeightWitness: Codec<IcPallet_whitelistPalletErrorInvalidCallWeightWitness> =
  _void

type IcPallet_whitelistPalletErrorCallIsNotWhitelisted = undefined
const cPallet_whitelistPalletErrorCallIsNotWhitelisted: Codec<IcPallet_whitelistPalletErrorCallIsNotWhitelisted> =
  _void

type IcPallet_whitelistPalletErrorCallAlreadyWhitelisted = undefined
const cPallet_whitelistPalletErrorCallAlreadyWhitelisted: Codec<IcPallet_whitelistPalletErrorCallAlreadyWhitelisted> =
  _void

type IcPallet_collectiveVotes = {
  index: number
  threshold: number
  ayes: Icdc109
  nays: Icdc109
  end: number
}
const cPallet_collectiveVotes: Codec<IcPallet_collectiveVotes> = Struct({
  index: u32,
  threshold: u32,
  ayes: cdc109,
  nays: cdc109,
  end: u32,
})

type IcPallet_collectivePalletCallSet_membersTupled = [
  New_members: Icdc109,
  Prime: IcOption,
  Old_count: number,
]
const cPallet_collectivePalletCallSet_membersTupled: Codec<IcPallet_collectivePalletCallSet_membersTupled> =
  Tuple(cdc109, cOption, u32)

type IcPallet_collectivePalletCallExecuteTupled = [
  Proposal: IcMoonbeam_runtimeRuntimeCall,
  Length_bound: number,
]
const cPallet_collectivePalletCallExecuteTupled: Codec<IcPallet_collectivePalletCallExecuteTupled> =
  Tuple(cMoonbeam_runtimeRuntimeCall, compactNumber)

type IcPallet_collectivePalletCallProposeTupled = [
  Threshold: number,
  Proposal: IcMoonbeam_runtimeRuntimeCall,
  Length_bound: number,
]
const cPallet_collectivePalletCallProposeTupled: Codec<IcPallet_collectivePalletCallProposeTupled> =
  Tuple(compactNumber, cMoonbeam_runtimeRuntimeCall, compactNumber)

type IcPallet_collectivePalletCallVoteTupled = [
  Proposal: Icdc13,
  Index: number,
  Approve: boolean,
]
const cPallet_collectivePalletCallVoteTupled: Codec<IcPallet_collectivePalletCallVoteTupled> =
  Tuple(cdc13, compactNumber, bool)

type IcPallet_collectivePalletCallDisapprove_proposalTupled = [
  Proposal_hash: Icdc13,
]
const cPallet_collectivePalletCallDisapprove_proposalTupled: Codec<IcPallet_collectivePalletCallDisapprove_proposalTupled> =
  Tuple(cdc13)

type IcPallet_collectivePalletCallCloseTupled = [
  Proposal_hash: Icdc13,
  Index: number,
  Proposal_weight_bound: IcSp_weightsWeight_v2Weight,
  Length_bound: number,
]
const cPallet_collectivePalletCallCloseTupled: Codec<IcPallet_collectivePalletCallCloseTupled> =
  Tuple(cdc13, compactNumber, cSp_weightsWeight_v2Weight, compactNumber)

type IcPallet_collectivePalletError =
  | { tag: "NotMember"; value: undefined }
  | { tag: "DuplicateProposal"; value: undefined }
  | { tag: "ProposalMissing"; value: undefined }
  | { tag: "WrongIndex"; value: undefined }
  | { tag: "DuplicateVote"; value: undefined }
  | { tag: "AlreadyInitialized"; value: undefined }
  | { tag: "TooEarly"; value: undefined }
  | { tag: "TooManyProposals"; value: undefined }
  | { tag: "WrongProposalWeight"; value: undefined }
  | { tag: "WrongProposalLength"; value: undefined }
const cPallet_collectivePalletError: Codec<IcPallet_collectivePalletError> =
  Enum({
    NotMember: _void,
    DuplicateProposal: _void,
    ProposalMissing: _void,
    WrongIndex: _void,
    DuplicateVote: _void,
    AlreadyInitialized: _void,
    TooEarly: _void,
    TooManyProposals: _void,
    WrongProposalWeight: _void,
    WrongProposalLength: _void,
  })

type IcPallet_collectivePalletErrorNotMember = undefined
const cPallet_collectivePalletErrorNotMember: Codec<IcPallet_collectivePalletErrorNotMember> =
  _void

type IcPallet_collectivePalletErrorDuplicateProposal = undefined
const cPallet_collectivePalletErrorDuplicateProposal: Codec<IcPallet_collectivePalletErrorDuplicateProposal> =
  _void

type IcPallet_collectivePalletErrorProposalMissing = undefined
const cPallet_collectivePalletErrorProposalMissing: Codec<IcPallet_collectivePalletErrorProposalMissing> =
  _void

type IcPallet_collectivePalletErrorWrongIndex = undefined
const cPallet_collectivePalletErrorWrongIndex: Codec<IcPallet_collectivePalletErrorWrongIndex> =
  _void

type IcPallet_collectivePalletErrorDuplicateVote = undefined
const cPallet_collectivePalletErrorDuplicateVote: Codec<IcPallet_collectivePalletErrorDuplicateVote> =
  _void

type IcPallet_collectivePalletErrorAlreadyInitialized = undefined
const cPallet_collectivePalletErrorAlreadyInitialized: Codec<IcPallet_collectivePalletErrorAlreadyInitialized> =
  _void

type IcPallet_collectivePalletErrorTooEarly = undefined
const cPallet_collectivePalletErrorTooEarly: Codec<IcPallet_collectivePalletErrorTooEarly> =
  _void

type IcPallet_collectivePalletErrorTooManyProposals = undefined
const cPallet_collectivePalletErrorTooManyProposals: Codec<IcPallet_collectivePalletErrorTooManyProposals> =
  _void

type IcPallet_collectivePalletErrorWrongProposalWeight = undefined
const cPallet_collectivePalletErrorWrongProposalWeight: Codec<IcPallet_collectivePalletErrorWrongProposalWeight> =
  _void

type IcPallet_collectivePalletErrorWrongProposalLength = undefined
const cPallet_collectivePalletErrorWrongProposalLength: Codec<IcPallet_collectivePalletErrorWrongProposalLength> =
  _void

type IcPallet_treasuryProposal = {
  proposer: Icdc1
  value: bigint
  beneficiary: Icdc1
  bond: bigint
}
const cPallet_treasuryProposal: Codec<IcPallet_treasuryProposal> = Struct({
  proposer: cdc1,
  value: u128,
  beneficiary: cdc1,
  bond: u128,
})

type Icdc544 = Array<number>
const cdc544: Codec<Icdc544> = Vector(u32)

type IcPallet_treasuryPalletCallPropose_spendTupled = [
  Value: bigint,
  Beneficiary: Icdc1,
]
const cPallet_treasuryPalletCallPropose_spendTupled: Codec<IcPallet_treasuryPalletCallPropose_spendTupled> =
  Tuple(compactBn, cdc1)

type IcPallet_treasuryPalletCallReject_proposalTupled = [Proposal_id: number]
const cPallet_treasuryPalletCallReject_proposalTupled: Codec<IcPallet_treasuryPalletCallReject_proposalTupled> =
  Tuple(compactNumber)

type IcPallet_treasuryPalletCallApprove_proposalTupled = [Proposal_id: number]
const cPallet_treasuryPalletCallApprove_proposalTupled: Codec<IcPallet_treasuryPalletCallApprove_proposalTupled> =
  Tuple(compactNumber)

type IcPallet_treasuryPalletCallSpendTupled = [
  Amount: bigint,
  Beneficiary: Icdc1,
]
const cPallet_treasuryPalletCallSpendTupled: Codec<IcPallet_treasuryPalletCallSpendTupled> =
  Tuple(compactBn, cdc1)

type IcPallet_treasuryPalletCallRemove_approvalTupled = [Proposal_id: number]
const cPallet_treasuryPalletCallRemove_approvalTupled: Codec<IcPallet_treasuryPalletCallRemove_approvalTupled> =
  Tuple(compactNumber)

type IcPallet_treasuryPalletError =
  | { tag: "InsufficientProposersBalance"; value: undefined }
  | { tag: "InvalidIndex"; value: undefined }
  | { tag: "TooManyApprovals"; value: undefined }
  | { tag: "InsufficientPermission"; value: undefined }
  | { tag: "ProposalNotApproved"; value: undefined }
const cPallet_treasuryPalletError: Codec<IcPallet_treasuryPalletError> = Enum({
  InsufficientProposersBalance: _void,
  InvalidIndex: _void,
  TooManyApprovals: _void,
  InsufficientPermission: _void,
  ProposalNotApproved: _void,
})

type IcPallet_treasuryPalletErrorInsufficientProposersBalance = undefined
const cPallet_treasuryPalletErrorInsufficientProposersBalance: Codec<IcPallet_treasuryPalletErrorInsufficientProposersBalance> =
  _void

type IcPallet_treasuryPalletErrorInvalidIndex = undefined
const cPallet_treasuryPalletErrorInvalidIndex: Codec<IcPallet_treasuryPalletErrorInvalidIndex> =
  _void

type IcPallet_treasuryPalletErrorTooManyApprovals = undefined
const cPallet_treasuryPalletErrorTooManyApprovals: Codec<IcPallet_treasuryPalletErrorTooManyApprovals> =
  _void

type IcPallet_treasuryPalletErrorInsufficientPermission = undefined
const cPallet_treasuryPalletErrorInsufficientPermission: Codec<IcPallet_treasuryPalletErrorInsufficientPermission> =
  _void

type IcPallet_treasuryPalletErrorProposalNotApproved = undefined
const cPallet_treasuryPalletErrorProposalNotApproved: Codec<IcPallet_treasuryPalletErrorProposalNotApproved> =
  _void

type Icdc549 = Array<Icdc13>
const cdc549: Codec<Icdc549> = Vector(cdc13)

type IcPallet_crowdloan_rewardsPalletRewardInfo = {
  total_reward: bigint
  claimed_reward: bigint
  contributed_relay_addresses: Icdc549
}
const cPallet_crowdloan_rewardsPalletRewardInfo: Codec<IcPallet_crowdloan_rewardsPalletRewardInfo> =
  Struct({
    total_reward: u128,
    claimed_reward: u128,
    contributed_relay_addresses: cdc549,
  })

type IcPallet_crowdloan_rewardsPalletCallAssociate_native_identityTupled = [
  Reward_account: Icdc1,
  Relay_account: Icdc13,
  Proof: IcSp_runtimeMultiSignature,
]
const cPallet_crowdloan_rewardsPalletCallAssociate_native_identityTupled: Codec<IcPallet_crowdloan_rewardsPalletCallAssociate_native_identityTupled> =
  Tuple(cdc1, cdc13, cSp_runtimeMultiSignature)

type IcPallet_crowdloan_rewardsPalletCallChange_association_with_relay_keysTupled =
  [Reward_account: Icdc1, Previous_account: Icdc1, Proofs: Icdc229]
const cPallet_crowdloan_rewardsPalletCallChange_association_with_relay_keysTupled: Codec<IcPallet_crowdloan_rewardsPalletCallChange_association_with_relay_keysTupled> =
  Tuple(cdc1, cdc1, cdc229)

type IcPallet_crowdloan_rewardsPalletCallUpdate_reward_addressTupled = [
  New_reward_account: Icdc1,
]
const cPallet_crowdloan_rewardsPalletCallUpdate_reward_addressTupled: Codec<IcPallet_crowdloan_rewardsPalletCallUpdate_reward_addressTupled> =
  Tuple(cdc1)

type IcPallet_crowdloan_rewardsPalletCallComplete_initializationTupled = [
  Lease_ending_block: number,
]
const cPallet_crowdloan_rewardsPalletCallComplete_initializationTupled: Codec<IcPallet_crowdloan_rewardsPalletCallComplete_initializationTupled> =
  Tuple(u32)

type IcPallet_crowdloan_rewardsPalletCallInitialize_reward_vecTupled = [
  Rewards: Icdc231,
]
const cPallet_crowdloan_rewardsPalletCallInitialize_reward_vecTupled: Codec<IcPallet_crowdloan_rewardsPalletCallInitialize_reward_vecTupled> =
  Tuple(cdc231)

type IcPallet_crowdloan_rewardsPalletError =
  | { tag: "AlreadyAssociated"; value: undefined }
  | { tag: "BatchBeyondFundPot"; value: undefined }
  | { tag: "FirstClaimAlreadyDone"; value: undefined }
  | { tag: "RewardNotHighEnough"; value: undefined }
  | { tag: "InvalidClaimSignature"; value: undefined }
  | { tag: "InvalidFreeClaimSignature"; value: undefined }
  | { tag: "NoAssociatedClaim"; value: undefined }
  | { tag: "RewardsAlreadyClaimed"; value: undefined }
  | { tag: "RewardVecAlreadyInitialized"; value: undefined }
  | { tag: "RewardVecNotFullyInitializedYet"; value: undefined }
  | { tag: "RewardsDoNotMatchFund"; value: undefined }
  | { tag: "TooManyContributors"; value: undefined }
  | { tag: "VestingPeriodNonValid"; value: undefined }
  | { tag: "NonContributedAddressProvided"; value: undefined }
  | { tag: "InsufficientNumberOfValidProofs"; value: undefined }
const cPallet_crowdloan_rewardsPalletError: Codec<IcPallet_crowdloan_rewardsPalletError> =
  Enum({
    AlreadyAssociated: _void,
    BatchBeyondFundPot: _void,
    FirstClaimAlreadyDone: _void,
    RewardNotHighEnough: _void,
    InvalidClaimSignature: _void,
    InvalidFreeClaimSignature: _void,
    NoAssociatedClaim: _void,
    RewardsAlreadyClaimed: _void,
    RewardVecAlreadyInitialized: _void,
    RewardVecNotFullyInitializedYet: _void,
    RewardsDoNotMatchFund: _void,
    TooManyContributors: _void,
    VestingPeriodNonValid: _void,
    NonContributedAddressProvided: _void,
    InsufficientNumberOfValidProofs: _void,
  })

type IcPallet_crowdloan_rewardsPalletErrorAlreadyAssociated = undefined
const cPallet_crowdloan_rewardsPalletErrorAlreadyAssociated: Codec<IcPallet_crowdloan_rewardsPalletErrorAlreadyAssociated> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorBatchBeyondFundPot = undefined
const cPallet_crowdloan_rewardsPalletErrorBatchBeyondFundPot: Codec<IcPallet_crowdloan_rewardsPalletErrorBatchBeyondFundPot> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorFirstClaimAlreadyDone = undefined
const cPallet_crowdloan_rewardsPalletErrorFirstClaimAlreadyDone: Codec<IcPallet_crowdloan_rewardsPalletErrorFirstClaimAlreadyDone> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorRewardNotHighEnough = undefined
const cPallet_crowdloan_rewardsPalletErrorRewardNotHighEnough: Codec<IcPallet_crowdloan_rewardsPalletErrorRewardNotHighEnough> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorInvalidClaimSignature = undefined
const cPallet_crowdloan_rewardsPalletErrorInvalidClaimSignature: Codec<IcPallet_crowdloan_rewardsPalletErrorInvalidClaimSignature> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorInvalidFreeClaimSignature = undefined
const cPallet_crowdloan_rewardsPalletErrorInvalidFreeClaimSignature: Codec<IcPallet_crowdloan_rewardsPalletErrorInvalidFreeClaimSignature> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorNoAssociatedClaim = undefined
const cPallet_crowdloan_rewardsPalletErrorNoAssociatedClaim: Codec<IcPallet_crowdloan_rewardsPalletErrorNoAssociatedClaim> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorRewardsAlreadyClaimed = undefined
const cPallet_crowdloan_rewardsPalletErrorRewardsAlreadyClaimed: Codec<IcPallet_crowdloan_rewardsPalletErrorRewardsAlreadyClaimed> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorRewardVecAlreadyInitialized =
  undefined
const cPallet_crowdloan_rewardsPalletErrorRewardVecAlreadyInitialized: Codec<IcPallet_crowdloan_rewardsPalletErrorRewardVecAlreadyInitialized> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorRewardVecNotFullyInitializedYet =
  undefined
const cPallet_crowdloan_rewardsPalletErrorRewardVecNotFullyInitializedYet: Codec<IcPallet_crowdloan_rewardsPalletErrorRewardVecNotFullyInitializedYet> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorRewardsDoNotMatchFund = undefined
const cPallet_crowdloan_rewardsPalletErrorRewardsDoNotMatchFund: Codec<IcPallet_crowdloan_rewardsPalletErrorRewardsDoNotMatchFund> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorTooManyContributors = undefined
const cPallet_crowdloan_rewardsPalletErrorTooManyContributors: Codec<IcPallet_crowdloan_rewardsPalletErrorTooManyContributors> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorVestingPeriodNonValid = undefined
const cPallet_crowdloan_rewardsPalletErrorVestingPeriodNonValid: Codec<IcPallet_crowdloan_rewardsPalletErrorVestingPeriodNonValid> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorNonContributedAddressProvided =
  undefined
const cPallet_crowdloan_rewardsPalletErrorNonContributedAddressProvided: Codec<IcPallet_crowdloan_rewardsPalletErrorNonContributedAddressProvided> =
  _void

type IcPallet_crowdloan_rewardsPalletErrorInsufficientNumberOfValidProofs =
  undefined
const cPallet_crowdloan_rewardsPalletErrorInsufficientNumberOfValidProofs: Codec<IcPallet_crowdloan_rewardsPalletErrorInsufficientNumberOfValidProofs> =
  _void

type IcCumulus_pallet_xcmp_queueInboundState =
  | { tag: "Ok"; value: undefined }
  | { tag: "Suspended"; value: undefined }
const cCumulus_pallet_xcmp_queueInboundState: Codec<IcCumulus_pallet_xcmp_queueInboundState> =
  Enum({ Ok: _void, Suspended: _void })

type IcPolkadot_parachainPrimitivesXcmpMessageFormat =
  | { tag: "ConcatenatedVersionedXcm"; value: undefined }
  | { tag: "ConcatenatedEncodedBlob"; value: undefined }
  | { tag: "Signals"; value: undefined }
const cPolkadot_parachainPrimitivesXcmpMessageFormat: Codec<IcPolkadot_parachainPrimitivesXcmpMessageFormat> =
  Enum({
    ConcatenatedVersionedXcm: _void,
    ConcatenatedEncodedBlob: _void,
    Signals: _void,
  })

type Icdc555 = [number, IcPolkadot_parachainPrimitivesXcmpMessageFormat]
const cdc555: Codec<Icdc555> = Tuple(
  u32,
  cPolkadot_parachainPrimitivesXcmpMessageFormat,
)

type Icdc554 = Array<Icdc555>
const cdc554: Codec<Icdc554> = Vector(cdc555)

type IcCumulus_pallet_xcmp_queueInboundChannelDetails = {
  sender: number
  state: IcCumulus_pallet_xcmp_queueInboundState
  message_metadata: Icdc554
}
const cCumulus_pallet_xcmp_queueInboundChannelDetails: Codec<IcCumulus_pallet_xcmp_queueInboundChannelDetails> =
  Struct({
    sender: u32,
    state: cCumulus_pallet_xcmp_queueInboundState,
    message_metadata: cdc554,
  })

type Icdc551 = Array<IcCumulus_pallet_xcmp_queueInboundChannelDetails>
const cdc551: Codec<Icdc551> = Vector(
  cCumulus_pallet_xcmp_queueInboundChannelDetails,
)

type Icdc557 = [number, number]
const cdc557: Codec<Icdc557> = Tuple(u32, u32)

type IcCumulus_pallet_xcmp_queueOutboundState =
  | { tag: "Ok"; value: undefined }
  | { tag: "Suspended"; value: undefined }
const cCumulus_pallet_xcmp_queueOutboundState: Codec<IcCumulus_pallet_xcmp_queueOutboundState> =
  Enum({ Ok: _void, Suspended: _void })

type IcCumulus_pallet_xcmp_queueOutboundChannelDetails = {
  recipient: number
  state: IcCumulus_pallet_xcmp_queueOutboundState
  signals_exist: boolean
  first_index: number
  last_index: number
}
const cCumulus_pallet_xcmp_queueOutboundChannelDetails: Codec<IcCumulus_pallet_xcmp_queueOutboundChannelDetails> =
  Struct({
    recipient: u32,
    state: cCumulus_pallet_xcmp_queueOutboundState,
    signals_exist: bool,
    first_index: u16,
    last_index: u16,
  })

type Icdc558 = Array<IcCumulus_pallet_xcmp_queueOutboundChannelDetails>
const cdc558: Codec<Icdc558> = Vector(
  cCumulus_pallet_xcmp_queueOutboundChannelDetails,
)

type Icdc561 = [number, number]
const cdc561: Codec<Icdc561> = Tuple(u32, u16)

type IcPolkadot_parachainPrimitivesIdTupled = [Key: number]
const cPolkadot_parachainPrimitivesIdTupled: Codec<IcPolkadot_parachainPrimitivesIdTupled> =
  Tuple(u32)

type IcCumulus_pallet_xcmp_queueQueueConfigData = {
  suspend_threshold: number
  drop_threshold: number
  resume_threshold: number
  threshold_weight: IcSp_weightsWeight_v2Weight
  weight_restrict_decay: IcSp_weightsWeight_v2Weight
  xcmp_max_individual_weight: IcSp_weightsWeight_v2Weight
}
const cCumulus_pallet_xcmp_queueQueueConfigData: Codec<IcCumulus_pallet_xcmp_queueQueueConfigData> =
  Struct({
    suspend_threshold: u32,
    drop_threshold: u32,
    resume_threshold: u32,
    threshold_weight: cSp_weightsWeight_v2Weight,
    weight_restrict_decay: cSp_weightsWeight_v2Weight,
    xcmp_max_individual_weight: cSp_weightsWeight_v2Weight,
  })

type Icdc563 = [number, number, I_bytesSeq]
const cdc563: Codec<Icdc563> = Tuple(u32, u32, _bytesSeq)

type Icdc11Tupled = [Key: bigint]
const cdc11Tupled: Codec<Icdc11Tupled> = Tuple(u64)

type IcCumulus_pallet_xcmp_queuePalletError =
  | { tag: "FailedToSend"; value: undefined }
  | { tag: "BadXcmOrigin"; value: undefined }
  | { tag: "BadXcm"; value: undefined }
  | { tag: "BadOverweightIndex"; value: undefined }
  | { tag: "WeightOverLimit"; value: undefined }
const cCumulus_pallet_xcmp_queuePalletError: Codec<IcCumulus_pallet_xcmp_queuePalletError> =
  Enum({
    FailedToSend: _void,
    BadXcmOrigin: _void,
    BadXcm: _void,
    BadOverweightIndex: _void,
    WeightOverLimit: _void,
  })

type IcCumulus_pallet_xcmp_queuePalletErrorFailedToSend = undefined
const cCumulus_pallet_xcmp_queuePalletErrorFailedToSend: Codec<IcCumulus_pallet_xcmp_queuePalletErrorFailedToSend> =
  _void

type IcCumulus_pallet_xcmp_queuePalletErrorBadXcmOrigin = undefined
const cCumulus_pallet_xcmp_queuePalletErrorBadXcmOrigin: Codec<IcCumulus_pallet_xcmp_queuePalletErrorBadXcmOrigin> =
  _void

type IcCumulus_pallet_xcmp_queuePalletErrorBadXcm = undefined
const cCumulus_pallet_xcmp_queuePalletErrorBadXcm: Codec<IcCumulus_pallet_xcmp_queuePalletErrorBadXcm> =
  _void

type IcCumulus_pallet_xcmp_queuePalletErrorBadOverweightIndex = undefined
const cCumulus_pallet_xcmp_queuePalletErrorBadOverweightIndex: Codec<IcCumulus_pallet_xcmp_queuePalletErrorBadOverweightIndex> =
  _void

type IcCumulus_pallet_xcmp_queuePalletErrorWeightOverLimit = undefined
const cCumulus_pallet_xcmp_queuePalletErrorWeightOverLimit: Codec<IcCumulus_pallet_xcmp_queuePalletErrorWeightOverLimit> =
  _void

type IcCumulus_pallet_dmp_queuePageIndexData = {
  begin_used: number
  end_used: number
  overweight_count: bigint
}
const cCumulus_pallet_dmp_queuePageIndexData: Codec<IcCumulus_pallet_dmp_queuePageIndexData> =
  Struct({ begin_used: u32, end_used: u32, overweight_count: u64 })

type Icdc569 = [number, I_bytesSeq]
const cdc569: Codec<Icdc569> = Tuple(u32, _bytesSeq)

type Icdc568 = Array<Icdc569>
const cdc568: Codec<Icdc568> = Vector(cdc569)

type IcCumulus_pallet_dmp_queuePalletCallService_overweightTupled = [
  Index: bigint,
  Weight_limit: IcSp_weightsWeight_v2Weight,
]
const cCumulus_pallet_dmp_queuePalletCallService_overweightTupled: Codec<IcCumulus_pallet_dmp_queuePalletCallService_overweightTupled> =
  Tuple(u64, cSp_weightsWeight_v2Weight)

type IcCumulus_pallet_dmp_queuePalletError =
  | { tag: "Unknown"; value: undefined }
  | { tag: "OverLimit"; value: undefined }
const cCumulus_pallet_dmp_queuePalletError: Codec<IcCumulus_pallet_dmp_queuePalletError> =
  Enum({ Unknown: _void, OverLimit: _void })

type IcCumulus_pallet_dmp_queuePalletErrorUnknown = undefined
const cCumulus_pallet_dmp_queuePalletErrorUnknown: Codec<IcCumulus_pallet_dmp_queuePalletErrorUnknown> =
  _void

type IcCumulus_pallet_dmp_queuePalletErrorOverLimit = undefined
const cCumulus_pallet_dmp_queuePalletErrorOverLimit: Codec<IcCumulus_pallet_dmp_queuePalletErrorOverLimit> =
  _void

type IcPallet_xcmPalletQueryStatusPending = {
  responder: IcXcmVersionedMultiLocation
  maybe_match_querier: IcOption
  maybe_notify: IcOption
  timeout: number
}
const cPallet_xcmPalletQueryStatusPending: Codec<IcPallet_xcmPalletQueryStatusPending> =
  Struct({
    responder: cXcmVersionedMultiLocation,
    maybe_match_querier: cOption,
    maybe_notify: cOption,
    timeout: u32,
  })

type IcPallet_xcmPalletQueryStatusVersionNotifier = {
  origin: IcXcmVersionedMultiLocation
  is_active: boolean
}
const cPallet_xcmPalletQueryStatusVersionNotifier: Codec<IcPallet_xcmPalletQueryStatusVersionNotifier> =
  Struct({ origin: cXcmVersionedMultiLocation, is_active: bool })

type IcXcmVersionedResponseV2 = IcXcmV2Response
const cXcmVersionedResponseV2: Codec<IcXcmVersionedResponseV2> = cXcmV2Response

type IcXcmVersionedResponseV3 = IcXcmV3Response
const cXcmVersionedResponseV3: Codec<IcXcmVersionedResponseV3> = cXcmV3Response

type IcXcmVersionedResponse =
  | { tag: "V2"; value: IcXcmVersionedResponseV2 }
  | { tag: "V3"; value: IcXcmVersionedResponseV3 }
const cXcmVersionedResponse: Codec<IcXcmVersionedResponse> = Enum(
  { V2: cXcmVersionedResponseV2, V3: cXcmVersionedResponseV3 },
  [2, 3],
)

type IcPallet_xcmPalletQueryStatusReady = {
  response: IcXcmVersionedResponse
  at: number
}
const cPallet_xcmPalletQueryStatusReady: Codec<IcPallet_xcmPalletQueryStatusReady> =
  Struct({ response: cXcmVersionedResponse, at: u32 })

type IcPallet_xcmPalletQueryStatus =
  | { tag: "Pending"; value: IcPallet_xcmPalletQueryStatusPending }
  | {
      tag: "VersionNotifier"
      value: IcPallet_xcmPalletQueryStatusVersionNotifier
    }
  | { tag: "Ready"; value: IcPallet_xcmPalletQueryStatusReady }
const cPallet_xcmPalletQueryStatus: Codec<IcPallet_xcmPalletQueryStatus> = Enum(
  {
    Pending: cPallet_xcmPalletQueryStatusPending,
    VersionNotifier: cPallet_xcmPalletQueryStatusVersionNotifier,
    Ready: cPallet_xcmPalletQueryStatusReady,
  },
)

type Icdc576 = [number, IcXcmVersionedMultiLocation]
const cdc576: Codec<Icdc576> = Tuple(u32, cXcmVersionedMultiLocation)

type Icdc577 = [bigint, IcSp_weightsWeight_v2Weight, number]
const cdc577: Codec<Icdc577> = Tuple(u64, cSp_weightsWeight_v2Weight, u32)

type Icdc579 = [IcXcmVersionedMultiLocation, number]
const cdc579: Codec<Icdc579> = Tuple(cXcmVersionedMultiLocation, u32)

type Icdc580 = Array<Icdc579>
const cdc580: Codec<Icdc580> = Vector(cdc579)

type IcPallet_xcmPalletVersionMigrationStageNotifyCurrentTargets = IcOption
const cPallet_xcmPalletVersionMigrationStageNotifyCurrentTargets: Codec<IcPallet_xcmPalletVersionMigrationStageNotifyCurrentTargets> =
  cOption

type IcPallet_xcmPalletVersionMigrationStage =
  | { tag: "MigrateSupportedVersion"; value: undefined }
  | { tag: "MigrateVersionNotifiers"; value: undefined }
  | {
      tag: "NotifyCurrentTargets"
      value: IcPallet_xcmPalletVersionMigrationStageNotifyCurrentTargets
    }
  | { tag: "MigrateAndNotifyOldTargets"; value: undefined }
const cPallet_xcmPalletVersionMigrationStage: Codec<IcPallet_xcmPalletVersionMigrationStage> =
  Enum({
    MigrateSupportedVersion: _void,
    MigrateVersionNotifiers: _void,
    NotifyCurrentTargets:
      cPallet_xcmPalletVersionMigrationStageNotifyCurrentTargets,
    MigrateAndNotifyOldTargets: _void,
  })

type Icdc587 = [undefined, bigint]
const cdc587: Codec<Icdc587> = Tuple(_void, u128)

type Icdc588 = Array<Icdc587>
const cdc588: Codec<Icdc588> = Vector(cdc587)

type IcPallet_xcmPalletRemoteLockedFungibleRecord = {
  amount: bigint
  owner: IcXcmVersionedMultiLocation
  locker: IcXcmVersionedMultiLocation
  consumers: Icdc588
}
const cPallet_xcmPalletRemoteLockedFungibleRecord: Codec<IcPallet_xcmPalletRemoteLockedFungibleRecord> =
  Struct({
    amount: u128,
    owner: cXcmVersionedMultiLocation,
    locker: cXcmVersionedMultiLocation,
    consumers: cdc588,
  })

type IcXcmVersionedAssetIdV3 = IcXcmV3MultiassetAssetId
const cXcmVersionedAssetIdV3: Codec<IcXcmVersionedAssetIdV3> =
  cXcmV3MultiassetAssetId

type IcXcmVersionedAssetId = { tag: "V3"; value: IcXcmVersionedAssetIdV3 }
const cXcmVersionedAssetId: Codec<IcXcmVersionedAssetId> = Enum(
  { V3: cXcmVersionedAssetIdV3 },
  [3],
)

type Icdc583 = [number, Icdc1, IcXcmVersionedAssetId]
const cdc583: Codec<Icdc583> = Tuple(u32, cdc1, cXcmVersionedAssetId)

type Icdc590 = [bigint, IcXcmVersionedMultiLocation]
const cdc590: Codec<Icdc590> = Tuple(u128, cXcmVersionedMultiLocation)

type Icdc591 = Array<Icdc590>
const cdc591: Codec<Icdc591> = Vector(cdc590)

type IcPallet_xcmPalletCallSendTupled = [
  Dest: IcXcmVersionedMultiLocation,
  Message: IcXcmVersionedXcm,
]
const cPallet_xcmPalletCallSendTupled: Codec<IcPallet_xcmPalletCallSendTupled> =
  Tuple(cXcmVersionedMultiLocation, cXcmVersionedXcm)

type IcPallet_xcmPalletCallTeleport_assetsTupled = [
  Dest: IcXcmVersionedMultiLocation,
  Beneficiary: IcXcmVersionedMultiLocation,
  Assets: IcXcmVersionedMultiAssets,
  Fee_asset_item: number,
]
const cPallet_xcmPalletCallTeleport_assetsTupled: Codec<IcPallet_xcmPalletCallTeleport_assetsTupled> =
  Tuple(
    cXcmVersionedMultiLocation,
    cXcmVersionedMultiLocation,
    cXcmVersionedMultiAssets,
    u32,
  )

type IcPallet_xcmPalletCallReserve_transfer_assetsTupled = [
  Dest: IcXcmVersionedMultiLocation,
  Beneficiary: IcXcmVersionedMultiLocation,
  Assets: IcXcmVersionedMultiAssets,
  Fee_asset_item: number,
]
const cPallet_xcmPalletCallReserve_transfer_assetsTupled: Codec<IcPallet_xcmPalletCallReserve_transfer_assetsTupled> =
  Tuple(
    cXcmVersionedMultiLocation,
    cXcmVersionedMultiLocation,
    cXcmVersionedMultiAssets,
    u32,
  )

type IcPallet_xcmPalletCallExecuteTupled = [
  Message: IcXcmVersionedXcm,
  Max_weight: IcSp_weightsWeight_v2Weight,
]
const cPallet_xcmPalletCallExecuteTupled: Codec<IcPallet_xcmPalletCallExecuteTupled> =
  Tuple(cXcmVersionedXcm, cSp_weightsWeight_v2Weight)

type IcPallet_xcmPalletCallForce_xcm_versionTupled = [
  Location: IcXcmV3MultilocationMultiLocation,
  Xcm_version: number,
]
const cPallet_xcmPalletCallForce_xcm_versionTupled: Codec<IcPallet_xcmPalletCallForce_xcm_versionTupled> =
  Tuple(cXcmV3MultilocationMultiLocation, u32)

type IcPallet_xcmPalletCallForce_default_xcm_versionTupled = [
  Maybe_xcm_version: IcOption,
]
const cPallet_xcmPalletCallForce_default_xcm_versionTupled: Codec<IcPallet_xcmPalletCallForce_default_xcm_versionTupled> =
  Tuple(cOption)

type IcPallet_xcmPalletCallForce_subscribe_version_notifyTupled = [
  Location: IcXcmVersionedMultiLocation,
]
const cPallet_xcmPalletCallForce_subscribe_version_notifyTupled: Codec<IcPallet_xcmPalletCallForce_subscribe_version_notifyTupled> =
  Tuple(cXcmVersionedMultiLocation)

type IcPallet_xcmPalletCallForce_unsubscribe_version_notifyTupled = [
  Location: IcXcmVersionedMultiLocation,
]
const cPallet_xcmPalletCallForce_unsubscribe_version_notifyTupled: Codec<IcPallet_xcmPalletCallForce_unsubscribe_version_notifyTupled> =
  Tuple(cXcmVersionedMultiLocation)

type IcPallet_xcmPalletCallLimited_reserve_transfer_assetsTupled = [
  Dest: IcXcmVersionedMultiLocation,
  Beneficiary: IcXcmVersionedMultiLocation,
  Assets: IcXcmVersionedMultiAssets,
  Fee_asset_item: number,
  Weight_limit: IcXcmV3WeightLimit,
]
const cPallet_xcmPalletCallLimited_reserve_transfer_assetsTupled: Codec<IcPallet_xcmPalletCallLimited_reserve_transfer_assetsTupled> =
  Tuple(
    cXcmVersionedMultiLocation,
    cXcmVersionedMultiLocation,
    cXcmVersionedMultiAssets,
    u32,
    cXcmV3WeightLimit,
  )

type IcPallet_xcmPalletCallLimited_teleport_assetsTupled = [
  Dest: IcXcmVersionedMultiLocation,
  Beneficiary: IcXcmVersionedMultiLocation,
  Assets: IcXcmVersionedMultiAssets,
  Fee_asset_item: number,
  Weight_limit: IcXcmV3WeightLimit,
]
const cPallet_xcmPalletCallLimited_teleport_assetsTupled: Codec<IcPallet_xcmPalletCallLimited_teleport_assetsTupled> =
  Tuple(
    cXcmVersionedMultiLocation,
    cXcmVersionedMultiLocation,
    cXcmVersionedMultiAssets,
    u32,
    cXcmV3WeightLimit,
  )

type IcPallet_xcmPalletCallForce_suspensionTupled = [Suspended: boolean]
const cPallet_xcmPalletCallForce_suspensionTupled: Codec<IcPallet_xcmPalletCallForce_suspensionTupled> =
  Tuple(bool)

type IcPallet_xcmPalletError =
  | { tag: "Unreachable"; value: undefined }
  | { tag: "SendFailure"; value: undefined }
  | { tag: "Filtered"; value: undefined }
  | { tag: "UnweighableMessage"; value: undefined }
  | { tag: "DestinationNotInvertible"; value: undefined }
  | { tag: "Empty"; value: undefined }
  | { tag: "CannotReanchor"; value: undefined }
  | { tag: "TooManyAssets"; value: undefined }
  | { tag: "InvalidOrigin"; value: undefined }
  | { tag: "BadVersion"; value: undefined }
  | { tag: "BadLocation"; value: undefined }
  | { tag: "NoSubscription"; value: undefined }
  | { tag: "AlreadySubscribed"; value: undefined }
  | { tag: "InvalidAsset"; value: undefined }
  | { tag: "LowBalance"; value: undefined }
  | { tag: "TooManyLocks"; value: undefined }
  | { tag: "AccountNotSovereign"; value: undefined }
  | { tag: "FeesNotMet"; value: undefined }
  | { tag: "LockNotFound"; value: undefined }
  | { tag: "InUse"; value: undefined }
const cPallet_xcmPalletError: Codec<IcPallet_xcmPalletError> = Enum({
  Unreachable: _void,
  SendFailure: _void,
  Filtered: _void,
  UnweighableMessage: _void,
  DestinationNotInvertible: _void,
  Empty: _void,
  CannotReanchor: _void,
  TooManyAssets: _void,
  InvalidOrigin: _void,
  BadVersion: _void,
  BadLocation: _void,
  NoSubscription: _void,
  AlreadySubscribed: _void,
  InvalidAsset: _void,
  LowBalance: _void,
  TooManyLocks: _void,
  AccountNotSovereign: _void,
  FeesNotMet: _void,
  LockNotFound: _void,
  InUse: _void,
})

type IcPallet_xcmPalletErrorUnreachable = undefined
const cPallet_xcmPalletErrorUnreachable: Codec<IcPallet_xcmPalletErrorUnreachable> =
  _void

type IcPallet_xcmPalletErrorSendFailure = undefined
const cPallet_xcmPalletErrorSendFailure: Codec<IcPallet_xcmPalletErrorSendFailure> =
  _void

type IcPallet_xcmPalletErrorFiltered = undefined
const cPallet_xcmPalletErrorFiltered: Codec<IcPallet_xcmPalletErrorFiltered> =
  _void

type IcPallet_xcmPalletErrorUnweighableMessage = undefined
const cPallet_xcmPalletErrorUnweighableMessage: Codec<IcPallet_xcmPalletErrorUnweighableMessage> =
  _void

type IcPallet_xcmPalletErrorDestinationNotInvertible = undefined
const cPallet_xcmPalletErrorDestinationNotInvertible: Codec<IcPallet_xcmPalletErrorDestinationNotInvertible> =
  _void

type IcPallet_xcmPalletErrorEmpty = undefined
const cPallet_xcmPalletErrorEmpty: Codec<IcPallet_xcmPalletErrorEmpty> = _void

type IcPallet_xcmPalletErrorCannotReanchor = undefined
const cPallet_xcmPalletErrorCannotReanchor: Codec<IcPallet_xcmPalletErrorCannotReanchor> =
  _void

type IcPallet_xcmPalletErrorTooManyAssets = undefined
const cPallet_xcmPalletErrorTooManyAssets: Codec<IcPallet_xcmPalletErrorTooManyAssets> =
  _void

type IcPallet_xcmPalletErrorInvalidOrigin = undefined
const cPallet_xcmPalletErrorInvalidOrigin: Codec<IcPallet_xcmPalletErrorInvalidOrigin> =
  _void

type IcPallet_xcmPalletErrorBadVersion = undefined
const cPallet_xcmPalletErrorBadVersion: Codec<IcPallet_xcmPalletErrorBadVersion> =
  _void

type IcPallet_xcmPalletErrorBadLocation = undefined
const cPallet_xcmPalletErrorBadLocation: Codec<IcPallet_xcmPalletErrorBadLocation> =
  _void

type IcPallet_xcmPalletErrorNoSubscription = undefined
const cPallet_xcmPalletErrorNoSubscription: Codec<IcPallet_xcmPalletErrorNoSubscription> =
  _void

type IcPallet_xcmPalletErrorAlreadySubscribed = undefined
const cPallet_xcmPalletErrorAlreadySubscribed: Codec<IcPallet_xcmPalletErrorAlreadySubscribed> =
  _void

type IcPallet_xcmPalletErrorInvalidAsset = undefined
const cPallet_xcmPalletErrorInvalidAsset: Codec<IcPallet_xcmPalletErrorInvalidAsset> =
  _void

type IcPallet_xcmPalletErrorLowBalance = undefined
const cPallet_xcmPalletErrorLowBalance: Codec<IcPallet_xcmPalletErrorLowBalance> =
  _void

type IcPallet_xcmPalletErrorTooManyLocks = undefined
const cPallet_xcmPalletErrorTooManyLocks: Codec<IcPallet_xcmPalletErrorTooManyLocks> =
  _void

type IcPallet_xcmPalletErrorAccountNotSovereign = undefined
const cPallet_xcmPalletErrorAccountNotSovereign: Codec<IcPallet_xcmPalletErrorAccountNotSovereign> =
  _void

type IcPallet_xcmPalletErrorFeesNotMet = undefined
const cPallet_xcmPalletErrorFeesNotMet: Codec<IcPallet_xcmPalletErrorFeesNotMet> =
  _void

type IcPallet_xcmPalletErrorLockNotFound = undefined
const cPallet_xcmPalletErrorLockNotFound: Codec<IcPallet_xcmPalletErrorLockNotFound> =
  _void

type IcPallet_xcmPalletErrorInUse = undefined
const cPallet_xcmPalletErrorInUse: Codec<IcPallet_xcmPalletErrorInUse> = _void

type IcPallet_assetsTypesAssetStatus =
  | { tag: "Live"; value: undefined }
  | { tag: "Frozen"; value: undefined }
  | { tag: "Destroying"; value: undefined }
const cPallet_assetsTypesAssetStatus: Codec<IcPallet_assetsTypesAssetStatus> =
  Enum({ Live: _void, Frozen: _void, Destroying: _void })

type IcPallet_assetsTypesAssetDetails = {
  owner: Icdc1
  issuer: Icdc1
  admin: Icdc1
  freezer: Icdc1
  supply: bigint
  deposit: bigint
  min_balance: bigint
  is_sufficient: boolean
  accounts: number
  sufficients: number
  approvals: number
  status: IcPallet_assetsTypesAssetStatus
}
const cPallet_assetsTypesAssetDetails: Codec<IcPallet_assetsTypesAssetDetails> =
  Struct({
    owner: cdc1,
    issuer: cdc1,
    admin: cdc1,
    freezer: cdc1,
    supply: u128,
    deposit: u128,
    min_balance: u128,
    is_sufficient: bool,
    accounts: u32,
    sufficients: u32,
    approvals: u32,
    status: cPallet_assetsTypesAssetStatus,
  })

type Icdc6Tupled = [Key: bigint]
const cdc6Tupled: Codec<Icdc6Tupled> = Tuple(u128)

type IcPallet_assetsTypesAccountStatus =
  | { tag: "Liquid"; value: undefined }
  | { tag: "Frozen"; value: undefined }
  | { tag: "Blocked"; value: undefined }
const cPallet_assetsTypesAccountStatus: Codec<IcPallet_assetsTypesAccountStatus> =
  Enum({ Liquid: _void, Frozen: _void, Blocked: _void })

type IcPallet_assetsTypesExistenceReasonDepositHeld = bigint
const cPallet_assetsTypesExistenceReasonDepositHeld: Codec<IcPallet_assetsTypesExistenceReasonDepositHeld> =
  u128

type IcPallet_assetsTypesExistenceReasonDepositFrom = [Icdc1, bigint]
const cPallet_assetsTypesExistenceReasonDepositFrom: Codec<IcPallet_assetsTypesExistenceReasonDepositFrom> =
  Tuple(cdc1, u128)

type IcPallet_assetsTypesExistenceReason =
  | { tag: "Consumer"; value: undefined }
  | { tag: "Sufficient"; value: undefined }
  | {
      tag: "DepositHeld"
      value: IcPallet_assetsTypesExistenceReasonDepositHeld
    }
  | { tag: "DepositRefunded"; value: undefined }
  | {
      tag: "DepositFrom"
      value: IcPallet_assetsTypesExistenceReasonDepositFrom
    }
const cPallet_assetsTypesExistenceReason: Codec<IcPallet_assetsTypesExistenceReason> =
  Enum({
    Consumer: _void,
    Sufficient: _void,
    DepositHeld: cPallet_assetsTypesExistenceReasonDepositHeld,
    DepositRefunded: _void,
    DepositFrom: cPallet_assetsTypesExistenceReasonDepositFrom,
  })

type IcPallet_assetsTypesAssetAccount = {
  balance: bigint
  status: IcPallet_assetsTypesAccountStatus
  reason: IcPallet_assetsTypesExistenceReason
  extra: undefined
}
const cPallet_assetsTypesAssetAccount: Codec<IcPallet_assetsTypesAssetAccount> =
  Struct({
    balance: u128,
    status: cPallet_assetsTypesAccountStatus,
    reason: cPallet_assetsTypesExistenceReason,
    extra: _void,
  })

type Icdc595 = [bigint, Icdc1]
const cdc595: Codec<Icdc595> = Tuple(u128, cdc1)

type IcPallet_assetsTypesApproval = { amount: bigint; deposit: bigint }
const cPallet_assetsTypesApproval: Codec<IcPallet_assetsTypesApproval> = Struct(
  { amount: u128, deposit: u128 },
)

type Icdc599 = [bigint, Icdc1, Icdc1]
const cdc599: Codec<Icdc599> = Tuple(u128, cdc1, cdc1)

type IcPallet_assetsTypesAssetMetadata = {
  deposit: bigint
  name: I_bytesSeq
  symbol: I_bytesSeq
  decimals: number
  is_frozen: boolean
}
const cPallet_assetsTypesAssetMetadata: Codec<IcPallet_assetsTypesAssetMetadata> =
  Struct({
    deposit: u128,
    name: _bytesSeq,
    symbol: _bytesSeq,
    decimals: u8,
    is_frozen: bool,
  })

type IcPallet_assetsPalletCallCreateTupled = [
  Id: bigint,
  Admin: Icdc1,
  Min_balance: bigint,
]
const cPallet_assetsPalletCallCreateTupled: Codec<IcPallet_assetsPalletCallCreateTupled> =
  Tuple(compactBn, cdc1, u128)

type IcPallet_assetsPalletCallForce_createTupled = [
  Id: bigint,
  Owner: Icdc1,
  Is_sufficient: boolean,
  Min_balance: bigint,
]
const cPallet_assetsPalletCallForce_createTupled: Codec<IcPallet_assetsPalletCallForce_createTupled> =
  Tuple(compactBn, cdc1, bool, compactBn)

type IcPallet_assetsPalletCallStart_destroyTupled = [Id: bigint]
const cPallet_assetsPalletCallStart_destroyTupled: Codec<IcPallet_assetsPalletCallStart_destroyTupled> =
  Tuple(compactBn)

type IcPallet_assetsPalletCallDestroy_accountsTupled = [Id: bigint]
const cPallet_assetsPalletCallDestroy_accountsTupled: Codec<IcPallet_assetsPalletCallDestroy_accountsTupled> =
  Tuple(compactBn)

type IcPallet_assetsPalletCallDestroy_approvalsTupled = [Id: bigint]
const cPallet_assetsPalletCallDestroy_approvalsTupled: Codec<IcPallet_assetsPalletCallDestroy_approvalsTupled> =
  Tuple(compactBn)

type IcPallet_assetsPalletCallFinish_destroyTupled = [Id: bigint]
const cPallet_assetsPalletCallFinish_destroyTupled: Codec<IcPallet_assetsPalletCallFinish_destroyTupled> =
  Tuple(compactBn)

type IcPallet_assetsPalletCallMintTupled = [
  Id: bigint,
  Beneficiary: Icdc1,
  Amount: bigint,
]
const cPallet_assetsPalletCallMintTupled: Codec<IcPallet_assetsPalletCallMintTupled> =
  Tuple(compactBn, cdc1, compactBn)

type IcPallet_assetsPalletCallBurnTupled = [
  Id: bigint,
  Who: Icdc1,
  Amount: bigint,
]
const cPallet_assetsPalletCallBurnTupled: Codec<IcPallet_assetsPalletCallBurnTupled> =
  Tuple(compactBn, cdc1, compactBn)

type IcPallet_assetsPalletCallTransferTupled = [
  Id: bigint,
  Target: Icdc1,
  Amount: bigint,
]
const cPallet_assetsPalletCallTransferTupled: Codec<IcPallet_assetsPalletCallTransferTupled> =
  Tuple(compactBn, cdc1, compactBn)

type IcPallet_assetsPalletCallTransfer_keep_aliveTupled = [
  Id: bigint,
  Target: Icdc1,
  Amount: bigint,
]
const cPallet_assetsPalletCallTransfer_keep_aliveTupled: Codec<IcPallet_assetsPalletCallTransfer_keep_aliveTupled> =
  Tuple(compactBn, cdc1, compactBn)

type IcPallet_assetsPalletCallForce_transferTupled = [
  Id: bigint,
  Source: Icdc1,
  Dest: Icdc1,
  Amount: bigint,
]
const cPallet_assetsPalletCallForce_transferTupled: Codec<IcPallet_assetsPalletCallForce_transferTupled> =
  Tuple(compactBn, cdc1, cdc1, compactBn)

type IcPallet_assetsPalletCallFreezeTupled = [Id: bigint, Who: Icdc1]
const cPallet_assetsPalletCallFreezeTupled: Codec<IcPallet_assetsPalletCallFreezeTupled> =
  Tuple(compactBn, cdc1)

type IcPallet_assetsPalletCallThawTupled = [Id: bigint, Who: Icdc1]
const cPallet_assetsPalletCallThawTupled: Codec<IcPallet_assetsPalletCallThawTupled> =
  Tuple(compactBn, cdc1)

type IcPallet_assetsPalletCallFreeze_assetTupled = [Id: bigint]
const cPallet_assetsPalletCallFreeze_assetTupled: Codec<IcPallet_assetsPalletCallFreeze_assetTupled> =
  Tuple(compactBn)

type IcPallet_assetsPalletCallThaw_assetTupled = [Id: bigint]
const cPallet_assetsPalletCallThaw_assetTupled: Codec<IcPallet_assetsPalletCallThaw_assetTupled> =
  Tuple(compactBn)

type IcPallet_assetsPalletCallTransfer_ownershipTupled = [
  Id: bigint,
  Owner: Icdc1,
]
const cPallet_assetsPalletCallTransfer_ownershipTupled: Codec<IcPallet_assetsPalletCallTransfer_ownershipTupled> =
  Tuple(compactBn, cdc1)

type IcPallet_assetsPalletCallSet_teamTupled = [
  Id: bigint,
  Issuer: Icdc1,
  Admin: Icdc1,
  Freezer: Icdc1,
]
const cPallet_assetsPalletCallSet_teamTupled: Codec<IcPallet_assetsPalletCallSet_teamTupled> =
  Tuple(compactBn, cdc1, cdc1, cdc1)

type IcPallet_assetsPalletCallSet_metadataTupled = [
  Id: bigint,
  Name: I_bytesSeq,
  Symbol: I_bytesSeq,
  Decimals: number,
]
const cPallet_assetsPalletCallSet_metadataTupled: Codec<IcPallet_assetsPalletCallSet_metadataTupled> =
  Tuple(compactBn, _bytesSeq, _bytesSeq, u8)

type IcPallet_assetsPalletCallClear_metadataTupled = [Id: bigint]
const cPallet_assetsPalletCallClear_metadataTupled: Codec<IcPallet_assetsPalletCallClear_metadataTupled> =
  Tuple(compactBn)

type IcPallet_assetsPalletCallForce_set_metadataTupled = [
  Id: bigint,
  Name: I_bytesSeq,
  Symbol: I_bytesSeq,
  Decimals: number,
  Is_frozen: boolean,
]
const cPallet_assetsPalletCallForce_set_metadataTupled: Codec<IcPallet_assetsPalletCallForce_set_metadataTupled> =
  Tuple(compactBn, _bytesSeq, _bytesSeq, u8, bool)

type IcPallet_assetsPalletCallForce_clear_metadataTupled = [Id: bigint]
const cPallet_assetsPalletCallForce_clear_metadataTupled: Codec<IcPallet_assetsPalletCallForce_clear_metadataTupled> =
  Tuple(compactBn)

type IcPallet_assetsPalletCallForce_asset_statusTupled = [
  Id: bigint,
  Owner: Icdc1,
  Issuer: Icdc1,
  Admin: Icdc1,
  Freezer: Icdc1,
  Min_balance: bigint,
  Is_sufficient: boolean,
  Is_frozen: boolean,
]
const cPallet_assetsPalletCallForce_asset_statusTupled: Codec<IcPallet_assetsPalletCallForce_asset_statusTupled> =
  Tuple(compactBn, cdc1, cdc1, cdc1, cdc1, compactBn, bool, bool)

type IcPallet_assetsPalletCallApprove_transferTupled = [
  Id: bigint,
  Delegate: Icdc1,
  Amount: bigint,
]
const cPallet_assetsPalletCallApprove_transferTupled: Codec<IcPallet_assetsPalletCallApprove_transferTupled> =
  Tuple(compactBn, cdc1, compactBn)

type IcPallet_assetsPalletCallCancel_approvalTupled = [
  Id: bigint,
  Delegate: Icdc1,
]
const cPallet_assetsPalletCallCancel_approvalTupled: Codec<IcPallet_assetsPalletCallCancel_approvalTupled> =
  Tuple(compactBn, cdc1)

type IcPallet_assetsPalletCallForce_cancel_approvalTupled = [
  Id: bigint,
  Owner: Icdc1,
  Delegate: Icdc1,
]
const cPallet_assetsPalletCallForce_cancel_approvalTupled: Codec<IcPallet_assetsPalletCallForce_cancel_approvalTupled> =
  Tuple(compactBn, cdc1, cdc1)

type IcPallet_assetsPalletCallTransfer_approvedTupled = [
  Id: bigint,
  Owner: Icdc1,
  Destination: Icdc1,
  Amount: bigint,
]
const cPallet_assetsPalletCallTransfer_approvedTupled: Codec<IcPallet_assetsPalletCallTransfer_approvedTupled> =
  Tuple(compactBn, cdc1, cdc1, compactBn)

type IcPallet_assetsPalletCallTouchTupled = [Id: bigint]
const cPallet_assetsPalletCallTouchTupled: Codec<IcPallet_assetsPalletCallTouchTupled> =
  Tuple(compactBn)

type IcPallet_assetsPalletCallRefundTupled = [Id: bigint, Allow_burn: boolean]
const cPallet_assetsPalletCallRefundTupled: Codec<IcPallet_assetsPalletCallRefundTupled> =
  Tuple(compactBn, bool)

type IcPallet_assetsPalletCallSet_min_balanceTupled = [
  Id: bigint,
  Min_balance: bigint,
]
const cPallet_assetsPalletCallSet_min_balanceTupled: Codec<IcPallet_assetsPalletCallSet_min_balanceTupled> =
  Tuple(compactBn, u128)

type IcPallet_assetsPalletCallTouch_otherTupled = [Id: bigint, Who: Icdc1]
const cPallet_assetsPalletCallTouch_otherTupled: Codec<IcPallet_assetsPalletCallTouch_otherTupled> =
  Tuple(compactBn, cdc1)

type IcPallet_assetsPalletCallRefund_otherTupled = [Id: bigint, Who: Icdc1]
const cPallet_assetsPalletCallRefund_otherTupled: Codec<IcPallet_assetsPalletCallRefund_otherTupled> =
  Tuple(compactBn, cdc1)

type IcPallet_assetsPalletCallBlockTupled = [Id: bigint, Who: Icdc1]
const cPallet_assetsPalletCallBlockTupled: Codec<IcPallet_assetsPalletCallBlockTupled> =
  Tuple(compactBn, cdc1)

type IcPallet_assetsPalletError =
  | { tag: "BalanceLow"; value: undefined }
  | { tag: "NoAccount"; value: undefined }
  | { tag: "NoPermission"; value: undefined }
  | { tag: "Unknown"; value: undefined }
  | { tag: "Frozen"; value: undefined }
  | { tag: "InUse"; value: undefined }
  | { tag: "BadWitness"; value: undefined }
  | { tag: "MinBalanceZero"; value: undefined }
  | { tag: "UnavailableConsumer"; value: undefined }
  | { tag: "BadMetadata"; value: undefined }
  | { tag: "Unapproved"; value: undefined }
  | { tag: "WouldDie"; value: undefined }
  | { tag: "AlreadyExists"; value: undefined }
  | { tag: "NoDeposit"; value: undefined }
  | { tag: "WouldBurn"; value: undefined }
  | { tag: "LiveAsset"; value: undefined }
  | { tag: "AssetNotLive"; value: undefined }
  | { tag: "IncorrectStatus"; value: undefined }
  | { tag: "NotFrozen"; value: undefined }
  | { tag: "CallbackFailed"; value: undefined }
const cPallet_assetsPalletError: Codec<IcPallet_assetsPalletError> = Enum({
  BalanceLow: _void,
  NoAccount: _void,
  NoPermission: _void,
  Unknown: _void,
  Frozen: _void,
  InUse: _void,
  BadWitness: _void,
  MinBalanceZero: _void,
  UnavailableConsumer: _void,
  BadMetadata: _void,
  Unapproved: _void,
  WouldDie: _void,
  AlreadyExists: _void,
  NoDeposit: _void,
  WouldBurn: _void,
  LiveAsset: _void,
  AssetNotLive: _void,
  IncorrectStatus: _void,
  NotFrozen: _void,
  CallbackFailed: _void,
})

type IcPallet_assetsPalletErrorBalanceLow = undefined
const cPallet_assetsPalletErrorBalanceLow: Codec<IcPallet_assetsPalletErrorBalanceLow> =
  _void

type IcPallet_assetsPalletErrorNoAccount = undefined
const cPallet_assetsPalletErrorNoAccount: Codec<IcPallet_assetsPalletErrorNoAccount> =
  _void

type IcPallet_assetsPalletErrorNoPermission = undefined
const cPallet_assetsPalletErrorNoPermission: Codec<IcPallet_assetsPalletErrorNoPermission> =
  _void

type IcPallet_assetsPalletErrorUnknown = undefined
const cPallet_assetsPalletErrorUnknown: Codec<IcPallet_assetsPalletErrorUnknown> =
  _void

type IcPallet_assetsPalletErrorFrozen = undefined
const cPallet_assetsPalletErrorFrozen: Codec<IcPallet_assetsPalletErrorFrozen> =
  _void

type IcPallet_assetsPalletErrorInUse = undefined
const cPallet_assetsPalletErrorInUse: Codec<IcPallet_assetsPalletErrorInUse> =
  _void

type IcPallet_assetsPalletErrorBadWitness = undefined
const cPallet_assetsPalletErrorBadWitness: Codec<IcPallet_assetsPalletErrorBadWitness> =
  _void

type IcPallet_assetsPalletErrorMinBalanceZero = undefined
const cPallet_assetsPalletErrorMinBalanceZero: Codec<IcPallet_assetsPalletErrorMinBalanceZero> =
  _void

type IcPallet_assetsPalletErrorUnavailableConsumer = undefined
const cPallet_assetsPalletErrorUnavailableConsumer: Codec<IcPallet_assetsPalletErrorUnavailableConsumer> =
  _void

type IcPallet_assetsPalletErrorBadMetadata = undefined
const cPallet_assetsPalletErrorBadMetadata: Codec<IcPallet_assetsPalletErrorBadMetadata> =
  _void

type IcPallet_assetsPalletErrorUnapproved = undefined
const cPallet_assetsPalletErrorUnapproved: Codec<IcPallet_assetsPalletErrorUnapproved> =
  _void

type IcPallet_assetsPalletErrorWouldDie = undefined
const cPallet_assetsPalletErrorWouldDie: Codec<IcPallet_assetsPalletErrorWouldDie> =
  _void

type IcPallet_assetsPalletErrorAlreadyExists = undefined
const cPallet_assetsPalletErrorAlreadyExists: Codec<IcPallet_assetsPalletErrorAlreadyExists> =
  _void

type IcPallet_assetsPalletErrorNoDeposit = undefined
const cPallet_assetsPalletErrorNoDeposit: Codec<IcPallet_assetsPalletErrorNoDeposit> =
  _void

type IcPallet_assetsPalletErrorWouldBurn = undefined
const cPallet_assetsPalletErrorWouldBurn: Codec<IcPallet_assetsPalletErrorWouldBurn> =
  _void

type IcPallet_assetsPalletErrorLiveAsset = undefined
const cPallet_assetsPalletErrorLiveAsset: Codec<IcPallet_assetsPalletErrorLiveAsset> =
  _void

type IcPallet_assetsPalletErrorAssetNotLive = undefined
const cPallet_assetsPalletErrorAssetNotLive: Codec<IcPallet_assetsPalletErrorAssetNotLive> =
  _void

type IcPallet_assetsPalletErrorIncorrectStatus = undefined
const cPallet_assetsPalletErrorIncorrectStatus: Codec<IcPallet_assetsPalletErrorIncorrectStatus> =
  _void

type IcPallet_assetsPalletErrorNotFrozen = undefined
const cPallet_assetsPalletErrorNotFrozen: Codec<IcPallet_assetsPalletErrorNotFrozen> =
  _void

type IcPallet_assetsPalletErrorCallbackFailed = undefined
const cPallet_assetsPalletErrorCallbackFailed: Codec<IcPallet_assetsPalletErrorCallbackFailed> =
  _void

type IcMoonbeam_runtimeXcm_configAssetTypeTupled = [
  Key: IcMoonbeam_runtimeXcm_configAssetType,
]
const cMoonbeam_runtimeXcm_configAssetTypeTupled: Codec<IcMoonbeam_runtimeXcm_configAssetTypeTupled> =
  Tuple(cMoonbeam_runtimeXcm_configAssetType)

type IcPallet_asset_managerPalletAssetInfo = { creator: Icdc1; deposit: bigint }
const cPallet_asset_managerPalletAssetInfo: Codec<IcPallet_asset_managerPalletAssetInfo> =
  Struct({ creator: cdc1, deposit: u128 })

type Icdc605 = Array<IcMoonbeam_runtimeXcm_configAssetType>
const cdc605: Codec<Icdc605> = Vector(cMoonbeam_runtimeXcm_configAssetType)

type IcPallet_asset_managerPalletCallRegister_foreign_assetTupled = [
  Asset: IcMoonbeam_runtimeXcm_configAssetType,
  Metadata: IcMoonbeam_runtimeAsset_configAssetRegistrarMetadata,
  Min_amount: bigint,
  Is_sufficient: boolean,
]
const cPallet_asset_managerPalletCallRegister_foreign_assetTupled: Codec<IcPallet_asset_managerPalletCallRegister_foreign_assetTupled> =
  Tuple(
    cMoonbeam_runtimeXcm_configAssetType,
    cMoonbeam_runtimeAsset_configAssetRegistrarMetadata,
    u128,
    bool,
  )

type IcPallet_asset_managerPalletCallSet_asset_units_per_secondTupled = [
  Asset_type: IcMoonbeam_runtimeXcm_configAssetType,
  Units_per_second: bigint,
  Num_assets_weight_hint: number,
]
const cPallet_asset_managerPalletCallSet_asset_units_per_secondTupled: Codec<IcPallet_asset_managerPalletCallSet_asset_units_per_secondTupled> =
  Tuple(cMoonbeam_runtimeXcm_configAssetType, u128, u32)

type IcPallet_asset_managerPalletCallChange_existing_asset_typeTupled = [
  Asset_id: bigint,
  New_asset_type: IcMoonbeam_runtimeXcm_configAssetType,
  Num_assets_weight_hint: number,
]
const cPallet_asset_managerPalletCallChange_existing_asset_typeTupled: Codec<IcPallet_asset_managerPalletCallChange_existing_asset_typeTupled> =
  Tuple(u128, cMoonbeam_runtimeXcm_configAssetType, u32)

type IcPallet_asset_managerPalletCallRemove_supported_assetTupled = [
  Asset_type: IcMoonbeam_runtimeXcm_configAssetType,
  Num_assets_weight_hint: number,
]
const cPallet_asset_managerPalletCallRemove_supported_assetTupled: Codec<IcPallet_asset_managerPalletCallRemove_supported_assetTupled> =
  Tuple(cMoonbeam_runtimeXcm_configAssetType, u32)

type IcPallet_asset_managerPalletCallRemove_existing_asset_typeTupled = [
  Asset_id: bigint,
  Num_assets_weight_hint: number,
]
const cPallet_asset_managerPalletCallRemove_existing_asset_typeTupled: Codec<IcPallet_asset_managerPalletCallRemove_existing_asset_typeTupled> =
  Tuple(u128, u32)

type IcPallet_asset_managerPalletCallRegister_local_assetTupled = [
  Creator: Icdc1,
  Owner: Icdc1,
  Is_sufficient: boolean,
  Min_balance: bigint,
]
const cPallet_asset_managerPalletCallRegister_local_assetTupled: Codec<IcPallet_asset_managerPalletCallRegister_local_assetTupled> =
  Tuple(cdc1, cdc1, bool, u128)

type IcPallet_asset_managerPalletCallDestroy_foreign_assetTupled = [
  Asset_id: bigint,
  Num_assets_weight_hint: number,
]
const cPallet_asset_managerPalletCallDestroy_foreign_assetTupled: Codec<IcPallet_asset_managerPalletCallDestroy_foreign_assetTupled> =
  Tuple(u128, u32)

type IcPallet_asset_managerPalletCallDestroy_local_assetTupled = [
  Asset_id: bigint,
]
const cPallet_asset_managerPalletCallDestroy_local_assetTupled: Codec<IcPallet_asset_managerPalletCallDestroy_local_assetTupled> =
  Tuple(u128)

type IcPallet_asset_managerPalletError =
  | { tag: "ErrorCreatingAsset"; value: undefined }
  | { tag: "AssetAlreadyExists"; value: undefined }
  | { tag: "AssetDoesNotExist"; value: undefined }
  | { tag: "TooLowNumAssetsWeightHint"; value: undefined }
  | { tag: "LocalAssetLimitReached"; value: undefined }
  | { tag: "ErrorDestroyingAsset"; value: undefined }
  | { tag: "NotSufficientDeposit"; value: undefined }
  | { tag: "NonExistentLocalAsset"; value: undefined }
const cPallet_asset_managerPalletError: Codec<IcPallet_asset_managerPalletError> =
  Enum({
    ErrorCreatingAsset: _void,
    AssetAlreadyExists: _void,
    AssetDoesNotExist: _void,
    TooLowNumAssetsWeightHint: _void,
    LocalAssetLimitReached: _void,
    ErrorDestroyingAsset: _void,
    NotSufficientDeposit: _void,
    NonExistentLocalAsset: _void,
  })

type IcPallet_asset_managerPalletErrorErrorCreatingAsset = undefined
const cPallet_asset_managerPalletErrorErrorCreatingAsset: Codec<IcPallet_asset_managerPalletErrorErrorCreatingAsset> =
  _void

type IcPallet_asset_managerPalletErrorAssetAlreadyExists = undefined
const cPallet_asset_managerPalletErrorAssetAlreadyExists: Codec<IcPallet_asset_managerPalletErrorAssetAlreadyExists> =
  _void

type IcPallet_asset_managerPalletErrorAssetDoesNotExist = undefined
const cPallet_asset_managerPalletErrorAssetDoesNotExist: Codec<IcPallet_asset_managerPalletErrorAssetDoesNotExist> =
  _void

type IcPallet_asset_managerPalletErrorTooLowNumAssetsWeightHint = undefined
const cPallet_asset_managerPalletErrorTooLowNumAssetsWeightHint: Codec<IcPallet_asset_managerPalletErrorTooLowNumAssetsWeightHint> =
  _void

type IcPallet_asset_managerPalletErrorLocalAssetLimitReached = undefined
const cPallet_asset_managerPalletErrorLocalAssetLimitReached: Codec<IcPallet_asset_managerPalletErrorLocalAssetLimitReached> =
  _void

type IcPallet_asset_managerPalletErrorErrorDestroyingAsset = undefined
const cPallet_asset_managerPalletErrorErrorDestroyingAsset: Codec<IcPallet_asset_managerPalletErrorErrorDestroyingAsset> =
  _void

type IcPallet_asset_managerPalletErrorNotSufficientDeposit = undefined
const cPallet_asset_managerPalletErrorNotSufficientDeposit: Codec<IcPallet_asset_managerPalletErrorNotSufficientDeposit> =
  _void

type IcPallet_asset_managerPalletErrorNonExistentLocalAsset = undefined
const cPallet_asset_managerPalletErrorNonExistentLocalAsset: Codec<IcPallet_asset_managerPalletErrorNonExistentLocalAsset> =
  _void

type IcOrml_xtokensModuleCallTransferTupled = [
  Currency_id: IcMoonbeam_runtimeXcm_configCurrencyId,
  Amount: bigint,
  Dest: IcXcmVersionedMultiLocation,
  Dest_weight_limit: IcXcmV3WeightLimit,
]
const cOrml_xtokensModuleCallTransferTupled: Codec<IcOrml_xtokensModuleCallTransferTupled> =
  Tuple(
    cMoonbeam_runtimeXcm_configCurrencyId,
    u128,
    cXcmVersionedMultiLocation,
    cXcmV3WeightLimit,
  )

type IcOrml_xtokensModuleCallTransfer_multiassetTupled = [
  Asset: IcXcmVersionedMultiAsset,
  Dest: IcXcmVersionedMultiLocation,
  Dest_weight_limit: IcXcmV3WeightLimit,
]
const cOrml_xtokensModuleCallTransfer_multiassetTupled: Codec<IcOrml_xtokensModuleCallTransfer_multiassetTupled> =
  Tuple(cXcmVersionedMultiAsset, cXcmVersionedMultiLocation, cXcmV3WeightLimit)

type IcOrml_xtokensModuleCallTransfer_with_feeTupled = [
  Currency_id: IcMoonbeam_runtimeXcm_configCurrencyId,
  Amount: bigint,
  Fee: bigint,
  Dest: IcXcmVersionedMultiLocation,
  Dest_weight_limit: IcXcmV3WeightLimit,
]
const cOrml_xtokensModuleCallTransfer_with_feeTupled: Codec<IcOrml_xtokensModuleCallTransfer_with_feeTupled> =
  Tuple(
    cMoonbeam_runtimeXcm_configCurrencyId,
    u128,
    u128,
    cXcmVersionedMultiLocation,
    cXcmV3WeightLimit,
  )

type IcOrml_xtokensModuleCallTransfer_multiasset_with_feeTupled = [
  Asset: IcXcmVersionedMultiAsset,
  Fee: IcXcmVersionedMultiAsset,
  Dest: IcXcmVersionedMultiLocation,
  Dest_weight_limit: IcXcmV3WeightLimit,
]
const cOrml_xtokensModuleCallTransfer_multiasset_with_feeTupled: Codec<IcOrml_xtokensModuleCallTransfer_multiasset_with_feeTupled> =
  Tuple(
    cXcmVersionedMultiAsset,
    cXcmVersionedMultiAsset,
    cXcmVersionedMultiLocation,
    cXcmV3WeightLimit,
  )

type IcOrml_xtokensModuleCallTransfer_multicurrenciesTupled = [
  Currencies: Icdc304,
  Fee_item: number,
  Dest: IcXcmVersionedMultiLocation,
  Dest_weight_limit: IcXcmV3WeightLimit,
]
const cOrml_xtokensModuleCallTransfer_multicurrenciesTupled: Codec<IcOrml_xtokensModuleCallTransfer_multicurrenciesTupled> =
  Tuple(cdc304, u32, cXcmVersionedMultiLocation, cXcmV3WeightLimit)

type IcOrml_xtokensModuleCallTransfer_multiassetsTupled = [
  Assets: IcXcmVersionedMultiAssets,
  Fee_item: number,
  Dest: IcXcmVersionedMultiLocation,
  Dest_weight_limit: IcXcmV3WeightLimit,
]
const cOrml_xtokensModuleCallTransfer_multiassetsTupled: Codec<IcOrml_xtokensModuleCallTransfer_multiassetsTupled> =
  Tuple(
    cXcmVersionedMultiAssets,
    u32,
    cXcmVersionedMultiLocation,
    cXcmV3WeightLimit,
  )

type IcOrml_xtokensModuleError =
  | { tag: "AssetHasNoReserve"; value: undefined }
  | { tag: "NotCrossChainTransfer"; value: undefined }
  | { tag: "InvalidDest"; value: undefined }
  | { tag: "NotCrossChainTransferableCurrency"; value: undefined }
  | { tag: "UnweighableMessage"; value: undefined }
  | { tag: "XcmExecutionFailed"; value: undefined }
  | { tag: "CannotReanchor"; value: undefined }
  | { tag: "InvalidAncestry"; value: undefined }
  | { tag: "InvalidAsset"; value: undefined }
  | { tag: "DestinationNotInvertible"; value: undefined }
  | { tag: "BadVersion"; value: undefined }
  | { tag: "DistinctReserveForAssetAndFee"; value: undefined }
  | { tag: "ZeroFee"; value: undefined }
  | { tag: "ZeroAmount"; value: undefined }
  | { tag: "TooManyAssetsBeingSent"; value: undefined }
  | { tag: "AssetIndexNonExistent"; value: undefined }
  | { tag: "FeeNotEnough"; value: undefined }
  | { tag: "NotSupportedMultiLocation"; value: undefined }
  | { tag: "MinXcmFeeNotDefined"; value: undefined }
const cOrml_xtokensModuleError: Codec<IcOrml_xtokensModuleError> = Enum({
  AssetHasNoReserve: _void,
  NotCrossChainTransfer: _void,
  InvalidDest: _void,
  NotCrossChainTransferableCurrency: _void,
  UnweighableMessage: _void,
  XcmExecutionFailed: _void,
  CannotReanchor: _void,
  InvalidAncestry: _void,
  InvalidAsset: _void,
  DestinationNotInvertible: _void,
  BadVersion: _void,
  DistinctReserveForAssetAndFee: _void,
  ZeroFee: _void,
  ZeroAmount: _void,
  TooManyAssetsBeingSent: _void,
  AssetIndexNonExistent: _void,
  FeeNotEnough: _void,
  NotSupportedMultiLocation: _void,
  MinXcmFeeNotDefined: _void,
})

type IcOrml_xtokensModuleErrorAssetHasNoReserve = undefined
const cOrml_xtokensModuleErrorAssetHasNoReserve: Codec<IcOrml_xtokensModuleErrorAssetHasNoReserve> =
  _void

type IcOrml_xtokensModuleErrorNotCrossChainTransfer = undefined
const cOrml_xtokensModuleErrorNotCrossChainTransfer: Codec<IcOrml_xtokensModuleErrorNotCrossChainTransfer> =
  _void

type IcOrml_xtokensModuleErrorInvalidDest = undefined
const cOrml_xtokensModuleErrorInvalidDest: Codec<IcOrml_xtokensModuleErrorInvalidDest> =
  _void

type IcOrml_xtokensModuleErrorNotCrossChainTransferableCurrency = undefined
const cOrml_xtokensModuleErrorNotCrossChainTransferableCurrency: Codec<IcOrml_xtokensModuleErrorNotCrossChainTransferableCurrency> =
  _void

type IcOrml_xtokensModuleErrorUnweighableMessage = undefined
const cOrml_xtokensModuleErrorUnweighableMessage: Codec<IcOrml_xtokensModuleErrorUnweighableMessage> =
  _void

type IcOrml_xtokensModuleErrorXcmExecutionFailed = undefined
const cOrml_xtokensModuleErrorXcmExecutionFailed: Codec<IcOrml_xtokensModuleErrorXcmExecutionFailed> =
  _void

type IcOrml_xtokensModuleErrorCannotReanchor = undefined
const cOrml_xtokensModuleErrorCannotReanchor: Codec<IcOrml_xtokensModuleErrorCannotReanchor> =
  _void

type IcOrml_xtokensModuleErrorInvalidAncestry = undefined
const cOrml_xtokensModuleErrorInvalidAncestry: Codec<IcOrml_xtokensModuleErrorInvalidAncestry> =
  _void

type IcOrml_xtokensModuleErrorInvalidAsset = undefined
const cOrml_xtokensModuleErrorInvalidAsset: Codec<IcOrml_xtokensModuleErrorInvalidAsset> =
  _void

type IcOrml_xtokensModuleErrorDestinationNotInvertible = undefined
const cOrml_xtokensModuleErrorDestinationNotInvertible: Codec<IcOrml_xtokensModuleErrorDestinationNotInvertible> =
  _void

type IcOrml_xtokensModuleErrorBadVersion = undefined
const cOrml_xtokensModuleErrorBadVersion: Codec<IcOrml_xtokensModuleErrorBadVersion> =
  _void

type IcOrml_xtokensModuleErrorDistinctReserveForAssetAndFee = undefined
const cOrml_xtokensModuleErrorDistinctReserveForAssetAndFee: Codec<IcOrml_xtokensModuleErrorDistinctReserveForAssetAndFee> =
  _void

type IcOrml_xtokensModuleErrorZeroFee = undefined
const cOrml_xtokensModuleErrorZeroFee: Codec<IcOrml_xtokensModuleErrorZeroFee> =
  _void

type IcOrml_xtokensModuleErrorZeroAmount = undefined
const cOrml_xtokensModuleErrorZeroAmount: Codec<IcOrml_xtokensModuleErrorZeroAmount> =
  _void

type IcOrml_xtokensModuleErrorTooManyAssetsBeingSent = undefined
const cOrml_xtokensModuleErrorTooManyAssetsBeingSent: Codec<IcOrml_xtokensModuleErrorTooManyAssetsBeingSent> =
  _void

type IcOrml_xtokensModuleErrorAssetIndexNonExistent = undefined
const cOrml_xtokensModuleErrorAssetIndexNonExistent: Codec<IcOrml_xtokensModuleErrorAssetIndexNonExistent> =
  _void

type IcOrml_xtokensModuleErrorFeeNotEnough = undefined
const cOrml_xtokensModuleErrorFeeNotEnough: Codec<IcOrml_xtokensModuleErrorFeeNotEnough> =
  _void

type IcOrml_xtokensModuleErrorNotSupportedMultiLocation = undefined
const cOrml_xtokensModuleErrorNotSupportedMultiLocation: Codec<IcOrml_xtokensModuleErrorNotSupportedMultiLocation> =
  _void

type IcOrml_xtokensModuleErrorMinXcmFeeNotDefined = undefined
const cOrml_xtokensModuleErrorMinXcmFeeNotDefined: Codec<IcOrml_xtokensModuleErrorMinXcmFeeNotDefined> =
  _void

type IcXcmV3MultilocationMultiLocationTupled = [
  Key: IcXcmV3MultilocationMultiLocation,
]
const cXcmV3MultilocationMultiLocationTupled: Codec<IcXcmV3MultilocationMultiLocationTupled> =
  Tuple(cXcmV3MultilocationMultiLocation)

type IcPallet_xcm_transactorPalletCallRegisterTupled = [
  Who: Icdc1,
  Index: number,
]
const cPallet_xcm_transactorPalletCallRegisterTupled: Codec<IcPallet_xcm_transactorPalletCallRegisterTupled> =
  Tuple(cdc1, u16)

type IcPallet_xcm_transactorPalletCallDeregisterTupled = [Index: number]
const cPallet_xcm_transactorPalletCallDeregisterTupled: Codec<IcPallet_xcm_transactorPalletCallDeregisterTupled> =
  Tuple(u16)

type IcPallet_xcm_transactorPalletCallTransact_through_derivativeTupled = [
  Dest: IcMoonbeam_runtimeXcm_configTransactors,
  Index: number,
  Fee: IcPallet_xcm_transactorPalletCurrencyPayment,
  Inner_call: I_bytesSeq,
  Weight_info: IcPallet_xcm_transactorPalletTransactWeights,
  Refund: boolean,
]
const cPallet_xcm_transactorPalletCallTransact_through_derivativeTupled: Codec<IcPallet_xcm_transactorPalletCallTransact_through_derivativeTupled> =
  Tuple(
    cMoonbeam_runtimeXcm_configTransactors,
    u16,
    cPallet_xcm_transactorPalletCurrencyPayment,
    _bytesSeq,
    cPallet_xcm_transactorPalletTransactWeights,
    bool,
  )

type IcPallet_xcm_transactorPalletCallTransact_through_sovereignTupled = [
  Dest: IcXcmVersionedMultiLocation,
  Fee_payer: Icdc1,
  Fee: IcPallet_xcm_transactorPalletCurrencyPayment,
  Call: I_bytesSeq,
  Origin_kind: IcXcmV2OriginKind,
  Weight_info: IcPallet_xcm_transactorPalletTransactWeights,
  Refund: boolean,
]
const cPallet_xcm_transactorPalletCallTransact_through_sovereignTupled: Codec<IcPallet_xcm_transactorPalletCallTransact_through_sovereignTupled> =
  Tuple(
    cXcmVersionedMultiLocation,
    cdc1,
    cPallet_xcm_transactorPalletCurrencyPayment,
    _bytesSeq,
    cXcmV2OriginKind,
    cPallet_xcm_transactorPalletTransactWeights,
    bool,
  )

type IcPallet_xcm_transactorPalletCallSet_transact_infoTupled = [
  Location: IcXcmVersionedMultiLocation,
  Transact_extra_weight: IcSp_weightsWeight_v2Weight,
  Max_weight: IcSp_weightsWeight_v2Weight,
  Transact_extra_weight_signed: IcOption,
]
const cPallet_xcm_transactorPalletCallSet_transact_infoTupled: Codec<IcPallet_xcm_transactorPalletCallSet_transact_infoTupled> =
  Tuple(
    cXcmVersionedMultiLocation,
    cSp_weightsWeight_v2Weight,
    cSp_weightsWeight_v2Weight,
    cOption,
  )

type IcPallet_xcm_transactorPalletCallRemove_transact_infoTupled = [
  Location: IcXcmVersionedMultiLocation,
]
const cPallet_xcm_transactorPalletCallRemove_transact_infoTupled: Codec<IcPallet_xcm_transactorPalletCallRemove_transact_infoTupled> =
  Tuple(cXcmVersionedMultiLocation)

type IcPallet_xcm_transactorPalletCallTransact_through_signedTupled = [
  Dest: IcXcmVersionedMultiLocation,
  Fee: IcPallet_xcm_transactorPalletCurrencyPayment,
  Call: I_bytesSeq,
  Weight_info: IcPallet_xcm_transactorPalletTransactWeights,
  Refund: boolean,
]
const cPallet_xcm_transactorPalletCallTransact_through_signedTupled: Codec<IcPallet_xcm_transactorPalletCallTransact_through_signedTupled> =
  Tuple(
    cXcmVersionedMultiLocation,
    cPallet_xcm_transactorPalletCurrencyPayment,
    _bytesSeq,
    cPallet_xcm_transactorPalletTransactWeights,
    bool,
  )

type IcPallet_xcm_transactorPalletCallSet_fee_per_secondTupled = [
  Asset_location: IcXcmVersionedMultiLocation,
  Fee_per_second: bigint,
]
const cPallet_xcm_transactorPalletCallSet_fee_per_secondTupled: Codec<IcPallet_xcm_transactorPalletCallSet_fee_per_secondTupled> =
  Tuple(cXcmVersionedMultiLocation, u128)

type IcPallet_xcm_transactorPalletCallRemove_fee_per_secondTupled = [
  Asset_location: IcXcmVersionedMultiLocation,
]
const cPallet_xcm_transactorPalletCallRemove_fee_per_secondTupled: Codec<IcPallet_xcm_transactorPalletCallRemove_fee_per_secondTupled> =
  Tuple(cXcmVersionedMultiLocation)

type IcPallet_xcm_transactorPalletCallHrmp_manageTupled = [
  Action: IcPallet_xcm_transactorPalletHrmpOperation,
  Fee: IcPallet_xcm_transactorPalletCurrencyPayment,
  Weight_info: IcPallet_xcm_transactorPalletTransactWeights,
]
const cPallet_xcm_transactorPalletCallHrmp_manageTupled: Codec<IcPallet_xcm_transactorPalletCallHrmp_manageTupled> =
  Tuple(
    cPallet_xcm_transactorPalletHrmpOperation,
    cPallet_xcm_transactorPalletCurrencyPayment,
    cPallet_xcm_transactorPalletTransactWeights,
  )

type IcPallet_xcm_transactorPalletError =
  | { tag: "IndexAlreadyClaimed"; value: undefined }
  | { tag: "UnclaimedIndex"; value: undefined }
  | { tag: "NotOwner"; value: undefined }
  | { tag: "UnweighableMessage"; value: undefined }
  | { tag: "CannotReanchor"; value: undefined }
  | { tag: "AssetHasNoReserve"; value: undefined }
  | { tag: "InvalidDest"; value: undefined }
  | { tag: "NotCrossChainTransfer"; value: undefined }
  | { tag: "AssetIsNotReserveInDestination"; value: undefined }
  | { tag: "DestinationNotInvertible"; value: undefined }
  | { tag: "ErrorDelivering"; value: undefined }
  | { tag: "DispatchWeightBiggerThanTotalWeight"; value: undefined }
  | { tag: "WeightOverflow"; value: undefined }
  | { tag: "AmountOverflow"; value: undefined }
  | { tag: "TransactorInfoNotSet"; value: undefined }
  | { tag: "NotCrossChainTransferableCurrency"; value: undefined }
  | { tag: "XcmExecuteError"; value: undefined }
  | { tag: "BadVersion"; value: undefined }
  | { tag: "MaxWeightTransactReached"; value: undefined }
  | { tag: "UnableToWithdrawAsset"; value: undefined }
  | { tag: "FeePerSecondNotSet"; value: undefined }
  | { tag: "SignedTransactNotAllowedForDestination"; value: undefined }
  | { tag: "FailedMultiLocationToJunction"; value: undefined }
  | { tag: "HrmpHandlerNotImplemented"; value: undefined }
  | { tag: "TooMuchFeeUsed"; value: undefined }
  | { tag: "ErrorValidating"; value: undefined }
  | { tag: "RefundNotSupportedWithTransactInfo"; value: undefined }
const cPallet_xcm_transactorPalletError: Codec<IcPallet_xcm_transactorPalletError> =
  Enum({
    IndexAlreadyClaimed: _void,
    UnclaimedIndex: _void,
    NotOwner: _void,
    UnweighableMessage: _void,
    CannotReanchor: _void,
    AssetHasNoReserve: _void,
    InvalidDest: _void,
    NotCrossChainTransfer: _void,
    AssetIsNotReserveInDestination: _void,
    DestinationNotInvertible: _void,
    ErrorDelivering: _void,
    DispatchWeightBiggerThanTotalWeight: _void,
    WeightOverflow: _void,
    AmountOverflow: _void,
    TransactorInfoNotSet: _void,
    NotCrossChainTransferableCurrency: _void,
    XcmExecuteError: _void,
    BadVersion: _void,
    MaxWeightTransactReached: _void,
    UnableToWithdrawAsset: _void,
    FeePerSecondNotSet: _void,
    SignedTransactNotAllowedForDestination: _void,
    FailedMultiLocationToJunction: _void,
    HrmpHandlerNotImplemented: _void,
    TooMuchFeeUsed: _void,
    ErrorValidating: _void,
    RefundNotSupportedWithTransactInfo: _void,
  })

type IcPallet_xcm_transactorPalletErrorIndexAlreadyClaimed = undefined
const cPallet_xcm_transactorPalletErrorIndexAlreadyClaimed: Codec<IcPallet_xcm_transactorPalletErrorIndexAlreadyClaimed> =
  _void

type IcPallet_xcm_transactorPalletErrorUnclaimedIndex = undefined
const cPallet_xcm_transactorPalletErrorUnclaimedIndex: Codec<IcPallet_xcm_transactorPalletErrorUnclaimedIndex> =
  _void

type IcPallet_xcm_transactorPalletErrorNotOwner = undefined
const cPallet_xcm_transactorPalletErrorNotOwner: Codec<IcPallet_xcm_transactorPalletErrorNotOwner> =
  _void

type IcPallet_xcm_transactorPalletErrorUnweighableMessage = undefined
const cPallet_xcm_transactorPalletErrorUnweighableMessage: Codec<IcPallet_xcm_transactorPalletErrorUnweighableMessage> =
  _void

type IcPallet_xcm_transactorPalletErrorCannotReanchor = undefined
const cPallet_xcm_transactorPalletErrorCannotReanchor: Codec<IcPallet_xcm_transactorPalletErrorCannotReanchor> =
  _void

type IcPallet_xcm_transactorPalletErrorAssetHasNoReserve = undefined
const cPallet_xcm_transactorPalletErrorAssetHasNoReserve: Codec<IcPallet_xcm_transactorPalletErrorAssetHasNoReserve> =
  _void

type IcPallet_xcm_transactorPalletErrorInvalidDest = undefined
const cPallet_xcm_transactorPalletErrorInvalidDest: Codec<IcPallet_xcm_transactorPalletErrorInvalidDest> =
  _void

type IcPallet_xcm_transactorPalletErrorNotCrossChainTransfer = undefined
const cPallet_xcm_transactorPalletErrorNotCrossChainTransfer: Codec<IcPallet_xcm_transactorPalletErrorNotCrossChainTransfer> =
  _void

type IcPallet_xcm_transactorPalletErrorAssetIsNotReserveInDestination =
  undefined
const cPallet_xcm_transactorPalletErrorAssetIsNotReserveInDestination: Codec<IcPallet_xcm_transactorPalletErrorAssetIsNotReserveInDestination> =
  _void

type IcPallet_xcm_transactorPalletErrorDestinationNotInvertible = undefined
const cPallet_xcm_transactorPalletErrorDestinationNotInvertible: Codec<IcPallet_xcm_transactorPalletErrorDestinationNotInvertible> =
  _void

type IcPallet_xcm_transactorPalletErrorErrorDelivering = undefined
const cPallet_xcm_transactorPalletErrorErrorDelivering: Codec<IcPallet_xcm_transactorPalletErrorErrorDelivering> =
  _void

type IcPallet_xcm_transactorPalletErrorDispatchWeightBiggerThanTotalWeight =
  undefined
const cPallet_xcm_transactorPalletErrorDispatchWeightBiggerThanTotalWeight: Codec<IcPallet_xcm_transactorPalletErrorDispatchWeightBiggerThanTotalWeight> =
  _void

type IcPallet_xcm_transactorPalletErrorWeightOverflow = undefined
const cPallet_xcm_transactorPalletErrorWeightOverflow: Codec<IcPallet_xcm_transactorPalletErrorWeightOverflow> =
  _void

type IcPallet_xcm_transactorPalletErrorAmountOverflow = undefined
const cPallet_xcm_transactorPalletErrorAmountOverflow: Codec<IcPallet_xcm_transactorPalletErrorAmountOverflow> =
  _void

type IcPallet_xcm_transactorPalletErrorTransactorInfoNotSet = undefined
const cPallet_xcm_transactorPalletErrorTransactorInfoNotSet: Codec<IcPallet_xcm_transactorPalletErrorTransactorInfoNotSet> =
  _void

type IcPallet_xcm_transactorPalletErrorNotCrossChainTransferableCurrency =
  undefined
const cPallet_xcm_transactorPalletErrorNotCrossChainTransferableCurrency: Codec<IcPallet_xcm_transactorPalletErrorNotCrossChainTransferableCurrency> =
  _void

type IcPallet_xcm_transactorPalletErrorXcmExecuteError = undefined
const cPallet_xcm_transactorPalletErrorXcmExecuteError: Codec<IcPallet_xcm_transactorPalletErrorXcmExecuteError> =
  _void

type IcPallet_xcm_transactorPalletErrorBadVersion = undefined
const cPallet_xcm_transactorPalletErrorBadVersion: Codec<IcPallet_xcm_transactorPalletErrorBadVersion> =
  _void

type IcPallet_xcm_transactorPalletErrorMaxWeightTransactReached = undefined
const cPallet_xcm_transactorPalletErrorMaxWeightTransactReached: Codec<IcPallet_xcm_transactorPalletErrorMaxWeightTransactReached> =
  _void

type IcPallet_xcm_transactorPalletErrorUnableToWithdrawAsset = undefined
const cPallet_xcm_transactorPalletErrorUnableToWithdrawAsset: Codec<IcPallet_xcm_transactorPalletErrorUnableToWithdrawAsset> =
  _void

type IcPallet_xcm_transactorPalletErrorFeePerSecondNotSet = undefined
const cPallet_xcm_transactorPalletErrorFeePerSecondNotSet: Codec<IcPallet_xcm_transactorPalletErrorFeePerSecondNotSet> =
  _void

type IcPallet_xcm_transactorPalletErrorSignedTransactNotAllowedForDestination =
  undefined
const cPallet_xcm_transactorPalletErrorSignedTransactNotAllowedForDestination: Codec<IcPallet_xcm_transactorPalletErrorSignedTransactNotAllowedForDestination> =
  _void

type IcPallet_xcm_transactorPalletErrorFailedMultiLocationToJunction = undefined
const cPallet_xcm_transactorPalletErrorFailedMultiLocationToJunction: Codec<IcPallet_xcm_transactorPalletErrorFailedMultiLocationToJunction> =
  _void

type IcPallet_xcm_transactorPalletErrorHrmpHandlerNotImplemented = undefined
const cPallet_xcm_transactorPalletErrorHrmpHandlerNotImplemented: Codec<IcPallet_xcm_transactorPalletErrorHrmpHandlerNotImplemented> =
  _void

type IcPallet_xcm_transactorPalletErrorTooMuchFeeUsed = undefined
const cPallet_xcm_transactorPalletErrorTooMuchFeeUsed: Codec<IcPallet_xcm_transactorPalletErrorTooMuchFeeUsed> =
  _void

type IcPallet_xcm_transactorPalletErrorErrorValidating = undefined
const cPallet_xcm_transactorPalletErrorErrorValidating: Codec<IcPallet_xcm_transactorPalletErrorErrorValidating> =
  _void

type IcPallet_xcm_transactorPalletErrorRefundNotSupportedWithTransactInfo =
  undefined
const cPallet_xcm_transactorPalletErrorRefundNotSupportedWithTransactInfo: Codec<IcPallet_xcm_transactorPalletErrorRefundNotSupportedWithTransactInfo> =
  _void

type IcPallet_ethereum_xcmPalletCallTransactTupled = [
  Xcm_transaction: IcXcm_primitivesEthereum_xcmEthereumXcmTransaction,
]
const cPallet_ethereum_xcmPalletCallTransactTupled: Codec<IcPallet_ethereum_xcmPalletCallTransactTupled> =
  Tuple(cXcm_primitivesEthereum_xcmEthereumXcmTransaction)

type IcPallet_ethereum_xcmPalletCallTransact_through_proxyTupled = [
  Transact_as: Icdc1,
  Xcm_transaction: IcXcm_primitivesEthereum_xcmEthereumXcmTransaction,
]
const cPallet_ethereum_xcmPalletCallTransact_through_proxyTupled: Codec<IcPallet_ethereum_xcmPalletCallTransact_through_proxyTupled> =
  Tuple(cdc1, cXcm_primitivesEthereum_xcmEthereumXcmTransaction)

type IcPallet_ethereum_xcmPalletError = {
  tag: "EthereumXcmExecutionSuspended"
  value: undefined
}
const cPallet_ethereum_xcmPalletError: Codec<IcPallet_ethereum_xcmPalletError> =
  Enum({ EthereumXcmExecutionSuspended: _void })

type IcPallet_ethereum_xcmPalletErrorEthereumXcmExecutionSuspended = undefined
const cPallet_ethereum_xcmPalletErrorEthereumXcmExecutionSuspended: Codec<IcPallet_ethereum_xcmPalletErrorEthereumXcmExecutionSuspended> =
  _void

type IcPallet_randomnessTypesRequestInfoBabeEpoch = [bigint, bigint]
const cPallet_randomnessTypesRequestInfoBabeEpoch: Codec<IcPallet_randomnessTypesRequestInfoBabeEpoch> =
  Tuple(u64, u64)

type IcPallet_randomnessTypesRequestInfoLocal = [number, number]
const cPallet_randomnessTypesRequestInfoLocal: Codec<IcPallet_randomnessTypesRequestInfoLocal> =
  Tuple(u32, u32)

type IcPallet_randomnessTypesRequestInfo =
  | { tag: "BabeEpoch"; value: IcPallet_randomnessTypesRequestInfoBabeEpoch }
  | { tag: "Local"; value: IcPallet_randomnessTypesRequestInfoLocal }
const cPallet_randomnessTypesRequestInfo: Codec<IcPallet_randomnessTypesRequestInfo> =
  Enum({
    BabeEpoch: cPallet_randomnessTypesRequestInfoBabeEpoch,
    Local: cPallet_randomnessTypesRequestInfoLocal,
  })

type IcPallet_randomnessTypesRequest = {
  refund_address: Icdc1
  contract_address: Icdc1
  fee: bigint
  gas_limit: bigint
  num_words: number
  salt: Icdc13
  info: IcPallet_randomnessTypesRequestInfo
}
const cPallet_randomnessTypesRequest: Codec<IcPallet_randomnessTypesRequest> =
  Struct({
    refund_address: cdc1,
    contract_address: cdc1,
    fee: u128,
    gas_limit: u64,
    num_words: u8,
    salt: cdc13,
    info: cPallet_randomnessTypesRequestInfo,
  })

type IcPallet_randomnessTypesRequestState = {
  request: IcPallet_randomnessTypesRequest
  deposit: bigint
}
const cPallet_randomnessTypesRequestState: Codec<IcPallet_randomnessTypesRequestState> =
  Struct({ request: cPallet_randomnessTypesRequest, deposit: u128 })

type IcPallet_randomnessTypesRandomnessResult = {
  randomness: IcOption
  request_count: bigint
}
const cPallet_randomnessTypesRandomnessResult: Codec<IcPallet_randomnessTypesRandomnessResult> =
  Struct({ randomness: cOption, request_count: u64 })

type IcPallet_randomnessTypesRequestTypeBabeEpoch = bigint
const cPallet_randomnessTypesRequestTypeBabeEpoch: Codec<IcPallet_randomnessTypesRequestTypeBabeEpoch> =
  u64

type IcPallet_randomnessTypesRequestTypeLocal = number
const cPallet_randomnessTypesRequestTypeLocal: Codec<IcPallet_randomnessTypesRequestTypeLocal> =
  u32

type IcPallet_randomnessTypesRequestType =
  | { tag: "BabeEpoch"; value: IcPallet_randomnessTypesRequestTypeBabeEpoch }
  | { tag: "Local"; value: IcPallet_randomnessTypesRequestTypeLocal }
const cPallet_randomnessTypesRequestType: Codec<IcPallet_randomnessTypesRequestType> =
  Enum({
    BabeEpoch: cPallet_randomnessTypesRequestTypeBabeEpoch,
    Local: cPallet_randomnessTypesRequestTypeLocal,
  })

type IcPallet_randomnessTypesRequestTypeTupled = [
  Key: IcPallet_randomnessTypesRequestType,
]
const cPallet_randomnessTypesRequestTypeTupled: Codec<IcPallet_randomnessTypesRequestTypeTupled> =
  Tuple(cPallet_randomnessTypesRequestType)

type IcPallet_randomnessPalletError =
  | { tag: "RequestCounterOverflowed"; value: undefined }
  | { tag: "RequestFeeOverflowed"; value: undefined }
  | { tag: "MustRequestAtLeastOneWord"; value: undefined }
  | { tag: "CannotRequestMoreWordsThanMax"; value: undefined }
  | { tag: "CannotRequestRandomnessAfterMaxDelay"; value: undefined }
  | { tag: "CannotRequestRandomnessBeforeMinDelay"; value: undefined }
  | { tag: "RequestDNE"; value: undefined }
  | { tag: "RequestCannotYetBeFulfilled"; value: undefined }
  | { tag: "OnlyRequesterCanIncreaseFee"; value: undefined }
  | { tag: "RequestHasNotExpired"; value: undefined }
  | { tag: "RandomnessResultDNE"; value: undefined }
  | { tag: "RandomnessResultNotFilled"; value: undefined }
const cPallet_randomnessPalletError: Codec<IcPallet_randomnessPalletError> =
  Enum({
    RequestCounterOverflowed: _void,
    RequestFeeOverflowed: _void,
    MustRequestAtLeastOneWord: _void,
    CannotRequestMoreWordsThanMax: _void,
    CannotRequestRandomnessAfterMaxDelay: _void,
    CannotRequestRandomnessBeforeMinDelay: _void,
    RequestDNE: _void,
    RequestCannotYetBeFulfilled: _void,
    OnlyRequesterCanIncreaseFee: _void,
    RequestHasNotExpired: _void,
    RandomnessResultDNE: _void,
    RandomnessResultNotFilled: _void,
  })

type IcPallet_randomnessPalletErrorRequestCounterOverflowed = undefined
const cPallet_randomnessPalletErrorRequestCounterOverflowed: Codec<IcPallet_randomnessPalletErrorRequestCounterOverflowed> =
  _void

type IcPallet_randomnessPalletErrorRequestFeeOverflowed = undefined
const cPallet_randomnessPalletErrorRequestFeeOverflowed: Codec<IcPallet_randomnessPalletErrorRequestFeeOverflowed> =
  _void

type IcPallet_randomnessPalletErrorMustRequestAtLeastOneWord = undefined
const cPallet_randomnessPalletErrorMustRequestAtLeastOneWord: Codec<IcPallet_randomnessPalletErrorMustRequestAtLeastOneWord> =
  _void

type IcPallet_randomnessPalletErrorCannotRequestMoreWordsThanMax = undefined
const cPallet_randomnessPalletErrorCannotRequestMoreWordsThanMax: Codec<IcPallet_randomnessPalletErrorCannotRequestMoreWordsThanMax> =
  _void

type IcPallet_randomnessPalletErrorCannotRequestRandomnessAfterMaxDelay =
  undefined
const cPallet_randomnessPalletErrorCannotRequestRandomnessAfterMaxDelay: Codec<IcPallet_randomnessPalletErrorCannotRequestRandomnessAfterMaxDelay> =
  _void

type IcPallet_randomnessPalletErrorCannotRequestRandomnessBeforeMinDelay =
  undefined
const cPallet_randomnessPalletErrorCannotRequestRandomnessBeforeMinDelay: Codec<IcPallet_randomnessPalletErrorCannotRequestRandomnessBeforeMinDelay> =
  _void

type IcPallet_randomnessPalletErrorRequestDNE = undefined
const cPallet_randomnessPalletErrorRequestDNE: Codec<IcPallet_randomnessPalletErrorRequestDNE> =
  _void

type IcPallet_randomnessPalletErrorRequestCannotYetBeFulfilled = undefined
const cPallet_randomnessPalletErrorRequestCannotYetBeFulfilled: Codec<IcPallet_randomnessPalletErrorRequestCannotYetBeFulfilled> =
  _void

type IcPallet_randomnessPalletErrorOnlyRequesterCanIncreaseFee = undefined
const cPallet_randomnessPalletErrorOnlyRequesterCanIncreaseFee: Codec<IcPallet_randomnessPalletErrorOnlyRequesterCanIncreaseFee> =
  _void

type IcPallet_randomnessPalletErrorRequestHasNotExpired = undefined
const cPallet_randomnessPalletErrorRequestHasNotExpired: Codec<IcPallet_randomnessPalletErrorRequestHasNotExpired> =
  _void

type IcPallet_randomnessPalletErrorRandomnessResultDNE = undefined
const cPallet_randomnessPalletErrorRandomnessResultDNE: Codec<IcPallet_randomnessPalletErrorRandomnessResultDNE> =
  _void

type IcPallet_randomnessPalletErrorRandomnessResultNotFilled = undefined
const cPallet_randomnessPalletErrorRandomnessResultNotFilled: Codec<IcPallet_randomnessPalletErrorRandomnessResultNotFilled> =
  _void

export type moonbeam_Storage_System_Account = {
  nonce: number
  consumers: number
  providers: number
  sufficients: number
  data: IcPallet_balancesTypesAccountData
}
export type moonbeam_Storage_System_Account_Args = [Key: Icdc1]
export type moonbeam_Storage_System_ExtrinsicCount = number
export type moonbeam_Storage_System_ExtrinsicCount_Args = []
export type moonbeam_Storage_System_BlockWeight = {
  normal: IcSp_weightsWeight_v2Weight
  operational: IcSp_weightsWeight_v2Weight
  mandatory: IcSp_weightsWeight_v2Weight
}
export type moonbeam_Storage_System_BlockWeight_Args = []
export type moonbeam_Storage_System_AllExtrinsicsLen = number
export type moonbeam_Storage_System_AllExtrinsicsLen_Args = []
export type moonbeam_Storage_System_BlockHash = HexString
export type moonbeam_Storage_System_BlockHash_Args = [Key: number]
export type moonbeam_Storage_System_ExtrinsicData = HexString
export type moonbeam_Storage_System_ExtrinsicData_Args = [Key: number]
export type moonbeam_Storage_System_Number = number
export type moonbeam_Storage_System_Number_Args = []
export type moonbeam_Storage_System_ParentHash = HexString
export type moonbeam_Storage_System_ParentHash_Args = []
export type moonbeam_Storage_System_Digest =
  Array<IcSp_runtimeGenericDigestDigestItem>
export type moonbeam_Storage_System_Digest_Args = []
export type moonbeam_Storage_System_Events = Array<IcFrame_systemEventRecord>
export type moonbeam_Storage_System_Events_Args = []
export type moonbeam_Storage_System_EventCount = number
export type moonbeam_Storage_System_EventCount_Args = []
export type moonbeam_Storage_System_EventTopics = Array<Icdc76>
export type moonbeam_Storage_System_EventTopics_Args = [Key: Icdc13]
export type moonbeam_Storage_System_LastRuntimeUpgrade = {
  spec_version: number
  spec_name: string
}
export type moonbeam_Storage_System_LastRuntimeUpgrade_Args = []
export type moonbeam_Storage_System_UpgradedToU32RefCount = boolean
export type moonbeam_Storage_System_UpgradedToU32RefCount_Args = []
export type moonbeam_Storage_System_UpgradedToTripleRefCount = boolean
export type moonbeam_Storage_System_UpgradedToTripleRefCount_Args = []
export type moonbeam_Storage_System_ExecutionPhase =
  | { tag: "ApplyExtrinsic"; value: IcFrame_systemPhaseApplyExtrinsic }
  | { tag: "Finalization"; value: undefined }
  | { tag: "Initialization"; value: undefined }
export type moonbeam_Storage_System_ExecutionPhase_Args = []
export type moonbeam_Tx_System_remark = [Remark: I_bytesSeq]
export type moonbeam_Tx_System_set_heap_pages = [Pages: bigint]
export type moonbeam_Tx_System_set_code = [Code: I_bytesSeq]
export type moonbeam_Tx_System_set_code_without_checks = [Code: I_bytesSeq]
export type moonbeam_Tx_System_set_storage = [Items: Icdc88]
export type moonbeam_Tx_System_kill_storage = [Keys: Icdc90]
export type moonbeam_Tx_System_kill_prefix = [
  Prefix: I_bytesSeq,
  Subkeys: number,
]
export type moonbeam_Tx_System_remark_with_event = [Remark: I_bytesSeq]
export type moonbeam_Error_System_InvalidSpecName = undefined
export type moonbeam_Error_System_SpecVersionNeedsToIncrease = undefined
export type moonbeam_Error_System_FailedToExtractRuntimeVersion = undefined
export type moonbeam_Error_System_NonDefaultComposite = undefined
export type moonbeam_Error_System_NonZeroRefCount = undefined
export type moonbeam_Error_System_CallFiltered = undefined
export type moonbeam_Event_System_ExtrinsicSuccess = {
  dispatch_info: IcFrame_supportDispatchDispatchInfo
}
export type moonbeam_Event_System_ExtrinsicFailed = {
  dispatch_error: IcSp_runtimeDispatchError
  dispatch_info: IcFrame_supportDispatchDispatchInfo
}
export type moonbeam_Event_System_CodeUpdated = undefined
export type moonbeam_Event_System_NewAccount = { account: Icdc1 }
export type moonbeam_Event_System_KilledAccount = { account: Icdc1 }
export type moonbeam_Event_System_Remarked = { sender: Icdc1; hash: Icdc13 }
export type moonbeam_Constant_System_BlockWeights = {
  base_block: IcSp_weightsWeight_v2Weight
  max_block: IcSp_weightsWeight_v2Weight
  per_class: IcFrame_supportDispatchPerDispatchClass
}
export type moonbeam_Constant_System_BlockLength = {
  normal: IcSp_weightsWeight_v2Weight
  operational: IcSp_weightsWeight_v2Weight
  mandatory: IcSp_weightsWeight_v2Weight
}
export type moonbeam_Constant_System_BlockHashCount = number
export type moonbeam_Constant_System_DbWeight = { read: bigint; write: bigint }
export type moonbeam_Constant_System_Version = {
  spec_name: string
  impl_name: string
  authoring_version: number
  spec_version: number
  impl_version: number
  apis: Icdc361
  transaction_version: number
  state_version: number
}
export type moonbeam_Constant_System_SS58Prefix = number
export type moonbeam_Storage_ParachainSystem_PendingValidationCode = HexString
export type moonbeam_Storage_ParachainSystem_PendingValidationCode_Args = []
export type moonbeam_Storage_ParachainSystem_NewValidationCode = HexString
export type moonbeam_Storage_ParachainSystem_NewValidationCode_Args = []
export type moonbeam_Storage_ParachainSystem_ValidationData = {
  parent_head: I_bytesSeq
  relay_parent_number: number
  relay_parent_storage_root: Icdc13
  max_pov_size: number
}
export type moonbeam_Storage_ParachainSystem_ValidationData_Args = []
export type moonbeam_Storage_ParachainSystem_DidSetValidationCode = boolean
export type moonbeam_Storage_ParachainSystem_DidSetValidationCode_Args = []
export type moonbeam_Storage_ParachainSystem_LastRelayChainBlockNumber = number
export type moonbeam_Storage_ParachainSystem_LastRelayChainBlockNumber_Args = []
export type moonbeam_Storage_ParachainSystem_UpgradeRestrictionSignal =
  | { tag: "None"; value: undefined }
  | { tag: "Some"; value: IcOptionSome }
export type moonbeam_Storage_ParachainSystem_UpgradeRestrictionSignal_Args = []
export type moonbeam_Storage_ParachainSystem_RelayStateProof = Array<I_bytesSeq>
export type moonbeam_Storage_ParachainSystem_RelayStateProof_Args = []
export type moonbeam_Storage_ParachainSystem_RelevantMessagingState = {
  dmq_mqc_head: Icdc13
  relay_dispatch_queue_size: IcCumulus_pallet_parachain_systemRelay_state_snapshotRelayDispachQueueSize
  ingress_channels: Icdc368
  egress_channels: Icdc368
}
export type moonbeam_Storage_ParachainSystem_RelevantMessagingState_Args = []
export type moonbeam_Storage_ParachainSystem_HostConfiguration = {
  max_code_size: number
  max_head_data_size: number
  max_upward_queue_count: number
  max_upward_queue_size: number
  max_upward_message_size: number
  max_upward_message_num_per_candidate: number
  hrmp_max_message_num_per_candidate: number
  validation_upgrade_cooldown: number
  validation_upgrade_delay: number
}
export type moonbeam_Storage_ParachainSystem_HostConfiguration_Args = []
export type moonbeam_Storage_ParachainSystem_LastDmqMqcHead = HexString
export type moonbeam_Storage_ParachainSystem_LastDmqMqcHead_Args = []
export type moonbeam_Storage_ParachainSystem_LastHrmpMqcHeads = Array<Icdc375>
export type moonbeam_Storage_ParachainSystem_LastHrmpMqcHeads_Args = []
export type moonbeam_Storage_ParachainSystem_ProcessedDownwardMessages = number
export type moonbeam_Storage_ParachainSystem_ProcessedDownwardMessages_Args = []
export type moonbeam_Storage_ParachainSystem_HrmpWatermark = number
export type moonbeam_Storage_ParachainSystem_HrmpWatermark_Args = []
export type moonbeam_Storage_ParachainSystem_HrmpOutboundMessages =
  Array<IcPolkadot_core_primitivesOutboundHrmpMessage>
export type moonbeam_Storage_ParachainSystem_HrmpOutboundMessages_Args = []
export type moonbeam_Storage_ParachainSystem_UpwardMessages = Array<I_bytesSeq>
export type moonbeam_Storage_ParachainSystem_UpwardMessages_Args = []
export type moonbeam_Storage_ParachainSystem_PendingUpwardMessages =
  Array<I_bytesSeq>
export type moonbeam_Storage_ParachainSystem_PendingUpwardMessages_Args = []
export type moonbeam_Storage_ParachainSystem_AnnouncedHrmpMessagesPerCandidate =
  number
export type moonbeam_Storage_ParachainSystem_AnnouncedHrmpMessagesPerCandidate_Args =
  []
export type moonbeam_Storage_ParachainSystem_ReservedXcmpWeightOverride = {
  ref_time: bigint
  proof_size: bigint
}
export type moonbeam_Storage_ParachainSystem_ReservedXcmpWeightOverride_Args =
  []
export type moonbeam_Storage_ParachainSystem_ReservedDmpWeightOverride = {
  ref_time: bigint
  proof_size: bigint
}
export type moonbeam_Storage_ParachainSystem_ReservedDmpWeightOverride_Args = []
export type moonbeam_Storage_ParachainSystem_AuthorizedUpgrade = {
  code_hash: Icdc13
  check_version: boolean
}
export type moonbeam_Storage_ParachainSystem_AuthorizedUpgrade_Args = []
export type moonbeam_Storage_ParachainSystem_CustomValidationHeadData =
  HexString
export type moonbeam_Storage_ParachainSystem_CustomValidationHeadData_Args = []
export type moonbeam_Tx_ParachainSystem_set_validation_data = [
  Data: IcCumulus_primitives_parachain_inherentParachainInherentData,
]
export type moonbeam_Tx_ParachainSystem_sudo_send_upward_message = [
  Message: I_bytesSeq,
]
export type moonbeam_Tx_ParachainSystem_authorize_upgrade = [
  Code_hash: Icdc13,
  Check_version: boolean,
]
export type moonbeam_Tx_ParachainSystem_enact_authorized_upgrade = [
  Code: I_bytesSeq,
]
export type moonbeam_Error_ParachainSystem_OverlappingUpgrades = undefined
export type moonbeam_Error_ParachainSystem_ProhibitedByPolkadot = undefined
export type moonbeam_Error_ParachainSystem_TooBig = undefined
export type moonbeam_Error_ParachainSystem_ValidationDataNotAvailable =
  undefined
export type moonbeam_Error_ParachainSystem_HostConfigurationNotAvailable =
  undefined
export type moonbeam_Error_ParachainSystem_NotScheduled = undefined
export type moonbeam_Error_ParachainSystem_NothingAuthorized = undefined
export type moonbeam_Error_ParachainSystem_Unauthorized = undefined
export type moonbeam_Event_ParachainSystem_ValidationFunctionStored = undefined
export type moonbeam_Event_ParachainSystem_ValidationFunctionApplied = {
  relay_chain_block_num: number
}
export type moonbeam_Event_ParachainSystem_ValidationFunctionDiscarded =
  undefined
export type moonbeam_Event_ParachainSystem_UpgradeAuthorized = {
  code_hash: Icdc13
}
export type moonbeam_Event_ParachainSystem_DownwardMessagesReceived = {
  count: number
}
export type moonbeam_Event_ParachainSystem_DownwardMessagesProcessed = {
  weight_used: IcSp_weightsWeight_v2Weight
  dmq_head: Icdc13
}
export type moonbeam_Event_ParachainSystem_UpwardMessageSent = {
  message_hash: IcOption
}
export type moonbeam_Storage_Timestamp_Now = bigint
export type moonbeam_Storage_Timestamp_Now_Args = []
export type moonbeam_Storage_Timestamp_DidUpdate = boolean
export type moonbeam_Storage_Timestamp_DidUpdate_Args = []
export type moonbeam_Tx_Timestamp_set = [Now: bigint]
export type moonbeam_Constant_Timestamp_MinimumPeriod = bigint
export type moonbeam_Storage_ParachainInfo_ParachainId = number
export type moonbeam_Storage_ParachainInfo_ParachainId_Args = []
export type moonbeam_Tx_RootTesting_fill_block = [Ratio: number]
export type moonbeam_Storage_Balances_TotalIssuance = bigint
export type moonbeam_Storage_Balances_TotalIssuance_Args = []
export type moonbeam_Storage_Balances_InactiveIssuance = bigint
export type moonbeam_Storage_Balances_InactiveIssuance_Args = []
export type moonbeam_Storage_Balances_Account = {
  free: bigint
  reserved: bigint
  frozen: bigint
  flags: bigint
}
export type moonbeam_Storage_Balances_Account_Args = [Key: Icdc1]
export type moonbeam_Storage_Balances_Locks =
  Array<IcPallet_balancesTypesBalanceLock>
export type moonbeam_Storage_Balances_Locks_Args = [Key: Icdc1]
export type moonbeam_Storage_Balances_Reserves =
  Array<IcPallet_balancesTypesReserveData>
export type moonbeam_Storage_Balances_Reserves_Args = [Key: Icdc1]
export type moonbeam_Storage_Balances_Holds =
  Array<IcPallet_balancesTypesIdAmount>
export type moonbeam_Storage_Balances_Holds_Args = [Key: Icdc1]
export type moonbeam_Storage_Balances_Freezes =
  Array<IcPallet_balancesTypesIdAmount>
export type moonbeam_Storage_Balances_Freezes_Args = [Key: Icdc1]
export type moonbeam_Tx_Balances_transfer_allow_death = [
  Dest: Icdc1,
  Value: bigint,
]
export type moonbeam_Tx_Balances_set_balance_deprecated = [
  Who: Icdc1,
  New_free: bigint,
  Old_reserved: bigint,
]
export type moonbeam_Tx_Balances_force_transfer = [
  Source: Icdc1,
  Dest: Icdc1,
  Value: bigint,
]
export type moonbeam_Tx_Balances_transfer_keep_alive = [
  Dest: Icdc1,
  Value: bigint,
]
export type moonbeam_Tx_Balances_transfer_all = [
  Dest: Icdc1,
  Keep_alive: boolean,
]
export type moonbeam_Tx_Balances_force_unreserve = [Who: Icdc1, Amount: bigint]
export type moonbeam_Tx_Balances_upgrade_accounts = [Who: Icdc109]
export type moonbeam_Tx_Balances_transfer = [Dest: Icdc1, Value: bigint]
export type moonbeam_Tx_Balances_force_set_balance = [
  Who: Icdc1,
  New_free: bigint,
]
export type moonbeam_Error_Balances_VestingBalance = undefined
export type moonbeam_Error_Balances_LiquidityRestrictions = undefined
export type moonbeam_Error_Balances_InsufficientBalance = undefined
export type moonbeam_Error_Balances_ExistentialDeposit = undefined
export type moonbeam_Error_Balances_Expendability = undefined
export type moonbeam_Error_Balances_ExistingVestingSchedule = undefined
export type moonbeam_Error_Balances_DeadAccount = undefined
export type moonbeam_Error_Balances_TooManyReserves = undefined
export type moonbeam_Error_Balances_TooManyHolds = undefined
export type moonbeam_Error_Balances_TooManyFreezes = undefined
export type moonbeam_Event_Balances_Endowed = {
  account: Icdc1
  free_balance: bigint
}
export type moonbeam_Event_Balances_DustLost = {
  account: Icdc1
  amount: bigint
}
export type moonbeam_Event_Balances_Transfer = {
  from: Icdc1
  to: Icdc1
  amount: bigint
}
export type moonbeam_Event_Balances_BalanceSet = { who: Icdc1; free: bigint }
export type moonbeam_Event_Balances_Reserved = { who: Icdc1; amount: bigint }
export type moonbeam_Event_Balances_Unreserved = { who: Icdc1; amount: bigint }
export type moonbeam_Event_Balances_ReserveRepatriated = {
  from: Icdc1
  to: Icdc1
  amount: bigint
  destination_status: IcFrame_supportTraitsTokensMiscBalanceStatus
}
export type moonbeam_Event_Balances_Deposit = { who: Icdc1; amount: bigint }
export type moonbeam_Event_Balances_Withdraw = { who: Icdc1; amount: bigint }
export type moonbeam_Event_Balances_Slashed = { who: Icdc1; amount: bigint }
export type moonbeam_Event_Balances_Minted = { who: Icdc1; amount: bigint }
export type moonbeam_Event_Balances_Burned = { who: Icdc1; amount: bigint }
export type moonbeam_Event_Balances_Suspended = { who: Icdc1; amount: bigint }
export type moonbeam_Event_Balances_Restored = { who: Icdc1; amount: bigint }
export type moonbeam_Event_Balances_Upgraded = { who: Icdc1 }
export type moonbeam_Event_Balances_Issued = { amount: bigint }
export type moonbeam_Event_Balances_Rescinded = { amount: bigint }
export type moonbeam_Event_Balances_Locked = { who: Icdc1; amount: bigint }
export type moonbeam_Event_Balances_Unlocked = { who: Icdc1; amount: bigint }
export type moonbeam_Event_Balances_Frozen = { who: Icdc1; amount: bigint }
export type moonbeam_Event_Balances_Thawed = { who: Icdc1; amount: bigint }
export type moonbeam_Constant_Balances_ExistentialDeposit = bigint
export type moonbeam_Constant_Balances_MaxLocks = number
export type moonbeam_Constant_Balances_MaxReserves = number
export type moonbeam_Constant_Balances_MaxHolds = number
export type moonbeam_Constant_Balances_MaxFreezes = number
export type moonbeam_Storage_TransactionPayment_NextFeeMultiplier = bigint
export type moonbeam_Storage_TransactionPayment_NextFeeMultiplier_Args = []
export type moonbeam_Storage_TransactionPayment_StorageVersion =
  | { tag: "V1Ancient"; value: undefined }
  | { tag: "V2"; value: undefined }
export type moonbeam_Storage_TransactionPayment_StorageVersion_Args = []
export type moonbeam_Event_TransactionPayment_TransactionFeePaid = {
  who: Icdc1
  actual_fee: bigint
  tip: bigint
}
export type moonbeam_Constant_TransactionPayment_OperationalFeeMultiplier =
  number
export type moonbeam_Storage_ParachainStaking_CollatorCommission = number
export type moonbeam_Storage_ParachainStaking_CollatorCommission_Args = []
export type moonbeam_Storage_ParachainStaking_TotalSelected = number
export type moonbeam_Storage_ParachainStaking_TotalSelected_Args = []
export type moonbeam_Storage_ParachainStaking_ParachainBondInfo = {
  account: Icdc1
  percent: number
}
export type moonbeam_Storage_ParachainStaking_ParachainBondInfo_Args = []
export type moonbeam_Storage_ParachainStaking_Round = {
  current: number
  first: number
  length: number
}
export type moonbeam_Storage_ParachainStaking_Round_Args = []
export type moonbeam_Storage_ParachainStaking_DelegatorState = {
  id: Icdc1
  delegations: Icdc398
  total: bigint
  less_total: bigint
  status: IcPallet_parachain_stakingTypesDelegatorStatus
}
export type moonbeam_Storage_ParachainStaking_DelegatorState_Args = [Key: Icdc1]
export type moonbeam_Storage_ParachainStaking_CandidateInfo = {
  bond: bigint
  delegation_count: number
  total_counted: bigint
  lowest_top_delegation_amount: bigint
  highest_bottom_delegation_amount: bigint
  lowest_bottom_delegation_amount: bigint
  top_capacity: IcPallet_parachain_stakingTypesCapacityStatus
  bottom_capacity: IcPallet_parachain_stakingTypesCapacityStatus
  request: IcOption
  status: IcPallet_parachain_stakingTypesCollatorStatus
}
export type moonbeam_Storage_ParachainStaking_CandidateInfo_Args = [Key: Icdc1]
export type moonbeam_Storage_ParachainStaking_DelegationScheduledRequests =
  Array<IcPallet_parachain_stakingDelegation_requestsScheduledRequest>
export type moonbeam_Storage_ParachainStaking_DelegationScheduledRequests_Args =
  [Key: Icdc1]
export type moonbeam_Storage_ParachainStaking_AutoCompoundingDelegations =
  Array<IcPallet_parachain_stakingAuto_compoundAutoCompoundConfig>
export type moonbeam_Storage_ParachainStaking_AutoCompoundingDelegations_Args =
  [Key: Icdc1]
export type moonbeam_Storage_ParachainStaking_TopDelegations = {
  delegations: Icdc398
  total: bigint
}
export type moonbeam_Storage_ParachainStaking_TopDelegations_Args = [Key: Icdc1]
export type moonbeam_Storage_ParachainStaking_BottomDelegations = {
  delegations: Icdc398
  total: bigint
}
export type moonbeam_Storage_ParachainStaking_BottomDelegations_Args = [
  Key: Icdc1,
]
export type moonbeam_Storage_ParachainStaking_SelectedCandidates = Array<Icdc1>
export type moonbeam_Storage_ParachainStaking_SelectedCandidates_Args = []
export type moonbeam_Storage_ParachainStaking_Total = bigint
export type moonbeam_Storage_ParachainStaking_Total_Args = []
export type moonbeam_Storage_ParachainStaking_CandidatePool =
  Array<IcPallet_parachain_stakingTypesBond>
export type moonbeam_Storage_ParachainStaking_CandidatePool_Args = []
export type moonbeam_Storage_ParachainStaking_AtStake = {
  bond: bigint
  delegations: Icdc417
  total: bigint
}
export type moonbeam_Storage_ParachainStaking_AtStake_Args = [number, Icdc1]
export type moonbeam_Storage_ParachainStaking_DelayedPayouts = {
  round_issuance: bigint
  total_staking_reward: bigint
  collator_commission: number
}
export type moonbeam_Storage_ParachainStaking_DelayedPayouts_Args = [
  Key: number,
]
export type moonbeam_Storage_ParachainStaking_Staked = bigint
export type moonbeam_Storage_ParachainStaking_Staked_Args = [Key: number]
export type moonbeam_Storage_ParachainStaking_InflationConfig = {
  expect: IcPallet_parachain_stakingInflationRange
  annual: IcPallet_parachain_stakingInflationRange
  round: IcPallet_parachain_stakingInflationRange
}
export type moonbeam_Storage_ParachainStaking_InflationConfig_Args = []
export type moonbeam_Storage_ParachainStaking_Points = number
export type moonbeam_Storage_ParachainStaking_Points_Args = [Key: number]
export type moonbeam_Storage_ParachainStaking_AwardedPts = number
export type moonbeam_Storage_ParachainStaking_AwardedPts_Args = [number, Icdc1]
export type moonbeam_Tx_ParachainStaking_set_staking_expectations = [
  Expectations: IcPallet_parachain_stakingInflationRange,
]
export type moonbeam_Tx_ParachainStaking_set_inflation = [
  Schedule: IcPallet_parachain_stakingInflationRange,
]
export type moonbeam_Tx_ParachainStaking_set_parachain_bond_account = [
  New: Icdc1,
]
export type moonbeam_Tx_ParachainStaking_set_parachain_bond_reserve_percent = [
  New: number,
]
export type moonbeam_Tx_ParachainStaking_set_total_selected = [New: number]
export type moonbeam_Tx_ParachainStaking_set_collator_commission = [New: number]
export type moonbeam_Tx_ParachainStaking_set_blocks_per_round = [New: number]
export type moonbeam_Tx_ParachainStaking_join_candidates = [
  Bond: bigint,
  Candidate_count: number,
]
export type moonbeam_Tx_ParachainStaking_schedule_leave_candidates = [
  Candidate_count: number,
]
export type moonbeam_Tx_ParachainStaking_execute_leave_candidates = [
  Candidate: Icdc1,
  Candidate_delegation_count: number,
]
export type moonbeam_Tx_ParachainStaking_cancel_leave_candidates = [
  Candidate_count: number,
]
export type moonbeam_Tx_ParachainStaking_go_offline = []
export type moonbeam_Tx_ParachainStaking_go_online = []
export type moonbeam_Tx_ParachainStaking_candidate_bond_more = [More: bigint]
export type moonbeam_Tx_ParachainStaking_schedule_candidate_bond_less = [
  Less: bigint,
]
export type moonbeam_Tx_ParachainStaking_execute_candidate_bond_less = [
  Candidate: Icdc1,
]
export type moonbeam_Tx_ParachainStaking_cancel_candidate_bond_less = []
export type moonbeam_Tx_ParachainStaking_delegate = [
  Candidate: Icdc1,
  Amount: bigint,
  Candidate_delegation_count: number,
  Delegation_count: number,
]
export type moonbeam_Tx_ParachainStaking_delegate_with_auto_compound = [
  Candidate: Icdc1,
  Amount: bigint,
  Auto_compound: number,
  Candidate_delegation_count: number,
  Candidate_auto_compounding_delegation_count: number,
  Delegation_count: number,
]
export type moonbeam_Tx_ParachainStaking_removed_call_19 = []
export type moonbeam_Tx_ParachainStaking_removed_call_20 = []
export type moonbeam_Tx_ParachainStaking_removed_call_21 = []
export type moonbeam_Tx_ParachainStaking_schedule_revoke_delegation = [
  Collator: Icdc1,
]
export type moonbeam_Tx_ParachainStaking_delegator_bond_more = [
  Candidate: Icdc1,
  More: bigint,
]
export type moonbeam_Tx_ParachainStaking_schedule_delegator_bond_less = [
  Candidate: Icdc1,
  Less: bigint,
]
export type moonbeam_Tx_ParachainStaking_execute_delegation_request = [
  Delegator: Icdc1,
  Candidate: Icdc1,
]
export type moonbeam_Tx_ParachainStaking_cancel_delegation_request = [
  Candidate: Icdc1,
]
export type moonbeam_Tx_ParachainStaking_set_auto_compound = [
  Candidate: Icdc1,
  Value: number,
  Candidate_auto_compounding_delegation_count_hint: number,
  Delegation_count_hint: number,
]
export type moonbeam_Tx_ParachainStaking_hotfix_remove_delegation_requests_exited_candidates =
  [Candidates: Icdc109]
export type moonbeam_Error_ParachainStaking_DelegatorDNE = undefined
export type moonbeam_Error_ParachainStaking_DelegatorDNEinTopNorBottom =
  undefined
export type moonbeam_Error_ParachainStaking_DelegatorDNEInDelegatorSet =
  undefined
export type moonbeam_Error_ParachainStaking_CandidateDNE = undefined
export type moonbeam_Error_ParachainStaking_DelegationDNE = undefined
export type moonbeam_Error_ParachainStaking_DelegatorExists = undefined
export type moonbeam_Error_ParachainStaking_CandidateExists = undefined
export type moonbeam_Error_ParachainStaking_CandidateBondBelowMin = undefined
export type moonbeam_Error_ParachainStaking_InsufficientBalance = undefined
export type moonbeam_Error_ParachainStaking_DelegatorBondBelowMin = undefined
export type moonbeam_Error_ParachainStaking_DelegationBelowMin = undefined
export type moonbeam_Error_ParachainStaking_AlreadyOffline = undefined
export type moonbeam_Error_ParachainStaking_AlreadyActive = undefined
export type moonbeam_Error_ParachainStaking_DelegatorAlreadyLeaving = undefined
export type moonbeam_Error_ParachainStaking_DelegatorNotLeaving = undefined
export type moonbeam_Error_ParachainStaking_DelegatorCannotLeaveYet = undefined
export type moonbeam_Error_ParachainStaking_CannotDelegateIfLeaving = undefined
export type moonbeam_Error_ParachainStaking_CandidateAlreadyLeaving = undefined
export type moonbeam_Error_ParachainStaking_CandidateNotLeaving = undefined
export type moonbeam_Error_ParachainStaking_CandidateCannotLeaveYet = undefined
export type moonbeam_Error_ParachainStaking_CannotGoOnlineIfLeaving = undefined
export type moonbeam_Error_ParachainStaking_ExceedMaxDelegationsPerDelegator =
  undefined
export type moonbeam_Error_ParachainStaking_AlreadyDelegatedCandidate =
  undefined
export type moonbeam_Error_ParachainStaking_InvalidSchedule = undefined
export type moonbeam_Error_ParachainStaking_CannotSetBelowMin = undefined
export type moonbeam_Error_ParachainStaking_RoundLengthMustBeGreaterThanTotalSelectedCollators =
  undefined
export type moonbeam_Error_ParachainStaking_NoWritingSameValue = undefined
export type moonbeam_Error_ParachainStaking_TooLowCandidateCountWeightHintJoinCandidates =
  undefined
export type moonbeam_Error_ParachainStaking_TooLowCandidateCountWeightHintCancelLeaveCandidates =
  undefined
export type moonbeam_Error_ParachainStaking_TooLowCandidateCountToLeaveCandidates =
  undefined
export type moonbeam_Error_ParachainStaking_TooLowDelegationCountToDelegate =
  undefined
export type moonbeam_Error_ParachainStaking_TooLowCandidateDelegationCountToDelegate =
  undefined
export type moonbeam_Error_ParachainStaking_TooLowCandidateDelegationCountToLeaveCandidates =
  undefined
export type moonbeam_Error_ParachainStaking_TooLowDelegationCountToLeaveDelegators =
  undefined
export type moonbeam_Error_ParachainStaking_PendingCandidateRequestsDNE =
  undefined
export type moonbeam_Error_ParachainStaking_PendingCandidateRequestAlreadyExists =
  undefined
export type moonbeam_Error_ParachainStaking_PendingCandidateRequestNotDueYet =
  undefined
export type moonbeam_Error_ParachainStaking_PendingDelegationRequestDNE =
  undefined
export type moonbeam_Error_ParachainStaking_PendingDelegationRequestAlreadyExists =
  undefined
export type moonbeam_Error_ParachainStaking_PendingDelegationRequestNotDueYet =
  undefined
export type moonbeam_Error_ParachainStaking_CannotDelegateLessThanOrEqualToLowestBottomWhenFull =
  undefined
export type moonbeam_Error_ParachainStaking_PendingDelegationRevoke = undefined
export type moonbeam_Error_ParachainStaking_TooLowDelegationCountToAutoCompound =
  undefined
export type moonbeam_Error_ParachainStaking_TooLowCandidateAutoCompoundingDelegationCountToAutoCompound =
  undefined
export type moonbeam_Error_ParachainStaking_TooLowCandidateAutoCompoundingDelegationCountToDelegate =
  undefined
export type moonbeam_Error_ParachainStaking_TooLowCandidateAutoCompoundingDelegationCountToLeaveCandidates =
  undefined
export type moonbeam_Error_ParachainStaking_TooLowCandidateCountWeightHint =
  undefined
export type moonbeam_Error_ParachainStaking_TooLowCandidateCountWeightHintGoOffline =
  undefined
export type moonbeam_Error_ParachainStaking_CandidateLimitReached = undefined
export type moonbeam_Error_ParachainStaking_CannotSetAboveMaxCandidates =
  undefined
export type moonbeam_Error_ParachainStaking_RemovedCall = undefined
export type moonbeam_Event_ParachainStaking_NewRound = {
  starting_block: number
  round: number
  selected_collators_number: number
  total_balance: bigint
}
export type moonbeam_Event_ParachainStaking_JoinedCollatorCandidates = {
  account: Icdc1
  amount_locked: bigint
  new_total_amt_locked: bigint
}
export type moonbeam_Event_ParachainStaking_CollatorChosen = {
  round: number
  collator_account: Icdc1
  total_exposed_amount: bigint
}
export type moonbeam_Event_ParachainStaking_CandidateBondLessRequested = {
  candidate: Icdc1
  amount_to_decrease: bigint
  execute_round: number
}
export type moonbeam_Event_ParachainStaking_CandidateBondedMore = {
  candidate: Icdc1
  amount: bigint
  new_total_bond: bigint
}
export type moonbeam_Event_ParachainStaking_CandidateBondedLess = {
  candidate: Icdc1
  amount: bigint
  new_bond: bigint
}
export type moonbeam_Event_ParachainStaking_CandidateWentOffline = {
  candidate: Icdc1
}
export type moonbeam_Event_ParachainStaking_CandidateBackOnline = {
  candidate: Icdc1
}
export type moonbeam_Event_ParachainStaking_CandidateScheduledExit = {
  exit_allowed_round: number
  candidate: Icdc1
  scheduled_exit: number
}
export type moonbeam_Event_ParachainStaking_CancelledCandidateExit = {
  candidate: Icdc1
}
export type moonbeam_Event_ParachainStaking_CancelledCandidateBondLess = {
  candidate: Icdc1
  amount: bigint
  execute_round: number
}
export type moonbeam_Event_ParachainStaking_CandidateLeft = {
  ex_candidate: Icdc1
  unlocked_amount: bigint
  new_total_amt_locked: bigint
}
export type moonbeam_Event_ParachainStaking_DelegationDecreaseScheduled = {
  delegator: Icdc1
  candidate: Icdc1
  amount_to_decrease: bigint
  execute_round: number
}
export type moonbeam_Event_ParachainStaking_DelegationIncreased = {
  delegator: Icdc1
  candidate: Icdc1
  amount: bigint
  in_top: boolean
}
export type moonbeam_Event_ParachainStaking_DelegationDecreased = {
  delegator: Icdc1
  candidate: Icdc1
  amount: bigint
  in_top: boolean
}
export type moonbeam_Event_ParachainStaking_DelegatorExitScheduled = {
  round: number
  delegator: Icdc1
  scheduled_exit: number
}
export type moonbeam_Event_ParachainStaking_DelegationRevocationScheduled = {
  round: number
  delegator: Icdc1
  candidate: Icdc1
  scheduled_exit: number
}
export type moonbeam_Event_ParachainStaking_DelegatorLeft = {
  delegator: Icdc1
  unstaked_amount: bigint
}
export type moonbeam_Event_ParachainStaking_DelegationRevoked = {
  delegator: Icdc1
  candidate: Icdc1
  unstaked_amount: bigint
}
export type moonbeam_Event_ParachainStaking_DelegationKicked = {
  delegator: Icdc1
  candidate: Icdc1
  unstaked_amount: bigint
}
export type moonbeam_Event_ParachainStaking_DelegatorExitCancelled = {
  delegator: Icdc1
}
export type moonbeam_Event_ParachainStaking_CancelledDelegationRequest = {
  delegator: Icdc1
  cancelled_request: IcPallet_parachain_stakingDelegation_requestsCancelledScheduledRequest
  collator: Icdc1
}
export type moonbeam_Event_ParachainStaking_Delegation = {
  delegator: Icdc1
  locked_amount: bigint
  candidate: Icdc1
  delegator_position: IcPallet_parachain_stakingTypesDelegatorAdded
  auto_compound: number
}
export type moonbeam_Event_ParachainStaking_DelegatorLeftCandidate = {
  delegator: Icdc1
  candidate: Icdc1
  unstaked_amount: bigint
  total_candidate_staked: bigint
}
export type moonbeam_Event_ParachainStaking_Rewarded = {
  account: Icdc1
  rewards: bigint
}
export type moonbeam_Event_ParachainStaking_ReservedForParachainBond = {
  account: Icdc1
  value: bigint
}
export type moonbeam_Event_ParachainStaking_ParachainBondAccountSet = {
  old: Icdc1
  new: Icdc1
}
export type moonbeam_Event_ParachainStaking_ParachainBondReservePercentSet = {
  old: number
  new: number
}
export type moonbeam_Event_ParachainStaking_InflationSet = {
  annual_min: number
  annual_ideal: number
  annual_max: number
  round_min: number
  round_ideal: number
  round_max: number
}
export type moonbeam_Event_ParachainStaking_StakeExpectationsSet = {
  expect_min: bigint
  expect_ideal: bigint
  expect_max: bigint
}
export type moonbeam_Event_ParachainStaking_TotalSelectedSet = {
  old: number
  new: number
}
export type moonbeam_Event_ParachainStaking_CollatorCommissionSet = {
  old: number
  new: number
}
export type moonbeam_Event_ParachainStaking_BlocksPerRoundSet = {
  current_round: number
  first_block: number
  old: number
  new: number
  new_per_round_inflation_min: number
  new_per_round_inflation_ideal: number
  new_per_round_inflation_max: number
}
export type moonbeam_Event_ParachainStaking_AutoCompoundSet = {
  candidate: Icdc1
  delegator: Icdc1
  value: number
}
export type moonbeam_Event_ParachainStaking_Compounded = {
  candidate: Icdc1
  delegator: Icdc1
  amount: bigint
}
export type moonbeam_Constant_ParachainStaking_MinBlocksPerRound = number
export type moonbeam_Constant_ParachainStaking_LeaveCandidatesDelay = number
export type moonbeam_Constant_ParachainStaking_CandidateBondLessDelay = number
export type moonbeam_Constant_ParachainStaking_LeaveDelegatorsDelay = number
export type moonbeam_Constant_ParachainStaking_RevokeDelegationDelay = number
export type moonbeam_Constant_ParachainStaking_DelegationBondLessDelay = number
export type moonbeam_Constant_ParachainStaking_RewardPaymentDelay = number
export type moonbeam_Constant_ParachainStaking_MinSelectedCandidates = number
export type moonbeam_Constant_ParachainStaking_MaxTopDelegationsPerCandidate =
  number
export type moonbeam_Constant_ParachainStaking_MaxBottomDelegationsPerCandidate =
  number
export type moonbeam_Constant_ParachainStaking_MaxDelegationsPerDelegator =
  number
export type moonbeam_Constant_ParachainStaking_MinCandidateStk = bigint
export type moonbeam_Constant_ParachainStaking_MinDelegation = bigint
export type moonbeam_Constant_ParachainStaking_MaxCandidates = number
export type moonbeam_Storage_AuthorInherent_Author = HexString
export type moonbeam_Storage_AuthorInherent_Author_Args = []
export type moonbeam_Storage_AuthorInherent_HighestSlotSeen = number
export type moonbeam_Storage_AuthorInherent_HighestSlotSeen_Args = []
export type moonbeam_Tx_AuthorInherent_kick_off_authorship_validation = []
export type moonbeam_Error_AuthorInherent_AuthorAlreadySet = undefined
export type moonbeam_Error_AuthorInherent_NoAccountId = undefined
export type moonbeam_Error_AuthorInherent_CannotBeAuthor = undefined
export type moonbeam_Storage_AuthorFilter_EligibleRatio = number
export type moonbeam_Storage_AuthorFilter_EligibleRatio_Args = []
export type moonbeam_Storage_AuthorFilter_EligibleCount = number
export type moonbeam_Storage_AuthorFilter_EligibleCount_Args = []
export type moonbeam_Tx_AuthorFilter_set_eligible = [New: number]
export type moonbeam_Event_AuthorFilter_EligibleUpdated = number
export type moonbeam_Storage_AuthorMapping_MappingWithDeposit = {
  account: Icdc1
  deposit: bigint
  keys: Icdc13
}
export type moonbeam_Storage_AuthorMapping_MappingWithDeposit_Args = [
  Key: Icdc13,
]
export type moonbeam_Storage_AuthorMapping_NimbusLookup = HexString
export type moonbeam_Storage_AuthorMapping_NimbusLookup_Args = [Key: Icdc1]
export type moonbeam_Tx_AuthorMapping_add_association = [Nimbus_id: Icdc13]
export type moonbeam_Tx_AuthorMapping_update_association = [
  Old_nimbus_id: Icdc13,
  New_nimbus_id: Icdc13,
]
export type moonbeam_Tx_AuthorMapping_clear_association = [Nimbus_id: Icdc13]
export type moonbeam_Tx_AuthorMapping_remove_keys = []
export type moonbeam_Tx_AuthorMapping_set_keys = [Keys: I_bytesSeq]
export type moonbeam_Error_AuthorMapping_AssociationNotFound = undefined
export type moonbeam_Error_AuthorMapping_NotYourAssociation = undefined
export type moonbeam_Error_AuthorMapping_CannotAffordSecurityDeposit = undefined
export type moonbeam_Error_AuthorMapping_AlreadyAssociated = undefined
export type moonbeam_Error_AuthorMapping_OldAuthorIdNotFound = undefined
export type moonbeam_Error_AuthorMapping_WrongKeySize = undefined
export type moonbeam_Error_AuthorMapping_DecodeNimbusFailed = undefined
export type moonbeam_Error_AuthorMapping_DecodeKeysFailed = undefined
export type moonbeam_Event_AuthorMapping_KeysRegistered = {
  nimbus_id: Icdc13
  account_id: Icdc1
  keys: Icdc13
}
export type moonbeam_Event_AuthorMapping_KeysRemoved = {
  nimbus_id: Icdc13
  account_id: Icdc1
  keys: Icdc13
}
export type moonbeam_Event_AuthorMapping_KeysRotated = {
  new_nimbus_id: Icdc13
  account_id: Icdc1
  new_keys: Icdc13
}
export type moonbeam_Storage_MoonbeamOrbiters_AccountLookupOverride =
  | { tag: "None"; value: undefined }
  | { tag: "Some"; value: IcOptionSome }
export type moonbeam_Storage_MoonbeamOrbiters_AccountLookupOverride_Args = [
  Key: Icdc1,
]
export type moonbeam_Storage_MoonbeamOrbiters_CollatorsPool = {
  orbiters: Icdc109
  maybe_current_orbiter: IcOption
  next_orbiter: number
}
export type moonbeam_Storage_MoonbeamOrbiters_CollatorsPool_Args = [Key: Icdc1]
export type moonbeam_Storage_MoonbeamOrbiters_CounterForCollatorsPool = number
export type moonbeam_Storage_MoonbeamOrbiters_CounterForCollatorsPool_Args = []
export type moonbeam_Storage_MoonbeamOrbiters_CurrentRound = number
export type moonbeam_Storage_MoonbeamOrbiters_CurrentRound_Args = []
export type moonbeam_Storage_MoonbeamOrbiters_ForceRotation = boolean
export type moonbeam_Storage_MoonbeamOrbiters_ForceRotation_Args = []
export type moonbeam_Storage_MoonbeamOrbiters_MinOrbiterDeposit = bigint
export type moonbeam_Storage_MoonbeamOrbiters_MinOrbiterDeposit_Args = []
export type moonbeam_Storage_MoonbeamOrbiters_OrbiterPerRound = HexString
export type moonbeam_Storage_MoonbeamOrbiters_OrbiterPerRound_Args = [
  number,
  Icdc1,
]
export type moonbeam_Storage_MoonbeamOrbiters_RegisteredOrbiter = boolean
export type moonbeam_Storage_MoonbeamOrbiters_RegisteredOrbiter_Args = [
  Key: Icdc1,
]
export type moonbeam_Tx_MoonbeamOrbiters_collator_add_orbiter = [Orbiter: Icdc1]
export type moonbeam_Tx_MoonbeamOrbiters_collator_remove_orbiter = [
  Orbiter: Icdc1,
]
export type moonbeam_Tx_MoonbeamOrbiters_orbiter_leave_collator_pool = [
  Collator: Icdc1,
]
export type moonbeam_Tx_MoonbeamOrbiters_orbiter_register = []
export type moonbeam_Tx_MoonbeamOrbiters_orbiter_unregister = [
  Collators_pool_count: number,
]
export type moonbeam_Tx_MoonbeamOrbiters_add_collator = [Collator: Icdc1]
export type moonbeam_Tx_MoonbeamOrbiters_remove_collator = [Collator: Icdc1]
export type moonbeam_Error_MoonbeamOrbiters_CollatorAlreadyAdded = undefined
export type moonbeam_Error_MoonbeamOrbiters_CollatorNotFound = undefined
export type moonbeam_Error_MoonbeamOrbiters_CollatorPoolTooLarge = undefined
export type moonbeam_Error_MoonbeamOrbiters_CollatorsPoolCountTooLow = undefined
export type moonbeam_Error_MoonbeamOrbiters_MinOrbiterDepositNotSet = undefined
export type moonbeam_Error_MoonbeamOrbiters_OrbiterAlreadyInPool = undefined
export type moonbeam_Error_MoonbeamOrbiters_OrbiterDepositNotFound = undefined
export type moonbeam_Error_MoonbeamOrbiters_OrbiterNotFound = undefined
export type moonbeam_Error_MoonbeamOrbiters_OrbiterStillInAPool = undefined
export type moonbeam_Event_MoonbeamOrbiters_OrbiterJoinCollatorPool = {
  collator: Icdc1
  orbiter: Icdc1
}
export type moonbeam_Event_MoonbeamOrbiters_OrbiterLeaveCollatorPool = {
  collator: Icdc1
  orbiter: Icdc1
}
export type moonbeam_Event_MoonbeamOrbiters_OrbiterRewarded = {
  account: Icdc1
  rewards: bigint
}
export type moonbeam_Event_MoonbeamOrbiters_OrbiterRotation = {
  collator: Icdc1
  old_orbiter: IcOption
  new_orbiter: IcOption
}
export type moonbeam_Event_MoonbeamOrbiters_OrbiterRegistered = {
  account: Icdc1
  deposit: bigint
}
export type moonbeam_Event_MoonbeamOrbiters_OrbiterUnregistered = {
  account: Icdc1
}
export type moonbeam_Constant_MoonbeamOrbiters_MaxPoolSize = number
export type moonbeam_Constant_MoonbeamOrbiters_MaxRoundArchive = number
export type moonbeam_Constant_MoonbeamOrbiters_RotatePeriod = number
export type moonbeam_Tx_Utility_batch = [Calls: Icdc118]
export type moonbeam_Tx_Utility_as_derivative = [
  Index: number,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
export type moonbeam_Tx_Utility_batch_all = [Calls: Icdc118]
export type moonbeam_Tx_Utility_dispatch_as = [
  As_origin: IcMoonbeam_runtimeOriginCaller,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
export type moonbeam_Tx_Utility_force_batch = [Calls: Icdc118]
export type moonbeam_Tx_Utility_with_weight = [
  Call: IcMoonbeam_runtimeRuntimeCall,
  Weight: IcSp_weightsWeight_v2Weight,
]
export type moonbeam_Error_Utility_TooManyCalls = undefined
export type moonbeam_Event_Utility_BatchInterrupted = {
  index: number
  error: IcSp_runtimeDispatchError
}
export type moonbeam_Event_Utility_BatchCompleted = undefined
export type moonbeam_Event_Utility_BatchCompletedWithErrors = undefined
export type moonbeam_Event_Utility_ItemCompleted = undefined
export type moonbeam_Event_Utility_ItemFailed = {
  error: IcSp_runtimeDispatchError
}
export type moonbeam_Event_Utility_DispatchedAs = { result: IcResult }
export type moonbeam_Constant_Utility_batched_calls_limit = number
export type moonbeam_Storage_Proxy_Proxies = [Icdc433, bigint]
export type moonbeam_Storage_Proxy_Proxies_Args = [Key: Icdc1]
export type moonbeam_Storage_Proxy_Announcements = [Icdc437, bigint]
export type moonbeam_Storage_Proxy_Announcements_Args = [Key: Icdc1]
export type moonbeam_Tx_Proxy_proxy = [
  Real: Icdc1,
  Force_proxy_type: IcOption,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
export type moonbeam_Tx_Proxy_add_proxy = [
  Delegate: Icdc1,
  Proxy_type: IcMoonbeam_runtimeProxyType,
  Delay: number,
]
export type moonbeam_Tx_Proxy_remove_proxy = [
  Delegate: Icdc1,
  Proxy_type: IcMoonbeam_runtimeProxyType,
  Delay: number,
]
export type moonbeam_Tx_Proxy_remove_proxies = []
export type moonbeam_Tx_Proxy_create_pure = [
  Proxy_type: IcMoonbeam_runtimeProxyType,
  Delay: number,
  Index: number,
]
export type moonbeam_Tx_Proxy_kill_pure = [
  Spawner: Icdc1,
  Proxy_type: IcMoonbeam_runtimeProxyType,
  Index: number,
  Height: number,
  Ext_index: number,
]
export type moonbeam_Tx_Proxy_announce = [Real: Icdc1, Call_hash: Icdc13]
export type moonbeam_Tx_Proxy_remove_announcement = [
  Real: Icdc1,
  Call_hash: Icdc13,
]
export type moonbeam_Tx_Proxy_reject_announcement = [
  Delegate: Icdc1,
  Call_hash: Icdc13,
]
export type moonbeam_Tx_Proxy_proxy_announced = [
  Delegate: Icdc1,
  Real: Icdc1,
  Force_proxy_type: IcOption,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
export type moonbeam_Error_Proxy_TooMany = undefined
export type moonbeam_Error_Proxy_NotFound = undefined
export type moonbeam_Error_Proxy_NotProxy = undefined
export type moonbeam_Error_Proxy_Unproxyable = undefined
export type moonbeam_Error_Proxy_Duplicate = undefined
export type moonbeam_Error_Proxy_NoPermission = undefined
export type moonbeam_Error_Proxy_Unannounced = undefined
export type moonbeam_Error_Proxy_NoSelfProxy = undefined
export type moonbeam_Event_Proxy_ProxyExecuted = { result: IcResult }
export type moonbeam_Event_Proxy_PureCreated = {
  pure: Icdc1
  who: Icdc1
  proxy_type: IcMoonbeam_runtimeProxyType
  disambiguation_index: number
}
export type moonbeam_Event_Proxy_Announced = {
  real: Icdc1
  proxy: Icdc1
  call_hash: Icdc13
}
export type moonbeam_Event_Proxy_ProxyAdded = {
  delegator: Icdc1
  delegatee: Icdc1
  proxy_type: IcMoonbeam_runtimeProxyType
  delay: number
}
export type moonbeam_Event_Proxy_ProxyRemoved = {
  delegator: Icdc1
  delegatee: Icdc1
  proxy_type: IcMoonbeam_runtimeProxyType
  delay: number
}
export type moonbeam_Constant_Proxy_ProxyDepositBase = bigint
export type moonbeam_Constant_Proxy_ProxyDepositFactor = bigint
export type moonbeam_Constant_Proxy_MaxProxies = number
export type moonbeam_Constant_Proxy_MaxPending = number
export type moonbeam_Constant_Proxy_AnnouncementDepositBase = bigint
export type moonbeam_Constant_Proxy_AnnouncementDepositFactor = bigint
export type moonbeam_Storage_MaintenanceMode_MaintenanceMode = boolean
export type moonbeam_Storage_MaintenanceMode_MaintenanceMode_Args = []
export type moonbeam_Tx_MaintenanceMode_enter_maintenance_mode = []
export type moonbeam_Tx_MaintenanceMode_resume_normal_operation = []
export type moonbeam_Error_MaintenanceMode_AlreadyInMaintenanceMode = undefined
export type moonbeam_Error_MaintenanceMode_NotInMaintenanceMode = undefined
export type moonbeam_Event_MaintenanceMode_EnteredMaintenanceMode = undefined
export type moonbeam_Event_MaintenanceMode_NormalOperationResumed = undefined
export type moonbeam_Event_MaintenanceMode_FailedToSuspendIdleXcmExecution = {
  error: IcSp_runtimeDispatchError
}
export type moonbeam_Event_MaintenanceMode_FailedToResumeIdleXcmExecution = {
  error: IcSp_runtimeDispatchError
}
export type moonbeam_Storage_Identity_IdentityOf = {
  judgements: Icdc443
  deposit: bigint
  info: IcPallet_identityTypesIdentityInfo
}
export type moonbeam_Storage_Identity_IdentityOf_Args = [Key: Icdc1]
export type moonbeam_Storage_Identity_SuperOf = [
  Icdc1,
  IcPallet_identityTypesData,
]
export type moonbeam_Storage_Identity_SuperOf_Args = [Key: Icdc1]
export type moonbeam_Storage_Identity_SubsOf = [bigint, Icdc109]
export type moonbeam_Storage_Identity_SubsOf_Args = [Key: Icdc1]
export type moonbeam_Storage_Identity_Registrars = Array<IcOption>
export type moonbeam_Storage_Identity_Registrars_Args = []
export type moonbeam_Tx_Identity_add_registrar = [Account: Icdc1]
export type moonbeam_Tx_Identity_set_identity = [
  Info: IcPallet_identityTypesIdentityInfo,
]
export type moonbeam_Tx_Identity_set_subs = [Subs: Icdc179]
export type moonbeam_Tx_Identity_clear_identity = []
export type moonbeam_Tx_Identity_request_judgement = [
  Reg_index: number,
  Max_fee: bigint,
]
export type moonbeam_Tx_Identity_cancel_request = [Reg_index: number]
export type moonbeam_Tx_Identity_set_fee = [Index: number, Fee: bigint]
export type moonbeam_Tx_Identity_set_account_id = [Index: number, New: Icdc1]
export type moonbeam_Tx_Identity_set_fields = [Index: number, Fields: bigint]
export type moonbeam_Tx_Identity_provide_judgement = [
  Reg_index: number,
  Target: Icdc1,
  Judgement: IcPallet_identityTypesJudgement,
  Identity: Icdc13,
]
export type moonbeam_Tx_Identity_kill_identity = [Target: Icdc1]
export type moonbeam_Tx_Identity_add_sub = [
  Sub: Icdc1,
  Data: IcPallet_identityTypesData,
]
export type moonbeam_Tx_Identity_rename_sub = [
  Sub: Icdc1,
  Data: IcPallet_identityTypesData,
]
export type moonbeam_Tx_Identity_remove_sub = [Sub: Icdc1]
export type moonbeam_Tx_Identity_quit_sub = []
export type moonbeam_Error_Identity_TooManySubAccounts = undefined
export type moonbeam_Error_Identity_NotFound = undefined
export type moonbeam_Error_Identity_NotNamed = undefined
export type moonbeam_Error_Identity_EmptyIndex = undefined
export type moonbeam_Error_Identity_FeeChanged = undefined
export type moonbeam_Error_Identity_NoIdentity = undefined
export type moonbeam_Error_Identity_StickyJudgement = undefined
export type moonbeam_Error_Identity_JudgementGiven = undefined
export type moonbeam_Error_Identity_InvalidJudgement = undefined
export type moonbeam_Error_Identity_InvalidIndex = undefined
export type moonbeam_Error_Identity_InvalidTarget = undefined
export type moonbeam_Error_Identity_TooManyFields = undefined
export type moonbeam_Error_Identity_TooManyRegistrars = undefined
export type moonbeam_Error_Identity_AlreadyClaimed = undefined
export type moonbeam_Error_Identity_NotSub = undefined
export type moonbeam_Error_Identity_NotOwned = undefined
export type moonbeam_Error_Identity_JudgementForDifferentIdentity = undefined
export type moonbeam_Error_Identity_JudgementPaymentFailed = undefined
export type moonbeam_Event_Identity_IdentitySet = { who: Icdc1 }
export type moonbeam_Event_Identity_IdentityCleared = {
  who: Icdc1
  deposit: bigint
}
export type moonbeam_Event_Identity_IdentityKilled = {
  who: Icdc1
  deposit: bigint
}
export type moonbeam_Event_Identity_JudgementRequested = {
  who: Icdc1
  registrar_index: number
}
export type moonbeam_Event_Identity_JudgementUnrequested = {
  who: Icdc1
  registrar_index: number
}
export type moonbeam_Event_Identity_JudgementGiven = {
  target: Icdc1
  registrar_index: number
}
export type moonbeam_Event_Identity_RegistrarAdded = { registrar_index: number }
export type moonbeam_Event_Identity_SubIdentityAdded = {
  sub: Icdc1
  main: Icdc1
  deposit: bigint
}
export type moonbeam_Event_Identity_SubIdentityRemoved = {
  sub: Icdc1
  main: Icdc1
  deposit: bigint
}
export type moonbeam_Event_Identity_SubIdentityRevoked = {
  sub: Icdc1
  main: Icdc1
  deposit: bigint
}
export type moonbeam_Constant_Identity_BasicDeposit = bigint
export type moonbeam_Constant_Identity_FieldDeposit = bigint
export type moonbeam_Constant_Identity_SubAccountDeposit = bigint
export type moonbeam_Constant_Identity_MaxSubAccounts = number
export type moonbeam_Constant_Identity_MaxAdditionalFields = number
export type moonbeam_Constant_Identity_MaxRegistrars = number
export type moonbeam_Storage_Migrations_FullyUpgraded = boolean
export type moonbeam_Storage_Migrations_FullyUpgraded_Args = []
export type moonbeam_Storage_Migrations_MigrationState = boolean
export type moonbeam_Storage_Migrations_MigrationState_Args = [Key: I_bytesSeq]
export type moonbeam_Storage_Migrations_ShouldPauseXcm = boolean
export type moonbeam_Storage_Migrations_ShouldPauseXcm_Args = []
export type moonbeam_Error_Migrations_PreimageMissing = undefined
export type moonbeam_Error_Migrations_WrongUpperBound = undefined
export type moonbeam_Error_Migrations_PreimageIsTooBig = undefined
export type moonbeam_Error_Migrations_PreimageAlreadyExists = undefined
export type moonbeam_Event_Migrations_RuntimeUpgradeStarted = undefined
export type moonbeam_Event_Migrations_RuntimeUpgradeCompleted = {
  weight: IcSp_weightsWeight_v2Weight
}
export type moonbeam_Event_Migrations_MigrationStarted = {
  migration_name: I_bytesSeq
}
export type moonbeam_Event_Migrations_MigrationCompleted = {
  migration_name: I_bytesSeq
  consumed_weight: IcSp_weightsWeight_v2Weight
}
export type moonbeam_Event_Migrations_FailedToSuspendIdleXcmExecution = {
  error: IcSp_runtimeDispatchError
}
export type moonbeam_Event_Migrations_FailedToResumeIdleXcmExecution = {
  error: IcSp_runtimeDispatchError
}
export type moonbeam_Storage_Multisig_Multisigs = {
  when: IcPallet_multisigTimepoint
  deposit: bigint
  depositor: Icdc1
  approvals: Icdc109
}
export type moonbeam_Storage_Multisig_Multisigs_Args = [Icdc1, Icdc13]
export type moonbeam_Tx_Multisig_as_multi_threshold_1 = [
  Other_signatories: Icdc109,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
export type moonbeam_Tx_Multisig_as_multi = [
  Threshold: number,
  Other_signatories: Icdc109,
  Maybe_timepoint: IcOption,
  Call: IcMoonbeam_runtimeRuntimeCall,
  Max_weight: IcSp_weightsWeight_v2Weight,
]
export type moonbeam_Tx_Multisig_approve_as_multi = [
  Threshold: number,
  Other_signatories: Icdc109,
  Maybe_timepoint: IcOption,
  Call_hash: Icdc13,
  Max_weight: IcSp_weightsWeight_v2Weight,
]
export type moonbeam_Tx_Multisig_cancel_as_multi = [
  Threshold: number,
  Other_signatories: Icdc109,
  Timepoint: IcPallet_multisigTimepoint,
  Call_hash: Icdc13,
]
export type moonbeam_Error_Multisig_MinimumThreshold = undefined
export type moonbeam_Error_Multisig_AlreadyApproved = undefined
export type moonbeam_Error_Multisig_NoApprovalsNeeded = undefined
export type moonbeam_Error_Multisig_TooFewSignatories = undefined
export type moonbeam_Error_Multisig_TooManySignatories = undefined
export type moonbeam_Error_Multisig_SignatoriesOutOfOrder = undefined
export type moonbeam_Error_Multisig_SenderInSignatories = undefined
export type moonbeam_Error_Multisig_NotFound = undefined
export type moonbeam_Error_Multisig_NotOwner = undefined
export type moonbeam_Error_Multisig_NoTimepoint = undefined
export type moonbeam_Error_Multisig_WrongTimepoint = undefined
export type moonbeam_Error_Multisig_UnexpectedTimepoint = undefined
export type moonbeam_Error_Multisig_MaxWeightTooLow = undefined
export type moonbeam_Error_Multisig_AlreadyStored = undefined
export type moonbeam_Event_Multisig_NewMultisig = {
  approving: Icdc1
  multisig: Icdc1
  call_hash: Icdc13
}
export type moonbeam_Event_Multisig_MultisigApproval = {
  approving: Icdc1
  timepoint: IcPallet_multisigTimepoint
  multisig: Icdc1
  call_hash: Icdc13
}
export type moonbeam_Event_Multisig_MultisigExecuted = {
  approving: Icdc1
  timepoint: IcPallet_multisigTimepoint
  multisig: Icdc1
  call_hash: Icdc13
  result: IcResult
}
export type moonbeam_Event_Multisig_MultisigCancelled = {
  cancelling: Icdc1
  timepoint: IcPallet_multisigTimepoint
  multisig: Icdc1
  call_hash: Icdc13
}
export type moonbeam_Constant_Multisig_DepositBase = bigint
export type moonbeam_Constant_Multisig_DepositFactor = bigint
export type moonbeam_Constant_Multisig_MaxSignatories = number
export type moonbeam_Storage_EthereumChainId_ChainId = bigint
export type moonbeam_Storage_EthereumChainId_ChainId_Args = []
export type moonbeam_Storage_EVM_AccountCodes = HexString
export type moonbeam_Storage_EVM_AccountCodes_Args = [Key: Icdc1]
export type moonbeam_Storage_EVM_AccountCodesMetadata = {
  size: bigint
  hash: Icdc13
}
export type moonbeam_Storage_EVM_AccountCodesMetadata_Args = [Key: Icdc1]
export type moonbeam_Storage_EVM_AccountStorages = HexString
export type moonbeam_Storage_EVM_AccountStorages_Args = [Icdc1, Icdc13]
export type moonbeam_Tx_EVM_withdraw = [Address: Icdc1, Value: bigint]
export type moonbeam_Tx_EVM_call = [
  Source: Icdc1,
  Target: Icdc1,
  Input: I_bytesSeq,
  Value: Icdc188,
  Gas_limit: bigint,
  Max_fee_per_gas: Icdc188,
  Max_priority_fee_per_gas: IcOption,
  Nonce: IcOption,
  Access_list: Icdc190,
]
export type moonbeam_Tx_EVM_create = [
  Source: Icdc1,
  Init: I_bytesSeq,
  Value: Icdc188,
  Gas_limit: bigint,
  Max_fee_per_gas: Icdc188,
  Max_priority_fee_per_gas: IcOption,
  Nonce: IcOption,
  Access_list: Icdc190,
]
export type moonbeam_Tx_EVM_create2 = [
  Source: Icdc1,
  Init: I_bytesSeq,
  Salt: Icdc13,
  Value: Icdc188,
  Gas_limit: bigint,
  Max_fee_per_gas: Icdc188,
  Max_priority_fee_per_gas: IcOption,
  Nonce: IcOption,
  Access_list: Icdc190,
]
export type moonbeam_Error_EVM_BalanceLow = undefined
export type moonbeam_Error_EVM_FeeOverflow = undefined
export type moonbeam_Error_EVM_PaymentOverflow = undefined
export type moonbeam_Error_EVM_WithdrawFailed = undefined
export type moonbeam_Error_EVM_GasPriceTooLow = undefined
export type moonbeam_Error_EVM_InvalidNonce = undefined
export type moonbeam_Error_EVM_GasLimitTooLow = undefined
export type moonbeam_Error_EVM_GasLimitTooHigh = undefined
export type moonbeam_Error_EVM_Undefined = undefined
export type moonbeam_Error_EVM_Reentrancy = undefined
export type moonbeam_Error_EVM_TransactionMustComeFromEOA = undefined
export type moonbeam_Event_EVM_Log = { log: IcEthereumLogLog }
export type moonbeam_Event_EVM_Created = { address: Icdc1 }
export type moonbeam_Event_EVM_CreatedFailed = { address: Icdc1 }
export type moonbeam_Event_EVM_Executed = { address: Icdc1 }
export type moonbeam_Event_EVM_ExecutedFailed = { address: Icdc1 }
export type moonbeam_Storage_Ethereum_Pending = Array<Icdc460>
export type moonbeam_Storage_Ethereum_Pending_Args = []
export type moonbeam_Storage_Ethereum_CurrentBlock = {
  header: IcEthereumHeaderHeader
  transactions: Icdc471
  ommers: Icdc472
}
export type moonbeam_Storage_Ethereum_CurrentBlock_Args = []
export type moonbeam_Storage_Ethereum_CurrentReceipts =
  Array<IcEthereumReceiptReceiptV3>
export type moonbeam_Storage_Ethereum_CurrentReceipts_Args = []
export type moonbeam_Storage_Ethereum_CurrentTransactionStatuses =
  Array<IcFp_rpcTransactionStatus>
export type moonbeam_Storage_Ethereum_CurrentTransactionStatuses_Args = []
export type moonbeam_Storage_Ethereum_BlockHash = HexString
export type moonbeam_Storage_Ethereum_BlockHash_Args = [Key: Icdc188]
export type moonbeam_Tx_Ethereum_transact = [
  Transaction: IcEthereumTransactionTransactionV2,
]
export type moonbeam_Error_Ethereum_InvalidSignature = undefined
export type moonbeam_Error_Ethereum_PreLogExists = undefined
export type moonbeam_Event_Ethereum_Executed = {
  from: Icdc1
  to: Icdc1
  transaction_hash: Icdc13
  exit_reason: IcEvm_coreErrorExitReason
  extra_data: I_bytesSeq
}
export type moonbeam_Storage_Scheduler_IncompleteSince = number
export type moonbeam_Storage_Scheduler_IncompleteSince_Args = []
export type moonbeam_Storage_Scheduler_Agenda = Array<IcOption>
export type moonbeam_Storage_Scheduler_Agenda_Args = [Key: number]
export type moonbeam_Storage_Scheduler_Lookup = [number, number]
export type moonbeam_Storage_Scheduler_Lookup_Args = [Key: Icdc13]
export type moonbeam_Tx_Scheduler_schedule = [
  When: number,
  Maybe_periodic: IcOption,
  Priority: number,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
export type moonbeam_Tx_Scheduler_cancel = [When: number, Index: number]
export type moonbeam_Tx_Scheduler_schedule_named = [
  Id: Icdc13,
  When: number,
  Maybe_periodic: IcOption,
  Priority: number,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
export type moonbeam_Tx_Scheduler_cancel_named = [Id: Icdc13]
export type moonbeam_Tx_Scheduler_schedule_after = [
  After: number,
  Maybe_periodic: IcOption,
  Priority: number,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
export type moonbeam_Tx_Scheduler_schedule_named_after = [
  Id: Icdc13,
  After: number,
  Maybe_periodic: IcOption,
  Priority: number,
  Call: IcMoonbeam_runtimeRuntimeCall,
]
export type moonbeam_Error_Scheduler_FailedToSchedule = undefined
export type moonbeam_Error_Scheduler_NotFound = undefined
export type moonbeam_Error_Scheduler_TargetBlockNumberInPast = undefined
export type moonbeam_Error_Scheduler_RescheduleNoChange = undefined
export type moonbeam_Error_Scheduler_Named = undefined
export type moonbeam_Event_Scheduler_Scheduled = { when: number; index: number }
export type moonbeam_Event_Scheduler_Canceled = { when: number; index: number }
export type moonbeam_Event_Scheduler_Dispatched = {
  task: Icdc76
  id: IcOption
  result: IcResult
}
export type moonbeam_Event_Scheduler_CallUnavailable = {
  task: Icdc76
  id: IcOption
}
export type moonbeam_Event_Scheduler_PeriodicFailed = {
  task: Icdc76
  id: IcOption
}
export type moonbeam_Event_Scheduler_PermanentlyOverweight = {
  task: Icdc76
  id: IcOption
}
export type moonbeam_Constant_Scheduler_MaximumWeight = {
  ref_time: bigint
  proof_size: bigint
}
export type moonbeam_Constant_Scheduler_MaxScheduledPerBlock = number
export type moonbeam_Storage_Democracy_PublicPropCount = number
export type moonbeam_Storage_Democracy_PublicPropCount_Args = []
export type moonbeam_Storage_Democracy_PublicProps = Array<Icdc482>
export type moonbeam_Storage_Democracy_PublicProps_Args = []
export type moonbeam_Storage_Democracy_DepositOf = [Icdc109, bigint]
export type moonbeam_Storage_Democracy_DepositOf_Args = [Key: number]
export type moonbeam_Storage_Democracy_ReferendumCount = number
export type moonbeam_Storage_Democracy_ReferendumCount_Args = []
export type moonbeam_Storage_Democracy_LowestUnbaked = number
export type moonbeam_Storage_Democracy_LowestUnbaked_Args = []
export type moonbeam_Storage_Democracy_ReferendumInfoOf =
  | { tag: "Ongoing"; value: IcPallet_democracyTypesReferendumInfoOngoing }
  | { tag: "Finished"; value: IcPallet_democracyTypesReferendumInfoFinished }
export type moonbeam_Storage_Democracy_ReferendumInfoOf_Args = [Key: number]
export type moonbeam_Storage_Democracy_VotingOf =
  | { tag: "Direct"; value: IcPallet_democracyVoteVotingDirect }
  | { tag: "Delegating"; value: IcPallet_democracyVoteVotingDelegating }
export type moonbeam_Storage_Democracy_VotingOf_Args = [Key: Icdc1]
export type moonbeam_Storage_Democracy_LastTabledWasExternal = boolean
export type moonbeam_Storage_Democracy_LastTabledWasExternal_Args = []
export type moonbeam_Storage_Democracy_NextExternal = [
  IcFrame_supportTraitsPreimagesBounded,
  IcPallet_democracyVote_thresholdVoteThreshold,
]
export type moonbeam_Storage_Democracy_NextExternal_Args = []
export type moonbeam_Storage_Democracy_Blacklist = [number, Icdc109]
export type moonbeam_Storage_Democracy_Blacklist_Args = [Key: Icdc13]
export type moonbeam_Storage_Democracy_Cancellations = boolean
export type moonbeam_Storage_Democracy_Cancellations_Args = [Key: Icdc13]
export type moonbeam_Storage_Democracy_MetadataOf = HexString
export type moonbeam_Storage_Democracy_MetadataOf_Args = [
  Key: IcPallet_democracyTypesMetadataOwner,
]
export type moonbeam_Tx_Democracy_propose = [
  Proposal: IcFrame_supportTraitsPreimagesBounded,
  Value: bigint,
]
export type moonbeam_Tx_Democracy_second = [Proposal: number]
export type moonbeam_Tx_Democracy_vote = [
  Ref_index: number,
  Vote: IcPallet_democracyVoteAccountVote,
]
export type moonbeam_Tx_Democracy_emergency_cancel = [Ref_index: number]
export type moonbeam_Tx_Democracy_external_propose = [
  Proposal: IcFrame_supportTraitsPreimagesBounded,
]
export type moonbeam_Tx_Democracy_external_propose_majority = [
  Proposal: IcFrame_supportTraitsPreimagesBounded,
]
export type moonbeam_Tx_Democracy_external_propose_default = [
  Proposal: IcFrame_supportTraitsPreimagesBounded,
]
export type moonbeam_Tx_Democracy_fast_track = [
  Proposal_hash: Icdc13,
  Voting_period: number,
  Delay: number,
]
export type moonbeam_Tx_Democracy_veto_external = [Proposal_hash: Icdc13]
export type moonbeam_Tx_Democracy_cancel_referendum = [Ref_index: number]
export type moonbeam_Tx_Democracy_delegate = [
  To: Icdc1,
  Conviction: IcPallet_democracyConvictionConviction,
  Balance: bigint,
]
export type moonbeam_Tx_Democracy_undelegate = []
export type moonbeam_Tx_Democracy_clear_public_proposals = []
export type moonbeam_Tx_Democracy_unlock = [Target: Icdc1]
export type moonbeam_Tx_Democracy_remove_vote = [Index: number]
export type moonbeam_Tx_Democracy_remove_other_vote = [
  Target: Icdc1,
  Index: number,
]
export type moonbeam_Tx_Democracy_blacklist = [
  Proposal_hash: Icdc13,
  Maybe_ref_index: IcOption,
]
export type moonbeam_Tx_Democracy_cancel_proposal = [Prop_index: number]
export type moonbeam_Tx_Democracy_set_metadata = [
  Owner: IcPallet_democracyTypesMetadataOwner,
  Maybe_hash: IcOption,
]
export type moonbeam_Error_Democracy_ValueLow = undefined
export type moonbeam_Error_Democracy_ProposalMissing = undefined
export type moonbeam_Error_Democracy_AlreadyCanceled = undefined
export type moonbeam_Error_Democracy_DuplicateProposal = undefined
export type moonbeam_Error_Democracy_ProposalBlacklisted = undefined
export type moonbeam_Error_Democracy_NotSimpleMajority = undefined
export type moonbeam_Error_Democracy_InvalidHash = undefined
export type moonbeam_Error_Democracy_NoProposal = undefined
export type moonbeam_Error_Democracy_AlreadyVetoed = undefined
export type moonbeam_Error_Democracy_ReferendumInvalid = undefined
export type moonbeam_Error_Democracy_NoneWaiting = undefined
export type moonbeam_Error_Democracy_NotVoter = undefined
export type moonbeam_Error_Democracy_NoPermission = undefined
export type moonbeam_Error_Democracy_AlreadyDelegating = undefined
export type moonbeam_Error_Democracy_InsufficientFunds = undefined
export type moonbeam_Error_Democracy_NotDelegating = undefined
export type moonbeam_Error_Democracy_VotesExist = undefined
export type moonbeam_Error_Democracy_InstantNotAllowed = undefined
export type moonbeam_Error_Democracy_Nonsense = undefined
export type moonbeam_Error_Democracy_WrongUpperBound = undefined
export type moonbeam_Error_Democracy_MaxVotesReached = undefined
export type moonbeam_Error_Democracy_TooMany = undefined
export type moonbeam_Error_Democracy_VotingPeriodLow = undefined
export type moonbeam_Error_Democracy_PreimageNotExist = undefined
export type moonbeam_Event_Democracy_Proposed = {
  proposal_index: number
  deposit: bigint
}
export type moonbeam_Event_Democracy_Tabled = {
  proposal_index: number
  deposit: bigint
}
export type moonbeam_Event_Democracy_ExternalTabled = undefined
export type moonbeam_Event_Democracy_Started = {
  ref_index: number
  threshold: IcPallet_democracyVote_thresholdVoteThreshold
}
export type moonbeam_Event_Democracy_Passed = { ref_index: number }
export type moonbeam_Event_Democracy_NotPassed = { ref_index: number }
export type moonbeam_Event_Democracy_Cancelled = { ref_index: number }
export type moonbeam_Event_Democracy_Delegated = { who: Icdc1; target: Icdc1 }
export type moonbeam_Event_Democracy_Undelegated = { account: Icdc1 }
export type moonbeam_Event_Democracy_Vetoed = {
  who: Icdc1
  proposal_hash: Icdc13
  until: number
}
export type moonbeam_Event_Democracy_Blacklisted = { proposal_hash: Icdc13 }
export type moonbeam_Event_Democracy_Voted = {
  voter: Icdc1
  ref_index: number
  vote: IcPallet_democracyVoteAccountVote
}
export type moonbeam_Event_Democracy_Seconded = {
  seconder: Icdc1
  prop_index: number
}
export type moonbeam_Event_Democracy_ProposalCanceled = { prop_index: number }
export type moonbeam_Event_Democracy_MetadataSet = {
  owner: IcPallet_democracyTypesMetadataOwner
  hash: Icdc13
}
export type moonbeam_Event_Democracy_MetadataCleared = {
  owner: IcPallet_democracyTypesMetadataOwner
  hash: Icdc13
}
export type moonbeam_Event_Democracy_MetadataTransferred = {
  prev_owner: IcPallet_democracyTypesMetadataOwner
  owner: IcPallet_democracyTypesMetadataOwner
  hash: Icdc13
}
export type moonbeam_Constant_Democracy_EnactmentPeriod = number
export type moonbeam_Constant_Democracy_LaunchPeriod = number
export type moonbeam_Constant_Democracy_VotingPeriod = number
export type moonbeam_Constant_Democracy_VoteLockingPeriod = number
export type moonbeam_Constant_Democracy_MinimumDeposit = bigint
export type moonbeam_Constant_Democracy_InstantAllowed = boolean
export type moonbeam_Constant_Democracy_FastTrackVotingPeriod = number
export type moonbeam_Constant_Democracy_CooloffPeriod = number
export type moonbeam_Constant_Democracy_MaxVotes = number
export type moonbeam_Constant_Democracy_MaxProposals = number
export type moonbeam_Constant_Democracy_MaxDeposits = number
export type moonbeam_Constant_Democracy_MaxBlacklisted = number
export type moonbeam_Storage_Preimage_StatusFor =
  | { tag: "Unrequested"; value: IcPallet_preimageRequestStatusUnrequested }
  | { tag: "Requested"; value: IcPallet_preimageRequestStatusRequested }
export type moonbeam_Storage_Preimage_StatusFor_Args = [Key: Icdc13]
export type moonbeam_Storage_Preimage_PreimageFor = HexString
export type moonbeam_Storage_Preimage_PreimageFor_Args = [Key: Icdc500]
export type moonbeam_Tx_Preimage_note_preimage = [Bytes: I_bytesSeq]
export type moonbeam_Tx_Preimage_unnote_preimage = [Hash: Icdc13]
export type moonbeam_Tx_Preimage_request_preimage = [Hash: Icdc13]
export type moonbeam_Tx_Preimage_unrequest_preimage = [Hash: Icdc13]
export type moonbeam_Error_Preimage_TooBig = undefined
export type moonbeam_Error_Preimage_AlreadyNoted = undefined
export type moonbeam_Error_Preimage_NotAuthorized = undefined
export type moonbeam_Error_Preimage_NotNoted = undefined
export type moonbeam_Error_Preimage_Requested = undefined
export type moonbeam_Error_Preimage_NotRequested = undefined
export type moonbeam_Event_Preimage_Noted = { hash: Icdc13 }
export type moonbeam_Event_Preimage_Requested = { hash: Icdc13 }
export type moonbeam_Event_Preimage_Cleared = { hash: Icdc13 }
export type moonbeam_Storage_ConvictionVoting_VotingFor =
  | { tag: "Casting"; value: IcPallet_conviction_votingVoteVotingCasting }
  | { tag: "Delegating"; value: IcPallet_conviction_votingVoteVotingDelegating }
export type moonbeam_Storage_ConvictionVoting_VotingFor_Args = [Icdc1, number]
export type moonbeam_Storage_ConvictionVoting_ClassLocksFor = Array<Icdc513>
export type moonbeam_Storage_ConvictionVoting_ClassLocksFor_Args = [Key: Icdc1]
export type moonbeam_Tx_ConvictionVoting_vote = [
  Poll_index: number,
  Vote: IcPallet_conviction_votingVoteAccountVote,
]
export type moonbeam_Tx_ConvictionVoting_delegate = [
  Class: number,
  To: Icdc1,
  Conviction: IcPallet_conviction_votingConvictionConviction,
  Balance: bigint,
]
export type moonbeam_Tx_ConvictionVoting_undelegate = [Class: number]
export type moonbeam_Tx_ConvictionVoting_unlock = [Class: number, Target: Icdc1]
export type moonbeam_Tx_ConvictionVoting_remove_vote = [
  Class: IcOption,
  Index: number,
]
export type moonbeam_Tx_ConvictionVoting_remove_other_vote = [
  Target: Icdc1,
  Class: number,
  Index: number,
]
export type moonbeam_Error_ConvictionVoting_NotOngoing = undefined
export type moonbeam_Error_ConvictionVoting_NotVoter = undefined
export type moonbeam_Error_ConvictionVoting_NoPermission = undefined
export type moonbeam_Error_ConvictionVoting_NoPermissionYet = undefined
export type moonbeam_Error_ConvictionVoting_AlreadyDelegating = undefined
export type moonbeam_Error_ConvictionVoting_AlreadyVoting = undefined
export type moonbeam_Error_ConvictionVoting_InsufficientFunds = undefined
export type moonbeam_Error_ConvictionVoting_NotDelegating = undefined
export type moonbeam_Error_ConvictionVoting_Nonsense = undefined
export type moonbeam_Error_ConvictionVoting_MaxVotesReached = undefined
export type moonbeam_Error_ConvictionVoting_ClassNeeded = undefined
export type moonbeam_Error_ConvictionVoting_BadClass = undefined
export type moonbeam_Event_ConvictionVoting_Delegated = [Icdc1, Icdc1]
export type moonbeam_Event_ConvictionVoting_Undelegated = Icdc1
export type moonbeam_Constant_ConvictionVoting_MaxVotes = number
export type moonbeam_Constant_ConvictionVoting_VoteLockingPeriod = number
export type moonbeam_Storage_Referenda_ReferendumCount = number
export type moonbeam_Storage_Referenda_ReferendumCount_Args = []
export type moonbeam_Storage_Referenda_ReferendumInfoFor =
  | { tag: "Ongoing"; value: IcPallet_referendaTypesReferendumInfoOngoing }
  | { tag: "Approved"; value: IcPallet_referendaTypesReferendumInfoApproved }
  | { tag: "Rejected"; value: IcPallet_referendaTypesReferendumInfoRejected }
  | { tag: "Cancelled"; value: IcPallet_referendaTypesReferendumInfoCancelled }
  | { tag: "TimedOut"; value: IcPallet_referendaTypesReferendumInfoTimedOut }
  | { tag: "Killed"; value: IcPallet_referendaTypesReferendumInfoKilled }
export type moonbeam_Storage_Referenda_ReferendumInfoFor_Args = [Key: number]
export type moonbeam_Storage_Referenda_TrackQueue = Array<Icdc525>
export type moonbeam_Storage_Referenda_TrackQueue_Args = [Key: number]
export type moonbeam_Storage_Referenda_DecidingCount = number
export type moonbeam_Storage_Referenda_DecidingCount_Args = [Key: number]
export type moonbeam_Storage_Referenda_MetadataOf = HexString
export type moonbeam_Storage_Referenda_MetadataOf_Args = [Key: number]
export type moonbeam_Tx_Referenda_submit = [
  Proposal_origin: IcMoonbeam_runtimeOriginCaller,
  Proposal: IcFrame_supportTraitsPreimagesBounded,
  Enactment_moment: IcFrame_supportTraitsScheduleDispatchTime,
]
export type moonbeam_Tx_Referenda_place_decision_deposit = [Index: number]
export type moonbeam_Tx_Referenda_refund_decision_deposit = [Index: number]
export type moonbeam_Tx_Referenda_cancel = [Index: number]
export type moonbeam_Tx_Referenda_kill = [Index: number]
export type moonbeam_Tx_Referenda_nudge_referendum = [Index: number]
export type moonbeam_Tx_Referenda_one_fewer_deciding = [Track: number]
export type moonbeam_Tx_Referenda_refund_submission_deposit = [Index: number]
export type moonbeam_Tx_Referenda_set_metadata = [
  Index: number,
  Maybe_hash: IcOption,
]
export type moonbeam_Error_Referenda_NotOngoing = undefined
export type moonbeam_Error_Referenda_HasDeposit = undefined
export type moonbeam_Error_Referenda_BadTrack = undefined
export type moonbeam_Error_Referenda_Full = undefined
export type moonbeam_Error_Referenda_QueueEmpty = undefined
export type moonbeam_Error_Referenda_BadReferendum = undefined
export type moonbeam_Error_Referenda_NothingToDo = undefined
export type moonbeam_Error_Referenda_NoTrack = undefined
export type moonbeam_Error_Referenda_Unfinished = undefined
export type moonbeam_Error_Referenda_NoPermission = undefined
export type moonbeam_Error_Referenda_NoDeposit = undefined
export type moonbeam_Error_Referenda_BadStatus = undefined
export type moonbeam_Error_Referenda_PreimageNotExist = undefined
export type moonbeam_Event_Referenda_Submitted = {
  index: number
  track: number
  proposal: IcFrame_supportTraitsPreimagesBounded
}
export type moonbeam_Event_Referenda_DecisionDepositPlaced = {
  index: number
  who: Icdc1
  amount: bigint
}
export type moonbeam_Event_Referenda_DecisionDepositRefunded = {
  index: number
  who: Icdc1
  amount: bigint
}
export type moonbeam_Event_Referenda_DepositSlashed = {
  who: Icdc1
  amount: bigint
}
export type moonbeam_Event_Referenda_DecisionStarted = {
  index: number
  track: number
  proposal: IcFrame_supportTraitsPreimagesBounded
  tally: IcPallet_conviction_votingTypesTally
}
export type moonbeam_Event_Referenda_ConfirmStarted = { index: number }
export type moonbeam_Event_Referenda_ConfirmAborted = { index: number }
export type moonbeam_Event_Referenda_Confirmed = {
  index: number
  tally: IcPallet_conviction_votingTypesTally
}
export type moonbeam_Event_Referenda_Approved = { index: number }
export type moonbeam_Event_Referenda_Rejected = {
  index: number
  tally: IcPallet_conviction_votingTypesTally
}
export type moonbeam_Event_Referenda_TimedOut = {
  index: number
  tally: IcPallet_conviction_votingTypesTally
}
export type moonbeam_Event_Referenda_Cancelled = {
  index: number
  tally: IcPallet_conviction_votingTypesTally
}
export type moonbeam_Event_Referenda_Killed = {
  index: number
  tally: IcPallet_conviction_votingTypesTally
}
export type moonbeam_Event_Referenda_SubmissionDepositRefunded = {
  index: number
  who: Icdc1
  amount: bigint
}
export type moonbeam_Event_Referenda_MetadataSet = {
  index: number
  hash: Icdc13
}
export type moonbeam_Event_Referenda_MetadataCleared = {
  index: number
  hash: Icdc13
}
export type moonbeam_Constant_Referenda_SubmissionDeposit = bigint
export type moonbeam_Constant_Referenda_MaxQueued = number
export type moonbeam_Constant_Referenda_UndecidingTimeout = number
export type moonbeam_Constant_Referenda_AlarmInterval = number
export type moonbeam_Constant_Referenda_Tracks = Array<Icdc528>
export type moonbeam_Storage_Whitelist_WhitelistedCall = undefined
export type moonbeam_Storage_Whitelist_WhitelistedCall_Args = [Key: Icdc13]
export type moonbeam_Tx_Whitelist_whitelist_call = [Call_hash: Icdc13]
export type moonbeam_Tx_Whitelist_remove_whitelisted_call = [Call_hash: Icdc13]
export type moonbeam_Tx_Whitelist_dispatch_whitelisted_call = [
  Call_hash: Icdc13,
  Call_encoded_len: number,
  Call_weight_witness: IcSp_weightsWeight_v2Weight,
]
export type moonbeam_Tx_Whitelist_dispatch_whitelisted_call_with_preimage = [
  Call: IcMoonbeam_runtimeRuntimeCall,
]
export type moonbeam_Error_Whitelist_UnavailablePreImage = undefined
export type moonbeam_Error_Whitelist_UndecodableCall = undefined
export type moonbeam_Error_Whitelist_InvalidCallWeightWitness = undefined
export type moonbeam_Error_Whitelist_CallIsNotWhitelisted = undefined
export type moonbeam_Error_Whitelist_CallAlreadyWhitelisted = undefined
export type moonbeam_Event_Whitelist_CallWhitelisted = { call_hash: Icdc13 }
export type moonbeam_Event_Whitelist_WhitelistedCallRemoved = {
  call_hash: Icdc13
}
export type moonbeam_Event_Whitelist_WhitelistedCallDispatched = {
  call_hash: Icdc13
  result: IcResult
}
export type moonbeam_Storage_CouncilCollective_Proposals = Array<Icdc13>
export type moonbeam_Storage_CouncilCollective_Proposals_Args = []
export type moonbeam_Storage_CouncilCollective_ProposalOf =
  | { tag: "System"; value: IcMoonbeam_runtimeRuntimeCallSystem }
  | {
      tag: "ParachainSystem"
      value: IcMoonbeam_runtimeRuntimeCallParachainSystem
    }
  | { tag: "Timestamp"; value: IcMoonbeam_runtimeRuntimeCallTimestamp }
  | { tag: "RootTesting"; value: IcMoonbeam_runtimeRuntimeCallRootTesting }
  | { tag: "Balances"; value: IcMoonbeam_runtimeRuntimeCallBalances }
  | {
      tag: "ParachainStaking"
      value: IcMoonbeam_runtimeRuntimeCallParachainStaking
    }
  | {
      tag: "AuthorInherent"
      value: IcMoonbeam_runtimeRuntimeCallAuthorInherent
    }
  | { tag: "AuthorFilter"; value: IcMoonbeam_runtimeRuntimeCallAuthorFilter }
  | { tag: "AuthorMapping"; value: IcMoonbeam_runtimeRuntimeCallAuthorMapping }
  | {
      tag: "MoonbeamOrbiters"
      value: IcMoonbeam_runtimeRuntimeCallMoonbeamOrbiters
    }
  | { tag: "Utility"; value: IcMoonbeam_runtimeRuntimeCallUtility }
  | { tag: "Proxy"; value: IcMoonbeam_runtimeRuntimeCallProxy }
  | {
      tag: "MaintenanceMode"
      value: IcMoonbeam_runtimeRuntimeCallMaintenanceMode
    }
  | { tag: "Identity"; value: IcMoonbeam_runtimeRuntimeCallIdentity }
  | { tag: "Multisig"; value: IcMoonbeam_runtimeRuntimeCallMultisig }
  | { tag: "EVM"; value: IcMoonbeam_runtimeRuntimeCallEVM }
  | { tag: "Ethereum"; value: IcMoonbeam_runtimeRuntimeCallEthereum }
  | { tag: "Scheduler"; value: IcMoonbeam_runtimeRuntimeCallScheduler }
  | { tag: "Democracy"; value: IcMoonbeam_runtimeRuntimeCallDemocracy }
  | { tag: "Preimage"; value: IcMoonbeam_runtimeRuntimeCallPreimage }
  | {
      tag: "ConvictionVoting"
      value: IcMoonbeam_runtimeRuntimeCallConvictionVoting
    }
  | { tag: "Referenda"; value: IcMoonbeam_runtimeRuntimeCallReferenda }
  | { tag: "Whitelist"; value: IcMoonbeam_runtimeRuntimeCallWhitelist }
  | {
      tag: "CouncilCollective"
      value: IcMoonbeam_runtimeRuntimeCallCouncilCollective
    }
  | {
      tag: "TechCommitteeCollective"
      value: IcMoonbeam_runtimeRuntimeCallTechCommitteeCollective
    }
  | {
      tag: "TreasuryCouncilCollective"
      value: IcMoonbeam_runtimeRuntimeCallTreasuryCouncilCollective
    }
  | {
      tag: "OpenTechCommitteeCollective"
      value: IcMoonbeam_runtimeRuntimeCallOpenTechCommitteeCollective
    }
  | { tag: "Treasury"; value: IcMoonbeam_runtimeRuntimeCallTreasury }
  | {
      tag: "CrowdloanRewards"
      value: IcMoonbeam_runtimeRuntimeCallCrowdloanRewards
    }
  | { tag: "DmpQueue"; value: IcMoonbeam_runtimeRuntimeCallDmpQueue }
  | { tag: "PolkadotXcm"; value: IcMoonbeam_runtimeRuntimeCallPolkadotXcm }
  | { tag: "Assets"; value: IcMoonbeam_runtimeRuntimeCallAssets }
  | { tag: "AssetManager"; value: IcMoonbeam_runtimeRuntimeCallAssetManager }
  | { tag: "XTokens"; value: IcMoonbeam_runtimeRuntimeCallXTokens }
  | { tag: "XcmTransactor"; value: IcMoonbeam_runtimeRuntimeCallXcmTransactor }
  | { tag: "LocalAssets"; value: IcMoonbeam_runtimeRuntimeCallLocalAssets }
  | { tag: "EthereumXcm"; value: IcMoonbeam_runtimeRuntimeCallEthereumXcm }
  | { tag: "Randomness"; value: IcMoonbeam_runtimeRuntimeCallRandomness }
export type moonbeam_Storage_CouncilCollective_ProposalOf_Args = [Key: Icdc13]
export type moonbeam_Storage_CouncilCollective_Voting = {
  index: number
  threshold: number
  ayes: Icdc109
  nays: Icdc109
  end: number
}
export type moonbeam_Storage_CouncilCollective_Voting_Args = [Key: Icdc13]
export type moonbeam_Storage_CouncilCollective_ProposalCount = number
export type moonbeam_Storage_CouncilCollective_ProposalCount_Args = []
export type moonbeam_Storage_CouncilCollective_Members = Array<Icdc1>
export type moonbeam_Storage_CouncilCollective_Members_Args = []
export type moonbeam_Storage_CouncilCollective_Prime = HexString
export type moonbeam_Storage_CouncilCollective_Prime_Args = []
export type moonbeam_Tx_CouncilCollective_set_members = [
  New_members: Icdc109,
  Prime: IcOption,
  Old_count: number,
]
export type moonbeam_Tx_CouncilCollective_execute = [
  Proposal: IcMoonbeam_runtimeRuntimeCall,
  Length_bound: number,
]
export type moonbeam_Tx_CouncilCollective_propose = [
  Threshold: number,
  Proposal: IcMoonbeam_runtimeRuntimeCall,
  Length_bound: number,
]
export type moonbeam_Tx_CouncilCollective_vote = [
  Proposal: Icdc13,
  Index: number,
  Approve: boolean,
]
export type moonbeam_Tx_CouncilCollective_disapprove_proposal = [
  Proposal_hash: Icdc13,
]
export type moonbeam_Tx_CouncilCollective_close = [
  Proposal_hash: Icdc13,
  Index: number,
  Proposal_weight_bound: IcSp_weightsWeight_v2Weight,
  Length_bound: number,
]
export type moonbeam_Error_CouncilCollective_NotMember = undefined
export type moonbeam_Error_CouncilCollective_DuplicateProposal = undefined
export type moonbeam_Error_CouncilCollective_ProposalMissing = undefined
export type moonbeam_Error_CouncilCollective_WrongIndex = undefined
export type moonbeam_Error_CouncilCollective_DuplicateVote = undefined
export type moonbeam_Error_CouncilCollective_AlreadyInitialized = undefined
export type moonbeam_Error_CouncilCollective_TooEarly = undefined
export type moonbeam_Error_CouncilCollective_TooManyProposals = undefined
export type moonbeam_Error_CouncilCollective_WrongProposalWeight = undefined
export type moonbeam_Error_CouncilCollective_WrongProposalLength = undefined
export type moonbeam_Event_CouncilCollective_Proposed = {
  account: Icdc1
  proposal_index: number
  proposal_hash: Icdc13
  threshold: number
}
export type moonbeam_Event_CouncilCollective_Voted = {
  account: Icdc1
  proposal_hash: Icdc13
  voted: boolean
  yes: number
  no: number
}
export type moonbeam_Event_CouncilCollective_Approved = {
  proposal_hash: Icdc13
}
export type moonbeam_Event_CouncilCollective_Disapproved = {
  proposal_hash: Icdc13
}
export type moonbeam_Event_CouncilCollective_Executed = {
  proposal_hash: Icdc13
  result: IcResult
}
export type moonbeam_Event_CouncilCollective_MemberExecuted = {
  proposal_hash: Icdc13
  result: IcResult
}
export type moonbeam_Event_CouncilCollective_Closed = {
  proposal_hash: Icdc13
  yes: number
  no: number
}
export type moonbeam_Constant_CouncilCollective_MaxProposalWeight = {
  ref_time: bigint
  proof_size: bigint
}
export type moonbeam_Storage_TechCommitteeCollective_Proposals = Array<Icdc13>
export type moonbeam_Storage_TechCommitteeCollective_Proposals_Args = []
export type moonbeam_Storage_TechCommitteeCollective_ProposalOf =
  | { tag: "System"; value: IcMoonbeam_runtimeRuntimeCallSystem }
  | {
      tag: "ParachainSystem"
      value: IcMoonbeam_runtimeRuntimeCallParachainSystem
    }
  | { tag: "Timestamp"; value: IcMoonbeam_runtimeRuntimeCallTimestamp }
  | { tag: "RootTesting"; value: IcMoonbeam_runtimeRuntimeCallRootTesting }
  | { tag: "Balances"; value: IcMoonbeam_runtimeRuntimeCallBalances }
  | {
      tag: "ParachainStaking"
      value: IcMoonbeam_runtimeRuntimeCallParachainStaking
    }
  | {
      tag: "AuthorInherent"
      value: IcMoonbeam_runtimeRuntimeCallAuthorInherent
    }
  | { tag: "AuthorFilter"; value: IcMoonbeam_runtimeRuntimeCallAuthorFilter }
  | { tag: "AuthorMapping"; value: IcMoonbeam_runtimeRuntimeCallAuthorMapping }
  | {
      tag: "MoonbeamOrbiters"
      value: IcMoonbeam_runtimeRuntimeCallMoonbeamOrbiters
    }
  | { tag: "Utility"; value: IcMoonbeam_runtimeRuntimeCallUtility }
  | { tag: "Proxy"; value: IcMoonbeam_runtimeRuntimeCallProxy }
  | {
      tag: "MaintenanceMode"
      value: IcMoonbeam_runtimeRuntimeCallMaintenanceMode
    }
  | { tag: "Identity"; value: IcMoonbeam_runtimeRuntimeCallIdentity }
  | { tag: "Multisig"; value: IcMoonbeam_runtimeRuntimeCallMultisig }
  | { tag: "EVM"; value: IcMoonbeam_runtimeRuntimeCallEVM }
  | { tag: "Ethereum"; value: IcMoonbeam_runtimeRuntimeCallEthereum }
  | { tag: "Scheduler"; value: IcMoonbeam_runtimeRuntimeCallScheduler }
  | { tag: "Democracy"; value: IcMoonbeam_runtimeRuntimeCallDemocracy }
  | { tag: "Preimage"; value: IcMoonbeam_runtimeRuntimeCallPreimage }
  | {
      tag: "ConvictionVoting"
      value: IcMoonbeam_runtimeRuntimeCallConvictionVoting
    }
  | { tag: "Referenda"; value: IcMoonbeam_runtimeRuntimeCallReferenda }
  | { tag: "Whitelist"; value: IcMoonbeam_runtimeRuntimeCallWhitelist }
  | {
      tag: "CouncilCollective"
      value: IcMoonbeam_runtimeRuntimeCallCouncilCollective
    }
  | {
      tag: "TechCommitteeCollective"
      value: IcMoonbeam_runtimeRuntimeCallTechCommitteeCollective
    }
  | {
      tag: "TreasuryCouncilCollective"
      value: IcMoonbeam_runtimeRuntimeCallTreasuryCouncilCollective
    }
  | {
      tag: "OpenTechCommitteeCollective"
      value: IcMoonbeam_runtimeRuntimeCallOpenTechCommitteeCollective
    }
  | { tag: "Treasury"; value: IcMoonbeam_runtimeRuntimeCallTreasury }
  | {
      tag: "CrowdloanRewards"
      value: IcMoonbeam_runtimeRuntimeCallCrowdloanRewards
    }
  | { tag: "DmpQueue"; value: IcMoonbeam_runtimeRuntimeCallDmpQueue }
  | { tag: "PolkadotXcm"; value: IcMoonbeam_runtimeRuntimeCallPolkadotXcm }
  | { tag: "Assets"; value: IcMoonbeam_runtimeRuntimeCallAssets }
  | { tag: "AssetManager"; value: IcMoonbeam_runtimeRuntimeCallAssetManager }
  | { tag: "XTokens"; value: IcMoonbeam_runtimeRuntimeCallXTokens }
  | { tag: "XcmTransactor"; value: IcMoonbeam_runtimeRuntimeCallXcmTransactor }
  | { tag: "LocalAssets"; value: IcMoonbeam_runtimeRuntimeCallLocalAssets }
  | { tag: "EthereumXcm"; value: IcMoonbeam_runtimeRuntimeCallEthereumXcm }
  | { tag: "Randomness"; value: IcMoonbeam_runtimeRuntimeCallRandomness }
export type moonbeam_Storage_TechCommitteeCollective_ProposalOf_Args = [
  Key: Icdc13,
]
export type moonbeam_Storage_TechCommitteeCollective_Voting = {
  index: number
  threshold: number
  ayes: Icdc109
  nays: Icdc109
  end: number
}
export type moonbeam_Storage_TechCommitteeCollective_Voting_Args = [Key: Icdc13]
export type moonbeam_Storage_TechCommitteeCollective_ProposalCount = number
export type moonbeam_Storage_TechCommitteeCollective_ProposalCount_Args = []
export type moonbeam_Storage_TechCommitteeCollective_Members = Array<Icdc1>
export type moonbeam_Storage_TechCommitteeCollective_Members_Args = []
export type moonbeam_Storage_TechCommitteeCollective_Prime = HexString
export type moonbeam_Storage_TechCommitteeCollective_Prime_Args = []
export type moonbeam_Tx_TechCommitteeCollective_set_members = [
  New_members: Icdc109,
  Prime: IcOption,
  Old_count: number,
]
export type moonbeam_Tx_TechCommitteeCollective_execute = [
  Proposal: IcMoonbeam_runtimeRuntimeCall,
  Length_bound: number,
]
export type moonbeam_Tx_TechCommitteeCollective_propose = [
  Threshold: number,
  Proposal: IcMoonbeam_runtimeRuntimeCall,
  Length_bound: number,
]
export type moonbeam_Tx_TechCommitteeCollective_vote = [
  Proposal: Icdc13,
  Index: number,
  Approve: boolean,
]
export type moonbeam_Tx_TechCommitteeCollective_disapprove_proposal = [
  Proposal_hash: Icdc13,
]
export type moonbeam_Tx_TechCommitteeCollective_close = [
  Proposal_hash: Icdc13,
  Index: number,
  Proposal_weight_bound: IcSp_weightsWeight_v2Weight,
  Length_bound: number,
]
export type moonbeam_Error_TechCommitteeCollective_NotMember = undefined
export type moonbeam_Error_TechCommitteeCollective_DuplicateProposal = undefined
export type moonbeam_Error_TechCommitteeCollective_ProposalMissing = undefined
export type moonbeam_Error_TechCommitteeCollective_WrongIndex = undefined
export type moonbeam_Error_TechCommitteeCollective_DuplicateVote = undefined
export type moonbeam_Error_TechCommitteeCollective_AlreadyInitialized =
  undefined
export type moonbeam_Error_TechCommitteeCollective_TooEarly = undefined
export type moonbeam_Error_TechCommitteeCollective_TooManyProposals = undefined
export type moonbeam_Error_TechCommitteeCollective_WrongProposalWeight =
  undefined
export type moonbeam_Error_TechCommitteeCollective_WrongProposalLength =
  undefined
export type moonbeam_Event_TechCommitteeCollective_Proposed = {
  account: Icdc1
  proposal_index: number
  proposal_hash: Icdc13
  threshold: number
}
export type moonbeam_Event_TechCommitteeCollective_Voted = {
  account: Icdc1
  proposal_hash: Icdc13
  voted: boolean
  yes: number
  no: number
}
export type moonbeam_Event_TechCommitteeCollective_Approved = {
  proposal_hash: Icdc13
}
export type moonbeam_Event_TechCommitteeCollective_Disapproved = {
  proposal_hash: Icdc13
}
export type moonbeam_Event_TechCommitteeCollective_Executed = {
  proposal_hash: Icdc13
  result: IcResult
}
export type moonbeam_Event_TechCommitteeCollective_MemberExecuted = {
  proposal_hash: Icdc13
  result: IcResult
}
export type moonbeam_Event_TechCommitteeCollective_Closed = {
  proposal_hash: Icdc13
  yes: number
  no: number
}
export type moonbeam_Constant_TechCommitteeCollective_MaxProposalWeight = {
  ref_time: bigint
  proof_size: bigint
}
export type moonbeam_Storage_TreasuryCouncilCollective_Proposals = Array<Icdc13>
export type moonbeam_Storage_TreasuryCouncilCollective_Proposals_Args = []
export type moonbeam_Storage_TreasuryCouncilCollective_ProposalOf =
  | { tag: "System"; value: IcMoonbeam_runtimeRuntimeCallSystem }
  | {
      tag: "ParachainSystem"
      value: IcMoonbeam_runtimeRuntimeCallParachainSystem
    }
  | { tag: "Timestamp"; value: IcMoonbeam_runtimeRuntimeCallTimestamp }
  | { tag: "RootTesting"; value: IcMoonbeam_runtimeRuntimeCallRootTesting }
  | { tag: "Balances"; value: IcMoonbeam_runtimeRuntimeCallBalances }
  | {
      tag: "ParachainStaking"
      value: IcMoonbeam_runtimeRuntimeCallParachainStaking
    }
  | {
      tag: "AuthorInherent"
      value: IcMoonbeam_runtimeRuntimeCallAuthorInherent
    }
  | { tag: "AuthorFilter"; value: IcMoonbeam_runtimeRuntimeCallAuthorFilter }
  | { tag: "AuthorMapping"; value: IcMoonbeam_runtimeRuntimeCallAuthorMapping }
  | {
      tag: "MoonbeamOrbiters"
      value: IcMoonbeam_runtimeRuntimeCallMoonbeamOrbiters
    }
  | { tag: "Utility"; value: IcMoonbeam_runtimeRuntimeCallUtility }
  | { tag: "Proxy"; value: IcMoonbeam_runtimeRuntimeCallProxy }
  | {
      tag: "MaintenanceMode"
      value: IcMoonbeam_runtimeRuntimeCallMaintenanceMode
    }
  | { tag: "Identity"; value: IcMoonbeam_runtimeRuntimeCallIdentity }
  | { tag: "Multisig"; value: IcMoonbeam_runtimeRuntimeCallMultisig }
  | { tag: "EVM"; value: IcMoonbeam_runtimeRuntimeCallEVM }
  | { tag: "Ethereum"; value: IcMoonbeam_runtimeRuntimeCallEthereum }
  | { tag: "Scheduler"; value: IcMoonbeam_runtimeRuntimeCallScheduler }
  | { tag: "Democracy"; value: IcMoonbeam_runtimeRuntimeCallDemocracy }
  | { tag: "Preimage"; value: IcMoonbeam_runtimeRuntimeCallPreimage }
  | {
      tag: "ConvictionVoting"
      value: IcMoonbeam_runtimeRuntimeCallConvictionVoting
    }
  | { tag: "Referenda"; value: IcMoonbeam_runtimeRuntimeCallReferenda }
  | { tag: "Whitelist"; value: IcMoonbeam_runtimeRuntimeCallWhitelist }
  | {
      tag: "CouncilCollective"
      value: IcMoonbeam_runtimeRuntimeCallCouncilCollective
    }
  | {
      tag: "TechCommitteeCollective"
      value: IcMoonbeam_runtimeRuntimeCallTechCommitteeCollective
    }
  | {
      tag: "TreasuryCouncilCollective"
      value: IcMoonbeam_runtimeRuntimeCallTreasuryCouncilCollective
    }
  | {
      tag: "OpenTechCommitteeCollective"
      value: IcMoonbeam_runtimeRuntimeCallOpenTechCommitteeCollective
    }
  | { tag: "Treasury"; value: IcMoonbeam_runtimeRuntimeCallTreasury }
  | {
      tag: "CrowdloanRewards"
      value: IcMoonbeam_runtimeRuntimeCallCrowdloanRewards
    }
  | { tag: "DmpQueue"; value: IcMoonbeam_runtimeRuntimeCallDmpQueue }
  | { tag: "PolkadotXcm"; value: IcMoonbeam_runtimeRuntimeCallPolkadotXcm }
  | { tag: "Assets"; value: IcMoonbeam_runtimeRuntimeCallAssets }
  | { tag: "AssetManager"; value: IcMoonbeam_runtimeRuntimeCallAssetManager }
  | { tag: "XTokens"; value: IcMoonbeam_runtimeRuntimeCallXTokens }
  | { tag: "XcmTransactor"; value: IcMoonbeam_runtimeRuntimeCallXcmTransactor }
  | { tag: "LocalAssets"; value: IcMoonbeam_runtimeRuntimeCallLocalAssets }
  | { tag: "EthereumXcm"; value: IcMoonbeam_runtimeRuntimeCallEthereumXcm }
  | { tag: "Randomness"; value: IcMoonbeam_runtimeRuntimeCallRandomness }
export type moonbeam_Storage_TreasuryCouncilCollective_ProposalOf_Args = [
  Key: Icdc13,
]
export type moonbeam_Storage_TreasuryCouncilCollective_Voting = {
  index: number
  threshold: number
  ayes: Icdc109
  nays: Icdc109
  end: number
}
export type moonbeam_Storage_TreasuryCouncilCollective_Voting_Args = [
  Key: Icdc13,
]
export type moonbeam_Storage_TreasuryCouncilCollective_ProposalCount = number
export type moonbeam_Storage_TreasuryCouncilCollective_ProposalCount_Args = []
export type moonbeam_Storage_TreasuryCouncilCollective_Members = Array<Icdc1>
export type moonbeam_Storage_TreasuryCouncilCollective_Members_Args = []
export type moonbeam_Storage_TreasuryCouncilCollective_Prime = HexString
export type moonbeam_Storage_TreasuryCouncilCollective_Prime_Args = []
export type moonbeam_Tx_TreasuryCouncilCollective_set_members = [
  New_members: Icdc109,
  Prime: IcOption,
  Old_count: number,
]
export type moonbeam_Tx_TreasuryCouncilCollective_execute = [
  Proposal: IcMoonbeam_runtimeRuntimeCall,
  Length_bound: number,
]
export type moonbeam_Tx_TreasuryCouncilCollective_propose = [
  Threshold: number,
  Proposal: IcMoonbeam_runtimeRuntimeCall,
  Length_bound: number,
]
export type moonbeam_Tx_TreasuryCouncilCollective_vote = [
  Proposal: Icdc13,
  Index: number,
  Approve: boolean,
]
export type moonbeam_Tx_TreasuryCouncilCollective_disapprove_proposal = [
  Proposal_hash: Icdc13,
]
export type moonbeam_Tx_TreasuryCouncilCollective_close = [
  Proposal_hash: Icdc13,
  Index: number,
  Proposal_weight_bound: IcSp_weightsWeight_v2Weight,
  Length_bound: number,
]
export type moonbeam_Error_TreasuryCouncilCollective_NotMember = undefined
export type moonbeam_Error_TreasuryCouncilCollective_DuplicateProposal =
  undefined
export type moonbeam_Error_TreasuryCouncilCollective_ProposalMissing = undefined
export type moonbeam_Error_TreasuryCouncilCollective_WrongIndex = undefined
export type moonbeam_Error_TreasuryCouncilCollective_DuplicateVote = undefined
export type moonbeam_Error_TreasuryCouncilCollective_AlreadyInitialized =
  undefined
export type moonbeam_Error_TreasuryCouncilCollective_TooEarly = undefined
export type moonbeam_Error_TreasuryCouncilCollective_TooManyProposals =
  undefined
export type moonbeam_Error_TreasuryCouncilCollective_WrongProposalWeight =
  undefined
export type moonbeam_Error_TreasuryCouncilCollective_WrongProposalLength =
  undefined
export type moonbeam_Event_TreasuryCouncilCollective_Proposed = {
  account: Icdc1
  proposal_index: number
  proposal_hash: Icdc13
  threshold: number
}
export type moonbeam_Event_TreasuryCouncilCollective_Voted = {
  account: Icdc1
  proposal_hash: Icdc13
  voted: boolean
  yes: number
  no: number
}
export type moonbeam_Event_TreasuryCouncilCollective_Approved = {
  proposal_hash: Icdc13
}
export type moonbeam_Event_TreasuryCouncilCollective_Disapproved = {
  proposal_hash: Icdc13
}
export type moonbeam_Event_TreasuryCouncilCollective_Executed = {
  proposal_hash: Icdc13
  result: IcResult
}
export type moonbeam_Event_TreasuryCouncilCollective_MemberExecuted = {
  proposal_hash: Icdc13
  result: IcResult
}
export type moonbeam_Event_TreasuryCouncilCollective_Closed = {
  proposal_hash: Icdc13
  yes: number
  no: number
}
export type moonbeam_Constant_TreasuryCouncilCollective_MaxProposalWeight = {
  ref_time: bigint
  proof_size: bigint
}
export type moonbeam_Storage_OpenTechCommitteeCollective_Proposals =
  Array<Icdc13>
export type moonbeam_Storage_OpenTechCommitteeCollective_Proposals_Args = []
export type moonbeam_Storage_OpenTechCommitteeCollective_ProposalOf =
  | { tag: "System"; value: IcMoonbeam_runtimeRuntimeCallSystem }
  | {
      tag: "ParachainSystem"
      value: IcMoonbeam_runtimeRuntimeCallParachainSystem
    }
  | { tag: "Timestamp"; value: IcMoonbeam_runtimeRuntimeCallTimestamp }
  | { tag: "RootTesting"; value: IcMoonbeam_runtimeRuntimeCallRootTesting }
  | { tag: "Balances"; value: IcMoonbeam_runtimeRuntimeCallBalances }
  | {
      tag: "ParachainStaking"
      value: IcMoonbeam_runtimeRuntimeCallParachainStaking
    }
  | {
      tag: "AuthorInherent"
      value: IcMoonbeam_runtimeRuntimeCallAuthorInherent
    }
  | { tag: "AuthorFilter"; value: IcMoonbeam_runtimeRuntimeCallAuthorFilter }
  | { tag: "AuthorMapping"; value: IcMoonbeam_runtimeRuntimeCallAuthorMapping }
  | {
      tag: "MoonbeamOrbiters"
      value: IcMoonbeam_runtimeRuntimeCallMoonbeamOrbiters
    }
  | { tag: "Utility"; value: IcMoonbeam_runtimeRuntimeCallUtility }
  | { tag: "Proxy"; value: IcMoonbeam_runtimeRuntimeCallProxy }
  | {
      tag: "MaintenanceMode"
      value: IcMoonbeam_runtimeRuntimeCallMaintenanceMode
    }
  | { tag: "Identity"; value: IcMoonbeam_runtimeRuntimeCallIdentity }
  | { tag: "Multisig"; value: IcMoonbeam_runtimeRuntimeCallMultisig }
  | { tag: "EVM"; value: IcMoonbeam_runtimeRuntimeCallEVM }
  | { tag: "Ethereum"; value: IcMoonbeam_runtimeRuntimeCallEthereum }
  | { tag: "Scheduler"; value: IcMoonbeam_runtimeRuntimeCallScheduler }
  | { tag: "Democracy"; value: IcMoonbeam_runtimeRuntimeCallDemocracy }
  | { tag: "Preimage"; value: IcMoonbeam_runtimeRuntimeCallPreimage }
  | {
      tag: "ConvictionVoting"
      value: IcMoonbeam_runtimeRuntimeCallConvictionVoting
    }
  | { tag: "Referenda"; value: IcMoonbeam_runtimeRuntimeCallReferenda }
  | { tag: "Whitelist"; value: IcMoonbeam_runtimeRuntimeCallWhitelist }
  | {
      tag: "CouncilCollective"
      value: IcMoonbeam_runtimeRuntimeCallCouncilCollective
    }
  | {
      tag: "TechCommitteeCollective"
      value: IcMoonbeam_runtimeRuntimeCallTechCommitteeCollective
    }
  | {
      tag: "TreasuryCouncilCollective"
      value: IcMoonbeam_runtimeRuntimeCallTreasuryCouncilCollective
    }
  | {
      tag: "OpenTechCommitteeCollective"
      value: IcMoonbeam_runtimeRuntimeCallOpenTechCommitteeCollective
    }
  | { tag: "Treasury"; value: IcMoonbeam_runtimeRuntimeCallTreasury }
  | {
      tag: "CrowdloanRewards"
      value: IcMoonbeam_runtimeRuntimeCallCrowdloanRewards
    }
  | { tag: "DmpQueue"; value: IcMoonbeam_runtimeRuntimeCallDmpQueue }
  | { tag: "PolkadotXcm"; value: IcMoonbeam_runtimeRuntimeCallPolkadotXcm }
  | { tag: "Assets"; value: IcMoonbeam_runtimeRuntimeCallAssets }
  | { tag: "AssetManager"; value: IcMoonbeam_runtimeRuntimeCallAssetManager }
  | { tag: "XTokens"; value: IcMoonbeam_runtimeRuntimeCallXTokens }
  | { tag: "XcmTransactor"; value: IcMoonbeam_runtimeRuntimeCallXcmTransactor }
  | { tag: "LocalAssets"; value: IcMoonbeam_runtimeRuntimeCallLocalAssets }
  | { tag: "EthereumXcm"; value: IcMoonbeam_runtimeRuntimeCallEthereumXcm }
  | { tag: "Randomness"; value: IcMoonbeam_runtimeRuntimeCallRandomness }
export type moonbeam_Storage_OpenTechCommitteeCollective_ProposalOf_Args = [
  Key: Icdc13,
]
export type moonbeam_Storage_OpenTechCommitteeCollective_Voting = {
  index: number
  threshold: number
  ayes: Icdc109
  nays: Icdc109
  end: number
}
export type moonbeam_Storage_OpenTechCommitteeCollective_Voting_Args = [
  Key: Icdc13,
]
export type moonbeam_Storage_OpenTechCommitteeCollective_ProposalCount = number
export type moonbeam_Storage_OpenTechCommitteeCollective_ProposalCount_Args = []
export type moonbeam_Storage_OpenTechCommitteeCollective_Members = Array<Icdc1>
export type moonbeam_Storage_OpenTechCommitteeCollective_Members_Args = []
export type moonbeam_Storage_OpenTechCommitteeCollective_Prime = HexString
export type moonbeam_Storage_OpenTechCommitteeCollective_Prime_Args = []
export type moonbeam_Tx_OpenTechCommitteeCollective_set_members = [
  New_members: Icdc109,
  Prime: IcOption,
  Old_count: number,
]
export type moonbeam_Tx_OpenTechCommitteeCollective_execute = [
  Proposal: IcMoonbeam_runtimeRuntimeCall,
  Length_bound: number,
]
export type moonbeam_Tx_OpenTechCommitteeCollective_propose = [
  Threshold: number,
  Proposal: IcMoonbeam_runtimeRuntimeCall,
  Length_bound: number,
]
export type moonbeam_Tx_OpenTechCommitteeCollective_vote = [
  Proposal: Icdc13,
  Index: number,
  Approve: boolean,
]
export type moonbeam_Tx_OpenTechCommitteeCollective_disapprove_proposal = [
  Proposal_hash: Icdc13,
]
export type moonbeam_Tx_OpenTechCommitteeCollective_close = [
  Proposal_hash: Icdc13,
  Index: number,
  Proposal_weight_bound: IcSp_weightsWeight_v2Weight,
  Length_bound: number,
]
export type moonbeam_Error_OpenTechCommitteeCollective_NotMember = undefined
export type moonbeam_Error_OpenTechCommitteeCollective_DuplicateProposal =
  undefined
export type moonbeam_Error_OpenTechCommitteeCollective_ProposalMissing =
  undefined
export type moonbeam_Error_OpenTechCommitteeCollective_WrongIndex = undefined
export type moonbeam_Error_OpenTechCommitteeCollective_DuplicateVote = undefined
export type moonbeam_Error_OpenTechCommitteeCollective_AlreadyInitialized =
  undefined
export type moonbeam_Error_OpenTechCommitteeCollective_TooEarly = undefined
export type moonbeam_Error_OpenTechCommitteeCollective_TooManyProposals =
  undefined
export type moonbeam_Error_OpenTechCommitteeCollective_WrongProposalWeight =
  undefined
export type moonbeam_Error_OpenTechCommitteeCollective_WrongProposalLength =
  undefined
export type moonbeam_Event_OpenTechCommitteeCollective_Proposed = {
  account: Icdc1
  proposal_index: number
  proposal_hash: Icdc13
  threshold: number
}
export type moonbeam_Event_OpenTechCommitteeCollective_Voted = {
  account: Icdc1
  proposal_hash: Icdc13
  voted: boolean
  yes: number
  no: number
}
export type moonbeam_Event_OpenTechCommitteeCollective_Approved = {
  proposal_hash: Icdc13
}
export type moonbeam_Event_OpenTechCommitteeCollective_Disapproved = {
  proposal_hash: Icdc13
}
export type moonbeam_Event_OpenTechCommitteeCollective_Executed = {
  proposal_hash: Icdc13
  result: IcResult
}
export type moonbeam_Event_OpenTechCommitteeCollective_MemberExecuted = {
  proposal_hash: Icdc13
  result: IcResult
}
export type moonbeam_Event_OpenTechCommitteeCollective_Closed = {
  proposal_hash: Icdc13
  yes: number
  no: number
}
export type moonbeam_Constant_OpenTechCommitteeCollective_MaxProposalWeight = {
  ref_time: bigint
  proof_size: bigint
}
export type moonbeam_Storage_Treasury_ProposalCount = number
export type moonbeam_Storage_Treasury_ProposalCount_Args = []
export type moonbeam_Storage_Treasury_Proposals = {
  proposer: Icdc1
  value: bigint
  beneficiary: Icdc1
  bond: bigint
}
export type moonbeam_Storage_Treasury_Proposals_Args = [Key: number]
export type moonbeam_Storage_Treasury_Deactivated = bigint
export type moonbeam_Storage_Treasury_Deactivated_Args = []
export type moonbeam_Storage_Treasury_Approvals = Array<number>
export type moonbeam_Storage_Treasury_Approvals_Args = []
export type moonbeam_Tx_Treasury_propose_spend = [
  Value: bigint,
  Beneficiary: Icdc1,
]
export type moonbeam_Tx_Treasury_reject_proposal = [Proposal_id: number]
export type moonbeam_Tx_Treasury_approve_proposal = [Proposal_id: number]
export type moonbeam_Tx_Treasury_spend = [Amount: bigint, Beneficiary: Icdc1]
export type moonbeam_Tx_Treasury_remove_approval = [Proposal_id: number]
export type moonbeam_Error_Treasury_InsufficientProposersBalance = undefined
export type moonbeam_Error_Treasury_InvalidIndex = undefined
export type moonbeam_Error_Treasury_TooManyApprovals = undefined
export type moonbeam_Error_Treasury_InsufficientPermission = undefined
export type moonbeam_Error_Treasury_ProposalNotApproved = undefined
export type moonbeam_Event_Treasury_Proposed = { proposal_index: number }
export type moonbeam_Event_Treasury_Spending = { budget_remaining: bigint }
export type moonbeam_Event_Treasury_Awarded = {
  proposal_index: number
  award: bigint
  account: Icdc1
}
export type moonbeam_Event_Treasury_Rejected = {
  proposal_index: number
  slashed: bigint
}
export type moonbeam_Event_Treasury_Burnt = { burnt_funds: bigint }
export type moonbeam_Event_Treasury_Rollover = { rollover_balance: bigint }
export type moonbeam_Event_Treasury_Deposit = { value: bigint }
export type moonbeam_Event_Treasury_SpendApproved = {
  proposal_index: number
  amount: bigint
  beneficiary: Icdc1
}
export type moonbeam_Event_Treasury_UpdatedInactive = {
  reactivated: bigint
  deactivated: bigint
}
export type moonbeam_Constant_Treasury_ProposalBond = number
export type moonbeam_Constant_Treasury_ProposalBondMinimum = bigint
export type moonbeam_Constant_Treasury_ProposalBondMaximum =
  | { tag: "None"; value: undefined }
  | { tag: "Some"; value: IcOptionSome }
export type moonbeam_Constant_Treasury_SpendPeriod = number
export type moonbeam_Constant_Treasury_Burn = number
export type moonbeam_Constant_Treasury_PalletId = HexString
export type moonbeam_Constant_Treasury_MaxApprovals = number
export type moonbeam_Storage_CrowdloanRewards_AccountsPayable = {
  total_reward: bigint
  claimed_reward: bigint
  contributed_relay_addresses: Icdc549
}
export type moonbeam_Storage_CrowdloanRewards_AccountsPayable_Args = [
  Key: Icdc1,
]
export type moonbeam_Storage_CrowdloanRewards_ClaimedRelayChainIds = undefined
export type moonbeam_Storage_CrowdloanRewards_ClaimedRelayChainIds_Args = [
  Key: Icdc13,
]
export type moonbeam_Storage_CrowdloanRewards_UnassociatedContributions = {
  total_reward: bigint
  claimed_reward: bigint
  contributed_relay_addresses: Icdc549
}
export type moonbeam_Storage_CrowdloanRewards_UnassociatedContributions_Args = [
  Key: Icdc13,
]
export type moonbeam_Storage_CrowdloanRewards_Initialized = boolean
export type moonbeam_Storage_CrowdloanRewards_Initialized_Args = []
export type moonbeam_Storage_CrowdloanRewards_InitRelayBlock = number
export type moonbeam_Storage_CrowdloanRewards_InitRelayBlock_Args = []
export type moonbeam_Storage_CrowdloanRewards_EndRelayBlock = number
export type moonbeam_Storage_CrowdloanRewards_EndRelayBlock_Args = []
export type moonbeam_Storage_CrowdloanRewards_InitializedRewardAmount = bigint
export type moonbeam_Storage_CrowdloanRewards_InitializedRewardAmount_Args = []
export type moonbeam_Storage_CrowdloanRewards_TotalContributors = number
export type moonbeam_Storage_CrowdloanRewards_TotalContributors_Args = []
export type moonbeam_Tx_CrowdloanRewards_associate_native_identity = [
  Reward_account: Icdc1,
  Relay_account: Icdc13,
  Proof: IcSp_runtimeMultiSignature,
]
export type moonbeam_Tx_CrowdloanRewards_change_association_with_relay_keys = [
  Reward_account: Icdc1,
  Previous_account: Icdc1,
  Proofs: Icdc229,
]
export type moonbeam_Tx_CrowdloanRewards_claim = []
export type moonbeam_Tx_CrowdloanRewards_update_reward_address = [
  New_reward_account: Icdc1,
]
export type moonbeam_Tx_CrowdloanRewards_complete_initialization = [
  Lease_ending_block: number,
]
export type moonbeam_Tx_CrowdloanRewards_initialize_reward_vec = [
  Rewards: Icdc231,
]
export type moonbeam_Error_CrowdloanRewards_AlreadyAssociated = undefined
export type moonbeam_Error_CrowdloanRewards_BatchBeyondFundPot = undefined
export type moonbeam_Error_CrowdloanRewards_FirstClaimAlreadyDone = undefined
export type moonbeam_Error_CrowdloanRewards_RewardNotHighEnough = undefined
export type moonbeam_Error_CrowdloanRewards_InvalidClaimSignature = undefined
export type moonbeam_Error_CrowdloanRewards_InvalidFreeClaimSignature =
  undefined
export type moonbeam_Error_CrowdloanRewards_NoAssociatedClaim = undefined
export type moonbeam_Error_CrowdloanRewards_RewardsAlreadyClaimed = undefined
export type moonbeam_Error_CrowdloanRewards_RewardVecAlreadyInitialized =
  undefined
export type moonbeam_Error_CrowdloanRewards_RewardVecNotFullyInitializedYet =
  undefined
export type moonbeam_Error_CrowdloanRewards_RewardsDoNotMatchFund = undefined
export type moonbeam_Error_CrowdloanRewards_TooManyContributors = undefined
export type moonbeam_Error_CrowdloanRewards_VestingPeriodNonValid = undefined
export type moonbeam_Error_CrowdloanRewards_NonContributedAddressProvided =
  undefined
export type moonbeam_Error_CrowdloanRewards_InsufficientNumberOfValidProofs =
  undefined
export type moonbeam_Event_CrowdloanRewards_InitialPaymentMade = [Icdc1, bigint]
export type moonbeam_Event_CrowdloanRewards_NativeIdentityAssociated = [
  Icdc13,
  Icdc1,
  bigint,
]
export type moonbeam_Event_CrowdloanRewards_RewardsPaid = [Icdc1, bigint]
export type moonbeam_Event_CrowdloanRewards_RewardAddressUpdated = [
  Icdc1,
  Icdc1,
]
export type moonbeam_Event_CrowdloanRewards_InitializedAlreadyInitializedAccount =
  [Icdc13, IcOption, bigint]
export type moonbeam_Event_CrowdloanRewards_InitializedAccountWithNotEnoughContribution =
  [Icdc13, IcOption, bigint]
export type moonbeam_Constant_CrowdloanRewards_InitializationPayment = number
export type moonbeam_Constant_CrowdloanRewards_MaxInitContributors = number
export type moonbeam_Constant_CrowdloanRewards_RewardAddressRelayVoteThreshold =
  number
export type moonbeam_Constant_CrowdloanRewards_SignatureNetworkIdentifier =
  HexString
export type moonbeam_Storage_XcmpQueue_InboundXcmpStatus =
  Array<IcCumulus_pallet_xcmp_queueInboundChannelDetails>
export type moonbeam_Storage_XcmpQueue_InboundXcmpStatus_Args = []
export type moonbeam_Storage_XcmpQueue_InboundXcmpMessages = HexString
export type moonbeam_Storage_XcmpQueue_InboundXcmpMessages_Args = [
  number,
  number,
]
export type moonbeam_Storage_XcmpQueue_OutboundXcmpStatus =
  Array<IcCumulus_pallet_xcmp_queueOutboundChannelDetails>
export type moonbeam_Storage_XcmpQueue_OutboundXcmpStatus_Args = []
export type moonbeam_Storage_XcmpQueue_OutboundXcmpMessages = HexString
export type moonbeam_Storage_XcmpQueue_OutboundXcmpMessages_Args = [
  number,
  number,
]
export type moonbeam_Storage_XcmpQueue_SignalMessages = HexString
export type moonbeam_Storage_XcmpQueue_SignalMessages_Args = [Key: number]
export type moonbeam_Storage_XcmpQueue_QueueConfig = {
  suspend_threshold: number
  drop_threshold: number
  resume_threshold: number
  threshold_weight: IcSp_weightsWeight_v2Weight
  weight_restrict_decay: IcSp_weightsWeight_v2Weight
  xcmp_max_individual_weight: IcSp_weightsWeight_v2Weight
}
export type moonbeam_Storage_XcmpQueue_QueueConfig_Args = []
export type moonbeam_Storage_XcmpQueue_Overweight = [number, number, I_bytesSeq]
export type moonbeam_Storage_XcmpQueue_Overweight_Args = [Key: bigint]
export type moonbeam_Storage_XcmpQueue_CounterForOverweight = number
export type moonbeam_Storage_XcmpQueue_CounterForOverweight_Args = []
export type moonbeam_Storage_XcmpQueue_OverweightCount = bigint
export type moonbeam_Storage_XcmpQueue_OverweightCount_Args = []
export type moonbeam_Storage_XcmpQueue_QueueSuspended = boolean
export type moonbeam_Storage_XcmpQueue_QueueSuspended_Args = []
export type moonbeam_Error_XcmpQueue_FailedToSend = undefined
export type moonbeam_Error_XcmpQueue_BadXcmOrigin = undefined
export type moonbeam_Error_XcmpQueue_BadXcm = undefined
export type moonbeam_Error_XcmpQueue_BadOverweightIndex = undefined
export type moonbeam_Error_XcmpQueue_WeightOverLimit = undefined
export type moonbeam_Event_XcmpQueue_Success = {
  message_hash: IcOption
  weight: IcSp_weightsWeight_v2Weight
}
export type moonbeam_Event_XcmpQueue_Fail = {
  message_hash: IcOption
  error: IcXcmV3TraitsError
  weight: IcSp_weightsWeight_v2Weight
}
export type moonbeam_Event_XcmpQueue_BadVersion = { message_hash: IcOption }
export type moonbeam_Event_XcmpQueue_BadFormat = { message_hash: IcOption }
export type moonbeam_Event_XcmpQueue_XcmpMessageSent = {
  message_hash: IcOption
}
export type moonbeam_Event_XcmpQueue_OverweightEnqueued = {
  sender: number
  sent_at: number
  index: bigint
  required: IcSp_weightsWeight_v2Weight
}
export type moonbeam_Event_XcmpQueue_OverweightServiced = {
  index: bigint
  used: IcSp_weightsWeight_v2Weight
}
export type moonbeam_Event_CumulusXcm_InvalidFormat = Icdc13
export type moonbeam_Event_CumulusXcm_UnsupportedVersion = Icdc13
export type moonbeam_Event_CumulusXcm_ExecutedDownward = [
  Icdc13,
  IcXcmV3TraitsOutcome,
]
export type moonbeam_Storage_DmpQueue_Configuration = {
  ref_time: bigint
  proof_size: bigint
}
export type moonbeam_Storage_DmpQueue_Configuration_Args = []
export type moonbeam_Storage_DmpQueue_PageIndex = {
  begin_used: number
  end_used: number
  overweight_count: bigint
}
export type moonbeam_Storage_DmpQueue_PageIndex_Args = []
export type moonbeam_Storage_DmpQueue_Pages = Array<Icdc569>
export type moonbeam_Storage_DmpQueue_Pages_Args = [Key: number]
export type moonbeam_Storage_DmpQueue_Overweight = [number, I_bytesSeq]
export type moonbeam_Storage_DmpQueue_Overweight_Args = [Key: bigint]
export type moonbeam_Storage_DmpQueue_CounterForOverweight = number
export type moonbeam_Storage_DmpQueue_CounterForOverweight_Args = []
export type moonbeam_Tx_DmpQueue_service_overweight = [
  Index: bigint,
  Weight_limit: IcSp_weightsWeight_v2Weight,
]
export type moonbeam_Error_DmpQueue_Unknown = undefined
export type moonbeam_Error_DmpQueue_OverLimit = undefined
export type moonbeam_Event_DmpQueue_InvalidFormat = { message_id: Icdc13 }
export type moonbeam_Event_DmpQueue_UnsupportedVersion = { message_id: Icdc13 }
export type moonbeam_Event_DmpQueue_ExecutedDownward = {
  message_id: Icdc13
  outcome: IcXcmV3TraitsOutcome
}
export type moonbeam_Event_DmpQueue_WeightExhausted = {
  message_id: Icdc13
  remaining_weight: IcSp_weightsWeight_v2Weight
  required_weight: IcSp_weightsWeight_v2Weight
}
export type moonbeam_Event_DmpQueue_OverweightEnqueued = {
  message_id: Icdc13
  overweight_index: bigint
  required_weight: IcSp_weightsWeight_v2Weight
}
export type moonbeam_Event_DmpQueue_OverweightServiced = {
  overweight_index: bigint
  weight_used: IcSp_weightsWeight_v2Weight
}
export type moonbeam_Event_DmpQueue_MaxMessagesExhausted = {
  message_id: Icdc13
}
export type moonbeam_Storage_PolkadotXcm_QueryCounter = bigint
export type moonbeam_Storage_PolkadotXcm_QueryCounter_Args = []
export type moonbeam_Storage_PolkadotXcm_Queries =
  | { tag: "Pending"; value: IcPallet_xcmPalletQueryStatusPending }
  | {
      tag: "VersionNotifier"
      value: IcPallet_xcmPalletQueryStatusVersionNotifier
    }
  | { tag: "Ready"; value: IcPallet_xcmPalletQueryStatusReady }
export type moonbeam_Storage_PolkadotXcm_Queries_Args = [Key: bigint]
export type moonbeam_Storage_PolkadotXcm_AssetTraps = number
export type moonbeam_Storage_PolkadotXcm_AssetTraps_Args = [Key: Icdc13]
export type moonbeam_Storage_PolkadotXcm_SafeXcmVersion = number
export type moonbeam_Storage_PolkadotXcm_SafeXcmVersion_Args = []
export type moonbeam_Storage_PolkadotXcm_SupportedVersion = number
export type moonbeam_Storage_PolkadotXcm_SupportedVersion_Args = [
  number,
  IcXcmVersionedMultiLocation,
]
export type moonbeam_Storage_PolkadotXcm_VersionNotifiers = bigint
export type moonbeam_Storage_PolkadotXcm_VersionNotifiers_Args = [
  number,
  IcXcmVersionedMultiLocation,
]
export type moonbeam_Storage_PolkadotXcm_VersionNotifyTargets = [
  bigint,
  IcSp_weightsWeight_v2Weight,
  number,
]
export type moonbeam_Storage_PolkadotXcm_VersionNotifyTargets_Args = [
  number,
  IcXcmVersionedMultiLocation,
]
export type moonbeam_Storage_PolkadotXcm_VersionDiscoveryQueue = Array<Icdc579>
export type moonbeam_Storage_PolkadotXcm_VersionDiscoveryQueue_Args = []
export type moonbeam_Storage_PolkadotXcm_CurrentMigration =
  | { tag: "MigrateSupportedVersion"; value: undefined }
  | { tag: "MigrateVersionNotifiers"; value: undefined }
  | {
      tag: "NotifyCurrentTargets"
      value: IcPallet_xcmPalletVersionMigrationStageNotifyCurrentTargets
    }
  | { tag: "MigrateAndNotifyOldTargets"; value: undefined }
export type moonbeam_Storage_PolkadotXcm_CurrentMigration_Args = []
export type moonbeam_Storage_PolkadotXcm_RemoteLockedFungibles = {
  amount: bigint
  owner: IcXcmVersionedMultiLocation
  locker: IcXcmVersionedMultiLocation
  consumers: Icdc588
}
export type moonbeam_Storage_PolkadotXcm_RemoteLockedFungibles_Args = [
  number,
  Icdc1,
  IcXcmVersionedAssetId,
]
export type moonbeam_Storage_PolkadotXcm_LockedFungibles = Array<Icdc590>
export type moonbeam_Storage_PolkadotXcm_LockedFungibles_Args = [Key: Icdc1]
export type moonbeam_Storage_PolkadotXcm_XcmExecutionSuspended = boolean
export type moonbeam_Storage_PolkadotXcm_XcmExecutionSuspended_Args = []
export type moonbeam_Tx_PolkadotXcm_send = [
  Dest: IcXcmVersionedMultiLocation,
  Message: IcXcmVersionedXcm,
]
export type moonbeam_Tx_PolkadotXcm_teleport_assets = [
  Dest: IcXcmVersionedMultiLocation,
  Beneficiary: IcXcmVersionedMultiLocation,
  Assets: IcXcmVersionedMultiAssets,
  Fee_asset_item: number,
]
export type moonbeam_Tx_PolkadotXcm_reserve_transfer_assets = [
  Dest: IcXcmVersionedMultiLocation,
  Beneficiary: IcXcmVersionedMultiLocation,
  Assets: IcXcmVersionedMultiAssets,
  Fee_asset_item: number,
]
export type moonbeam_Tx_PolkadotXcm_execute = [
  Message: IcXcmVersionedXcm,
  Max_weight: IcSp_weightsWeight_v2Weight,
]
export type moonbeam_Tx_PolkadotXcm_force_xcm_version = [
  Location: IcXcmV3MultilocationMultiLocation,
  Xcm_version: number,
]
export type moonbeam_Tx_PolkadotXcm_force_default_xcm_version = [
  Maybe_xcm_version: IcOption,
]
export type moonbeam_Tx_PolkadotXcm_force_subscribe_version_notify = [
  Location: IcXcmVersionedMultiLocation,
]
export type moonbeam_Tx_PolkadotXcm_force_unsubscribe_version_notify = [
  Location: IcXcmVersionedMultiLocation,
]
export type moonbeam_Tx_PolkadotXcm_limited_reserve_transfer_assets = [
  Dest: IcXcmVersionedMultiLocation,
  Beneficiary: IcXcmVersionedMultiLocation,
  Assets: IcXcmVersionedMultiAssets,
  Fee_asset_item: number,
  Weight_limit: IcXcmV3WeightLimit,
]
export type moonbeam_Tx_PolkadotXcm_limited_teleport_assets = [
  Dest: IcXcmVersionedMultiLocation,
  Beneficiary: IcXcmVersionedMultiLocation,
  Assets: IcXcmVersionedMultiAssets,
  Fee_asset_item: number,
  Weight_limit: IcXcmV3WeightLimit,
]
export type moonbeam_Tx_PolkadotXcm_force_suspension = [Suspended: boolean]
export type moonbeam_Error_PolkadotXcm_Unreachable = undefined
export type moonbeam_Error_PolkadotXcm_SendFailure = undefined
export type moonbeam_Error_PolkadotXcm_Filtered = undefined
export type moonbeam_Error_PolkadotXcm_UnweighableMessage = undefined
export type moonbeam_Error_PolkadotXcm_DestinationNotInvertible = undefined
export type moonbeam_Error_PolkadotXcm_Empty = undefined
export type moonbeam_Error_PolkadotXcm_CannotReanchor = undefined
export type moonbeam_Error_PolkadotXcm_TooManyAssets = undefined
export type moonbeam_Error_PolkadotXcm_InvalidOrigin = undefined
export type moonbeam_Error_PolkadotXcm_BadVersion = undefined
export type moonbeam_Error_PolkadotXcm_BadLocation = undefined
export type moonbeam_Error_PolkadotXcm_NoSubscription = undefined
export type moonbeam_Error_PolkadotXcm_AlreadySubscribed = undefined
export type moonbeam_Error_PolkadotXcm_InvalidAsset = undefined
export type moonbeam_Error_PolkadotXcm_LowBalance = undefined
export type moonbeam_Error_PolkadotXcm_TooManyLocks = undefined
export type moonbeam_Error_PolkadotXcm_AccountNotSovereign = undefined
export type moonbeam_Error_PolkadotXcm_FeesNotMet = undefined
export type moonbeam_Error_PolkadotXcm_LockNotFound = undefined
export type moonbeam_Error_PolkadotXcm_InUse = undefined
export type moonbeam_Event_PolkadotXcm_Attempted = IcXcmV3TraitsOutcome
export type moonbeam_Event_PolkadotXcm_Sent = [
  IcXcmV3MultilocationMultiLocation,
  IcXcmV3MultilocationMultiLocation,
  Icdc264,
]
export type moonbeam_Event_PolkadotXcm_UnexpectedResponse = [
  IcXcmV3MultilocationMultiLocation,
  bigint,
]
export type moonbeam_Event_PolkadotXcm_ResponseReady = [bigint, IcXcmV3Response]
export type moonbeam_Event_PolkadotXcm_Notified = [bigint, number, number]
export type moonbeam_Event_PolkadotXcm_NotifyOverweight = [
  bigint,
  number,
  number,
  IcSp_weightsWeight_v2Weight,
  IcSp_weightsWeight_v2Weight,
]
export type moonbeam_Event_PolkadotXcm_NotifyDispatchError = [
  bigint,
  number,
  number,
]
export type moonbeam_Event_PolkadotXcm_NotifyDecodeFailed = [
  bigint,
  number,
  number,
]
export type moonbeam_Event_PolkadotXcm_InvalidResponder = [
  IcXcmV3MultilocationMultiLocation,
  bigint,
  IcOption,
]
export type moonbeam_Event_PolkadotXcm_InvalidResponderVersion = [
  IcXcmV3MultilocationMultiLocation,
  bigint,
]
export type moonbeam_Event_PolkadotXcm_ResponseTaken = bigint
export type moonbeam_Event_PolkadotXcm_AssetsTrapped = [
  Icdc13,
  IcXcmV3MultilocationMultiLocation,
  IcXcmVersionedMultiAssets,
]
export type moonbeam_Event_PolkadotXcm_VersionChangeNotified = [
  IcXcmV3MultilocationMultiLocation,
  number,
  Icdc267,
]
export type moonbeam_Event_PolkadotXcm_SupportedVersionChanged = [
  IcXcmV3MultilocationMultiLocation,
  number,
]
export type moonbeam_Event_PolkadotXcm_NotifyTargetSendFail = [
  IcXcmV3MultilocationMultiLocation,
  bigint,
  IcXcmV3TraitsError,
]
export type moonbeam_Event_PolkadotXcm_NotifyTargetMigrationFail = [
  IcXcmVersionedMultiLocation,
  bigint,
]
export type moonbeam_Event_PolkadotXcm_InvalidQuerierVersion = [
  IcXcmV3MultilocationMultiLocation,
  bigint,
]
export type moonbeam_Event_PolkadotXcm_InvalidQuerier = [
  IcXcmV3MultilocationMultiLocation,
  bigint,
  IcXcmV3MultilocationMultiLocation,
  IcOption,
]
export type moonbeam_Event_PolkadotXcm_VersionNotifyStarted = [
  IcXcmV3MultilocationMultiLocation,
  Icdc267,
]
export type moonbeam_Event_PolkadotXcm_VersionNotifyRequested = [
  IcXcmV3MultilocationMultiLocation,
  Icdc267,
]
export type moonbeam_Event_PolkadotXcm_VersionNotifyUnrequested = [
  IcXcmV3MultilocationMultiLocation,
  Icdc267,
]
export type moonbeam_Event_PolkadotXcm_FeesPaid = [
  IcXcmV3MultilocationMultiLocation,
  Icdc267,
]
export type moonbeam_Event_PolkadotXcm_AssetsClaimed = [
  Icdc13,
  IcXcmV3MultilocationMultiLocation,
  IcXcmVersionedMultiAssets,
]
export type moonbeam_Storage_Assets_Asset = {
  owner: Icdc1
  issuer: Icdc1
  admin: Icdc1
  freezer: Icdc1
  supply: bigint
  deposit: bigint
  min_balance: bigint
  is_sufficient: boolean
  accounts: number
  sufficients: number
  approvals: number
  status: IcPallet_assetsTypesAssetStatus
}
export type moonbeam_Storage_Assets_Asset_Args = [Key: bigint]
export type moonbeam_Storage_Assets_Account = {
  balance: bigint
  status: IcPallet_assetsTypesAccountStatus
  reason: IcPallet_assetsTypesExistenceReason
  extra: undefined
}
export type moonbeam_Storage_Assets_Account_Args = [bigint, Icdc1]
export type moonbeam_Storage_Assets_Approvals = {
  amount: bigint
  deposit: bigint
}
export type moonbeam_Storage_Assets_Approvals_Args = [bigint, Icdc1, Icdc1]
export type moonbeam_Storage_Assets_Metadata = {
  deposit: bigint
  name: I_bytesSeq
  symbol: I_bytesSeq
  decimals: number
  is_frozen: boolean
}
export type moonbeam_Storage_Assets_Metadata_Args = [Key: bigint]
export type moonbeam_Tx_Assets_create = [
  Id: bigint,
  Admin: Icdc1,
  Min_balance: bigint,
]
export type moonbeam_Tx_Assets_force_create = [
  Id: bigint,
  Owner: Icdc1,
  Is_sufficient: boolean,
  Min_balance: bigint,
]
export type moonbeam_Tx_Assets_start_destroy = [Id: bigint]
export type moonbeam_Tx_Assets_destroy_accounts = [Id: bigint]
export type moonbeam_Tx_Assets_destroy_approvals = [Id: bigint]
export type moonbeam_Tx_Assets_finish_destroy = [Id: bigint]
export type moonbeam_Tx_Assets_mint = [
  Id: bigint,
  Beneficiary: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_Assets_burn = [Id: bigint, Who: Icdc1, Amount: bigint]
export type moonbeam_Tx_Assets_transfer = [
  Id: bigint,
  Target: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_Assets_transfer_keep_alive = [
  Id: bigint,
  Target: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_Assets_force_transfer = [
  Id: bigint,
  Source: Icdc1,
  Dest: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_Assets_freeze = [Id: bigint, Who: Icdc1]
export type moonbeam_Tx_Assets_thaw = [Id: bigint, Who: Icdc1]
export type moonbeam_Tx_Assets_freeze_asset = [Id: bigint]
export type moonbeam_Tx_Assets_thaw_asset = [Id: bigint]
export type moonbeam_Tx_Assets_transfer_ownership = [Id: bigint, Owner: Icdc1]
export type moonbeam_Tx_Assets_set_team = [
  Id: bigint,
  Issuer: Icdc1,
  Admin: Icdc1,
  Freezer: Icdc1,
]
export type moonbeam_Tx_Assets_set_metadata = [
  Id: bigint,
  Name: I_bytesSeq,
  Symbol: I_bytesSeq,
  Decimals: number,
]
export type moonbeam_Tx_Assets_clear_metadata = [Id: bigint]
export type moonbeam_Tx_Assets_force_set_metadata = [
  Id: bigint,
  Name: I_bytesSeq,
  Symbol: I_bytesSeq,
  Decimals: number,
  Is_frozen: boolean,
]
export type moonbeam_Tx_Assets_force_clear_metadata = [Id: bigint]
export type moonbeam_Tx_Assets_force_asset_status = [
  Id: bigint,
  Owner: Icdc1,
  Issuer: Icdc1,
  Admin: Icdc1,
  Freezer: Icdc1,
  Min_balance: bigint,
  Is_sufficient: boolean,
  Is_frozen: boolean,
]
export type moonbeam_Tx_Assets_approve_transfer = [
  Id: bigint,
  Delegate: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_Assets_cancel_approval = [Id: bigint, Delegate: Icdc1]
export type moonbeam_Tx_Assets_force_cancel_approval = [
  Id: bigint,
  Owner: Icdc1,
  Delegate: Icdc1,
]
export type moonbeam_Tx_Assets_transfer_approved = [
  Id: bigint,
  Owner: Icdc1,
  Destination: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_Assets_touch = [Id: bigint]
export type moonbeam_Tx_Assets_refund = [Id: bigint, Allow_burn: boolean]
export type moonbeam_Tx_Assets_set_min_balance = [
  Id: bigint,
  Min_balance: bigint,
]
export type moonbeam_Tx_Assets_touch_other = [Id: bigint, Who: Icdc1]
export type moonbeam_Tx_Assets_refund_other = [Id: bigint, Who: Icdc1]
export type moonbeam_Tx_Assets_block = [Id: bigint, Who: Icdc1]
export type moonbeam_Error_Assets_BalanceLow = undefined
export type moonbeam_Error_Assets_NoAccount = undefined
export type moonbeam_Error_Assets_NoPermission = undefined
export type moonbeam_Error_Assets_Unknown = undefined
export type moonbeam_Error_Assets_Frozen = undefined
export type moonbeam_Error_Assets_InUse = undefined
export type moonbeam_Error_Assets_BadWitness = undefined
export type moonbeam_Error_Assets_MinBalanceZero = undefined
export type moonbeam_Error_Assets_UnavailableConsumer = undefined
export type moonbeam_Error_Assets_BadMetadata = undefined
export type moonbeam_Error_Assets_Unapproved = undefined
export type moonbeam_Error_Assets_WouldDie = undefined
export type moonbeam_Error_Assets_AlreadyExists = undefined
export type moonbeam_Error_Assets_NoDeposit = undefined
export type moonbeam_Error_Assets_WouldBurn = undefined
export type moonbeam_Error_Assets_LiveAsset = undefined
export type moonbeam_Error_Assets_AssetNotLive = undefined
export type moonbeam_Error_Assets_IncorrectStatus = undefined
export type moonbeam_Error_Assets_NotFrozen = undefined
export type moonbeam_Error_Assets_CallbackFailed = undefined
export type moonbeam_Event_Assets_Created = {
  asset_id: bigint
  creator: Icdc1
  owner: Icdc1
}
export type moonbeam_Event_Assets_Issued = {
  asset_id: bigint
  owner: Icdc1
  amount: bigint
}
export type moonbeam_Event_Assets_Transferred = {
  asset_id: bigint
  from: Icdc1
  to: Icdc1
  amount: bigint
}
export type moonbeam_Event_Assets_Burned = {
  asset_id: bigint
  owner: Icdc1
  balance: bigint
}
export type moonbeam_Event_Assets_TeamChanged = {
  asset_id: bigint
  issuer: Icdc1
  admin: Icdc1
  freezer: Icdc1
}
export type moonbeam_Event_Assets_OwnerChanged = {
  asset_id: bigint
  owner: Icdc1
}
export type moonbeam_Event_Assets_Frozen = { asset_id: bigint; who: Icdc1 }
export type moonbeam_Event_Assets_Thawed = { asset_id: bigint; who: Icdc1 }
export type moonbeam_Event_Assets_AssetFrozen = { asset_id: bigint }
export type moonbeam_Event_Assets_AssetThawed = { asset_id: bigint }
export type moonbeam_Event_Assets_AccountsDestroyed = {
  asset_id: bigint
  accounts_destroyed: number
  accounts_remaining: number
}
export type moonbeam_Event_Assets_ApprovalsDestroyed = {
  asset_id: bigint
  approvals_destroyed: number
  approvals_remaining: number
}
export type moonbeam_Event_Assets_DestructionStarted = { asset_id: bigint }
export type moonbeam_Event_Assets_Destroyed = { asset_id: bigint }
export type moonbeam_Event_Assets_ForceCreated = {
  asset_id: bigint
  owner: Icdc1
}
export type moonbeam_Event_Assets_MetadataSet = {
  asset_id: bigint
  name: I_bytesSeq
  symbol: I_bytesSeq
  decimals: number
  is_frozen: boolean
}
export type moonbeam_Event_Assets_MetadataCleared = { asset_id: bigint }
export type moonbeam_Event_Assets_ApprovedTransfer = {
  asset_id: bigint
  source: Icdc1
  delegate: Icdc1
  amount: bigint
}
export type moonbeam_Event_Assets_ApprovalCancelled = {
  asset_id: bigint
  owner: Icdc1
  delegate: Icdc1
}
export type moonbeam_Event_Assets_TransferredApproved = {
  asset_id: bigint
  owner: Icdc1
  delegate: Icdc1
  destination: Icdc1
  amount: bigint
}
export type moonbeam_Event_Assets_AssetStatusChanged = { asset_id: bigint }
export type moonbeam_Event_Assets_AssetMinBalanceChanged = {
  asset_id: bigint
  new_min_balance: bigint
}
export type moonbeam_Event_Assets_Touched = {
  asset_id: bigint
  who: Icdc1
  depositor: Icdc1
}
export type moonbeam_Event_Assets_Blocked = { asset_id: bigint; who: Icdc1 }
export type moonbeam_Constant_Assets_RemoveItemsLimit = number
export type moonbeam_Constant_Assets_AssetDeposit = bigint
export type moonbeam_Constant_Assets_AssetAccountDeposit = bigint
export type moonbeam_Constant_Assets_MetadataDepositBase = bigint
export type moonbeam_Constant_Assets_MetadataDepositPerByte = bigint
export type moonbeam_Constant_Assets_ApprovalDeposit = bigint
export type moonbeam_Constant_Assets_StringLimit = number
export type moonbeam_Storage_AssetManager_AssetIdType = {
  tag: "Xcm"
  value: IcMoonbeam_runtimeXcm_configAssetTypeXcm
}
export type moonbeam_Storage_AssetManager_AssetIdType_Args = [Key: bigint]
export type moonbeam_Storage_AssetManager_AssetTypeId = bigint
export type moonbeam_Storage_AssetManager_AssetTypeId_Args = [
  Key: IcMoonbeam_runtimeXcm_configAssetType,
]
export type moonbeam_Storage_AssetManager_AssetTypeUnitsPerSecond = bigint
export type moonbeam_Storage_AssetManager_AssetTypeUnitsPerSecond_Args = [
  Key: IcMoonbeam_runtimeXcm_configAssetType,
]
export type moonbeam_Storage_AssetManager_LocalAssetCounter = bigint
export type moonbeam_Storage_AssetManager_LocalAssetCounter_Args = []
export type moonbeam_Storage_AssetManager_LocalAssetDeposit = {
  creator: Icdc1
  deposit: bigint
}
export type moonbeam_Storage_AssetManager_LocalAssetDeposit_Args = [Key: bigint]
export type moonbeam_Storage_AssetManager_SupportedFeePaymentAssets =
  Array<IcMoonbeam_runtimeXcm_configAssetType>
export type moonbeam_Storage_AssetManager_SupportedFeePaymentAssets_Args = []
export type moonbeam_Tx_AssetManager_register_foreign_asset = [
  Asset: IcMoonbeam_runtimeXcm_configAssetType,
  Metadata: IcMoonbeam_runtimeAsset_configAssetRegistrarMetadata,
  Min_amount: bigint,
  Is_sufficient: boolean,
]
export type moonbeam_Tx_AssetManager_set_asset_units_per_second = [
  Asset_type: IcMoonbeam_runtimeXcm_configAssetType,
  Units_per_second: bigint,
  Num_assets_weight_hint: number,
]
export type moonbeam_Tx_AssetManager_change_existing_asset_type = [
  Asset_id: bigint,
  New_asset_type: IcMoonbeam_runtimeXcm_configAssetType,
  Num_assets_weight_hint: number,
]
export type moonbeam_Tx_AssetManager_remove_supported_asset = [
  Asset_type: IcMoonbeam_runtimeXcm_configAssetType,
  Num_assets_weight_hint: number,
]
export type moonbeam_Tx_AssetManager_remove_existing_asset_type = [
  Asset_id: bigint,
  Num_assets_weight_hint: number,
]
export type moonbeam_Tx_AssetManager_register_local_asset = [
  Creator: Icdc1,
  Owner: Icdc1,
  Is_sufficient: boolean,
  Min_balance: bigint,
]
export type moonbeam_Tx_AssetManager_destroy_foreign_asset = [
  Asset_id: bigint,
  Num_assets_weight_hint: number,
]
export type moonbeam_Tx_AssetManager_destroy_local_asset = [Asset_id: bigint]
export type moonbeam_Error_AssetManager_ErrorCreatingAsset = undefined
export type moonbeam_Error_AssetManager_AssetAlreadyExists = undefined
export type moonbeam_Error_AssetManager_AssetDoesNotExist = undefined
export type moonbeam_Error_AssetManager_TooLowNumAssetsWeightHint = undefined
export type moonbeam_Error_AssetManager_LocalAssetLimitReached = undefined
export type moonbeam_Error_AssetManager_ErrorDestroyingAsset = undefined
export type moonbeam_Error_AssetManager_NotSufficientDeposit = undefined
export type moonbeam_Error_AssetManager_NonExistentLocalAsset = undefined
export type moonbeam_Event_AssetManager_ForeignAssetRegistered = {
  asset_id: bigint
  asset: IcMoonbeam_runtimeXcm_configAssetType
  metadata: IcMoonbeam_runtimeAsset_configAssetRegistrarMetadata
}
export type moonbeam_Event_AssetManager_UnitsPerSecondChanged = {
  asset_type: IcMoonbeam_runtimeXcm_configAssetType
  units_per_second: bigint
}
export type moonbeam_Event_AssetManager_ForeignAssetTypeChanged = {
  asset_id: bigint
  new_asset_type: IcMoonbeam_runtimeXcm_configAssetType
}
export type moonbeam_Event_AssetManager_ForeignAssetRemoved = {
  asset_id: bigint
  asset_type: IcMoonbeam_runtimeXcm_configAssetType
}
export type moonbeam_Event_AssetManager_SupportedAssetRemoved = {
  asset_type: IcMoonbeam_runtimeXcm_configAssetType
}
export type moonbeam_Event_AssetManager_LocalAssetRegistered = {
  asset_id: bigint
  creator: Icdc1
  owner: Icdc1
}
export type moonbeam_Event_AssetManager_ForeignAssetDestroyed = {
  asset_id: bigint
  asset_type: IcMoonbeam_runtimeXcm_configAssetType
}
export type moonbeam_Event_AssetManager_LocalAssetDestroyed = {
  asset_id: bigint
}
export type moonbeam_Constant_AssetManager_LocalAssetDeposit = bigint
export type moonbeam_Tx_XTokens_transfer = [
  Currency_id: IcMoonbeam_runtimeXcm_configCurrencyId,
  Amount: bigint,
  Dest: IcXcmVersionedMultiLocation,
  Dest_weight_limit: IcXcmV3WeightLimit,
]
export type moonbeam_Tx_XTokens_transfer_multiasset = [
  Asset: IcXcmVersionedMultiAsset,
  Dest: IcXcmVersionedMultiLocation,
  Dest_weight_limit: IcXcmV3WeightLimit,
]
export type moonbeam_Tx_XTokens_transfer_with_fee = [
  Currency_id: IcMoonbeam_runtimeXcm_configCurrencyId,
  Amount: bigint,
  Fee: bigint,
  Dest: IcXcmVersionedMultiLocation,
  Dest_weight_limit: IcXcmV3WeightLimit,
]
export type moonbeam_Tx_XTokens_transfer_multiasset_with_fee = [
  Asset: IcXcmVersionedMultiAsset,
  Fee: IcXcmVersionedMultiAsset,
  Dest: IcXcmVersionedMultiLocation,
  Dest_weight_limit: IcXcmV3WeightLimit,
]
export type moonbeam_Tx_XTokens_transfer_multicurrencies = [
  Currencies: Icdc304,
  Fee_item: number,
  Dest: IcXcmVersionedMultiLocation,
  Dest_weight_limit: IcXcmV3WeightLimit,
]
export type moonbeam_Tx_XTokens_transfer_multiassets = [
  Assets: IcXcmVersionedMultiAssets,
  Fee_item: number,
  Dest: IcXcmVersionedMultiLocation,
  Dest_weight_limit: IcXcmV3WeightLimit,
]
export type moonbeam_Error_XTokens_AssetHasNoReserve = undefined
export type moonbeam_Error_XTokens_NotCrossChainTransfer = undefined
export type moonbeam_Error_XTokens_InvalidDest = undefined
export type moonbeam_Error_XTokens_NotCrossChainTransferableCurrency = undefined
export type moonbeam_Error_XTokens_UnweighableMessage = undefined
export type moonbeam_Error_XTokens_XcmExecutionFailed = undefined
export type moonbeam_Error_XTokens_CannotReanchor = undefined
export type moonbeam_Error_XTokens_InvalidAncestry = undefined
export type moonbeam_Error_XTokens_InvalidAsset = undefined
export type moonbeam_Error_XTokens_DestinationNotInvertible = undefined
export type moonbeam_Error_XTokens_BadVersion = undefined
export type moonbeam_Error_XTokens_DistinctReserveForAssetAndFee = undefined
export type moonbeam_Error_XTokens_ZeroFee = undefined
export type moonbeam_Error_XTokens_ZeroAmount = undefined
export type moonbeam_Error_XTokens_TooManyAssetsBeingSent = undefined
export type moonbeam_Error_XTokens_AssetIndexNonExistent = undefined
export type moonbeam_Error_XTokens_FeeNotEnough = undefined
export type moonbeam_Error_XTokens_NotSupportedMultiLocation = undefined
export type moonbeam_Error_XTokens_MinXcmFeeNotDefined = undefined
export type moonbeam_Event_XTokens_TransferredMultiAssets = {
  sender: Icdc1
  assets: Icdc267
  fee: IcXcmV3MultiassetMultiAsset
  dest: IcXcmV3MultilocationMultiLocation
}
export type moonbeam_Constant_XTokens_SelfLocation = {
  parents: number
  interior: IcXcmV3JunctionsJunctions
}
export type moonbeam_Constant_XTokens_BaseXcmWeight = {
  ref_time: bigint
  proof_size: bigint
}
export type moonbeam_Storage_XcmTransactor_IndexToAccount = HexString
export type moonbeam_Storage_XcmTransactor_IndexToAccount_Args = [Key: number]
export type moonbeam_Storage_XcmTransactor_TransactInfoWithWeightLimit = {
  transact_extra_weight: IcSp_weightsWeight_v2Weight
  max_weight: IcSp_weightsWeight_v2Weight
  transact_extra_weight_signed: IcOption
}
export type moonbeam_Storage_XcmTransactor_TransactInfoWithWeightLimit_Args = [
  Key: IcXcmV3MultilocationMultiLocation,
]
export type moonbeam_Storage_XcmTransactor_DestinationAssetFeePerSecond = bigint
export type moonbeam_Storage_XcmTransactor_DestinationAssetFeePerSecond_Args = [
  Key: IcXcmV3MultilocationMultiLocation,
]
export type moonbeam_Tx_XcmTransactor_register = [Who: Icdc1, Index: number]
export type moonbeam_Tx_XcmTransactor_deregister = [Index: number]
export type moonbeam_Tx_XcmTransactor_transact_through_derivative = [
  Dest: IcMoonbeam_runtimeXcm_configTransactors,
  Index: number,
  Fee: IcPallet_xcm_transactorPalletCurrencyPayment,
  Inner_call: I_bytesSeq,
  Weight_info: IcPallet_xcm_transactorPalletTransactWeights,
  Refund: boolean,
]
export type moonbeam_Tx_XcmTransactor_transact_through_sovereign = [
  Dest: IcXcmVersionedMultiLocation,
  Fee_payer: Icdc1,
  Fee: IcPallet_xcm_transactorPalletCurrencyPayment,
  Call: I_bytesSeq,
  Origin_kind: IcXcmV2OriginKind,
  Weight_info: IcPallet_xcm_transactorPalletTransactWeights,
  Refund: boolean,
]
export type moonbeam_Tx_XcmTransactor_set_transact_info = [
  Location: IcXcmVersionedMultiLocation,
  Transact_extra_weight: IcSp_weightsWeight_v2Weight,
  Max_weight: IcSp_weightsWeight_v2Weight,
  Transact_extra_weight_signed: IcOption,
]
export type moonbeam_Tx_XcmTransactor_remove_transact_info = [
  Location: IcXcmVersionedMultiLocation,
]
export type moonbeam_Tx_XcmTransactor_transact_through_signed = [
  Dest: IcXcmVersionedMultiLocation,
  Fee: IcPallet_xcm_transactorPalletCurrencyPayment,
  Call: I_bytesSeq,
  Weight_info: IcPallet_xcm_transactorPalletTransactWeights,
  Refund: boolean,
]
export type moonbeam_Tx_XcmTransactor_set_fee_per_second = [
  Asset_location: IcXcmVersionedMultiLocation,
  Fee_per_second: bigint,
]
export type moonbeam_Tx_XcmTransactor_remove_fee_per_second = [
  Asset_location: IcXcmVersionedMultiLocation,
]
export type moonbeam_Tx_XcmTransactor_hrmp_manage = [
  Action: IcPallet_xcm_transactorPalletHrmpOperation,
  Fee: IcPallet_xcm_transactorPalletCurrencyPayment,
  Weight_info: IcPallet_xcm_transactorPalletTransactWeights,
]
export type moonbeam_Error_XcmTransactor_IndexAlreadyClaimed = undefined
export type moonbeam_Error_XcmTransactor_UnclaimedIndex = undefined
export type moonbeam_Error_XcmTransactor_NotOwner = undefined
export type moonbeam_Error_XcmTransactor_UnweighableMessage = undefined
export type moonbeam_Error_XcmTransactor_CannotReanchor = undefined
export type moonbeam_Error_XcmTransactor_AssetHasNoReserve = undefined
export type moonbeam_Error_XcmTransactor_InvalidDest = undefined
export type moonbeam_Error_XcmTransactor_NotCrossChainTransfer = undefined
export type moonbeam_Error_XcmTransactor_AssetIsNotReserveInDestination =
  undefined
export type moonbeam_Error_XcmTransactor_DestinationNotInvertible = undefined
export type moonbeam_Error_XcmTransactor_ErrorDelivering = undefined
export type moonbeam_Error_XcmTransactor_DispatchWeightBiggerThanTotalWeight =
  undefined
export type moonbeam_Error_XcmTransactor_WeightOverflow = undefined
export type moonbeam_Error_XcmTransactor_AmountOverflow = undefined
export type moonbeam_Error_XcmTransactor_TransactorInfoNotSet = undefined
export type moonbeam_Error_XcmTransactor_NotCrossChainTransferableCurrency =
  undefined
export type moonbeam_Error_XcmTransactor_XcmExecuteError = undefined
export type moonbeam_Error_XcmTransactor_BadVersion = undefined
export type moonbeam_Error_XcmTransactor_MaxWeightTransactReached = undefined
export type moonbeam_Error_XcmTransactor_UnableToWithdrawAsset = undefined
export type moonbeam_Error_XcmTransactor_FeePerSecondNotSet = undefined
export type moonbeam_Error_XcmTransactor_SignedTransactNotAllowedForDestination =
  undefined
export type moonbeam_Error_XcmTransactor_FailedMultiLocationToJunction =
  undefined
export type moonbeam_Error_XcmTransactor_HrmpHandlerNotImplemented = undefined
export type moonbeam_Error_XcmTransactor_TooMuchFeeUsed = undefined
export type moonbeam_Error_XcmTransactor_ErrorValidating = undefined
export type moonbeam_Error_XcmTransactor_RefundNotSupportedWithTransactInfo =
  undefined
export type moonbeam_Event_XcmTransactor_TransactedDerivative = {
  account_id: Icdc1
  dest: IcXcmV3MultilocationMultiLocation
  call: I_bytesSeq
  index: number
}
export type moonbeam_Event_XcmTransactor_TransactedSovereign = {
  fee_payer: Icdc1
  dest: IcXcmV3MultilocationMultiLocation
  call: I_bytesSeq
}
export type moonbeam_Event_XcmTransactor_TransactedSigned = {
  fee_payer: Icdc1
  dest: IcXcmV3MultilocationMultiLocation
  call: I_bytesSeq
}
export type moonbeam_Event_XcmTransactor_RegisteredDerivative = {
  account_id: Icdc1
  index: number
}
export type moonbeam_Event_XcmTransactor_DeRegisteredDerivative = {
  index: number
}
export type moonbeam_Event_XcmTransactor_TransactFailed = {
  error: IcXcmV3TraitsError
}
export type moonbeam_Event_XcmTransactor_TransactInfoChanged = {
  location: IcXcmV3MultilocationMultiLocation
  remote_info: IcPallet_xcm_transactorPalletRemoteTransactInfoWithMaxWeight
}
export type moonbeam_Event_XcmTransactor_TransactInfoRemoved = {
  location: IcXcmV3MultilocationMultiLocation
}
export type moonbeam_Event_XcmTransactor_DestFeePerSecondChanged = {
  location: IcXcmV3MultilocationMultiLocation
  fee_per_second: bigint
}
export type moonbeam_Event_XcmTransactor_DestFeePerSecondRemoved = {
  location: IcXcmV3MultilocationMultiLocation
}
export type moonbeam_Event_XcmTransactor_HrmpManagementSent = {
  action: IcPallet_xcm_transactorPalletHrmpOperation
}
export type moonbeam_Constant_XcmTransactor_SelfLocation = {
  parents: number
  interior: IcXcmV3JunctionsJunctions
}
export type moonbeam_Constant_XcmTransactor_BaseXcmWeight = {
  ref_time: bigint
  proof_size: bigint
}
export type moonbeam_Storage_LocalAssets_Asset = {
  owner: Icdc1
  issuer: Icdc1
  admin: Icdc1
  freezer: Icdc1
  supply: bigint
  deposit: bigint
  min_balance: bigint
  is_sufficient: boolean
  accounts: number
  sufficients: number
  approvals: number
  status: IcPallet_assetsTypesAssetStatus
}
export type moonbeam_Storage_LocalAssets_Asset_Args = [Key: bigint]
export type moonbeam_Storage_LocalAssets_Account = {
  balance: bigint
  status: IcPallet_assetsTypesAccountStatus
  reason: IcPallet_assetsTypesExistenceReason
  extra: undefined
}
export type moonbeam_Storage_LocalAssets_Account_Args = [bigint, Icdc1]
export type moonbeam_Storage_LocalAssets_Approvals = {
  amount: bigint
  deposit: bigint
}
export type moonbeam_Storage_LocalAssets_Approvals_Args = [bigint, Icdc1, Icdc1]
export type moonbeam_Storage_LocalAssets_Metadata = {
  deposit: bigint
  name: I_bytesSeq
  symbol: I_bytesSeq
  decimals: number
  is_frozen: boolean
}
export type moonbeam_Storage_LocalAssets_Metadata_Args = [Key: bigint]
export type moonbeam_Tx_LocalAssets_create = [
  Id: bigint,
  Admin: Icdc1,
  Min_balance: bigint,
]
export type moonbeam_Tx_LocalAssets_force_create = [
  Id: bigint,
  Owner: Icdc1,
  Is_sufficient: boolean,
  Min_balance: bigint,
]
export type moonbeam_Tx_LocalAssets_start_destroy = [Id: bigint]
export type moonbeam_Tx_LocalAssets_destroy_accounts = [Id: bigint]
export type moonbeam_Tx_LocalAssets_destroy_approvals = [Id: bigint]
export type moonbeam_Tx_LocalAssets_finish_destroy = [Id: bigint]
export type moonbeam_Tx_LocalAssets_mint = [
  Id: bigint,
  Beneficiary: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_LocalAssets_burn = [
  Id: bigint,
  Who: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_LocalAssets_transfer = [
  Id: bigint,
  Target: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_LocalAssets_transfer_keep_alive = [
  Id: bigint,
  Target: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_LocalAssets_force_transfer = [
  Id: bigint,
  Source: Icdc1,
  Dest: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_LocalAssets_freeze = [Id: bigint, Who: Icdc1]
export type moonbeam_Tx_LocalAssets_thaw = [Id: bigint, Who: Icdc1]
export type moonbeam_Tx_LocalAssets_freeze_asset = [Id: bigint]
export type moonbeam_Tx_LocalAssets_thaw_asset = [Id: bigint]
export type moonbeam_Tx_LocalAssets_transfer_ownership = [
  Id: bigint,
  Owner: Icdc1,
]
export type moonbeam_Tx_LocalAssets_set_team = [
  Id: bigint,
  Issuer: Icdc1,
  Admin: Icdc1,
  Freezer: Icdc1,
]
export type moonbeam_Tx_LocalAssets_set_metadata = [
  Id: bigint,
  Name: I_bytesSeq,
  Symbol: I_bytesSeq,
  Decimals: number,
]
export type moonbeam_Tx_LocalAssets_clear_metadata = [Id: bigint]
export type moonbeam_Tx_LocalAssets_force_set_metadata = [
  Id: bigint,
  Name: I_bytesSeq,
  Symbol: I_bytesSeq,
  Decimals: number,
  Is_frozen: boolean,
]
export type moonbeam_Tx_LocalAssets_force_clear_metadata = [Id: bigint]
export type moonbeam_Tx_LocalAssets_force_asset_status = [
  Id: bigint,
  Owner: Icdc1,
  Issuer: Icdc1,
  Admin: Icdc1,
  Freezer: Icdc1,
  Min_balance: bigint,
  Is_sufficient: boolean,
  Is_frozen: boolean,
]
export type moonbeam_Tx_LocalAssets_approve_transfer = [
  Id: bigint,
  Delegate: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_LocalAssets_cancel_approval = [
  Id: bigint,
  Delegate: Icdc1,
]
export type moonbeam_Tx_LocalAssets_force_cancel_approval = [
  Id: bigint,
  Owner: Icdc1,
  Delegate: Icdc1,
]
export type moonbeam_Tx_LocalAssets_transfer_approved = [
  Id: bigint,
  Owner: Icdc1,
  Destination: Icdc1,
  Amount: bigint,
]
export type moonbeam_Tx_LocalAssets_touch = [Id: bigint]
export type moonbeam_Tx_LocalAssets_refund = [Id: bigint, Allow_burn: boolean]
export type moonbeam_Tx_LocalAssets_set_min_balance = [
  Id: bigint,
  Min_balance: bigint,
]
export type moonbeam_Tx_LocalAssets_touch_other = [Id: bigint, Who: Icdc1]
export type moonbeam_Tx_LocalAssets_refund_other = [Id: bigint, Who: Icdc1]
export type moonbeam_Tx_LocalAssets_block = [Id: bigint, Who: Icdc1]
export type moonbeam_Error_LocalAssets_BalanceLow = undefined
export type moonbeam_Error_LocalAssets_NoAccount = undefined
export type moonbeam_Error_LocalAssets_NoPermission = undefined
export type moonbeam_Error_LocalAssets_Unknown = undefined
export type moonbeam_Error_LocalAssets_Frozen = undefined
export type moonbeam_Error_LocalAssets_InUse = undefined
export type moonbeam_Error_LocalAssets_BadWitness = undefined
export type moonbeam_Error_LocalAssets_MinBalanceZero = undefined
export type moonbeam_Error_LocalAssets_UnavailableConsumer = undefined
export type moonbeam_Error_LocalAssets_BadMetadata = undefined
export type moonbeam_Error_LocalAssets_Unapproved = undefined
export type moonbeam_Error_LocalAssets_WouldDie = undefined
export type moonbeam_Error_LocalAssets_AlreadyExists = undefined
export type moonbeam_Error_LocalAssets_NoDeposit = undefined
export type moonbeam_Error_LocalAssets_WouldBurn = undefined
export type moonbeam_Error_LocalAssets_LiveAsset = undefined
export type moonbeam_Error_LocalAssets_AssetNotLive = undefined
export type moonbeam_Error_LocalAssets_IncorrectStatus = undefined
export type moonbeam_Error_LocalAssets_NotFrozen = undefined
export type moonbeam_Error_LocalAssets_CallbackFailed = undefined
export type moonbeam_Event_LocalAssets_Created = {
  asset_id: bigint
  creator: Icdc1
  owner: Icdc1
}
export type moonbeam_Event_LocalAssets_Issued = {
  asset_id: bigint
  owner: Icdc1
  amount: bigint
}
export type moonbeam_Event_LocalAssets_Transferred = {
  asset_id: bigint
  from: Icdc1
  to: Icdc1
  amount: bigint
}
export type moonbeam_Event_LocalAssets_Burned = {
  asset_id: bigint
  owner: Icdc1
  balance: bigint
}
export type moonbeam_Event_LocalAssets_TeamChanged = {
  asset_id: bigint
  issuer: Icdc1
  admin: Icdc1
  freezer: Icdc1
}
export type moonbeam_Event_LocalAssets_OwnerChanged = {
  asset_id: bigint
  owner: Icdc1
}
export type moonbeam_Event_LocalAssets_Frozen = { asset_id: bigint; who: Icdc1 }
export type moonbeam_Event_LocalAssets_Thawed = { asset_id: bigint; who: Icdc1 }
export type moonbeam_Event_LocalAssets_AssetFrozen = { asset_id: bigint }
export type moonbeam_Event_LocalAssets_AssetThawed = { asset_id: bigint }
export type moonbeam_Event_LocalAssets_AccountsDestroyed = {
  asset_id: bigint
  accounts_destroyed: number
  accounts_remaining: number
}
export type moonbeam_Event_LocalAssets_ApprovalsDestroyed = {
  asset_id: bigint
  approvals_destroyed: number
  approvals_remaining: number
}
export type moonbeam_Event_LocalAssets_DestructionStarted = { asset_id: bigint }
export type moonbeam_Event_LocalAssets_Destroyed = { asset_id: bigint }
export type moonbeam_Event_LocalAssets_ForceCreated = {
  asset_id: bigint
  owner: Icdc1
}
export type moonbeam_Event_LocalAssets_MetadataSet = {
  asset_id: bigint
  name: I_bytesSeq
  symbol: I_bytesSeq
  decimals: number
  is_frozen: boolean
}
export type moonbeam_Event_LocalAssets_MetadataCleared = { asset_id: bigint }
export type moonbeam_Event_LocalAssets_ApprovedTransfer = {
  asset_id: bigint
  source: Icdc1
  delegate: Icdc1
  amount: bigint
}
export type moonbeam_Event_LocalAssets_ApprovalCancelled = {
  asset_id: bigint
  owner: Icdc1
  delegate: Icdc1
}
export type moonbeam_Event_LocalAssets_TransferredApproved = {
  asset_id: bigint
  owner: Icdc1
  delegate: Icdc1
  destination: Icdc1
  amount: bigint
}
export type moonbeam_Event_LocalAssets_AssetStatusChanged = { asset_id: bigint }
export type moonbeam_Event_LocalAssets_AssetMinBalanceChanged = {
  asset_id: bigint
  new_min_balance: bigint
}
export type moonbeam_Event_LocalAssets_Touched = {
  asset_id: bigint
  who: Icdc1
  depositor: Icdc1
}
export type moonbeam_Event_LocalAssets_Blocked = {
  asset_id: bigint
  who: Icdc1
}
export type moonbeam_Constant_LocalAssets_RemoveItemsLimit = number
export type moonbeam_Constant_LocalAssets_AssetDeposit = bigint
export type moonbeam_Constant_LocalAssets_AssetAccountDeposit = bigint
export type moonbeam_Constant_LocalAssets_MetadataDepositBase = bigint
export type moonbeam_Constant_LocalAssets_MetadataDepositPerByte = bigint
export type moonbeam_Constant_LocalAssets_ApprovalDeposit = bigint
export type moonbeam_Constant_LocalAssets_StringLimit = number
export type moonbeam_Storage_EthereumXcm_Nonce = Array<bigint>
export type moonbeam_Storage_EthereumXcm_Nonce_Args = []
export type moonbeam_Storage_EthereumXcm_EthereumXcmSuspended = boolean
export type moonbeam_Storage_EthereumXcm_EthereumXcmSuspended_Args = []
export type moonbeam_Tx_EthereumXcm_transact = [
  Xcm_transaction: IcXcm_primitivesEthereum_xcmEthereumXcmTransaction,
]
export type moonbeam_Tx_EthereumXcm_transact_through_proxy = [
  Transact_as: Icdc1,
  Xcm_transaction: IcXcm_primitivesEthereum_xcmEthereumXcmTransaction,
]
export type moonbeam_Tx_EthereumXcm_suspend_ethereum_xcm_execution = []
export type moonbeam_Tx_EthereumXcm_resume_ethereum_xcm_execution = []
export type moonbeam_Error_EthereumXcm_EthereumXcmExecutionSuspended = undefined
export type moonbeam_Storage_Randomness_Requests = {
  request: IcPallet_randomnessTypesRequest
  deposit: bigint
}
export type moonbeam_Storage_Randomness_Requests_Args = [Key: bigint]
export type moonbeam_Storage_Randomness_RequestCount = bigint
export type moonbeam_Storage_Randomness_RequestCount_Args = []
export type moonbeam_Storage_Randomness_LocalVrfOutput =
  | { tag: "None"; value: undefined }
  | { tag: "Some"; value: IcOptionSome }
export type moonbeam_Storage_Randomness_LocalVrfOutput_Args = []
export type moonbeam_Storage_Randomness_RelayEpoch = bigint
export type moonbeam_Storage_Randomness_RelayEpoch_Args = []
export type moonbeam_Storage_Randomness_InherentIncluded = undefined
export type moonbeam_Storage_Randomness_InherentIncluded_Args = []
export type moonbeam_Storage_Randomness_NotFirstBlock = undefined
export type moonbeam_Storage_Randomness_NotFirstBlock_Args = []
export type moonbeam_Storage_Randomness_RandomnessResults = {
  randomness: IcOption
  request_count: bigint
}
export type moonbeam_Storage_Randomness_RandomnessResults_Args = [
  Key: IcPallet_randomnessTypesRequestType,
]
export type moonbeam_Storage_Randomness_PreviousLocalVrfOutput = HexString
export type moonbeam_Storage_Randomness_PreviousLocalVrfOutput_Args = []
export type moonbeam_Tx_Randomness_set_babe_randomness_results = []
export type moonbeam_Error_Randomness_RequestCounterOverflowed = undefined
export type moonbeam_Error_Randomness_RequestFeeOverflowed = undefined
export type moonbeam_Error_Randomness_MustRequestAtLeastOneWord = undefined
export type moonbeam_Error_Randomness_CannotRequestMoreWordsThanMax = undefined
export type moonbeam_Error_Randomness_CannotRequestRandomnessAfterMaxDelay =
  undefined
export type moonbeam_Error_Randomness_CannotRequestRandomnessBeforeMinDelay =
  undefined
export type moonbeam_Error_Randomness_RequestDNE = undefined
export type moonbeam_Error_Randomness_RequestCannotYetBeFulfilled = undefined
export type moonbeam_Error_Randomness_OnlyRequesterCanIncreaseFee = undefined
export type moonbeam_Error_Randomness_RequestHasNotExpired = undefined
export type moonbeam_Error_Randomness_RandomnessResultDNE = undefined
export type moonbeam_Error_Randomness_RandomnessResultNotFilled = undefined
export type moonbeam_Event_Randomness_RandomnessRequestedBabeEpoch = {
  id: bigint
  refund_address: Icdc1
  contract_address: Icdc1
  fee: bigint
  gas_limit: bigint
  num_words: number
  salt: Icdc13
  earliest_epoch: bigint
}
export type moonbeam_Event_Randomness_RandomnessRequestedLocal = {
  id: bigint
  refund_address: Icdc1
  contract_address: Icdc1
  fee: bigint
  gas_limit: bigint
  num_words: number
  salt: Icdc13
  earliest_block: number
}
export type moonbeam_Event_Randomness_RequestFulfilled = { id: bigint }
export type moonbeam_Event_Randomness_RequestFeeIncreased = {
  id: bigint
  new_fee: bigint
}
export type moonbeam_Event_Randomness_RequestExpirationExecuted = { id: bigint }
export type moonbeam_Constant_Randomness_Deposit = bigint
export type moonbeam_Constant_Randomness_MaxRandomWords = number
export type moonbeam_Constant_Randomness_MinBlockDelay = number
export type moonbeam_Constant_Randomness_MaxBlockDelay = number
export type moonbeam_Constant_Randomness_BlockExpirationDelay = number
export type moonbeam_Constant_Randomness_EpochExpirationDelay = bigint