lib/generated/gdev/types/pallet_identity/types/idty_name.dart

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

lib/generated/gdev/types/pallet_identity/types/idty_status.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 IdtyStatus {
+  unconfirmed('Unconfirmed', 0),
+  unvalidated('Unvalidated', 1),
+  member('Member', 2),
+  notMember('NotMember', 3),
+  revoked('Revoked', 4);
+
+  const IdtyStatus(
+    this.variantName,
+    this.codecIndex,
+  );
+
+  factory IdtyStatus.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  final String variantName;
+
+  final int codecIndex;
+
+  static const $IdtyStatusCodec codec = $IdtyStatusCodec();
+
+  String toJson() => variantName;
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+}
+
+class $IdtyStatusCodec with _i1.Codec<IdtyStatus> {
+  const $IdtyStatusCodec();
+
+  @override
+  IdtyStatus decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return IdtyStatus.unconfirmed;
+      case 1:
+        return IdtyStatus.unvalidated;
+      case 2:
+        return IdtyStatus.member;
+      case 3:
+        return IdtyStatus.notMember;
+      case 4:
+        return IdtyStatus.revoked;
+      default:
+        throw Exception('IdtyStatus: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    IdtyStatus value,
+    _i1.Output output,
+  ) {
+    _i1.U8Codec.codec.encodeTo(
+      value.codecIndex,
+      output,
+    );
+  }
+}

lib/generated/gdev/types/pallet_identity/types/idty_value.dart

+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'dart:typed_data' as _i6;
+
+import 'package:polkadart/scale_codec.dart' as _i1;
+import 'package:quiver/collection.dart' as _i7;
+
+import '../../common_runtime/entities/idty_data.dart' as _i2;
+import '../../sp_core/crypto/account_id32.dart' as _i4;
+import '../../tuples.dart' as _i3;
+import 'idty_status.dart' as _i5;
+
+class IdtyValue {
+  const IdtyValue({
+    required this.data,
+    required this.nextCreatableIdentityOn,
+    this.oldOwnerKey,
+    required this.ownerKey,
+    required this.nextScheduled,
+    required this.status,
+  });
+
+  factory IdtyValue.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  /// IdtyData
+  final _i2.IdtyData data;
+
+  /// BlockNumber
+  final int nextCreatableIdentityOn;
+
+  /// Option<(AccountId, BlockNumber)>
+  final _i3.Tuple2<_i4.AccountId32, int>? oldOwnerKey;
+
+  /// AccountId
+  final _i4.AccountId32 ownerKey;
+
+  /// BlockNumber
+  final int nextScheduled;
+
+  /// IdtyStatus
+  final _i5.IdtyStatus status;
+
+  static const $IdtyValueCodec codec = $IdtyValueCodec();
+
+  _i6.Uint8List encode() {
+    return codec.encode(this);
+  }
+
+  Map<String, dynamic> toJson() => {
+        'data': data.toJson(),
+        'nextCreatableIdentityOn': nextCreatableIdentityOn,
+        'oldOwnerKey': [
+          oldOwnerKey?.value0.toList(),
+          oldOwnerKey?.value1,
+        ],
+        'ownerKey': ownerKey.toList(),
+        'nextScheduled': nextScheduled,
+        'status': status.toJson(),
+      };
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is IdtyValue &&
+          other.data == data &&
+          other.nextCreatableIdentityOn == nextCreatableIdentityOn &&
+          other.oldOwnerKey == oldOwnerKey &&
+          _i7.listsEqual(
+            other.ownerKey,
+            ownerKey,
+          ) &&
+          other.nextScheduled == nextScheduled &&
+          other.status == status;
+
+  @override
+  int get hashCode => Object.hash(
+        data,
+        nextCreatableIdentityOn,
+        oldOwnerKey,
+        ownerKey,
+        nextScheduled,
+        status,
+      );
+}
+
+class $IdtyValueCodec with _i1.Codec<IdtyValue> {
+  const $IdtyValueCodec();
+
+  @override
+  void encodeTo(
+    IdtyValue obj,
+    _i1.Output output,
+  ) {
+    _i2.IdtyData.codec.encodeTo(
+      obj.data,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      obj.nextCreatableIdentityOn,
+      output,
+    );
+    const _i1.OptionCodec<_i3.Tuple2<_i4.AccountId32, int>>(
+        _i3.Tuple2Codec<_i4.AccountId32, int>(
+      _i4.AccountId32Codec(),
+      _i1.U32Codec.codec,
+    )).encodeTo(
+      obj.oldOwnerKey,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      obj.ownerKey,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      obj.nextScheduled,
+      output,
+    );
+    _i5.IdtyStatus.codec.encodeTo(
+      obj.status,
+      output,
+    );
+  }
+
+  @override
+  IdtyValue decode(_i1.Input input) {
+    return IdtyValue(
+      data: _i2.IdtyData.codec.decode(input),
+      nextCreatableIdentityOn: _i1.U32Codec.codec.decode(input),
+      oldOwnerKey: const _i1.OptionCodec<_i3.Tuple2<_i4.AccountId32, int>>(
+          _i3.Tuple2Codec<_i4.AccountId32, int>(
+        _i4.AccountId32Codec(),
+        _i1.U32Codec.codec,
+      )).decode(input),
+      ownerKey: const _i1.U8ArrayCodec(32).decode(input),
+      nextScheduled: _i1.U32Codec.codec.decode(input),
+      status: _i5.IdtyStatus.codec.decode(input),
+    );
+  }
+
+  @override
+  int sizeHint(IdtyValue obj) {
+    int size = 0;
+    size = size + _i2.IdtyData.codec.sizeHint(obj.data);
+    size = size + _i1.U32Codec.codec.sizeHint(obj.nextCreatableIdentityOn);
+    size = size +
+        const _i1.OptionCodec<_i3.Tuple2<_i4.AccountId32, int>>(
+            _i3.Tuple2Codec<_i4.AccountId32, int>(
+          _i4.AccountId32Codec(),
+          _i1.U32Codec.codec,
+        )).sizeHint(obj.oldOwnerKey);
+    size = size + const _i4.AccountId32Codec().sizeHint(obj.ownerKey);
+    size = size + _i1.U32Codec.codec.sizeHint(obj.nextScheduled);
+    size = size + _i5.IdtyStatus.codec.sizeHint(obj.status);
+    return size;
+  }
+}

