lib/generated/gdev/types/pallet_authority_members/pallet/call.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+import '../../gdev_runtime/opaque/session_keys.dart' as _i3;
+
+/// Contains a variant per dispatchable extrinsic that this pallet has.
+abstract class Call {
+  const Call();
+
+  factory Call.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  static const $CallCodec codec = $CallCodec();
+
+  static const $Call values = $Call();
+
+  _i2.Uint8List encode() {
+    final output = _i1.ByteOutput(codec.sizeHint(this));
+    codec.encodeTo(this, output);
+    return output.toBytes();
+  }
+
+  int sizeHint() {
+    return codec.sizeHint(this);
+  }
+
+  Map<String, dynamic> toJson();
+}
+
+class $Call {
+  const $Call();
+
+  GoOffline goOffline() {
+    return GoOffline();
+  }
+
+  GoOnline goOnline() {
+    return GoOnline();
+  }
+
+  SetSessionKeys setSessionKeys({required _i3.SessionKeys keys}) {
+    return SetSessionKeys(keys: keys);
+  }
+
+  RemoveMember removeMember({required int memberId}) {
+    return RemoveMember(memberId: memberId);
+  }
+
+  RemoveMemberFromBlacklist removeMemberFromBlacklist({required int memberId}) {
+    return RemoveMemberFromBlacklist(memberId: memberId);
+  }
+}
+
+class $CallCodec with _i1.Codec<Call> {
+  const $CallCodec();
+
+  @override
+  Call decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return const GoOffline();
+      case 1:
+        return const GoOnline();
+      case 2:
+        return SetSessionKeys._decode(input);
+      case 3:
+        return RemoveMember._decode(input);
+      case 4:
+        return RemoveMemberFromBlacklist._decode(input);
+      default:
+        throw Exception('Call: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Call value,
+    _i1.Output output,
+  ) {
+    switch (value.runtimeType) {
+      case GoOffline:
+        (value as GoOffline).encodeTo(output);
+        break;
+      case GoOnline:
+        (value as GoOnline).encodeTo(output);
+        break;
+      case SetSessionKeys:
+        (value as SetSessionKeys).encodeTo(output);
+        break;
+      case RemoveMember:
+        (value as RemoveMember).encodeTo(output);
+        break;
+      case RemoveMemberFromBlacklist:
+        (value as RemoveMemberFromBlacklist).encodeTo(output);
+        break;
+      default:
+        throw Exception(
+            'Call: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+
+  @override
+  int sizeHint(Call value) {
+    switch (value.runtimeType) {
+      case GoOffline:
+        return 1;
+      case GoOnline:
+        return 1;
+      case SetSessionKeys:
+        return (value as SetSessionKeys)._sizeHint();
+      case RemoveMember:
+        return (value as RemoveMember)._sizeHint();
+      case RemoveMemberFromBlacklist:
+        return (value as RemoveMemberFromBlacklist)._sizeHint();
+      default:
+        throw Exception(
+            'Call: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+}
+
+/// Request to leave the set of validators two sessions later.
+class GoOffline extends Call {
+  const GoOffline();
+
+  @override
+  Map<String, dynamic> toJson() => {'go_offline': null};
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      0,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) => other is GoOffline;
+
+  @override
+  int get hashCode => runtimeType.hashCode;
+}
+
+/// Request to join the set of validators two sessions later.
+class GoOnline extends Call {
+  const GoOnline();
+
+  @override
+  Map<String, dynamic> toJson() => {'go_online': null};
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      1,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) => other is GoOnline;
+
+  @override
+  int get hashCode => runtimeType.hashCode;
+}
+
+/// Declare new session keys to replace current ones.
+class SetSessionKeys extends Call {
+  const SetSessionKeys({required this.keys});
+
+  factory SetSessionKeys._decode(_i1.Input input) {
+    return SetSessionKeys(keys: _i3.SessionKeys.codec.decode(input));
+  }
+
+  /// T::Keys
+  final _i3.SessionKeys keys;
+
+  @override
+  Map<String, Map<String, Map<String, List<int>>>> toJson() => {
+        'set_session_keys': {'keys': keys.toJson()}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i3.SessionKeys.codec.sizeHint(keys);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      2,
+      output,
+    );
+    _i3.SessionKeys.codec.encodeTo(
+      keys,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is SetSessionKeys && other.keys == keys;
+
+  @override
+  int get hashCode => keys.hashCode;
+}
+
+/// Remove a member from the set of validators.
+class RemoveMember extends Call {
+  const RemoveMember({required this.memberId});
+
+  factory RemoveMember._decode(_i1.Input input) {
+    return RemoveMember(memberId: _i1.U32Codec.codec.decode(input));
+  }
+
+  /// T::MemberId
+  final int memberId;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'remove_member': {'memberId': memberId}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(memberId);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      3,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      memberId,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is RemoveMember && other.memberId == memberId;
+
+  @override
+  int get hashCode => memberId.hashCode;
+}
+
+/// Remove a member from the blacklist.
+/// remove an identity from the blacklist
+class RemoveMemberFromBlacklist extends Call {
+  const RemoveMemberFromBlacklist({required this.memberId});
+
+  factory RemoveMemberFromBlacklist._decode(_i1.Input input) {
+    return RemoveMemberFromBlacklist(
+        memberId: _i1.U32Codec.codec.decode(input));
+  }
+
+  /// T::MemberId
+  final int memberId;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'remove_member_from_blacklist': {'memberId': memberId}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(memberId);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      4,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      memberId,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is RemoveMemberFromBlacklist && other.memberId == memberId;
+
+  @override
+  int get hashCode => memberId.hashCode;
+}

lib/generated/gdev/types/pallet_authority_members/pallet/error.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+/// The `Error` enum of this pallet.
+enum Error {
+  /// Member already incoming.
+  alreadyIncoming('AlreadyIncoming', 0),
+
+  /// Member already online.
+  alreadyOnline('AlreadyOnline', 1),
+
+  /// Member already outgoing.
+  alreadyOutgoing('AlreadyOutgoing', 2),
+
+  /// Owner key is invalid as a member.
+  memberIdNotFound('MemberIdNotFound', 3),
+
+  /// Member is blacklisted.
+  memberBlacklisted('MemberBlacklisted', 4),
+
+  /// Member is not blacklisted.
+  memberNotBlacklisted('MemberNotBlacklisted', 5),
+
+  /// Member not found.
+  memberNotFound('MemberNotFound', 6),
+
+  /// Neither online nor scheduled.
+  notOnlineNorIncoming('NotOnlineNorIncoming', 7),
+
+  /// Not member.
+  notMember('NotMember', 8),
+
+  /// Session keys not provided.
+  sessionKeysNotProvided('SessionKeysNotProvided', 9),
+
+  /// Too many authorities.
+  tooManyAuthorities('TooManyAuthorities', 10);
+
+  const Error(
+    this.variantName,
+    this.codecIndex,
+  );
+
+  factory Error.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  final String variantName;
+
+  final int codecIndex;
+
+  static const $ErrorCodec codec = $ErrorCodec();
+
+  String toJson() => variantName;
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+}
+
+class $ErrorCodec with _i1.Codec<Error> {
+  const $ErrorCodec();
+
+  @override
+  Error decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return Error.alreadyIncoming;
+      case 1:
+        return Error.alreadyOnline;
+      case 2:
+        return Error.alreadyOutgoing;
+      case 3:
+        return Error.memberIdNotFound;
+      case 4:
+        return Error.memberBlacklisted;
+      case 5:
+        return Error.memberNotBlacklisted;
+      case 6:
+        return Error.memberNotFound;
+      case 7:
+        return Error.notOnlineNorIncoming;
+      case 8:
+        return Error.notMember;
+      case 9:
+        return Error.sessionKeysNotProvided;
+      case 10:
+        return Error.tooManyAuthorities;
+      default:
+        throw Exception('Error: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Error value,
+    _i1.Output output,
+  ) {
+    _i1.U8Codec.codec.encodeTo(
+      value.codecIndex,
+      output,
+    );
+  }
+}

lib/generated/gdev/types/pallet_authority_members/pallet/event.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+import 'package:quiver/collection.dart' as _i3;
+
+/// The `Event` enum of this pallet
+abstract class Event {
+  const Event();
+
+  factory Event.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  static const $EventCodec codec = $EventCodec();
+
+  static const $Event values = $Event();
+
+  _i2.Uint8List encode() {
+    final output = _i1.ByteOutput(codec.sizeHint(this));
+    codec.encodeTo(this, output);
+    return output.toBytes();
+  }
+
+  int sizeHint() {
+    return codec.sizeHint(this);
+  }
+
+  Map<String, Map<String, dynamic>> toJson();
+}
+
+class $Event {
+  const $Event();
+
+  IncomingAuthorities incomingAuthorities({required List<int> members}) {
+    return IncomingAuthorities(members: members);
+  }
+
+  OutgoingAuthorities outgoingAuthorities({required List<int> members}) {
+    return OutgoingAuthorities(members: members);
+  }
+
+  MemberGoOffline memberGoOffline({required int member}) {
+    return MemberGoOffline(member: member);
+  }
+
+  MemberGoOnline memberGoOnline({required int member}) {
+    return MemberGoOnline(member: member);
+  }
+
+  MemberRemoved memberRemoved({required int member}) {
+    return MemberRemoved(member: member);
+  }
+
+  MemberRemovedFromBlacklist memberRemovedFromBlacklist({required int member}) {
+    return MemberRemovedFromBlacklist(member: member);
+  }
+
+  MemberAddedToBlacklist memberAddedToBlacklist({required int member}) {
+    return MemberAddedToBlacklist(member: member);
+  }
+}
+
+class $EventCodec with _i1.Codec<Event> {
+  const $EventCodec();
+
+  @override
+  Event decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return IncomingAuthorities._decode(input);
+      case 1:
+        return OutgoingAuthorities._decode(input);
+      case 2:
+        return MemberGoOffline._decode(input);
+      case 3:
+        return MemberGoOnline._decode(input);
+      case 4:
+        return MemberRemoved._decode(input);
+      case 5:
+        return MemberRemovedFromBlacklist._decode(input);
+      case 6:
+        return MemberAddedToBlacklist._decode(input);
+      default:
+        throw Exception('Event: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Event value,
+    _i1.Output output,
+  ) {
+    switch (value.runtimeType) {
+      case IncomingAuthorities:
+        (value as IncomingAuthorities).encodeTo(output);
+        break;
+      case OutgoingAuthorities:
+        (value as OutgoingAuthorities).encodeTo(output);
+        break;
+      case MemberGoOffline:
+        (value as MemberGoOffline).encodeTo(output);
+        break;
+      case MemberGoOnline:
+        (value as MemberGoOnline).encodeTo(output);
+        break;
+      case MemberRemoved:
+        (value as MemberRemoved).encodeTo(output);
+        break;
+      case MemberRemovedFromBlacklist:
+        (value as MemberRemovedFromBlacklist).encodeTo(output);
+        break;
+      case MemberAddedToBlacklist:
+        (value as MemberAddedToBlacklist).encodeTo(output);
+        break;
+      default:
+        throw Exception(
+            'Event: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+
+  @override
+  int sizeHint(Event value) {
+    switch (value.runtimeType) {
+      case IncomingAuthorities:
+        return (value as IncomingAuthorities)._sizeHint();
+      case OutgoingAuthorities:
+        return (value as OutgoingAuthorities)._sizeHint();
+      case MemberGoOffline:
+        return (value as MemberGoOffline)._sizeHint();
+      case MemberGoOnline:
+        return (value as MemberGoOnline)._sizeHint();
+      case MemberRemoved:
+        return (value as MemberRemoved)._sizeHint();
+      case MemberRemovedFromBlacklist:
+        return (value as MemberRemovedFromBlacklist)._sizeHint();
+      case MemberAddedToBlacklist:
+        return (value as MemberAddedToBlacklist)._sizeHint();
+      default:
+        throw Exception(
+            'Event: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+}
+
+/// List of members scheduled to join the set of authorities in the next session.
+class IncomingAuthorities extends Event {
+  const IncomingAuthorities({required this.members});
+
+  factory IncomingAuthorities._decode(_i1.Input input) {
+    return IncomingAuthorities(
+        members: _i1.U32SequenceCodec.codec.decode(input));
+  }
+
+  /// Vec<T::MemberId>
+  final List<int> members;
+
+  @override
+  Map<String, Map<String, List<int>>> toJson() => {
+        'IncomingAuthorities': {'members': members}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32SequenceCodec.codec.sizeHint(members);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      0,
+      output,
+    );
+    _i1.U32SequenceCodec.codec.encodeTo(
+      members,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is IncomingAuthorities &&
+          _i3.listsEqual(
+            other.members,
+            members,
+          );
+
+  @override
+  int get hashCode => members.hashCode;
+}
+
+/// List of members leaving the set of authorities in the next session.
+class OutgoingAuthorities extends Event {
+  const OutgoingAuthorities({required this.members});
+
+  factory OutgoingAuthorities._decode(_i1.Input input) {
+    return OutgoingAuthorities(
+        members: _i1.U32SequenceCodec.codec.decode(input));
+  }
+
+  /// Vec<T::MemberId>
+  final List<int> members;
+
+  @override
+  Map<String, Map<String, List<int>>> toJson() => {
+        'OutgoingAuthorities': {'members': members}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32SequenceCodec.codec.sizeHint(members);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      1,
+      output,
+    );
+    _i1.U32SequenceCodec.codec.encodeTo(
+      members,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is OutgoingAuthorities &&
+          _i3.listsEqual(
+            other.members,
+            members,
+          );
+
+  @override
+  int get hashCode => members.hashCode;
+}
+
+/// A member will leave the set of authorities in 2 sessions.
+class MemberGoOffline extends Event {
+  const MemberGoOffline({required this.member});
+
+  factory MemberGoOffline._decode(_i1.Input input) {
+    return MemberGoOffline(member: _i1.U32Codec.codec.decode(input));
+  }
+
+  /// T::MemberId
+  final int member;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'MemberGoOffline': {'member': member}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(member);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      2,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      member,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is MemberGoOffline && other.member == member;
+
+  @override
+  int get hashCode => member.hashCode;
+}
+
+/// A member will join the set of authorities in 2 sessions.
+class MemberGoOnline extends Event {
+  const MemberGoOnline({required this.member});
+
+  factory MemberGoOnline._decode(_i1.Input input) {
+    return MemberGoOnline(member: _i1.U32Codec.codec.decode(input));
+  }
+
+  /// T::MemberId
+  final int member;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'MemberGoOnline': {'member': member}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(member);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      3,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      member,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is MemberGoOnline && other.member == member;
+
+  @override
+  int get hashCode => member.hashCode;
+}
+
+/// A member, who no longer has authority rights, will be removed from the authority set in 2 sessions.
+class MemberRemoved extends Event {
+  const MemberRemoved({required this.member});
+
+  factory MemberRemoved._decode(_i1.Input input) {
+    return MemberRemoved(member: _i1.U32Codec.codec.decode(input));
+  }
+
+  /// T::MemberId
+  final int member;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'MemberRemoved': {'member': member}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(member);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      4,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      member,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is MemberRemoved && other.member == member;
+
+  @override
+  int get hashCode => member.hashCode;
+}
+
+/// A member has been removed from the blacklist.
+class MemberRemovedFromBlacklist extends Event {
+  const MemberRemovedFromBlacklist({required this.member});
+
+  factory MemberRemovedFromBlacklist._decode(_i1.Input input) {
+    return MemberRemovedFromBlacklist(member: _i1.U32Codec.codec.decode(input));
+  }
+
+  /// T::MemberId
+  final int member;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'MemberRemovedFromBlacklist': {'member': member}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(member);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      5,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      member,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is MemberRemovedFromBlacklist && other.member == member;
+
+  @override
+  int get hashCode => member.hashCode;
+}
+
+/// A member has been blacklisted.
+class MemberAddedToBlacklist extends Event {
+  const MemberAddedToBlacklist({required this.member});
+
+  factory MemberAddedToBlacklist._decode(_i1.Input input) {
+    return MemberAddedToBlacklist(member: _i1.U32Codec.codec.decode(input));
+  }
+
+  /// T::MemberId
+  final int member;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'MemberAddedToBlacklist': {'member': member}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(member);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      6,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      member,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is MemberAddedToBlacklist && other.member == member;
+
+  @override
+  int get hashCode => member.hashCode;
+}

lib/generated/gdev/types/pallet_authority_members/types/member_data.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i3;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+import 'package:quiver/collection.dart' as _i4;
+
+import '../../sp_core/crypto/account_id32.dart' as _i2;
+
+class MemberData {
+  const MemberData({required this.ownerKey});
+
+  factory MemberData.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  /// AccountId
+  final _i2.AccountId32 ownerKey;
+
+  static const $MemberDataCodec codec = $MemberDataCodec();
+
+  _i3.Uint8List encode() {
+    return codec.encode(this);
+  }
+
+  Map<String, List<int>> toJson() => {'ownerKey': ownerKey.toList()};
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is MemberData &&
+          _i4.listsEqual(
+            other.ownerKey,
+            ownerKey,
+          );
+
+  @override
+  int get hashCode => ownerKey.hashCode;
+}
+
+class $MemberDataCodec with _i1.Codec<MemberData> {
+  const $MemberDataCodec();
+
+  @override
+  void encodeTo(
+    MemberData obj,
+    _i1.Output output,
+  ) {
+    const _i1.U8ArrayCodec(32).encodeTo(
+      obj.ownerKey,
+      output,
+    );
+  }
+
+  @override
+  MemberData decode(_i1.Input input) {
+    return MemberData(ownerKey: const _i1.U8ArrayCodec(32).decode(input));
+  }
+
+  @override
+  int sizeHint(MemberData obj) {
+    int size = 0;
+    size = size + const _i2.AccountId32Codec().sizeHint(obj.ownerKey);
+    return size;
+  }
+}

lib/generated/gdev/types/pallet_babe/pallet/call.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+import '../../sp_consensus_babe/digests/next_config_descriptor.dart' as _i5;
+import '../../sp_consensus_slots/equivocation_proof.dart' as _i3;
+import '../../sp_session/membership_proof.dart' as _i4;
+
+/// Contains a variant per dispatchable extrinsic that this pallet has.
+abstract class Call {
+  const Call();
+
+  factory Call.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  static const $CallCodec codec = $CallCodec();
+
+  static const $Call values = $Call();
+
+  _i2.Uint8List encode() {
+    final output = _i1.ByteOutput(codec.sizeHint(this));
+    codec.encodeTo(this, output);
+    return output.toBytes();
+  }
+
+  int sizeHint() {
+    return codec.sizeHint(this);
+  }
+
+  Map<String, Map<String, Map<String, dynamic>>> toJson();
+}
+
+class $Call {
+  const $Call();
+
+  ReportEquivocation reportEquivocation({
+    required _i3.EquivocationProof equivocationProof,
+    required _i4.MembershipProof keyOwnerProof,
+  }) {
+    return ReportEquivocation(
+      equivocationProof: equivocationProof,
+      keyOwnerProof: keyOwnerProof,
+    );
+  }
+
+  ReportEquivocationUnsigned reportEquivocationUnsigned({
+    required _i3.EquivocationProof equivocationProof,
+    required _i4.MembershipProof keyOwnerProof,
+  }) {
+    return ReportEquivocationUnsigned(
+      equivocationProof: equivocationProof,
+      keyOwnerProof: keyOwnerProof,
+    );
+  }
+
+  PlanConfigChange planConfigChange(
+      {required _i5.NextConfigDescriptor config}) {
+    return PlanConfigChange(config: config);
+  }
+}
+
+class $CallCodec with _i1.Codec<Call> {
+  const $CallCodec();
+
+  @override
+  Call decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return ReportEquivocation._decode(input);
+      case 1:
+        return ReportEquivocationUnsigned._decode(input);
+      case 2:
+        return PlanConfigChange._decode(input);
+      default:
+        throw Exception('Call: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Call value,
+    _i1.Output output,
+  ) {
+    switch (value.runtimeType) {
+      case ReportEquivocation:
+        (value as ReportEquivocation).encodeTo(output);
+        break;
+      case ReportEquivocationUnsigned:
+        (value as ReportEquivocationUnsigned).encodeTo(output);
+        break;
+      case PlanConfigChange:
+        (value as PlanConfigChange).encodeTo(output);
+        break;
+      default:
+        throw Exception(
+            'Call: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+
+  @override
+  int sizeHint(Call value) {
+    switch (value.runtimeType) {
+      case ReportEquivocation:
+        return (value as ReportEquivocation)._sizeHint();
+      case ReportEquivocationUnsigned:
+        return (value as ReportEquivocationUnsigned)._sizeHint();
+      case PlanConfigChange:
+        return (value as PlanConfigChange)._sizeHint();
+      default:
+        throw Exception(
+            'Call: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+}
+
+/// Report authority equivocation/misbehavior. This method will verify
+/// the equivocation proof and validate the given key ownership proof
+/// against the extracted offender. If both are valid, the offence will
+/// be reported.
+class ReportEquivocation extends Call {
+  const ReportEquivocation({
+    required this.equivocationProof,
+    required this.keyOwnerProof,
+  });
+
+  factory ReportEquivocation._decode(_i1.Input input) {
+    return ReportEquivocation(
+      equivocationProof: _i3.EquivocationProof.codec.decode(input),
+      keyOwnerProof: _i4.MembershipProof.codec.decode(input),
+    );
+  }
+
+  /// Box<EquivocationProof<HeaderFor<T>>>
+  final _i3.EquivocationProof equivocationProof;
+
+  /// T::KeyOwnerProof
+  final _i4.MembershipProof keyOwnerProof;
+
+  @override
+  Map<String, Map<String, Map<String, dynamic>>> toJson() => {
+        'report_equivocation': {
+          'equivocationProof': equivocationProof.toJson(),
+          'keyOwnerProof': keyOwnerProof.toJson(),
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i3.EquivocationProof.codec.sizeHint(equivocationProof);
+    size = size + _i4.MembershipProof.codec.sizeHint(keyOwnerProof);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      0,
+      output,
+    );
+    _i3.EquivocationProof.codec.encodeTo(
+      equivocationProof,
+      output,
+    );
+    _i4.MembershipProof.codec.encodeTo(
+      keyOwnerProof,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is ReportEquivocation &&
+          other.equivocationProof == equivocationProof &&
+          other.keyOwnerProof == keyOwnerProof;
+
+  @override
+  int get hashCode => Object.hash(
+        equivocationProof,
+        keyOwnerProof,
+      );
+}
+
+/// Report authority equivocation/misbehavior. This method will verify
+/// the equivocation proof and validate the given key ownership proof
+/// against the extracted offender. If both are valid, the offence will
+/// be reported.
+/// This extrinsic must be called unsigned and it is expected that only
+/// block authors will call it (validated in `ValidateUnsigned`), as such
+/// if the block author is defined it will be defined as the equivocation
+/// reporter.
+class ReportEquivocationUnsigned extends Call {
+  const ReportEquivocationUnsigned({
+    required this.equivocationProof,
+    required this.keyOwnerProof,
+  });
+
+  factory ReportEquivocationUnsigned._decode(_i1.Input input) {
+    return ReportEquivocationUnsigned(
+      equivocationProof: _i3.EquivocationProof.codec.decode(input),
+      keyOwnerProof: _i4.MembershipProof.codec.decode(input),
+    );
+  }
+
+  /// Box<EquivocationProof<HeaderFor<T>>>
+  final _i3.EquivocationProof equivocationProof;
+
+  /// T::KeyOwnerProof
+  final _i4.MembershipProof keyOwnerProof;
+
+  @override
+  Map<String, Map<String, Map<String, dynamic>>> toJson() => {
+        'report_equivocation_unsigned': {
+          'equivocationProof': equivocationProof.toJson(),
+          'keyOwnerProof': keyOwnerProof.toJson(),
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i3.EquivocationProof.codec.sizeHint(equivocationProof);
+    size = size + _i4.MembershipProof.codec.sizeHint(keyOwnerProof);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      1,
+      output,
+    );
+    _i3.EquivocationProof.codec.encodeTo(
+      equivocationProof,
+      output,
+    );
+    _i4.MembershipProof.codec.encodeTo(
+      keyOwnerProof,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is ReportEquivocationUnsigned &&
+          other.equivocationProof == equivocationProof &&
+          other.keyOwnerProof == keyOwnerProof;
+
+  @override
+  int get hashCode => Object.hash(
+        equivocationProof,
+        keyOwnerProof,
+      );
+}
+
+/// Plan an epoch config change. The epoch config change is recorded and will be enacted on
+/// the next call to `enact_epoch_change`. The config will be activated one epoch after.
+/// Multiple calls to this method will replace any existing planned config change that had
+/// not been enacted yet.
+class PlanConfigChange extends Call {
+  const PlanConfigChange({required this.config});
+
+  factory PlanConfigChange._decode(_i1.Input input) {
+    return PlanConfigChange(
+        config: _i5.NextConfigDescriptor.codec.decode(input));
+  }
+
+  /// NextConfigDescriptor
+  final _i5.NextConfigDescriptor config;
+
+  @override
+  Map<String, Map<String, Map<String, Map<String, dynamic>>>> toJson() => {
+        'plan_config_change': {'config': config.toJson()}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i5.NextConfigDescriptor.codec.sizeHint(config);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      2,
+      output,
+    );
+    _i5.NextConfigDescriptor.codec.encodeTo(
+      config,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is PlanConfigChange && other.config == config;
+
+  @override
+  int get hashCode => config.hashCode;
+}

lib/generated/gdev/types/pallet_babe/pallet/error.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+/// The `Error` enum of this pallet.
+enum Error {
+  /// An equivocation proof provided as part of an equivocation report is invalid.
+  invalidEquivocationProof('InvalidEquivocationProof', 0),
+
+  /// A key ownership proof provided as part of an equivocation report is invalid.
+  invalidKeyOwnershipProof('InvalidKeyOwnershipProof', 1),
+
+  /// A given equivocation report is valid but already previously reported.
+  duplicateOffenceReport('DuplicateOffenceReport', 2),
+
+  /// Submitted configuration is invalid.
+  invalidConfiguration('InvalidConfiguration', 3);
+
+  const Error(
+    this.variantName,
+    this.codecIndex,
+  );
+
+  factory Error.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  final String variantName;
+
+  final int codecIndex;
+
+  static const $ErrorCodec codec = $ErrorCodec();
+
+  String toJson() => variantName;
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+}
+
+class $ErrorCodec with _i1.Codec<Error> {
+  const $ErrorCodec();
+
+  @override
+  Error decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return Error.invalidEquivocationProof;
+      case 1:
+        return Error.invalidKeyOwnershipProof;
+      case 2:
+        return Error.duplicateOffenceReport;
+      case 3:
+        return Error.invalidConfiguration;
+      default:
+        throw Exception('Error: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Error value,
+    _i1.Output output,
+  ) {
+    _i1.U8Codec.codec.encodeTo(
+      value.codecIndex,
+      output,
+    );
+  }
+}

lib/generated/gdev/types/pallet_balances/pallet/call.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+import '../../sp_runtime/multiaddress/multi_address.dart' as _i3;
+import '../types/adjustment_direction.dart' as _i4;
+
+/// Contains a variant per dispatchable extrinsic that this pallet has.
+abstract class Call {
+  const Call();
+
+  factory Call.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  static const $CallCodec codec = $CallCodec();
+
+  static const $Call values = $Call();
+
+  _i2.Uint8List encode() {
+    final output = _i1.ByteOutput(codec.sizeHint(this));
+    codec.encodeTo(this, output);
+    return output.toBytes();
+  }
+
+  int sizeHint() {
+    return codec.sizeHint(this);
+  }
+
+  Map<String, Map<String, dynamic>> toJson();
+}
+
+class $Call {
+  const $Call();
+
+  TransferAllowDeath transferAllowDeath({
+    required _i3.MultiAddress dest,
+    required BigInt value,
+  }) {
+    return TransferAllowDeath(
+      dest: dest,
+      value: value,
+    );
+  }
+
+  ForceTransfer forceTransfer({
+    required _i3.MultiAddress source,
+    required _i3.MultiAddress dest,
+    required BigInt value,
+  }) {
+    return ForceTransfer(
+      source: source,
+      dest: dest,
+      value: value,
+    );
+  }
+
+  TransferKeepAlive transferKeepAlive({
+    required _i3.MultiAddress dest,
+    required BigInt value,
+  }) {
+    return TransferKeepAlive(
+      dest: dest,
+      value: value,
+    );
+  }
+
+  TransferAll transferAll({
+    required _i3.MultiAddress dest,
+    required bool keepAlive,
+  }) {
+    return TransferAll(
+      dest: dest,
+      keepAlive: keepAlive,
+    );
+  }
+
+  ForceUnreserve forceUnreserve({
+    required _i3.MultiAddress who,
+    required BigInt amount,
+  }) {
+    return ForceUnreserve(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  ForceSetBalance forceSetBalance({
+    required _i3.MultiAddress who,
+    required BigInt newFree,
+  }) {
+    return ForceSetBalance(
+      who: who,
+      newFree: newFree,
+    );
+  }
+
+  ForceAdjustTotalIssuance forceAdjustTotalIssuance({
+    required _i4.AdjustmentDirection direction,
+    required BigInt delta,
+  }) {
+    return ForceAdjustTotalIssuance(
+      direction: direction,
+      delta: delta,
+    );
+  }
+
+  Burn burn({
+    required BigInt value,
+    required bool keepAlive,
+  }) {
+    return Burn(
+      value: value,
+      keepAlive: keepAlive,
+    );
+  }
+}
+
+class $CallCodec with _i1.Codec<Call> {
+  const $CallCodec();
+
+  @override
+  Call decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return TransferAllowDeath._decode(input);
+      case 2:
+        return ForceTransfer._decode(input);
+      case 3:
+        return TransferKeepAlive._decode(input);
+      case 4:
+        return TransferAll._decode(input);
+      case 5:
+        return ForceUnreserve._decode(input);
+      case 8:
+        return ForceSetBalance._decode(input);
+      case 9:
+        return ForceAdjustTotalIssuance._decode(input);
+      case 10:
+        return Burn._decode(input);
+      default:
+        throw Exception('Call: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Call value,
+    _i1.Output output,
+  ) {
+    switch (value.runtimeType) {
+      case TransferAllowDeath:
+        (value as TransferAllowDeath).encodeTo(output);
+        break;
+      case ForceTransfer:
+        (value as ForceTransfer).encodeTo(output);
+        break;
+      case TransferKeepAlive:
+        (value as TransferKeepAlive).encodeTo(output);
+        break;
+      case TransferAll:
+        (value as TransferAll).encodeTo(output);
+        break;
+      case ForceUnreserve:
+        (value as ForceUnreserve).encodeTo(output);
+        break;
+      case ForceSetBalance:
+        (value as ForceSetBalance).encodeTo(output);
+        break;
+      case ForceAdjustTotalIssuance:
+        (value as ForceAdjustTotalIssuance).encodeTo(output);
+        break;
+      case Burn:
+        (value as Burn).encodeTo(output);
+        break;
+      default:
+        throw Exception(
+            'Call: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+
+  @override
+  int sizeHint(Call value) {
+    switch (value.runtimeType) {
+      case TransferAllowDeath:
+        return (value as TransferAllowDeath)._sizeHint();
+      case ForceTransfer:
+        return (value as ForceTransfer)._sizeHint();
+      case TransferKeepAlive:
+        return (value as TransferKeepAlive)._sizeHint();
+      case TransferAll:
+        return (value as TransferAll)._sizeHint();
+      case ForceUnreserve:
+        return (value as ForceUnreserve)._sizeHint();
+      case ForceSetBalance:
+        return (value as ForceSetBalance)._sizeHint();
+      case ForceAdjustTotalIssuance:
+        return (value as ForceAdjustTotalIssuance)._sizeHint();
+      case Burn:
+        return (value as Burn)._sizeHint();
+      default:
+        throw Exception(
+            'Call: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+}
+
+/// Transfer some liquid free balance to another account.
+///
+/// `transfer_allow_death` will set the `FreeBalance` of the sender and receiver.
+/// If the sender's account is below the existential deposit as a result
+/// of the transfer, the account will be reaped.
+///
+/// The dispatch origin for this call must be `Signed` by the transactor.
+class TransferAllowDeath extends Call {
+  const TransferAllowDeath({
+    required this.dest,
+    required this.value,
+  });
+
+  factory TransferAllowDeath._decode(_i1.Input input) {
+    return TransferAllowDeath(
+      dest: _i3.MultiAddress.codec.decode(input),
+      value: _i1.CompactBigIntCodec.codec.decode(input),
+    );
+  }
+
+  /// AccountIdLookupOf<T>
+  final _i3.MultiAddress dest;
+
+  /// T::Balance
+  final BigInt value;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'transfer_allow_death': {
+          'dest': dest.toJson(),
+          'value': value,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i3.MultiAddress.codec.sizeHint(dest);
+    size = size + _i1.CompactBigIntCodec.codec.sizeHint(value);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      0,
+      output,
+    );
+    _i3.MultiAddress.codec.encodeTo(
+      dest,
+      output,
+    );
+    _i1.CompactBigIntCodec.codec.encodeTo(
+      value,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is TransferAllowDeath && other.dest == dest && other.value == value;
+
+  @override
+  int get hashCode => Object.hash(
+        dest,
+        value,
+      );
+}
+
+/// Exactly as `transfer_allow_death`, except the origin must be root and the source account
+/// may be specified.
+class ForceTransfer extends Call {
+  const ForceTransfer({
+    required this.source,
+    required this.dest,
+    required this.value,
+  });
+
+  factory ForceTransfer._decode(_i1.Input input) {
+    return ForceTransfer(
+      source: _i3.MultiAddress.codec.decode(input),
+      dest: _i3.MultiAddress.codec.decode(input),
+      value: _i1.CompactBigIntCodec.codec.decode(input),
+    );
+  }
+
+  /// AccountIdLookupOf<T>
+  final _i3.MultiAddress source;
+
+  /// AccountIdLookupOf<T>
+  final _i3.MultiAddress dest;
+
+  /// T::Balance
+  final BigInt value;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'force_transfer': {
+          'source': source.toJson(),
+          'dest': dest.toJson(),
+          'value': value,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i3.MultiAddress.codec.sizeHint(source);
+    size = size + _i3.MultiAddress.codec.sizeHint(dest);
+    size = size + _i1.CompactBigIntCodec.codec.sizeHint(value);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      2,
+      output,
+    );
+    _i3.MultiAddress.codec.encodeTo(
+      source,
+      output,
+    );
+    _i3.MultiAddress.codec.encodeTo(
+      dest,
+      output,
+    );
+    _i1.CompactBigIntCodec.codec.encodeTo(
+      value,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is ForceTransfer &&
+          other.source == source &&
+          other.dest == dest &&
+          other.value == value;
+
+  @override
+  int get hashCode => Object.hash(
+        source,
+        dest,
+        value,
+      );
+}
+
+/// Same as the [`transfer_allow_death`] call, but with a check that the transfer will not
+/// kill the origin account.
+///
+/// 99% of the time you want [`transfer_allow_death`] instead.
+///
+/// [`transfer_allow_death`]: struct.Pallet.html#method.transfer
+class TransferKeepAlive extends Call {
+  const TransferKeepAlive({
+    required this.dest,
+    required this.value,
+  });
+
+  factory TransferKeepAlive._decode(_i1.Input input) {
+    return TransferKeepAlive(
+      dest: _i3.MultiAddress.codec.decode(input),
+      value: _i1.CompactBigIntCodec.codec.decode(input),
+    );
+  }
+
+  /// AccountIdLookupOf<T>
+  final _i3.MultiAddress dest;
+
+  /// T::Balance
+  final BigInt value;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'transfer_keep_alive': {
+          'dest': dest.toJson(),
+          'value': value,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i3.MultiAddress.codec.sizeHint(dest);
+    size = size + _i1.CompactBigIntCodec.codec.sizeHint(value);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      3,
+      output,
+    );
+    _i3.MultiAddress.codec.encodeTo(
+      dest,
+      output,
+    );
+    _i1.CompactBigIntCodec.codec.encodeTo(
+      value,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is TransferKeepAlive && other.dest == dest && other.value == value;
+
+  @override
+  int get hashCode => Object.hash(
+        dest,
+        value,
+      );
+}
+
+/// Transfer the entire transferable balance from the caller account.
+///
+/// NOTE: This function only attempts to transfer _transferable_ balances. This means that
+/// any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be
+/// transferred by this function. To ensure that this function results in a killed account,
+/// you might need to prepare the account by removing any reference counters, storage
+/// deposits, etc...
+///
+/// The dispatch origin of this call must be Signed.
+///
+/// - `dest`: The recipient of the transfer.
+/// - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all
+///  of the funds the account has, causing the sender account to be killed (false), or
+///  transfer everything except at least the existential deposit, which will guarantee to
+///  keep the sender account alive (true).
+class TransferAll extends Call {
+  const TransferAll({
+    required this.dest,
+    required this.keepAlive,
+  });
+
+  factory TransferAll._decode(_i1.Input input) {
+    return TransferAll(
+      dest: _i3.MultiAddress.codec.decode(input),
+      keepAlive: _i1.BoolCodec.codec.decode(input),
+    );
+  }
+
+  /// AccountIdLookupOf<T>
+  final _i3.MultiAddress dest;
+
+  /// bool
+  final bool keepAlive;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'transfer_all': {
+          'dest': dest.toJson(),
+          'keepAlive': keepAlive,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i3.MultiAddress.codec.sizeHint(dest);
+    size = size + _i1.BoolCodec.codec.sizeHint(keepAlive);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      4,
+      output,
+    );
+    _i3.MultiAddress.codec.encodeTo(
+      dest,
+      output,
+    );
+    _i1.BoolCodec.codec.encodeTo(
+      keepAlive,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is TransferAll &&
+          other.dest == dest &&
+          other.keepAlive == keepAlive;
+
+  @override
+  int get hashCode => Object.hash(
+        dest,
+        keepAlive,
+      );
+}
+
+/// Unreserve some balance from a user by force.
+///
+/// Can only be called by ROOT.
+class ForceUnreserve extends Call {
+  const ForceUnreserve({
+    required this.who,
+    required this.amount,
+  });
+
+  factory ForceUnreserve._decode(_i1.Input input) {
+    return ForceUnreserve(
+      who: _i3.MultiAddress.codec.decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// AccountIdLookupOf<T>
+  final _i3.MultiAddress who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'force_unreserve': {
+          'who': who.toJson(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i3.MultiAddress.codec.sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      5,
+      output,
+    );
+    _i3.MultiAddress.codec.encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is ForceUnreserve && other.who == who && other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// Upgrade a specified account.
+///
+/// - `origin`: Must be `Signed`.
+/// - `who`: The account to be upgraded.
+///
+/// This will waive the transaction fee if at least all but 10% of the accounts needed to
+/// be upgraded. (We let some not have to be upgraded just in order to allow for the
+/// possibility of churn).
+/// Set the regular balance of a given account.
+///
+/// The dispatch origin for this call is `root`.
+class ForceSetBalance extends Call {
+  const ForceSetBalance({
+    required this.who,
+    required this.newFree,
+  });
+
+  factory ForceSetBalance._decode(_i1.Input input) {
+    return ForceSetBalance(
+      who: _i3.MultiAddress.codec.decode(input),
+      newFree: _i1.CompactBigIntCodec.codec.decode(input),
+    );
+  }
+
+  /// AccountIdLookupOf<T>
+  final _i3.MultiAddress who;
+
+  /// T::Balance
+  final BigInt newFree;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'force_set_balance': {
+          'who': who.toJson(),
+          'newFree': newFree,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i3.MultiAddress.codec.sizeHint(who);
+    size = size + _i1.CompactBigIntCodec.codec.sizeHint(newFree);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      8,
+      output,
+    );
+    _i3.MultiAddress.codec.encodeTo(
+      who,
+      output,
+    );
+    _i1.CompactBigIntCodec.codec.encodeTo(
+      newFree,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is ForceSetBalance && other.who == who && other.newFree == newFree;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        newFree,
+      );
+}
+
+/// Adjust the total issuance in a saturating way.
+///
+/// Can only be called by root and always needs a positive `delta`.
+///
+/// # Example
+class ForceAdjustTotalIssuance extends Call {
+  const ForceAdjustTotalIssuance({
+    required this.direction,
+    required this.delta,
+  });
+
+  factory ForceAdjustTotalIssuance._decode(_i1.Input input) {
+    return ForceAdjustTotalIssuance(
+      direction: _i4.AdjustmentDirection.codec.decode(input),
+      delta: _i1.CompactBigIntCodec.codec.decode(input),
+    );
+  }
+
+  /// AdjustmentDirection
+  final _i4.AdjustmentDirection direction;
+
+  /// T::Balance
+  final BigInt delta;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'force_adjust_total_issuance': {
+          'direction': direction.toJson(),
+          'delta': delta,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i4.AdjustmentDirection.codec.sizeHint(direction);
+    size = size + _i1.CompactBigIntCodec.codec.sizeHint(delta);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      9,
+      output,
+    );
+    _i4.AdjustmentDirection.codec.encodeTo(
+      direction,
+      output,
+    );
+    _i1.CompactBigIntCodec.codec.encodeTo(
+      delta,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is ForceAdjustTotalIssuance &&
+          other.direction == direction &&
+          other.delta == delta;
+
+  @override
+  int get hashCode => Object.hash(
+        direction,
+        delta,
+      );
+}
+
+/// Burn the specified liquid free balance from the origin account.
+///
+/// If the origin's account ends up below the existential deposit as a result
+/// of the burn and `keep_alive` is false, the account will be reaped.
+///
+/// Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible,
+/// this `burn` operation will reduce total issuance by the amount _burned_.
+class Burn extends Call {
+  const Burn({
+    required this.value,
+    required this.keepAlive,
+  });
+
+  factory Burn._decode(_i1.Input input) {
+    return Burn(
+      value: _i1.CompactBigIntCodec.codec.decode(input),
+      keepAlive: _i1.BoolCodec.codec.decode(input),
+    );
+  }
+
+  /// T::Balance
+  final BigInt value;
+
+  /// bool
+  final bool keepAlive;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'burn': {
+          'value': value,
+          'keepAlive': keepAlive,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.CompactBigIntCodec.codec.sizeHint(value);
+    size = size + _i1.BoolCodec.codec.sizeHint(keepAlive);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      10,
+      output,
+    );
+    _i1.CompactBigIntCodec.codec.encodeTo(
+      value,
+      output,
+    );
+    _i1.BoolCodec.codec.encodeTo(
+      keepAlive,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Burn && other.value == value && other.keepAlive == keepAlive;
+
+  @override
+  int get hashCode => Object.hash(
+        value,
+        keepAlive,
+      );
+}

lib/generated/gdev/types/pallet_balances/pallet/error.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+/// The `Error` enum of this pallet.
+enum Error {
+  /// Vesting balance too high to send value.
+  vestingBalance('VestingBalance', 0),
+
+  /// Account liquidity restrictions prevent withdrawal.
+  liquidityRestrictions('LiquidityRestrictions', 1),
+
+  /// Balance too low to send value.
+  insufficientBalance('InsufficientBalance', 2),
+
+  /// Value too low to create account due to existential deposit.
+  existentialDeposit('ExistentialDeposit', 3),
+
+  /// Transfer/payment would kill account.
+  expendability('Expendability', 4),
+
+  /// A vesting schedule already exists for this account.
+  existingVestingSchedule('ExistingVestingSchedule', 5),
+
+  /// Beneficiary account must pre-exist.
+  deadAccount('DeadAccount', 6),
+
+  /// Number of named reserves exceed `MaxReserves`.
+  tooManyReserves('TooManyReserves', 7),
+
+  /// Number of holds exceed `VariantCountOf<T::RuntimeHoldReason>`.
+  tooManyHolds('TooManyHolds', 8),
+
+  /// Number of freezes exceed `MaxFreezes`.
+  tooManyFreezes('TooManyFreezes', 9),
+
+  /// The issuance cannot be modified since it is already deactivated.
+  issuanceDeactivated('IssuanceDeactivated', 10),
+
+  /// The delta cannot be zero.
+  deltaZero('DeltaZero', 11);
+
+  const Error(
+    this.variantName,
+    this.codecIndex,
+  );
+
+  factory Error.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  final String variantName;
+
+  final int codecIndex;
+
+  static const $ErrorCodec codec = $ErrorCodec();
+
+  String toJson() => variantName;
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+}
+
+class $ErrorCodec with _i1.Codec<Error> {
+  const $ErrorCodec();
+
+  @override
+  Error decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return Error.vestingBalance;
+      case 1:
+        return Error.liquidityRestrictions;
+      case 2:
+        return Error.insufficientBalance;
+      case 3:
+        return Error.existentialDeposit;
+      case 4:
+        return Error.expendability;
+      case 5:
+        return Error.existingVestingSchedule;
+      case 6:
+        return Error.deadAccount;
+      case 7:
+        return Error.tooManyReserves;
+      case 8:
+        return Error.tooManyHolds;
+      case 9:
+        return Error.tooManyFreezes;
+      case 10:
+        return Error.issuanceDeactivated;
+      case 11:
+        return Error.deltaZero;
+      default:
+        throw Exception('Error: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Error value,
+    _i1.Output output,
+  ) {
+    _i1.U8Codec.codec.encodeTo(
+      value.codecIndex,
+      output,
+    );
+  }
+}

lib/generated/gdev/types/pallet_balances/pallet/event.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+import 'package:quiver/collection.dart' as _i5;
+
+import '../../frame_support/traits/tokens/misc/balance_status.dart' as _i4;
+import '../../sp_core/crypto/account_id32.dart' as _i3;
+
+/// The `Event` enum of this pallet
+abstract class Event {
+  const Event();
+
+  factory Event.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  static const $EventCodec codec = $EventCodec();
+
+  static const $Event values = $Event();
+
+  _i2.Uint8List encode() {
+    final output = _i1.ByteOutput(codec.sizeHint(this));
+    codec.encodeTo(this, output);
+    return output.toBytes();
+  }
+
+  int sizeHint() {
+    return codec.sizeHint(this);
+  }
+
+  Map<String, Map<String, dynamic>> toJson();
+}
+
+class $Event {
+  const $Event();
+
+  Endowed endowed({
+    required _i3.AccountId32 account,
+    required BigInt freeBalance,
+  }) {
+    return Endowed(
+      account: account,
+      freeBalance: freeBalance,
+    );
+  }
+
+  DustLost dustLost({
+    required _i3.AccountId32 account,
+    required BigInt amount,
+  }) {
+    return DustLost(
+      account: account,
+      amount: amount,
+    );
+  }
+
+  Transfer transfer({
+    required _i3.AccountId32 from,
+    required _i3.AccountId32 to,
+    required BigInt amount,
+  }) {
+    return Transfer(
+      from: from,
+      to: to,
+      amount: amount,
+    );
+  }
+
+  BalanceSet balanceSet({
+    required _i3.AccountId32 who,
+    required BigInt free,
+  }) {
+    return BalanceSet(
+      who: who,
+      free: free,
+    );
+  }
+
+  Reserved reserved({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Reserved(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  Unreserved unreserved({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Unreserved(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  ReserveRepatriated reserveRepatriated({
+    required _i3.AccountId32 from,
+    required _i3.AccountId32 to,
+    required BigInt amount,
+    required _i4.BalanceStatus destinationStatus,
+  }) {
+    return ReserveRepatriated(
+      from: from,
+      to: to,
+      amount: amount,
+      destinationStatus: destinationStatus,
+    );
+  }
+
+  Deposit deposit({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Deposit(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  Withdraw withdraw({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Withdraw(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  Slashed slashed({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Slashed(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  Minted minted({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Minted(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  Burned burned({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Burned(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  Suspended suspended({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Suspended(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  Restored restored({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Restored(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  Upgraded upgraded({required _i3.AccountId32 who}) {
+    return Upgraded(who: who);
+  }
+
+  Issued issued({required BigInt amount}) {
+    return Issued(amount: amount);
+  }
+
+  Rescinded rescinded({required BigInt amount}) {
+    return Rescinded(amount: amount);
+  }
+
+  Locked locked({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Locked(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  Unlocked unlocked({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Unlocked(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  Frozen frozen({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Frozen(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  Thawed thawed({
+    required _i3.AccountId32 who,
+    required BigInt amount,
+  }) {
+    return Thawed(
+      who: who,
+      amount: amount,
+    );
+  }
+
+  TotalIssuanceForced totalIssuanceForced({
+    required BigInt old,
+    required BigInt new_,
+  }) {
+    return TotalIssuanceForced(
+      old: old,
+      new_: new_,
+    );
+  }
+}
+
+class $EventCodec with _i1.Codec<Event> {
+  const $EventCodec();
+
+  @override
+  Event decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return Endowed._decode(input);
+      case 1:
+        return DustLost._decode(input);
+      case 2:
+        return Transfer._decode(input);
+      case 3:
+        return BalanceSet._decode(input);
+      case 4:
+        return Reserved._decode(input);
+      case 5:
+        return Unreserved._decode(input);
+      case 6:
+        return ReserveRepatriated._decode(input);
+      case 7:
+        return Deposit._decode(input);
+      case 8:
+        return Withdraw._decode(input);
+      case 9:
+        return Slashed._decode(input);
+      case 10:
+        return Minted._decode(input);
+      case 11:
+        return Burned._decode(input);
+      case 12:
+        return Suspended._decode(input);
+      case 13:
+        return Restored._decode(input);
+      case 14:
+        return Upgraded._decode(input);
+      case 15:
+        return Issued._decode(input);
+      case 16:
+        return Rescinded._decode(input);
+      case 17:
+        return Locked._decode(input);
+      case 18:
+        return Unlocked._decode(input);
+      case 19:
+        return Frozen._decode(input);
+      case 20:
+        return Thawed._decode(input);
+      case 21:
+        return TotalIssuanceForced._decode(input);
+      default:
+        throw Exception('Event: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Event value,
+    _i1.Output output,
+  ) {
+    switch (value.runtimeType) {
+      case Endowed:
+        (value as Endowed).encodeTo(output);
+        break;
+      case DustLost:
+        (value as DustLost).encodeTo(output);
+        break;
+      case Transfer:
+        (value as Transfer).encodeTo(output);
+        break;
+      case BalanceSet:
+        (value as BalanceSet).encodeTo(output);
+        break;
+      case Reserved:
+        (value as Reserved).encodeTo(output);
+        break;
+      case Unreserved:
+        (value as Unreserved).encodeTo(output);
+        break;
+      case ReserveRepatriated:
+        (value as ReserveRepatriated).encodeTo(output);
+        break;
+      case Deposit:
+        (value as Deposit).encodeTo(output);
+        break;
+      case Withdraw:
+        (value as Withdraw).encodeTo(output);
+        break;
+      case Slashed:
+        (value as Slashed).encodeTo(output);
+        break;
+      case Minted:
+        (value as Minted).encodeTo(output);
+        break;
+      case Burned:
+        (value as Burned).encodeTo(output);
+        break;
+      case Suspended:
+        (value as Suspended).encodeTo(output);
+        break;
+      case Restored:
+        (value as Restored).encodeTo(output);
+        break;
+      case Upgraded:
+        (value as Upgraded).encodeTo(output);
+        break;
+      case Issued:
+        (value as Issued).encodeTo(output);
+        break;
+      case Rescinded:
+        (value as Rescinded).encodeTo(output);
+        break;
+      case Locked:
+        (value as Locked).encodeTo(output);
+        break;
+      case Unlocked:
+        (value as Unlocked).encodeTo(output);
+        break;
+      case Frozen:
+        (value as Frozen).encodeTo(output);
+        break;
+      case Thawed:
+        (value as Thawed).encodeTo(output);
+        break;
+      case TotalIssuanceForced:
+        (value as TotalIssuanceForced).encodeTo(output);
+        break;
+      default:
+        throw Exception(
+            'Event: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+
+  @override
+  int sizeHint(Event value) {
+    switch (value.runtimeType) {
+      case Endowed:
+        return (value as Endowed)._sizeHint();
+      case DustLost:
+        return (value as DustLost)._sizeHint();
+      case Transfer:
+        return (value as Transfer)._sizeHint();
+      case BalanceSet:
+        return (value as BalanceSet)._sizeHint();
+      case Reserved:
+        return (value as Reserved)._sizeHint();
+      case Unreserved:
+        return (value as Unreserved)._sizeHint();
+      case ReserveRepatriated:
+        return (value as ReserveRepatriated)._sizeHint();
+      case Deposit:
+        return (value as Deposit)._sizeHint();
+      case Withdraw:
+        return (value as Withdraw)._sizeHint();
+      case Slashed:
+        return (value as Slashed)._sizeHint();
+      case Minted:
+        return (value as Minted)._sizeHint();
+      case Burned:
+        return (value as Burned)._sizeHint();
+      case Suspended:
+        return (value as Suspended)._sizeHint();
+      case Restored:
+        return (value as Restored)._sizeHint();
+      case Upgraded:
+        return (value as Upgraded)._sizeHint();
+      case Issued:
+        return (value as Issued)._sizeHint();
+      case Rescinded:
+        return (value as Rescinded)._sizeHint();
+      case Locked:
+        return (value as Locked)._sizeHint();
+      case Unlocked:
+        return (value as Unlocked)._sizeHint();
+      case Frozen:
+        return (value as Frozen)._sizeHint();
+      case Thawed:
+        return (value as Thawed)._sizeHint();
+      case TotalIssuanceForced:
+        return (value as TotalIssuanceForced)._sizeHint();
+      default:
+        throw Exception(
+            'Event: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+}
+
+/// An account was created with some free balance.
+class Endowed extends Event {
+  const Endowed({
+    required this.account,
+    required this.freeBalance,
+  });
+
+  factory Endowed._decode(_i1.Input input) {
+    return Endowed(
+      account: const _i1.U8ArrayCodec(32).decode(input),
+      freeBalance: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 account;
+
+  /// T::Balance
+  final BigInt freeBalance;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Endowed': {
+          'account': account.toList(),
+          'freeBalance': freeBalance,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(account);
+    size = size + _i1.U64Codec.codec.sizeHint(freeBalance);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      0,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      account,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      freeBalance,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Endowed &&
+          _i5.listsEqual(
+            other.account,
+            account,
+          ) &&
+          other.freeBalance == freeBalance;
+
+  @override
+  int get hashCode => Object.hash(
+        account,
+        freeBalance,
+      );
+}
+
+/// An account was removed whose balance was non-zero but below ExistentialDeposit,
+/// resulting in an outright loss.
+class DustLost extends Event {
+  const DustLost({
+    required this.account,
+    required this.amount,
+  });
+
+  factory DustLost._decode(_i1.Input input) {
+    return DustLost(
+      account: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 account;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'DustLost': {
+          'account': account.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(account);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      1,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      account,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is DustLost &&
+          _i5.listsEqual(
+            other.account,
+            account,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        account,
+        amount,
+      );
+}
+
+/// Transfer succeeded.
+class Transfer extends Event {
+  const Transfer({
+    required this.from,
+    required this.to,
+    required this.amount,
+  });
+
+  factory Transfer._decode(_i1.Input input) {
+    return Transfer(
+      from: const _i1.U8ArrayCodec(32).decode(input),
+      to: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 from;
+
+  /// T::AccountId
+  final _i3.AccountId32 to;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Transfer': {
+          'from': from.toList(),
+          'to': to.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(from);
+    size = size + const _i3.AccountId32Codec().sizeHint(to);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      2,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      from,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      to,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Transfer &&
+          _i5.listsEqual(
+            other.from,
+            from,
+          ) &&
+          _i5.listsEqual(
+            other.to,
+            to,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        from,
+        to,
+        amount,
+      );
+}
+
+/// A balance was set by root.
+class BalanceSet extends Event {
+  const BalanceSet({
+    required this.who,
+    required this.free,
+  });
+
+  factory BalanceSet._decode(_i1.Input input) {
+    return BalanceSet(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      free: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt free;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'BalanceSet': {
+          'who': who.toList(),
+          'free': free,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(free);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      3,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      free,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is BalanceSet &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.free == free;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        free,
+      );
+}
+
+/// Some balance was reserved (moved from free to reserved).
+class Reserved extends Event {
+  const Reserved({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Reserved._decode(_i1.Input input) {
+    return Reserved(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Reserved': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      4,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Reserved &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// Some balance was unreserved (moved from reserved to free).
+class Unreserved extends Event {
+  const Unreserved({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Unreserved._decode(_i1.Input input) {
+    return Unreserved(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Unreserved': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      5,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Unreserved &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// Some balance was moved from the reserve of the first account to the second account.
+/// Final argument indicates the destination balance type.
+class ReserveRepatriated extends Event {
+  const ReserveRepatriated({
+    required this.from,
+    required this.to,
+    required this.amount,
+    required this.destinationStatus,
+  });
+
+  factory ReserveRepatriated._decode(_i1.Input input) {
+    return ReserveRepatriated(
+      from: const _i1.U8ArrayCodec(32).decode(input),
+      to: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+      destinationStatus: _i4.BalanceStatus.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 from;
+
+  /// T::AccountId
+  final _i3.AccountId32 to;
+
+  /// T::Balance
+  final BigInt amount;
+
+  /// Status
+  final _i4.BalanceStatus destinationStatus;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'ReserveRepatriated': {
+          'from': from.toList(),
+          'to': to.toList(),
+          'amount': amount,
+          'destinationStatus': destinationStatus.toJson(),
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(from);
+    size = size + const _i3.AccountId32Codec().sizeHint(to);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    size = size + _i4.BalanceStatus.codec.sizeHint(destinationStatus);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      6,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      from,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      to,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+    _i4.BalanceStatus.codec.encodeTo(
+      destinationStatus,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is ReserveRepatriated &&
+          _i5.listsEqual(
+            other.from,
+            from,
+          ) &&
+          _i5.listsEqual(
+            other.to,
+            to,
+          ) &&
+          other.amount == amount &&
+          other.destinationStatus == destinationStatus;
+
+  @override
+  int get hashCode => Object.hash(
+        from,
+        to,
+        amount,
+        destinationStatus,
+      );
+}
+
+/// Some amount was deposited (e.g. for transaction fees).
+class Deposit extends Event {
+  const Deposit({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Deposit._decode(_i1.Input input) {
+    return Deposit(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Deposit': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      7,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Deposit &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// Some amount was withdrawn from the account (e.g. for transaction fees).
+class Withdraw extends Event {
+  const Withdraw({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Withdraw._decode(_i1.Input input) {
+    return Withdraw(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Withdraw': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      8,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Withdraw &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// Some amount was removed from the account (e.g. for misbehavior).
+class Slashed extends Event {
+  const Slashed({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Slashed._decode(_i1.Input input) {
+    return Slashed(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Slashed': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      9,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Slashed &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// Some amount was minted into an account.
+class Minted extends Event {
+  const Minted({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Minted._decode(_i1.Input input) {
+    return Minted(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Minted': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      10,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Minted &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// Some amount was burned from an account.
+class Burned extends Event {
+  const Burned({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Burned._decode(_i1.Input input) {
+    return Burned(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Burned': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      11,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Burned &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// Some amount was suspended from an account (it can be restored later).
+class Suspended extends Event {
+  const Suspended({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Suspended._decode(_i1.Input input) {
+    return Suspended(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Suspended': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      12,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Suspended &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// Some amount was restored into an account.
+class Restored extends Event {
+  const Restored({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Restored._decode(_i1.Input input) {
+    return Restored(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Restored': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      13,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Restored &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// An account was upgraded.
+class Upgraded extends Event {
+  const Upgraded({required this.who});
+
+  factory Upgraded._decode(_i1.Input input) {
+    return Upgraded(who: const _i1.U8ArrayCodec(32).decode(input));
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  @override
+  Map<String, Map<String, List<int>>> toJson() => {
+        'Upgraded': {'who': who.toList()}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      14,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Upgraded &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          );
+
+  @override
+  int get hashCode => who.hashCode;
+}
+
+/// Total issuance was increased by `amount`, creating a credit to be balanced.
+class Issued extends Event {
+  const Issued({required this.amount});
+
+  factory Issued._decode(_i1.Input input) {
+    return Issued(amount: _i1.U64Codec.codec.decode(input));
+  }
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, BigInt>> toJson() => {
+        'Issued': {'amount': amount}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      15,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Issued && other.amount == amount;
+
+  @override
+  int get hashCode => amount.hashCode;
+}
+
+/// Total issuance was decreased by `amount`, creating a debt to be balanced.
+class Rescinded extends Event {
+  const Rescinded({required this.amount});
+
+  factory Rescinded._decode(_i1.Input input) {
+    return Rescinded(amount: _i1.U64Codec.codec.decode(input));
+  }
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, BigInt>> toJson() => {
+        'Rescinded': {'amount': amount}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      16,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Rescinded && other.amount == amount;
+
+  @override
+  int get hashCode => amount.hashCode;
+}
+
+/// Some balance was locked.
+class Locked extends Event {
+  const Locked({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Locked._decode(_i1.Input input) {
+    return Locked(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Locked': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      17,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Locked &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// Some balance was unlocked.
+class Unlocked extends Event {
+  const Unlocked({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Unlocked._decode(_i1.Input input) {
+    return Unlocked(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Unlocked': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      18,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Unlocked &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// Some balance was frozen.
+class Frozen extends Event {
+  const Frozen({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Frozen._decode(_i1.Input input) {
+    return Frozen(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Frozen': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      19,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Frozen &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// Some balance was thawed.
+class Thawed extends Event {
+  const Thawed({
+    required this.who,
+    required this.amount,
+  });
+
+  factory Thawed._decode(_i1.Input input) {
+    return Thawed(
+      who: const _i1.U8ArrayCodec(32).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::AccountId
+  final _i3.AccountId32 who;
+
+  /// T::Balance
+  final BigInt amount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'Thawed': {
+          'who': who.toList(),
+          'amount': amount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.AccountId32Codec().sizeHint(who);
+    size = size + _i1.U64Codec.codec.sizeHint(amount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      20,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      who,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      amount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Thawed &&
+          _i5.listsEqual(
+            other.who,
+            who,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        who,
+        amount,
+      );
+}
+
+/// The `TotalIssuance` was forcefully changed.
+class TotalIssuanceForced extends Event {
+  const TotalIssuanceForced({
+    required this.old,
+    required this.new_,
+  });
+
+  factory TotalIssuanceForced._decode(_i1.Input input) {
+    return TotalIssuanceForced(
+      old: _i1.U64Codec.codec.decode(input),
+      new_: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  /// T::Balance
+  final BigInt old;
+
+  /// T::Balance
+  final BigInt new_;
+
+  @override
+  Map<String, Map<String, BigInt>> toJson() => {
+        'TotalIssuanceForced': {
+          'old': old,
+          'new': new_,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U64Codec.codec.sizeHint(old);
+    size = size + _i1.U64Codec.codec.sizeHint(new_);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      21,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      old,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      new_,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is TotalIssuanceForced && other.old == old && other.new_ == new_;
+
+  @override
+  int get hashCode => Object.hash(
+        old,
+        new_,
+      );
+}

lib/generated/gdev/types/pallet_balances/types/account_data.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i3;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+import 'extra_flags.dart' as _i2;
+
+class AccountData {
+  const AccountData({
+    required this.free,
+    required this.reserved,
+    required this.frozen,
+    required this.flags,
+  });
+
+  factory AccountData.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  /// Balance
+  final BigInt free;
+
+  /// Balance
+  final BigInt reserved;
+
+  /// Balance
+  final BigInt frozen;
+
+  /// ExtraFlags
+  final _i2.ExtraFlags flags;
+
+  static const $AccountDataCodec codec = $AccountDataCodec();
+
+  _i3.Uint8List encode() {
+    return codec.encode(this);
+  }
+
+  Map<String, BigInt> toJson() => {
+        'free': free,
+        'reserved': reserved,
+        'frozen': frozen,
+        'flags': flags,
+      };
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is AccountData &&
+          other.free == free &&
+          other.reserved == reserved &&
+          other.frozen == frozen &&
+          other.flags == flags;
+
+  @override
+  int get hashCode => Object.hash(
+        free,
+        reserved,
+        frozen,
+        flags,
+      );
+}
+
+class $AccountDataCodec with _i1.Codec<AccountData> {
+  const $AccountDataCodec();
+
+  @override
+  void encodeTo(
+    AccountData obj,
+    _i1.Output output,
+  ) {
+    _i1.U64Codec.codec.encodeTo(
+      obj.free,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      obj.reserved,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      obj.frozen,
+      output,
+    );
+    _i1.U128Codec.codec.encodeTo(
+      obj.flags,
+      output,
+    );
+  }
+
+  @override
+  AccountData decode(_i1.Input input) {
+    return AccountData(
+      free: _i1.U64Codec.codec.decode(input),
+      reserved: _i1.U64Codec.codec.decode(input),
+      frozen: _i1.U64Codec.codec.decode(input),
+      flags: _i1.U128Codec.codec.decode(input),
+    );
+  }
+
+  @override
+  int sizeHint(AccountData obj) {
+    int size = 0;
+    size = size + _i1.U64Codec.codec.sizeHint(obj.free);
+    size = size + _i1.U64Codec.codec.sizeHint(obj.reserved);
+    size = size + _i1.U64Codec.codec.sizeHint(obj.frozen);
+    size = size + const _i2.ExtraFlagsCodec().sizeHint(obj.flags);
+    return size;
+  }
+}

lib/generated/gdev/types/pallet_balances/types/adjustment_direction.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+enum AdjustmentDirection {
+  increase('Increase', 0),
+  decrease('Decrease', 1);
+
+  const AdjustmentDirection(
+    this.variantName,
+    this.codecIndex,
+  );
+
+  factory AdjustmentDirection.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  final String variantName;
+
+  final int codecIndex;
+
+  static const $AdjustmentDirectionCodec codec = $AdjustmentDirectionCodec();
+
+  String toJson() => variantName;
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+}
+
+class $AdjustmentDirectionCodec with _i1.Codec<AdjustmentDirection> {
+  const $AdjustmentDirectionCodec();
+
+  @override
+  AdjustmentDirection decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return AdjustmentDirection.increase;
+      case 1:
+        return AdjustmentDirection.decrease;
+      default:
+        throw Exception('AdjustmentDirection: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    AdjustmentDirection value,
+    _i1.Output output,
+  ) {
+    _i1.U8Codec.codec.encodeTo(
+      value.codecIndex,
+      output,
+    );
+  }
+}

lib/generated/gdev/types/pallet_balances/types/balance_lock.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i3;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+import 'package:quiver/collection.dart' as _i4;
+
+import 'reasons.dart' as _i2;
+
+class BalanceLock {
+  const BalanceLock({
+    required this.id,
+    required this.amount,
+    required this.reasons,
+  });
+
+  factory BalanceLock.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  /// LockIdentifier
+  final List<int> id;
+
+  /// Balance
+  final BigInt amount;
+
+  /// Reasons
+  final _i2.Reasons reasons;
+
+  static const $BalanceLockCodec codec = $BalanceLockCodec();
+
+  _i3.Uint8List encode() {
+    return codec.encode(this);
+  }
+
+  Map<String, dynamic> toJson() => {
+        'id': id.toList(),
+        'amount': amount,
+        'reasons': reasons.toJson(),
+      };
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is BalanceLock &&
+          _i4.listsEqual(
+            other.id,
+            id,
+          ) &&
+          other.amount == amount &&
+          other.reasons == reasons;
+
+  @override
+  int get hashCode => Object.hash(
+        id,
+        amount,
+        reasons,
+      );
+}
+
+class $BalanceLockCodec with _i1.Codec<BalanceLock> {
+  const $BalanceLockCodec();
+
+  @override
+  void encodeTo(
+    BalanceLock obj,
+    _i1.Output output,
+  ) {
+    const _i1.U8ArrayCodec(8).encodeTo(
+      obj.id,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      obj.amount,
+      output,
+    );
+    _i2.Reasons.codec.encodeTo(
+      obj.reasons,
+      output,
+    );
+  }
+
+  @override
+  BalanceLock decode(_i1.Input input) {
+    return BalanceLock(
+      id: const _i1.U8ArrayCodec(8).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+      reasons: _i2.Reasons.codec.decode(input),
+    );
+  }
+
+  @override
+  int sizeHint(BalanceLock obj) {
+    int size = 0;
+    size = size + const _i1.U8ArrayCodec(8).sizeHint(obj.id);
+    size = size + _i1.U64Codec.codec.sizeHint(obj.amount);
+    size = size + _i2.Reasons.codec.sizeHint(obj.reasons);
+    return size;
+  }
+}

lib/generated/gdev/types/pallet_balances/types/extra_flags.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+typedef ExtraFlags = BigInt;
+
+class ExtraFlagsCodec with _i1.Codec<ExtraFlags> {
+  const ExtraFlagsCodec();
+
+  @override
+  ExtraFlags decode(_i1.Input input) {
+    return _i1.U128Codec.codec.decode(input);
+  }
+
+  @override
+  void encodeTo(
+    ExtraFlags value,
+    _i1.Output output,
+  ) {
+    _i1.U128Codec.codec.encodeTo(
+      value,
+      output,
+    );
+  }
+
+  @override
+  int sizeHint(ExtraFlags value) {
+    return _i1.U128Codec.codec.sizeHint(value);
+  }
+}

lib/generated/gdev/types/pallet_balances/types/reasons.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+enum Reasons {
+  fee('Fee', 0),
+  misc('Misc', 1),
+  all('All', 2);
+
+  const Reasons(
+    this.variantName,
+    this.codecIndex,
+  );
+
+  factory Reasons.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  final String variantName;
+
+  final int codecIndex;
+
+  static const $ReasonsCodec codec = $ReasonsCodec();
+
+  String toJson() => variantName;
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+}
+
+class $ReasonsCodec with _i1.Codec<Reasons> {
+  const $ReasonsCodec();
+
+  @override
+  Reasons decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return Reasons.fee;
+      case 1:
+        return Reasons.misc;
+      case 2:
+        return Reasons.all;
+      default:
+        throw Exception('Reasons: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Reasons value,
+    _i1.Output output,
+  ) {
+    _i1.U8Codec.codec.encodeTo(
+      value.codecIndex,
+      output,
+    );
+  }
+}

lib/generated/gdev/types/pallet_balances/types/reserve_data.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+import 'package:quiver/collection.dart' as _i3;
+
+class ReserveData {
+  const ReserveData({
+    required this.id,
+    required this.amount,
+  });
+
+  factory ReserveData.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  /// ReserveIdentifier
+  final List<int> id;
+
+  /// Balance
+  final BigInt amount;
+
+  static const $ReserveDataCodec codec = $ReserveDataCodec();
+
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+
+  Map<String, dynamic> toJson() => {
+        'id': id.toList(),
+        'amount': amount,
+      };
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is ReserveData &&
+          _i3.listsEqual(
+            other.id,
+            id,
+          ) &&
+          other.amount == amount;
+
+  @override
+  int get hashCode => Object.hash(
+        id,
+        amount,
+      );
+}
+
+class $ReserveDataCodec with _i1.Codec<ReserveData> {
+  const $ReserveDataCodec();
+
+  @override
+  void encodeTo(
+    ReserveData obj,
+    _i1.Output output,
+  ) {
+    const _i1.U8ArrayCodec(8).encodeTo(
+      obj.id,
+      output,
+    );
+    _i1.U64Codec.codec.encodeTo(
+      obj.amount,
+      output,
+    );
+  }
+
+  @override
+  ReserveData decode(_i1.Input input) {
+    return ReserveData(
+      id: const _i1.U8ArrayCodec(8).decode(input),
+      amount: _i1.U64Codec.codec.decode(input),
+    );
+  }
+
+  @override
+  int sizeHint(ReserveData obj) {
+    int size = 0;
+    size = size + const _i1.U8ArrayCodec(8).sizeHint(obj.id);
+    size = size + _i1.U64Codec.codec.sizeHint(obj.amount);
+    return size;
+  }
+}

lib/generated/gdev/types/pallet_certification/pallet/call.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+/// Contains a variant per dispatchable extrinsic that this pallet has.
+abstract class Call {
+  const Call();
+
+  factory Call.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  static const $CallCodec codec = $CallCodec();
+
+  static const $Call values = $Call();
+
+  _i2.Uint8List encode() {
+    final output = _i1.ByteOutput(codec.sizeHint(this));
+    codec.encodeTo(this, output);
+    return output.toBytes();
+  }
+
+  int sizeHint() {
+    return codec.sizeHint(this);
+  }
+
+  Map<String, Map<String, int>> toJson();
+}
+
+class $Call {
+  const $Call();
+
+  AddCert addCert({required int receiver}) {
+    return AddCert(receiver: receiver);
+  }
+
+  RenewCert renewCert({required int receiver}) {
+    return RenewCert(receiver: receiver);
+  }
+
+  DelCert delCert({
+    required int issuer,
+    required int receiver,
+  }) {
+    return DelCert(
+      issuer: issuer,
+      receiver: receiver,
+    );
+  }
+
+  RemoveAllCertsReceivedBy removeAllCertsReceivedBy({required int idtyIndex}) {
+    return RemoveAllCertsReceivedBy(idtyIndex: idtyIndex);
+  }
+}
+
+class $CallCodec with _i1.Codec<Call> {
+  const $CallCodec();
+
+  @override
+  Call decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return AddCert._decode(input);
+      case 3:
+        return RenewCert._decode(input);
+      case 1:
+        return DelCert._decode(input);
+      case 2:
+        return RemoveAllCertsReceivedBy._decode(input);
+      default:
+        throw Exception('Call: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Call value,
+    _i1.Output output,
+  ) {
+    switch (value.runtimeType) {
+      case AddCert:
+        (value as AddCert).encodeTo(output);
+        break;
+      case RenewCert:
+        (value as RenewCert).encodeTo(output);
+        break;
+      case DelCert:
+        (value as DelCert).encodeTo(output);
+        break;
+      case RemoveAllCertsReceivedBy:
+        (value as RemoveAllCertsReceivedBy).encodeTo(output);
+        break;
+      default:
+        throw Exception(
+            'Call: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+
+  @override
+  int sizeHint(Call value) {
+    switch (value.runtimeType) {
+      case AddCert:
+        return (value as AddCert)._sizeHint();
+      case RenewCert:
+        return (value as RenewCert)._sizeHint();
+      case DelCert:
+        return (value as DelCert)._sizeHint();
+      case RemoveAllCertsReceivedBy:
+        return (value as RemoveAllCertsReceivedBy)._sizeHint();
+      default:
+        throw Exception(
+            'Call: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+}
+
+/// Add a new certification.
+class AddCert extends Call {
+  const AddCert({required this.receiver});
+
+  factory AddCert._decode(_i1.Input input) {
+    return AddCert(receiver: _i1.U32Codec.codec.decode(input));
+  }
+
+  /// T::IdtyIndex
+  final int receiver;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'add_cert': {'receiver': receiver}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(receiver);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      0,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      receiver,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is AddCert && other.receiver == receiver;
+
+  @override
+  int get hashCode => receiver.hashCode;
+}
+
+/// Renew an existing certification.
+class RenewCert extends Call {
+  const RenewCert({required this.receiver});
+
+  factory RenewCert._decode(_i1.Input input) {
+    return RenewCert(receiver: _i1.U32Codec.codec.decode(input));
+  }
+
+  /// T::IdtyIndex
+  final int receiver;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'renew_cert': {'receiver': receiver}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(receiver);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      3,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      receiver,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is RenewCert && other.receiver == receiver;
+
+  @override
+  int get hashCode => receiver.hashCode;
+}
+
+/// Remove one certification given the issuer and the receiver.
+///
+/// - `origin`: Must be `Root`.
+class DelCert extends Call {
+  const DelCert({
+    required this.issuer,
+    required this.receiver,
+  });
+
+  factory DelCert._decode(_i1.Input input) {
+    return DelCert(
+      issuer: _i1.U32Codec.codec.decode(input),
+      receiver: _i1.U32Codec.codec.decode(input),
+    );
+  }
+
+  /// T::IdtyIndex
+  final int issuer;
+
+  /// T::IdtyIndex
+  final int receiver;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'del_cert': {
+          'issuer': issuer,
+          'receiver': receiver,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(issuer);
+    size = size + _i1.U32Codec.codec.sizeHint(receiver);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      1,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      issuer,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      receiver,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is DelCert && other.issuer == issuer && other.receiver == receiver;
+
+  @override
+  int get hashCode => Object.hash(
+        issuer,
+        receiver,
+      );
+}
+
+/// Remove all certifications received by an identity.
+///
+/// - `origin`: Must be `Root`.
+class RemoveAllCertsReceivedBy extends Call {
+  const RemoveAllCertsReceivedBy({required this.idtyIndex});
+
+  factory RemoveAllCertsReceivedBy._decode(_i1.Input input) {
+    return RemoveAllCertsReceivedBy(
+        idtyIndex: _i1.U32Codec.codec.decode(input));
+  }
+
+  /// T::IdtyIndex
+  final int idtyIndex;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'remove_all_certs_received_by': {'idtyIndex': idtyIndex}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(idtyIndex);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      2,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      idtyIndex,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is RemoveAllCertsReceivedBy && other.idtyIndex == idtyIndex;
+
+  @override
+  int get hashCode => idtyIndex.hashCode;
+}

lib/generated/gdev/types/pallet_certification/pallet/error.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+/// The `Error` enum of this pallet.
+enum Error {
+  /// Issuer of a certification must have an identity
+  originMustHaveAnIdentity('OriginMustHaveAnIdentity', 0),
+
+  /// Identity cannot certify itself.
+  cannotCertifySelf('CannotCertifySelf', 1),
+
+  /// Identity has already issued the maximum number of certifications.
+  issuedTooManyCert('IssuedTooManyCert', 2),
+
+  /// Insufficient certifications received.
+  notEnoughCertReceived('NotEnoughCertReceived', 3),
+
+  /// Identity has issued a certification too recently.
+  notRespectCertPeriod('NotRespectCertPeriod', 4),
+
+  /// Can not add an already-existing cert
+  certAlreadyExists('CertAlreadyExists', 5),
+
+  /// Can not renew a non-existing cert
+  certDoesNotExist('CertDoesNotExist', 6);
+
+  const Error(
+    this.variantName,
+    this.codecIndex,
+  );
+
+  factory Error.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  final String variantName;
+
+  final int codecIndex;
+
+  static const $ErrorCodec codec = $ErrorCodec();
+
+  String toJson() => variantName;
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+}
+
+class $ErrorCodec with _i1.Codec<Error> {
+  const $ErrorCodec();
+
+  @override
+  Error decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return Error.originMustHaveAnIdentity;
+      case 1:
+        return Error.cannotCertifySelf;
+      case 2:
+        return Error.issuedTooManyCert;
+      case 3:
+        return Error.notEnoughCertReceived;
+      case 4:
+        return Error.notRespectCertPeriod;
+      case 5:
+        return Error.certAlreadyExists;
+      case 6:
+        return Error.certDoesNotExist;
+      default:
+        throw Exception('Error: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Error value,
+    _i1.Output output,
+  ) {
+    _i1.U8Codec.codec.encodeTo(
+      value.codecIndex,
+      output,
+    );
+  }
+}

lib/generated/gdev/types/pallet_certification/pallet/event.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+/// The `Event` enum of this pallet
+abstract class Event {
+  const Event();
+
+  factory Event.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  static const $EventCodec codec = $EventCodec();
+
+  static const $Event values = $Event();
+
+  _i2.Uint8List encode() {
+    final output = _i1.ByteOutput(codec.sizeHint(this));
+    codec.encodeTo(this, output);
+    return output.toBytes();
+  }
+
+  int sizeHint() {
+    return codec.sizeHint(this);
+  }
+
+  Map<String, Map<String, dynamic>> toJson();
+}
+
+class $Event {
+  const $Event();
+
+  CertAdded certAdded({
+    required int issuer,
+    required int receiver,
+  }) {
+    return CertAdded(
+      issuer: issuer,
+      receiver: receiver,
+    );
+  }
+
+  CertRemoved certRemoved({
+    required int issuer,
+    required int receiver,
+    required bool expiration,
+  }) {
+    return CertRemoved(
+      issuer: issuer,
+      receiver: receiver,
+      expiration: expiration,
+    );
+  }
+
+  CertRenewed certRenewed({
+    required int issuer,
+    required int receiver,
+  }) {
+    return CertRenewed(
+      issuer: issuer,
+      receiver: receiver,
+    );
+  }
+}
+
+class $EventCodec with _i1.Codec<Event> {
+  const $EventCodec();
+
+  @override
+  Event decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return CertAdded._decode(input);
+      case 1:
+        return CertRemoved._decode(input);
+      case 2:
+        return CertRenewed._decode(input);
+      default:
+        throw Exception('Event: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Event value,
+    _i1.Output output,
+  ) {
+    switch (value.runtimeType) {
+      case CertAdded:
+        (value as CertAdded).encodeTo(output);
+        break;
+      case CertRemoved:
+        (value as CertRemoved).encodeTo(output);
+        break;
+      case CertRenewed:
+        (value as CertRenewed).encodeTo(output);
+        break;
+      default:
+        throw Exception(
+            'Event: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+
+  @override
+  int sizeHint(Event value) {
+    switch (value.runtimeType) {
+      case CertAdded:
+        return (value as CertAdded)._sizeHint();
+      case CertRemoved:
+        return (value as CertRemoved)._sizeHint();
+      case CertRenewed:
+        return (value as CertRenewed)._sizeHint();
+      default:
+        throw Exception(
+            'Event: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+}
+
+/// A new certification was added.
+class CertAdded extends Event {
+  const CertAdded({
+    required this.issuer,
+    required this.receiver,
+  });
+
+  factory CertAdded._decode(_i1.Input input) {
+    return CertAdded(
+      issuer: _i1.U32Codec.codec.decode(input),
+      receiver: _i1.U32Codec.codec.decode(input),
+    );
+  }
+
+  /// T::IdtyIndex
+  final int issuer;
+
+  /// T::IdtyIndex
+  final int receiver;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'CertAdded': {
+          'issuer': issuer,
+          'receiver': receiver,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(issuer);
+    size = size + _i1.U32Codec.codec.sizeHint(receiver);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      0,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      issuer,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      receiver,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is CertAdded &&
+          other.issuer == issuer &&
+          other.receiver == receiver;
+
+  @override
+  int get hashCode => Object.hash(
+        issuer,
+        receiver,
+      );
+}
+
+/// A certification was removed.
+class CertRemoved extends Event {
+  const CertRemoved({
+    required this.issuer,
+    required this.receiver,
+    required this.expiration,
+  });
+
+  factory CertRemoved._decode(_i1.Input input) {
+    return CertRemoved(
+      issuer: _i1.U32Codec.codec.decode(input),
+      receiver: _i1.U32Codec.codec.decode(input),
+      expiration: _i1.BoolCodec.codec.decode(input),
+    );
+  }
+
+  /// T::IdtyIndex
+  final int issuer;
+
+  /// T::IdtyIndex
+  final int receiver;
+
+  /// bool
+  final bool expiration;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'CertRemoved': {
+          'issuer': issuer,
+          'receiver': receiver,
+          'expiration': expiration,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(issuer);
+    size = size + _i1.U32Codec.codec.sizeHint(receiver);
+    size = size + _i1.BoolCodec.codec.sizeHint(expiration);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      1,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      issuer,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      receiver,
+      output,
+    );
+    _i1.BoolCodec.codec.encodeTo(
+      expiration,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is CertRemoved &&
+          other.issuer == issuer &&
+          other.receiver == receiver &&
+          other.expiration == expiration;
+
+  @override
+  int get hashCode => Object.hash(
+        issuer,
+        receiver,
+        expiration,
+      );
+}
+
+/// A certification was renewed.
+class CertRenewed extends Event {
+  const CertRenewed({
+    required this.issuer,
+    required this.receiver,
+  });
+
+  factory CertRenewed._decode(_i1.Input input) {
+    return CertRenewed(
+      issuer: _i1.U32Codec.codec.decode(input),
+      receiver: _i1.U32Codec.codec.decode(input),
+    );
+  }
+
+  /// T::IdtyIndex
+  final int issuer;
+
+  /// T::IdtyIndex
+  final int receiver;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'CertRenewed': {
+          'issuer': issuer,
+          'receiver': receiver,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(issuer);
+    size = size + _i1.U32Codec.codec.sizeHint(receiver);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      2,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      issuer,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      receiver,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is CertRenewed &&
+          other.issuer == issuer &&
+          other.receiver == receiver;
+
+  @override
+  int get hashCode => Object.hash(
+        issuer,
+        receiver,
+      );
+}

lib/generated/gdev/types/pallet_certification/types/idty_cert_meta.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+
+class IdtyCertMeta {
+  const IdtyCertMeta({
+    required this.issuedCount,
+    required this.nextIssuableOn,
+    required this.receivedCount,
+  });
+
+  factory IdtyCertMeta.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  /// u32
+  final int issuedCount;
+
+  /// BlockNumber
+  final int nextIssuableOn;
+
+  /// u32
+  final int receivedCount;
+
+  static const $IdtyCertMetaCodec codec = $IdtyCertMetaCodec();
+
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+
+  Map<String, int> toJson() => {
+        'issuedCount': issuedCount,
+        'nextIssuableOn': nextIssuableOn,
+        'receivedCount': receivedCount,
+      };
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is IdtyCertMeta &&
+          other.issuedCount == issuedCount &&
+          other.nextIssuableOn == nextIssuableOn &&
+          other.receivedCount == receivedCount;
+
+  @override
+  int get hashCode => Object.hash(
+        issuedCount,
+        nextIssuableOn,
+        receivedCount,
+      );
+}
+
+class $IdtyCertMetaCodec with _i1.Codec<IdtyCertMeta> {
+  const $IdtyCertMetaCodec();
+
+  @override
+  void encodeTo(
+    IdtyCertMeta obj,
+    _i1.Output output,
+  ) {
+    _i1.U32Codec.codec.encodeTo(
+      obj.issuedCount,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      obj.nextIssuableOn,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      obj.receivedCount,
+      output,
+    );
+  }
+
+  @override
+  IdtyCertMeta decode(_i1.Input input) {
+    return IdtyCertMeta(
+      issuedCount: _i1.U32Codec.codec.decode(input),
+      nextIssuableOn: _i1.U32Codec.codec.decode(input),
+      receivedCount: _i1.U32Codec.codec.decode(input),
+    );
+  }
+
+  @override
+  int sizeHint(IdtyCertMeta obj) {
+    int size = 0;
+    size = size + _i1.U32Codec.codec.sizeHint(obj.issuedCount);
+    size = size + _i1.U32Codec.codec.sizeHint(obj.nextIssuableOn);
+    size = size + _i1.U32Codec.codec.sizeHint(obj.receivedCount);
+    return size;
+  }
+}

lib/generated/gdev/types/pallet_collective/pallet/call.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i2;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+import 'package:quiver/collection.dart' as _i7;
+
+import '../../gdev_runtime/runtime_call.dart' as _i4;
+import '../../primitive_types/h256.dart' as _i5;
+import '../../sp_core/crypto/account_id32.dart' as _i3;
+import '../../sp_weights/weight_v2/weight.dart' as _i6;
+
+/// Contains a variant per dispatchable extrinsic that this pallet has.
+abstract class Call {
+  const Call();
+
+  factory Call.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  static const $CallCodec codec = $CallCodec();
+
+  static const $Call values = $Call();
+
+  _i2.Uint8List encode() {
+    final output = _i1.ByteOutput(codec.sizeHint(this));
+    codec.encodeTo(this, output);
+    return output.toBytes();
+  }
+
+  int sizeHint() {
+    return codec.sizeHint(this);
+  }
+
+  Map<String, Map<String, dynamic>> toJson();
+}
+
+class $Call {
+  const $Call();
+
+  SetMembers setMembers({
+    required List<_i3.AccountId32> newMembers,
+    _i3.AccountId32? prime,
+    required int oldCount,
+  }) {
+    return SetMembers(
+      newMembers: newMembers,
+      prime: prime,
+      oldCount: oldCount,
+    );
+  }
+
+  Execute execute({
+    required _i4.RuntimeCall proposal,
+    required BigInt lengthBound,
+  }) {
+    return Execute(
+      proposal: proposal,
+      lengthBound: lengthBound,
+    );
+  }
+
+  Propose propose({
+    required BigInt threshold,
+    required _i4.RuntimeCall proposal,
+    required BigInt lengthBound,
+  }) {
+    return Propose(
+      threshold: threshold,
+      proposal: proposal,
+      lengthBound: lengthBound,
+    );
+  }
+
+  Vote vote({
+    required _i5.H256 proposal,
+    required BigInt index,
+    required bool approve,
+  }) {
+    return Vote(
+      proposal: proposal,
+      index: index,
+      approve: approve,
+    );
+  }
+
+  DisapproveProposal disapproveProposal({required _i5.H256 proposalHash}) {
+    return DisapproveProposal(proposalHash: proposalHash);
+  }
+
+  Close close({
+    required _i5.H256 proposalHash,
+    required BigInt index,
+    required _i6.Weight proposalWeightBound,
+    required BigInt lengthBound,
+  }) {
+    return Close(
+      proposalHash: proposalHash,
+      index: index,
+      proposalWeightBound: proposalWeightBound,
+      lengthBound: lengthBound,
+    );
+  }
+}
+
+class $CallCodec with _i1.Codec<Call> {
+  const $CallCodec();
+
+  @override
+  Call decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return SetMembers._decode(input);
+      case 1:
+        return Execute._decode(input);
+      case 2:
+        return Propose._decode(input);
+      case 3:
+        return Vote._decode(input);
+      case 5:
+        return DisapproveProposal._decode(input);
+      case 6:
+        return Close._decode(input);
+      default:
+        throw Exception('Call: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Call value,
+    _i1.Output output,
+  ) {
+    switch (value.runtimeType) {
+      case SetMembers:
+        (value as SetMembers).encodeTo(output);
+        break;
+      case Execute:
+        (value as Execute).encodeTo(output);
+        break;
+      case Propose:
+        (value as Propose).encodeTo(output);
+        break;
+      case Vote:
+        (value as Vote).encodeTo(output);
+        break;
+      case DisapproveProposal:
+        (value as DisapproveProposal).encodeTo(output);
+        break;
+      case Close:
+        (value as Close).encodeTo(output);
+        break;
+      default:
+        throw Exception(
+            'Call: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+
+  @override
+  int sizeHint(Call value) {
+    switch (value.runtimeType) {
+      case SetMembers:
+        return (value as SetMembers)._sizeHint();
+      case Execute:
+        return (value as Execute)._sizeHint();
+      case Propose:
+        return (value as Propose)._sizeHint();
+      case Vote:
+        return (value as Vote)._sizeHint();
+      case DisapproveProposal:
+        return (value as DisapproveProposal)._sizeHint();
+      case Close:
+        return (value as Close)._sizeHint();
+      default:
+        throw Exception(
+            'Call: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+}
+
+/// Set the collective's membership.
+///
+/// - `new_members`: The new member list. Be nice to the chain and provide it sorted.
+/// - `prime`: The prime member whose vote sets the default.
+/// - `old_count`: The upper bound for the previous number of members in storage. Used for
+///  weight estimation.
+///
+/// The dispatch of this call must be `SetMembersOrigin`.
+///
+/// NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but
+///      the weight estimations rely on it to estimate dispatchable weight.
+///
+/// # WARNING:
+///
+/// The `pallet-collective` can also be managed by logic outside of the pallet through the
+/// implementation of the trait [`ChangeMembers`].
+/// Any call to `set_members` must be careful that the member set doesn't get out of sync
+/// with other logic managing the member set.
+///
+/// ## Complexity:
+/// - `O(MP + N)` where:
+///  - `M` old-members-count (code- and governance-bounded)
+///  - `N` new-members-count (code- and governance-bounded)
+///  - `P` proposals-count (code-bounded)
+class SetMembers extends Call {
+  const SetMembers({
+    required this.newMembers,
+    this.prime,
+    required this.oldCount,
+  });
+
+  factory SetMembers._decode(_i1.Input input) {
+    return SetMembers(
+      newMembers:
+          const _i1.SequenceCodec<_i3.AccountId32>(_i3.AccountId32Codec())
+              .decode(input),
+      prime: const _i1.OptionCodec<_i3.AccountId32>(_i3.AccountId32Codec())
+          .decode(input),
+      oldCount: _i1.U32Codec.codec.decode(input),
+    );
+  }
+
+  /// Vec<T::AccountId>
+  final List<_i3.AccountId32> newMembers;
+
+  /// Option<T::AccountId>
+  final _i3.AccountId32? prime;
+
+  /// MemberCount
+  final int oldCount;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'set_members': {
+          'newMembers': newMembers.map((value) => value.toList()).toList(),
+          'prime': prime?.toList(),
+          'oldCount': oldCount,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size +
+        const _i1.SequenceCodec<_i3.AccountId32>(_i3.AccountId32Codec())
+            .sizeHint(newMembers);
+    size = size +
+        const _i1.OptionCodec<_i3.AccountId32>(_i3.AccountId32Codec())
+            .sizeHint(prime);
+    size = size + _i1.U32Codec.codec.sizeHint(oldCount);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      0,
+      output,
+    );
+    const _i1.SequenceCodec<_i3.AccountId32>(_i3.AccountId32Codec()).encodeTo(
+      newMembers,
+      output,
+    );
+    const _i1.OptionCodec<_i3.AccountId32>(_i3.AccountId32Codec()).encodeTo(
+      prime,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      oldCount,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is SetMembers &&
+          _i7.listsEqual(
+            other.newMembers,
+            newMembers,
+          ) &&
+          other.prime == prime &&
+          other.oldCount == oldCount;
+
+  @override
+  int get hashCode => Object.hash(
+        newMembers,
+        prime,
+        oldCount,
+      );
+}
+
+/// Dispatch a proposal from a member using the `Member` origin.
+///
+/// Origin must be a member of the collective.
+///
+/// ## Complexity:
+/// - `O(B + M + P)` where:
+/// - `B` is `proposal` size in bytes (length-fee-bounded)
+/// - `M` members-count (code-bounded)
+/// - `P` complexity of dispatching `proposal`
+class Execute extends Call {
+  const Execute({
+    required this.proposal,
+    required this.lengthBound,
+  });
+
+  factory Execute._decode(_i1.Input input) {
+    return Execute(
+      proposal: _i4.RuntimeCall.codec.decode(input),
+      lengthBound: _i1.CompactBigIntCodec.codec.decode(input),
+    );
+  }
+
+  /// Box<<T as Config<I>>::Proposal>
+  final _i4.RuntimeCall proposal;
+
+  /// u32
+  final BigInt lengthBound;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'execute': {
+          'proposal': proposal.toJson(),
+          'lengthBound': lengthBound,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i4.RuntimeCall.codec.sizeHint(proposal);
+    size = size + _i1.CompactBigIntCodec.codec.sizeHint(lengthBound);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      1,
+      output,
+    );
+    _i4.RuntimeCall.codec.encodeTo(
+      proposal,
+      output,
+    );
+    _i1.CompactBigIntCodec.codec.encodeTo(
+      lengthBound,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Execute &&
+          other.proposal == proposal &&
+          other.lengthBound == lengthBound;
+
+  @override
+  int get hashCode => Object.hash(
+        proposal,
+        lengthBound,
+      );
+}
+
+/// Add a new proposal to either be voted on or executed directly.
+///
+/// Requires the sender to be member.
+///
+/// `threshold` determines whether `proposal` is executed directly (`threshold < 2`)
+/// or put up for voting.
+///
+/// ## Complexity
+/// - `O(B + M + P1)` or `O(B + M + P2)` where:
+///  - `B` is `proposal` size in bytes (length-fee-bounded)
+///  - `M` is members-count (code- and governance-bounded)
+///  - branching is influenced by `threshold` where:
+///    - `P1` is proposal execution complexity (`threshold < 2`)
+///    - `P2` is proposals-count (code-bounded) (`threshold >= 2`)
+class Propose extends Call {
+  const Propose({
+    required this.threshold,
+    required this.proposal,
+    required this.lengthBound,
+  });
+
+  factory Propose._decode(_i1.Input input) {
+    return Propose(
+      threshold: _i1.CompactBigIntCodec.codec.decode(input),
+      proposal: _i4.RuntimeCall.codec.decode(input),
+      lengthBound: _i1.CompactBigIntCodec.codec.decode(input),
+    );
+  }
+
+  /// MemberCount
+  final BigInt threshold;
+
+  /// Box<<T as Config<I>>::Proposal>
+  final _i4.RuntimeCall proposal;
+
+  /// u32
+  final BigInt lengthBound;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'propose': {
+          'threshold': threshold,
+          'proposal': proposal.toJson(),
+          'lengthBound': lengthBound,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.CompactBigIntCodec.codec.sizeHint(threshold);
+    size = size + _i4.RuntimeCall.codec.sizeHint(proposal);
+    size = size + _i1.CompactBigIntCodec.codec.sizeHint(lengthBound);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      2,
+      output,
+    );
+    _i1.CompactBigIntCodec.codec.encodeTo(
+      threshold,
+      output,
+    );
+    _i4.RuntimeCall.codec.encodeTo(
+      proposal,
+      output,
+    );
+    _i1.CompactBigIntCodec.codec.encodeTo(
+      lengthBound,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Propose &&
+          other.threshold == threshold &&
+          other.proposal == proposal &&
+          other.lengthBound == lengthBound;
+
+  @override
+  int get hashCode => Object.hash(
+        threshold,
+        proposal,
+        lengthBound,
+      );
+}
+
+/// Add an aye or nay vote for the sender to the given proposal.
+///
+/// Requires the sender to be a member.
+///
+/// Transaction fees will be waived if the member is voting on any particular proposal
+/// for the first time and the call is successful. Subsequent vote changes will charge a
+/// fee.
+/// ## Complexity
+/// - `O(M)` where `M` is members-count (code- and governance-bounded)
+class Vote extends Call {
+  const Vote({
+    required this.proposal,
+    required this.index,
+    required this.approve,
+  });
+
+  factory Vote._decode(_i1.Input input) {
+    return Vote(
+      proposal: const _i1.U8ArrayCodec(32).decode(input),
+      index: _i1.CompactBigIntCodec.codec.decode(input),
+      approve: _i1.BoolCodec.codec.decode(input),
+    );
+  }
+
+  /// T::Hash
+  final _i5.H256 proposal;
+
+  /// ProposalIndex
+  final BigInt index;
+
+  /// bool
+  final bool approve;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'vote': {
+          'proposal': proposal.toList(),
+          'index': index,
+          'approve': approve,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i5.H256Codec().sizeHint(proposal);
+    size = size + _i1.CompactBigIntCodec.codec.sizeHint(index);
+    size = size + _i1.BoolCodec.codec.sizeHint(approve);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      3,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      proposal,
+      output,
+    );
+    _i1.CompactBigIntCodec.codec.encodeTo(
+      index,
+      output,
+    );
+    _i1.BoolCodec.codec.encodeTo(
+      approve,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Vote &&
+          _i7.listsEqual(
+            other.proposal,
+            proposal,
+          ) &&
+          other.index == index &&
+          other.approve == approve;
+
+  @override
+  int get hashCode => Object.hash(
+        proposal,
+        index,
+        approve,
+      );
+}
+
+/// Disapprove a proposal, close, and remove it from the system, regardless of its current
+/// state.
+///
+/// Must be called by the Root origin.
+///
+/// Parameters:
+/// * `proposal_hash`: The hash of the proposal that should be disapproved.
+///
+/// ## Complexity
+/// O(P) where P is the number of max proposals
+class DisapproveProposal extends Call {
+  const DisapproveProposal({required this.proposalHash});
+
+  factory DisapproveProposal._decode(_i1.Input input) {
+    return DisapproveProposal(
+        proposalHash: const _i1.U8ArrayCodec(32).decode(input));
+  }
+
+  /// T::Hash
+  final _i5.H256 proposalHash;
+
+  @override
+  Map<String, Map<String, List<int>>> toJson() => {
+        'disapprove_proposal': {'proposalHash': proposalHash.toList()}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i5.H256Codec().sizeHint(proposalHash);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      5,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      proposalHash,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is DisapproveProposal &&
+          _i7.listsEqual(
+            other.proposalHash,
+            proposalHash,
+          );
+
+  @override
+  int get hashCode => proposalHash.hashCode;
+}
+
+/// Close a vote that is either approved, disapproved or whose voting period has ended.
+///
+/// May be called by any signed account in order to finish voting and close the proposal.
+///
+/// If called before the end of the voting period it will only close the vote if it is
+/// has enough votes to be approved or disapproved.
+///
+/// If called after the end of the voting period abstentions are counted as rejections
+/// unless there is a prime member set and the prime member cast an approval.
+///
+/// If the close operation completes successfully with disapproval, the transaction fee will
+/// be waived. Otherwise execution of the approved operation will be charged to the caller.
+///
+/// + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed
+/// proposal.
+/// + `length_bound`: The upper bound for the length of the proposal in storage. Checked via
+/// `storage::read` so it is `size_of::<u32>() == 4` larger than the pure length.
+///
+/// ## Complexity
+/// - `O(B + M + P1 + P2)` where:
+///  - `B` is `proposal` size in bytes (length-fee-bounded)
+///  - `M` is members-count (code- and governance-bounded)
+///  - `P1` is the complexity of `proposal` preimage.
+///  - `P2` is proposal-count (code-bounded)
+class Close extends Call {
+  const Close({
+    required this.proposalHash,
+    required this.index,
+    required this.proposalWeightBound,
+    required this.lengthBound,
+  });
+
+  factory Close._decode(_i1.Input input) {
+    return Close(
+      proposalHash: const _i1.U8ArrayCodec(32).decode(input),
+      index: _i1.CompactBigIntCodec.codec.decode(input),
+      proposalWeightBound: _i6.Weight.codec.decode(input),
+      lengthBound: _i1.CompactBigIntCodec.codec.decode(input),
+    );
+  }
+
+  /// T::Hash
+  final _i5.H256 proposalHash;
+
+  /// ProposalIndex
+  final BigInt index;
+
+  /// Weight
+  final _i6.Weight proposalWeightBound;
+
+  /// u32
+  final BigInt lengthBound;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'close': {
+          'proposalHash': proposalHash.toList(),
+          'index': index,
+          'proposalWeightBound': proposalWeightBound.toJson(),
+          'lengthBound': lengthBound,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i5.H256Codec().sizeHint(proposalHash);
+    size = size + _i1.CompactBigIntCodec.codec.sizeHint(index);
+    size = size + _i6.Weight.codec.sizeHint(proposalWeightBound);
+    size = size + _i1.CompactBigIntCodec.codec.sizeHint(lengthBound);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      6,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      proposalHash,
+      output,
+    );
+    _i1.CompactBigIntCodec.codec.encodeTo(
+      index,
+      output,
+    );
+    _i6.Weight.codec.encodeTo(
+      proposalWeightBound,
+      output,
+    );
+    _i1.CompactBigIntCodec.codec.encodeTo(
+      lengthBound,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Close &&
+          _i7.listsEqual(
+            other.proposalHash,
+            proposalHash,
+          ) &&
+          other.index == index &&
+          other.proposalWeightBound == proposalWeightBound &&
+          other.lengthBound == lengthBound;
+
+  @override
+  int get hashCode => Object.hash(
+        proposalHash,
+        index,
+        proposalWeightBound,
+        lengthBound,
+      );
+}