lib/generated/gdev/types/pallet_identity/types/removal_reason.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 RemovalReason {
+  root('Root', 0),
+  unconfirmed('Unconfirmed', 1),
+  unvalidated('Unvalidated', 2),
+  revoked('Revoked', 3);
+
+  const RemovalReason(
+    this.variantName,
+    this.codecIndex,
+  );
+
+  factory RemovalReason.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  final String variantName;
+
+  final int codecIndex;
+
+  static const $RemovalReasonCodec codec = $RemovalReasonCodec();
+
+  String toJson() => variantName;
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+}
+
+class $RemovalReasonCodec with _i1.Codec<RemovalReason> {
+  const $RemovalReasonCodec();
+
+  @override
+  RemovalReason decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return RemovalReason.root;
+      case 1:
+        return RemovalReason.unconfirmed;
+      case 2:
+        return RemovalReason.unvalidated;
+      case 3:
+        return RemovalReason.revoked;
+      default:
+        throw Exception('RemovalReason: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    RemovalReason value,
+    _i1.Output output,
+  ) {
+    _i1.U8Codec.codec.encodeTo(
+      value.codecIndex,
+      output,
+    );
+  }
+}

lib/generated/gdev/types/pallet_identity/types/revocation_reason.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 RevocationReason {
+  root('Root', 0),
+  user('User', 1),
+  expired('Expired', 2);
+
+  const RevocationReason(
+    this.variantName,
+    this.codecIndex,
+  );
+
+  factory RevocationReason.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  final String variantName;
+
+  final int codecIndex;
+
+  static const $RevocationReasonCodec codec = $RevocationReasonCodec();
+
+  String toJson() => variantName;
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+}
+
+class $RevocationReasonCodec with _i1.Codec<RevocationReason> {
+  const $RevocationReasonCodec();
+
+  @override
+  RevocationReason decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return RevocationReason.root;
+      case 1:
+        return RevocationReason.user;
+      case 2:
+        return RevocationReason.expired;
+      default:
+        throw Exception('RevocationReason: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    RevocationReason value,
+    _i1.Output output,
+  ) {
+    _i1.U8Codec.codec.encodeTo(
+      value.codecIndex,
+      output,
+    );
+  }
+}

lib/generated/gdev/types/pallet_im_online/heartbeat.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 Heartbeat {
+  const Heartbeat({
+    required this.blockNumber,
+    required this.sessionIndex,
+    required this.authorityIndex,
+    required this.validatorsLen,
+  });
+
+  factory Heartbeat.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  /// BlockNumber
+  final int blockNumber;
+
+  /// SessionIndex
+  final int sessionIndex;
+
+  /// AuthIndex
+  final int authorityIndex;
+
+  /// u32
+  final int validatorsLen;
+
+  static const $HeartbeatCodec codec = $HeartbeatCodec();
+
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+
+  Map<String, int> toJson() => {
+        'blockNumber': blockNumber,
+        'sessionIndex': sessionIndex,
+        'authorityIndex': authorityIndex,
+        'validatorsLen': validatorsLen,
+      };
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Heartbeat &&
+          other.blockNumber == blockNumber &&
+          other.sessionIndex == sessionIndex &&
+          other.authorityIndex == authorityIndex &&
+          other.validatorsLen == validatorsLen;
+
+  @override
+  int get hashCode => Object.hash(
+        blockNumber,
+        sessionIndex,
+        authorityIndex,
+        validatorsLen,
+      );
+}
+
+class $HeartbeatCodec with _i1.Codec<Heartbeat> {
+  const $HeartbeatCodec();
+
+  @override
+  void encodeTo(
+    Heartbeat obj,
+    _i1.Output output,
+  ) {
+    _i1.U32Codec.codec.encodeTo(
+      obj.blockNumber,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      obj.sessionIndex,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      obj.authorityIndex,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      obj.validatorsLen,
+      output,
+    );
+  }
+
+  @override
+  Heartbeat decode(_i1.Input input) {
+    return Heartbeat(
+      blockNumber: _i1.U32Codec.codec.decode(input),
+      sessionIndex: _i1.U32Codec.codec.decode(input),
+      authorityIndex: _i1.U32Codec.codec.decode(input),
+      validatorsLen: _i1.U32Codec.codec.decode(input),
+    );
+  }
+
+  @override
+  int sizeHint(Heartbeat obj) {
+    int size = 0;
+    size = size + _i1.U32Codec.codec.sizeHint(obj.blockNumber);
+    size = size + _i1.U32Codec.codec.sizeHint(obj.sessionIndex);
+    size = size + _i1.U32Codec.codec.sizeHint(obj.authorityIndex);
+    size = size + _i1.U32Codec.codec.sizeHint(obj.validatorsLen);
+    return size;
+  }
+}

lib/generated/gdev/types/pallet_im_online/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 _i5;
+
+import '../heartbeat.dart' as _i3;
+import '../sr25519/app_sr25519/signature.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();
+
+  Heartbeat heartbeat({
+    required _i3.Heartbeat heartbeat,
+    required _i4.Signature signature,
+  }) {
+    return Heartbeat(
+      heartbeat: heartbeat,
+      signature: signature,
+    );
+  }
+}
+
+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 Heartbeat._decode(input);
+      default:
+        throw Exception('Call: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Call value,
+    _i1.Output output,
+  ) {
+    switch (value.runtimeType) {
+      case Heartbeat:
+        (value as Heartbeat).encodeTo(output);
+        break;
+      default:
+        throw Exception(
+            'Call: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+
+  @override
+  int sizeHint(Call value) {
+    switch (value.runtimeType) {
+      case Heartbeat:
+        return (value as Heartbeat)._sizeHint();
+      default:
+        throw Exception(
+            'Call: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+}
+
+/// ## Complexity:
+/// - `O(K)` where K is length of `Keys` (heartbeat.validators_len)
+///  - `O(K)`: decoding of length `K`
+class Heartbeat extends Call {
+  const Heartbeat({
+    required this.heartbeat,
+    required this.signature,
+  });
+
+  factory Heartbeat._decode(_i1.Input input) {
+    return Heartbeat(
+      heartbeat: _i3.Heartbeat.codec.decode(input),
+      signature: const _i1.U8ArrayCodec(64).decode(input),
+    );
+  }
+
+  /// Heartbeat<BlockNumberFor<T>>
+  final _i3.Heartbeat heartbeat;
+
+  /// <T::AuthorityId as RuntimeAppPublic>::Signature
+  final _i4.Signature signature;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'heartbeat': {
+          'heartbeat': heartbeat.toJson(),
+          'signature': signature.toList(),
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i3.Heartbeat.codec.sizeHint(heartbeat);
+    size = size + const _i4.SignatureCodec().sizeHint(signature);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      0,
+      output,
+    );
+    _i3.Heartbeat.codec.encodeTo(
+      heartbeat,
+      output,
+    );
+    const _i1.U8ArrayCodec(64).encodeTo(
+      signature,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is Heartbeat &&
+          other.heartbeat == heartbeat &&
+          _i5.listsEqual(
+            other.signature,
+            signature,
+          );
+
+  @override
+  int get hashCode => Object.hash(
+        heartbeat,
+        signature,
+      );
+}

lib/generated/gdev/types/pallet_im_online/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 {
+  /// Non existent public key.
+  invalidKey('InvalidKey', 0),
+
+  /// Duplicated heartbeat.
+  duplicatedHeartbeat('DuplicatedHeartbeat', 1);
+
+  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.invalidKey;
+      case 1:
+        return Error.duplicatedHeartbeat;
+      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_im_online/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 _i7;
+
+import '../../common_runtime/entities/validator_full_identification.dart'
+    as _i6;
+import '../../sp_core/crypto/account_id32.dart' as _i5;
+import '../../tuples.dart' as _i4;
+import '../sr25519/app_sr25519/public.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, dynamic> toJson();
+}
+
+class $Event {
+  const $Event();
+
+  HeartbeatReceived heartbeatReceived({required _i3.Public authorityId}) {
+    return HeartbeatReceived(authorityId: authorityId);
+  }
+
+  AllGood allGood() {
+    return AllGood();
+  }
+
+  SomeOffline someOffline(
+      {required List<
+              _i4.Tuple2<_i5.AccountId32, _i6.ValidatorFullIdentification>>
+          offline}) {
+    return SomeOffline(offline: offline);
+  }
+}
+
+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 HeartbeatReceived._decode(input);
+      case 1:
+        return const AllGood();
+      case 2:
+        return SomeOffline._decode(input);
+      default:
+        throw Exception('Event: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Event value,
+    _i1.Output output,
+  ) {
+    switch (value.runtimeType) {
+      case HeartbeatReceived:
+        (value as HeartbeatReceived).encodeTo(output);
+        break;
+      case AllGood:
+        (value as AllGood).encodeTo(output);
+        break;
+      case SomeOffline:
+        (value as SomeOffline).encodeTo(output);
+        break;
+      default:
+        throw Exception(
+            'Event: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+
+  @override
+  int sizeHint(Event value) {
+    switch (value.runtimeType) {
+      case HeartbeatReceived:
+        return (value as HeartbeatReceived)._sizeHint();
+      case AllGood:
+        return 1;
+      case SomeOffline:
+        return (value as SomeOffline)._sizeHint();
+      default:
+        throw Exception(
+            'Event: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+}
+
+/// A new heartbeat was received from `AuthorityId`.
+class HeartbeatReceived extends Event {
+  const HeartbeatReceived({required this.authorityId});
+
+  factory HeartbeatReceived._decode(_i1.Input input) {
+    return HeartbeatReceived(
+        authorityId: const _i1.U8ArrayCodec(32).decode(input));
+  }
+
+  /// T::AuthorityId
+  final _i3.Public authorityId;
+
+  @override
+  Map<String, Map<String, List<int>>> toJson() => {
+        'HeartbeatReceived': {'authorityId': authorityId.toList()}
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + const _i3.PublicCodec().sizeHint(authorityId);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      0,
+      output,
+    );
+    const _i1.U8ArrayCodec(32).encodeTo(
+      authorityId,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is HeartbeatReceived &&
+          _i7.listsEqual(
+            other.authorityId,
+            authorityId,
+          );
+
+  @override
+  int get hashCode => authorityId.hashCode;
+}
+
+/// At the end of the session, no offence was committed.
+class AllGood extends Event {
+  const AllGood();
+
+  @override
+  Map<String, dynamic> toJson() => {'AllGood': null};
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      1,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) => other is AllGood;
+
+  @override
+  int get hashCode => runtimeType.hashCode;
+}
+
+/// At the end of the session, at least one validator was found to be offline.
+class SomeOffline extends Event {
+  const SomeOffline({required this.offline});
+
+  factory SomeOffline._decode(_i1.Input input) {
+    return SomeOffline(
+        offline: const _i1.SequenceCodec<
+                _i4.Tuple2<_i5.AccountId32, _i6.ValidatorFullIdentification>>(
+            _i4.Tuple2Codec<_i5.AccountId32, _i6.ValidatorFullIdentification>(
+      _i5.AccountId32Codec(),
+      _i6.ValidatorFullIdentificationCodec(),
+    )).decode(input));
+  }
+
+  /// Vec<IdentificationTuple<T>>
+  final List<_i4.Tuple2<_i5.AccountId32, _i6.ValidatorFullIdentification>>
+      offline;
+
+  @override
+  Map<String, Map<String, List<List<dynamic>>>> toJson() => {
+        'SomeOffline': {
+          'offline': offline
+              .map((value) => [
+                    value.value0.toList(),
+                    null,
+                  ])
+              .toList()
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size +
+        const _i1.SequenceCodec<
+                _i4.Tuple2<_i5.AccountId32, _i6.ValidatorFullIdentification>>(
+            _i4.Tuple2Codec<_i5.AccountId32, _i6.ValidatorFullIdentification>(
+          _i5.AccountId32Codec(),
+          _i6.ValidatorFullIdentificationCodec(),
+        )).sizeHint(offline);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      2,
+      output,
+    );
+    const _i1.SequenceCodec<
+            _i4.Tuple2<_i5.AccountId32, _i6.ValidatorFullIdentification>>(
+        _i4.Tuple2Codec<_i5.AccountId32, _i6.ValidatorFullIdentification>(
+      _i5.AccountId32Codec(),
+      _i6.ValidatorFullIdentificationCodec(),
+    )).encodeTo(
+      offline,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is SomeOffline &&
+          _i7.listsEqual(
+            other.offline,
+            offline,
+          );
+
+  @override
+  int get hashCode => offline.hashCode;
+}

lib/generated/gdev/types/pallet_im_online/sr25519/app_sr25519/public.dart

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

lib/generated/gdev/types/pallet_im_online/sr25519/app_sr25519/signature.dart

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

lib/generated/gdev/types/pallet_membership/membership_removal_reason.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 MembershipRemovalReason {
+  expired('Expired', 0),
+  revoked('Revoked', 1),
+  notEnoughCerts('NotEnoughCerts', 2),
+  system('System', 3);
+
+  const MembershipRemovalReason(
+    this.variantName,
+    this.codecIndex,
+  );
+
+  factory MembershipRemovalReason.decode(_i1.Input input) {
+    return codec.decode(input);
+  }
+
+  final String variantName;
+
+  final int codecIndex;
+
+  static const $MembershipRemovalReasonCodec codec =
+      $MembershipRemovalReasonCodec();
+
+  String toJson() => variantName;
+  _i2.Uint8List encode() {
+    return codec.encode(this);
+  }
+}
+
+class $MembershipRemovalReasonCodec with _i1.Codec<MembershipRemovalReason> {
+  const $MembershipRemovalReasonCodec();
+
+  @override
+  MembershipRemovalReason decode(_i1.Input input) {
+    final index = _i1.U8Codec.codec.decode(input);
+    switch (index) {
+      case 0:
+        return MembershipRemovalReason.expired;
+      case 1:
+        return MembershipRemovalReason.revoked;
+      case 2:
+        return MembershipRemovalReason.notEnoughCerts;
+      case 3:
+        return MembershipRemovalReason.system;
+      default:
+        throw Exception(
+            'MembershipRemovalReason: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    MembershipRemovalReason value,
+    _i1.Output output,
+  ) {
+    _i1.U8Codec.codec.encodeTo(
+      value.codecIndex,
+      output,
+    );
+  }
+}

lib/generated/gdev/types/pallet_membership/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 {
+  /// Membership not found, can not renew.
+  membershipNotFound('MembershipNotFound', 0),
+
+  /// Already member, can not add membership.
+  alreadyMember('AlreadyMember', 1);
+
+  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.membershipNotFound;
+      case 1:
+        return Error.alreadyMember;
+      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_membership/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 '../membership_removal_reason.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();
+
+  MembershipAdded membershipAdded({
+    required int member,
+    required int expireOn,
+  }) {
+    return MembershipAdded(
+      member: member,
+      expireOn: expireOn,
+    );
+  }
+
+  MembershipRenewed membershipRenewed({
+    required int member,
+    required int expireOn,
+  }) {
+    return MembershipRenewed(
+      member: member,
+      expireOn: expireOn,
+    );
+  }
+
+  MembershipRemoved membershipRemoved({
+    required int member,
+    required _i3.MembershipRemovalReason reason,
+  }) {
+    return MembershipRemoved(
+      member: member,
+      reason: reason,
+    );
+  }
+}
+
+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 MembershipAdded._decode(input);
+      case 1:
+        return MembershipRenewed._decode(input);
+      case 2:
+        return MembershipRemoved._decode(input);
+      default:
+        throw Exception('Event: Invalid variant index: "$index"');
+    }
+  }
+
+  @override
+  void encodeTo(
+    Event value,
+    _i1.Output output,
+  ) {
+    switch (value.runtimeType) {
+      case MembershipAdded:
+        (value as MembershipAdded).encodeTo(output);
+        break;
+      case MembershipRenewed:
+        (value as MembershipRenewed).encodeTo(output);
+        break;
+      case MembershipRemoved:
+        (value as MembershipRemoved).encodeTo(output);
+        break;
+      default:
+        throw Exception(
+            'Event: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+
+  @override
+  int sizeHint(Event value) {
+    switch (value.runtimeType) {
+      case MembershipAdded:
+        return (value as MembershipAdded)._sizeHint();
+      case MembershipRenewed:
+        return (value as MembershipRenewed)._sizeHint();
+      case MembershipRemoved:
+        return (value as MembershipRemoved)._sizeHint();
+      default:
+        throw Exception(
+            'Event: Unsupported "$value" of type "${value.runtimeType}"');
+    }
+  }
+}
+
+/// A membership was added.
+class MembershipAdded extends Event {
+  const MembershipAdded({
+    required this.member,
+    required this.expireOn,
+  });
+
+  factory MembershipAdded._decode(_i1.Input input) {
+    return MembershipAdded(
+      member: _i1.U32Codec.codec.decode(input),
+      expireOn: _i1.U32Codec.codec.decode(input),
+    );
+  }
+
+  /// T::IdtyId
+  final int member;
+
+  /// BlockNumberFor<T>
+  final int expireOn;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'MembershipAdded': {
+          'member': member,
+          'expireOn': expireOn,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(member);
+    size = size + _i1.U32Codec.codec.sizeHint(expireOn);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      0,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      member,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      expireOn,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is MembershipAdded &&
+          other.member == member &&
+          other.expireOn == expireOn;
+
+  @override
+  int get hashCode => Object.hash(
+        member,
+        expireOn,
+      );
+}
+
+/// A membership was renewed.
+class MembershipRenewed extends Event {
+  const MembershipRenewed({
+    required this.member,
+    required this.expireOn,
+  });
+
+  factory MembershipRenewed._decode(_i1.Input input) {
+    return MembershipRenewed(
+      member: _i1.U32Codec.codec.decode(input),
+      expireOn: _i1.U32Codec.codec.decode(input),
+    );
+  }
+
+  /// T::IdtyId
+  final int member;
+
+  /// BlockNumberFor<T>
+  final int expireOn;
+
+  @override
+  Map<String, Map<String, int>> toJson() => {
+        'MembershipRenewed': {
+          'member': member,
+          'expireOn': expireOn,
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(member);
+    size = size + _i1.U32Codec.codec.sizeHint(expireOn);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      1,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      member,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      expireOn,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is MembershipRenewed &&
+          other.member == member &&
+          other.expireOn == expireOn;
+
+  @override
+  int get hashCode => Object.hash(
+        member,
+        expireOn,
+      );
+}
+
+/// A membership was removed.
+class MembershipRemoved extends Event {
+  const MembershipRemoved({
+    required this.member,
+    required this.reason,
+  });
+
+  factory MembershipRemoved._decode(_i1.Input input) {
+    return MembershipRemoved(
+      member: _i1.U32Codec.codec.decode(input),
+      reason: _i3.MembershipRemovalReason.codec.decode(input),
+    );
+  }
+
+  /// T::IdtyId
+  final int member;
+
+  /// MembershipRemovalReason
+  final _i3.MembershipRemovalReason reason;
+
+  @override
+  Map<String, Map<String, dynamic>> toJson() => {
+        'MembershipRemoved': {
+          'member': member,
+          'reason': reason.toJson(),
+        }
+      };
+
+  int _sizeHint() {
+    int size = 1;
+    size = size + _i1.U32Codec.codec.sizeHint(member);
+    size = size + _i3.MembershipRemovalReason.codec.sizeHint(reason);
+    return size;
+  }
+
+  void encodeTo(_i1.Output output) {
+    _i1.U8Codec.codec.encodeTo(
+      2,
+      output,
+    );
+    _i1.U32Codec.codec.encodeTo(
+      member,
+      output,
+    );
+    _i3.MembershipRemovalReason.codec.encodeTo(
+      reason,
+      output,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(
+        this,
+        other,
+      ) ||
+      other is MembershipRemoved &&
+          other.member == member &&
+          other.reason == reason;
+
+  @override
+  int get hashCode => Object.hash(
+        member,
+        reason,
+      );
+}