mirror of
https://github.com/twonlyapp/twonly-app.git
synced 2026-05-25 13:12:13 +00:00
3104 lines
96 KiB
Dart
3104 lines
96 KiB
Dart
// This file is automatically generated, so please do not edit it.
|
|
// @generated by `flutter_rust_bridge`@ 2.12.0.
|
|
|
|
// ignore_for_file: unused_import, unused_element, unnecessary_import, duplicate_ignore, invalid_use_of_internal_member, annotate_overrides, non_constant_identifier_names, curly_braces_in_flow_control_structures, prefer_const_literals_to_create_immutables, unused_field
|
|
|
|
import 'bridge.dart';
|
|
import 'bridge/callbacks.dart';
|
|
import 'bridge/wrapper/backup.dart';
|
|
import 'bridge/wrapper/key_manager.dart';
|
|
import 'bridge/wrapper/user_discovery.dart';
|
|
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'frb_generated.dart';
|
|
import 'frb_generated.io.dart'
|
|
if (dart.library.js_interop) 'frb_generated.web.dart';
|
|
import 'keys/backup_password_keys.dart';
|
|
import 'lib.dart';
|
|
import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart';
|
|
|
|
/// Main entrypoint of the Rust API
|
|
class RustLib extends BaseEntrypoint<RustLibApi, RustLibApiImpl, RustLibWire> {
|
|
@internal
|
|
static final instance = RustLib._();
|
|
|
|
RustLib._();
|
|
|
|
/// Initialize flutter_rust_bridge
|
|
static Future<void> init({
|
|
RustLibApi? api,
|
|
BaseHandler? handler,
|
|
ExternalLibrary? externalLibrary,
|
|
bool forceSameCodegenVersion = true,
|
|
}) async {
|
|
await instance.initImpl(
|
|
api: api,
|
|
handler: handler,
|
|
externalLibrary: externalLibrary,
|
|
forceSameCodegenVersion: forceSameCodegenVersion,
|
|
);
|
|
}
|
|
|
|
/// Initialize flutter_rust_bridge in mock mode.
|
|
/// No libraries for FFI are loaded.
|
|
static void initMock({
|
|
required RustLibApi api,
|
|
}) {
|
|
instance.initMockImpl(
|
|
api: api,
|
|
);
|
|
}
|
|
|
|
/// Dispose flutter_rust_bridge
|
|
///
|
|
/// The call to this function is optional, since flutter_rust_bridge (and everything else)
|
|
/// is automatically disposed when the app stops.
|
|
static void dispose() => instance.disposeImpl();
|
|
|
|
@override
|
|
ApiImplConstructor<RustLibApiImpl, RustLibWire> get apiImplConstructor =>
|
|
RustLibApiImpl.new;
|
|
|
|
@override
|
|
WireConstructor<RustLibWire> get wireConstructor =>
|
|
RustLibWire.fromExternalLibrary;
|
|
|
|
@override
|
|
Future<void> executeRustInitializers() async {}
|
|
|
|
@override
|
|
ExternalLibraryLoaderConfig get defaultExternalLibraryLoaderConfig =>
|
|
kDefaultExternalLibraryLoaderConfig;
|
|
|
|
@override
|
|
String get codegenVersion => '2.12.0';
|
|
|
|
@override
|
|
int get rustContentHash => -1867463121;
|
|
|
|
static const kDefaultExternalLibraryLoaderConfig =
|
|
ExternalLibraryLoaderConfig(
|
|
stem: 'rust_lib_twonly',
|
|
ioDirectory: 'rust/target/release/',
|
|
webPrefix: 'pkg/',
|
|
wasmBindgenName: 'wasm_bindgen',
|
|
);
|
|
}
|
|
|
|
abstract class RustLibApi extends BaseApi {
|
|
Future<Uint8List>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryGetCurrentVersion();
|
|
|
|
Future<List<Uint8List>>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryGetNewMessages({
|
|
required PlatformInt64 contactId,
|
|
required List<int> receivedVersion,
|
|
});
|
|
|
|
Future<void>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryHandleNewMessages({
|
|
required PlatformInt64 contactId,
|
|
PlatformInt64? publicKeyVerifiedTimestamp,
|
|
required List<Uint8List> messages,
|
|
});
|
|
|
|
Future<void>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryInitializeOrUpdate({
|
|
required int threshold,
|
|
required PlatformInt64 userId,
|
|
required List<int> publicKey,
|
|
required bool sharePromotion,
|
|
});
|
|
|
|
Future<Uint8List?>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryShouldRequestNewMessages({
|
|
required PlatformInt64 contactId,
|
|
required List<int> version,
|
|
});
|
|
|
|
Future<void>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryUpdateVerificationStateForUser({
|
|
required PlatformInt64 contactId,
|
|
PlatformInt64? publicKeyVerifiedTimestamp,
|
|
});
|
|
|
|
Future<void> crateBridgeCallbacksInitFlutterCallbacks({
|
|
required FutureOr<RustStreamSink<String>> Function() loggingGetStreamSink,
|
|
required FutureOr<Uint8List?> Function(Uint8List) userDiscoverySignData,
|
|
required FutureOr<bool> Function(Uint8List, Uint8List, Uint8List)
|
|
userDiscoveryVerifySignature,
|
|
required FutureOr<bool> Function(PlatformInt64, Uint8List)
|
|
userDiscoveryVerifyStoredPubkey,
|
|
required FutureOr<bool> Function(List<Uint8List>) userDiscoverySetShares,
|
|
required FutureOr<Uint8List?> Function(PlatformInt64)
|
|
userDiscoveryGetShareForContact,
|
|
required FutureOr<bool> Function(PlatformInt64, PlatformInt64, Uint8List)
|
|
userDiscoveryPushOwnPromotionAndClearOldVersion,
|
|
required FutureOr<List<Uint8List>?> Function(PlatformInt64)
|
|
userDiscoveryGetOwnPromotionsAfterVersion,
|
|
required FutureOr<bool> Function(OtherPromotion)
|
|
userDiscoveryStoreOtherPromotion,
|
|
required FutureOr<List<OtherPromotion>?> Function(PlatformInt64)
|
|
userDiscoveryGetOtherPromotionsByPublicId,
|
|
required FutureOr<AnnouncedUser?> Function(PlatformInt64)
|
|
userDiscoveryGetAnnouncedUserByPublicId,
|
|
required FutureOr<Uint8List?> Function(PlatformInt64)
|
|
userDiscoveryGetContactVersion,
|
|
required FutureOr<bool> Function(PlatformInt64, Uint8List)
|
|
userDiscoverySetContactVersion,
|
|
required FutureOr<bool> Function(
|
|
PlatformInt64,
|
|
AnnouncedUser,
|
|
PlatformInt64?,
|
|
)
|
|
userDiscoveryPushNewUserRelation,
|
|
required FutureOr<Uint8List?> Function(PlatformInt64)
|
|
userDiscoveryGetContactPromotion,
|
|
});
|
|
|
|
Future<void> crateBridgeInitializeTwonlyFlutter({required InitConfig config});
|
|
|
|
Future<(String, String)>
|
|
crateBridgeWrapperBackupRustBackupArchiveCreateBackupArchive();
|
|
|
|
Future<String?>
|
|
crateBridgeWrapperBackupRustBackupArchiveGetBackupDownloadToken();
|
|
|
|
Future<void> crateBridgeWrapperBackupRustBackupArchiveRestoreBackupArchive({
|
|
required String filePath,
|
|
});
|
|
|
|
Future<String?> crateBridgeWrapperBackupRustBackupIdentityGetBackupId();
|
|
|
|
Future<BackupPasswordKeys>
|
|
crateBridgeWrapperBackupRustBackupIdentityGetBackupPasswordKeys({
|
|
required PlatformInt64 userId,
|
|
required String password,
|
|
});
|
|
|
|
Future<Uint8List>
|
|
crateBridgeWrapperBackupRustBackupIdentityGetIdentityBackupBytes();
|
|
|
|
Future<void>
|
|
crateBridgeWrapperBackupRustBackupIdentityImportBackupPasswordKeys({
|
|
required List<int> backupId,
|
|
required List<int> encryptionKey,
|
|
});
|
|
|
|
Future<void> crateBridgeWrapperBackupRustBackupIdentityRestoreIdentityBackup({
|
|
required BackupPasswordKeys keys,
|
|
required List<int> encryptedBytes,
|
|
});
|
|
|
|
Future<void> crateBridgeWrapperBackupRustBackupIdentitySetBackupPasswordKeys({
|
|
required PlatformInt64 userId,
|
|
required String password,
|
|
});
|
|
|
|
Future<Uint8List> crateBridgeWrapperKeyManagerRustKeyManagerGetLoginToken();
|
|
|
|
Future<(Uint8List, PlatformInt64)>
|
|
crateBridgeWrapperKeyManagerRustKeyManagerGetSignalIdentity();
|
|
|
|
Future<PlatformInt64?> crateBridgeWrapperKeyManagerRustKeyManagerGetUserId();
|
|
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerImportSignalIdentity({
|
|
required List<int> identityKeyPairStructure,
|
|
required PlatformInt64 registrationId,
|
|
required Map<PlatformInt64, Uint8List> signedPreKeyStore,
|
|
});
|
|
|
|
Future<Uint8List?>
|
|
crateBridgeWrapperKeyManagerRustKeyManagerLoadSignedPrekey({
|
|
required PlatformInt64 signedPreKeyId,
|
|
});
|
|
|
|
Future<Map<PlatformInt64, Uint8List>>
|
|
crateBridgeWrapperKeyManagerRustKeyManagerLoadSignedPrekeys();
|
|
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerRemoveKeyManager();
|
|
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerRemoveSignedPrekey({
|
|
required PlatformInt64 signedPreKeyId,
|
|
});
|
|
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerSetUserId({
|
|
required PlatformInt64 userId,
|
|
});
|
|
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerStoreSignedPrekey({
|
|
required PlatformInt64 signedPreKeyId,
|
|
required List<int> record,
|
|
});
|
|
}
|
|
|
|
class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
|
|
RustLibApiImpl({
|
|
required super.handler,
|
|
required super.wire,
|
|
required super.generalizedFrbRustBinding,
|
|
required super.portManager,
|
|
});
|
|
|
|
@override
|
|
Future<Uint8List>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryGetCurrentVersion() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 1,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryGetCurrentVersionConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryGetCurrentVersionConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "flutter_user_discovery_get_current_version",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<List<Uint8List>>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryGetNewMessages({
|
|
required PlatformInt64 contactId,
|
|
required List<int> receivedVersion,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(contactId, serializer);
|
|
sse_encode_list_prim_u_8_loose(receivedVersion, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 2,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryGetNewMessagesConstMeta,
|
|
argValues: [contactId, receivedVersion],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryGetNewMessagesConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "flutter_user_discovery_get_new_messages",
|
|
argNames: ["contactId", "receivedVersion"],
|
|
);
|
|
|
|
@override
|
|
Future<void>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryHandleNewMessages({
|
|
required PlatformInt64 contactId,
|
|
PlatformInt64? publicKeyVerifiedTimestamp,
|
|
required List<Uint8List> messages,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(contactId, serializer);
|
|
sse_encode_opt_box_autoadd_i_64(
|
|
publicKeyVerifiedTimestamp,
|
|
serializer,
|
|
);
|
|
sse_encode_list_list_prim_u_8_strict(messages, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 3,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryHandleNewMessagesConstMeta,
|
|
argValues: [contactId, publicKeyVerifiedTimestamp, messages],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryHandleNewMessagesConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "flutter_user_discovery_handle_new_messages",
|
|
argNames: ["contactId", "publicKeyVerifiedTimestamp", "messages"],
|
|
);
|
|
|
|
@override
|
|
Future<void>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryInitializeOrUpdate({
|
|
required int threshold,
|
|
required PlatformInt64 userId,
|
|
required List<int> publicKey,
|
|
required bool sharePromotion,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_8(threshold, serializer);
|
|
sse_encode_i_64(userId, serializer);
|
|
sse_encode_list_prim_u_8_loose(publicKey, serializer);
|
|
sse_encode_bool(sharePromotion, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 4,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryInitializeOrUpdateConstMeta,
|
|
argValues: [threshold, userId, publicKey, sharePromotion],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryInitializeOrUpdateConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "flutter_user_discovery_initialize_or_update",
|
|
argNames: ["threshold", "userId", "publicKey", "sharePromotion"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List?>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryShouldRequestNewMessages({
|
|
required PlatformInt64 contactId,
|
|
required List<int> version,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(contactId, serializer);
|
|
sse_encode_list_prim_u_8_loose(version, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 5,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_opt_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryShouldRequestNewMessagesConstMeta,
|
|
argValues: [contactId, version],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryShouldRequestNewMessagesConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "flutter_user_discovery_should_request_new_messages",
|
|
argNames: ["contactId", "version"],
|
|
);
|
|
|
|
@override
|
|
Future<void>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryUpdateVerificationStateForUser({
|
|
required PlatformInt64 contactId,
|
|
PlatformInt64? publicKeyVerifiedTimestamp,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(contactId, serializer);
|
|
sse_encode_opt_box_autoadd_i_64(
|
|
publicKeyVerifiedTimestamp,
|
|
serializer,
|
|
);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 6,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryUpdateVerificationStateForUserConstMeta,
|
|
argValues: [contactId, publicKeyVerifiedTimestamp],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryUpdateVerificationStateForUserConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "flutter_user_discovery_update_verification_state_for_user",
|
|
argNames: ["contactId", "publicKeyVerifiedTimestamp"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeCallbacksInitFlutterCallbacks({
|
|
required FutureOr<RustStreamSink<String>> Function() loggingGetStreamSink,
|
|
required FutureOr<Uint8List?> Function(Uint8List) userDiscoverySignData,
|
|
required FutureOr<bool> Function(Uint8List, Uint8List, Uint8List)
|
|
userDiscoveryVerifySignature,
|
|
required FutureOr<bool> Function(PlatformInt64, Uint8List)
|
|
userDiscoveryVerifyStoredPubkey,
|
|
required FutureOr<bool> Function(List<Uint8List>) userDiscoverySetShares,
|
|
required FutureOr<Uint8List?> Function(PlatformInt64)
|
|
userDiscoveryGetShareForContact,
|
|
required FutureOr<bool> Function(PlatformInt64, PlatformInt64, Uint8List)
|
|
userDiscoveryPushOwnPromotionAndClearOldVersion,
|
|
required FutureOr<List<Uint8List>?> Function(PlatformInt64)
|
|
userDiscoveryGetOwnPromotionsAfterVersion,
|
|
required FutureOr<bool> Function(OtherPromotion)
|
|
userDiscoveryStoreOtherPromotion,
|
|
required FutureOr<List<OtherPromotion>?> Function(PlatformInt64)
|
|
userDiscoveryGetOtherPromotionsByPublicId,
|
|
required FutureOr<AnnouncedUser?> Function(PlatformInt64)
|
|
userDiscoveryGetAnnouncedUserByPublicId,
|
|
required FutureOr<Uint8List?> Function(PlatformInt64)
|
|
userDiscoveryGetContactVersion,
|
|
required FutureOr<bool> Function(PlatformInt64, Uint8List)
|
|
userDiscoverySetContactVersion,
|
|
required FutureOr<bool> Function(
|
|
PlatformInt64,
|
|
AnnouncedUser,
|
|
PlatformInt64?,
|
|
)
|
|
userDiscoveryPushNewUserRelation,
|
|
required FutureOr<Uint8List?> Function(PlatformInt64)
|
|
userDiscoveryGetContactPromotion,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_DartFn_Inputs__Output_StreamSink_String_Sse_AnyhowException(
|
|
loggingGetStreamSink,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_list_prim_u_8_strict_Output_opt_list_prim_u_8_strict_AnyhowException(
|
|
userDiscoverySignData,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_list_prim_u_8_strict_list_prim_u_8_strict_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
userDiscoveryVerifySignature,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_i_64_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
userDiscoveryVerifyStoredPubkey,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_list_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
userDiscoverySetShares,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_i_64_Output_opt_list_prim_u_8_strict_AnyhowException(
|
|
userDiscoveryGetShareForContact,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_i_64_i_64_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
userDiscoveryPushOwnPromotionAndClearOldVersion,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_i_64_Output_opt_list_list_prim_u_8_strict_AnyhowException(
|
|
userDiscoveryGetOwnPromotionsAfterVersion,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_other_promotion_Output_bool_AnyhowException(
|
|
userDiscoveryStoreOtherPromotion,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_i_64_Output_opt_list_other_promotion_AnyhowException(
|
|
userDiscoveryGetOtherPromotionsByPublicId,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_i_64_Output_opt_box_autoadd_announced_user_AnyhowException(
|
|
userDiscoveryGetAnnouncedUserByPublicId,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_i_64_Output_opt_list_prim_u_8_strict_AnyhowException(
|
|
userDiscoveryGetContactVersion,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_i_64_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
userDiscoverySetContactVersion,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_i_64_announced_user_opt_box_autoadd_i_64_Output_bool_AnyhowException(
|
|
userDiscoveryPushNewUserRelation,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_i_64_Output_opt_list_prim_u_8_strict_AnyhowException(
|
|
userDiscoveryGetContactPromotion,
|
|
serializer,
|
|
);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 7,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateBridgeCallbacksInitFlutterCallbacksConstMeta,
|
|
argValues: [
|
|
loggingGetStreamSink,
|
|
userDiscoverySignData,
|
|
userDiscoveryVerifySignature,
|
|
userDiscoveryVerifyStoredPubkey,
|
|
userDiscoverySetShares,
|
|
userDiscoveryGetShareForContact,
|
|
userDiscoveryPushOwnPromotionAndClearOldVersion,
|
|
userDiscoveryGetOwnPromotionsAfterVersion,
|
|
userDiscoveryStoreOtherPromotion,
|
|
userDiscoveryGetOtherPromotionsByPublicId,
|
|
userDiscoveryGetAnnouncedUserByPublicId,
|
|
userDiscoveryGetContactVersion,
|
|
userDiscoverySetContactVersion,
|
|
userDiscoveryPushNewUserRelation,
|
|
userDiscoveryGetContactPromotion,
|
|
],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeCallbacksInitFlutterCallbacksConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "init_flutter_callbacks",
|
|
argNames: [
|
|
"loggingGetStreamSink",
|
|
"userDiscoverySignData",
|
|
"userDiscoveryVerifySignature",
|
|
"userDiscoveryVerifyStoredPubkey",
|
|
"userDiscoverySetShares",
|
|
"userDiscoveryGetShareForContact",
|
|
"userDiscoveryPushOwnPromotionAndClearOldVersion",
|
|
"userDiscoveryGetOwnPromotionsAfterVersion",
|
|
"userDiscoveryStoreOtherPromotion",
|
|
"userDiscoveryGetOtherPromotionsByPublicId",
|
|
"userDiscoveryGetAnnouncedUserByPublicId",
|
|
"userDiscoveryGetContactVersion",
|
|
"userDiscoverySetContactVersion",
|
|
"userDiscoveryPushNewUserRelation",
|
|
"userDiscoveryGetContactPromotion",
|
|
],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeInitializeTwonlyFlutter({
|
|
required InitConfig config,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_box_autoadd_init_config(config, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 8,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeInitializeTwonlyFlutterConstMeta,
|
|
argValues: [config],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeInitializeTwonlyFlutterConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "initialize_twonly_flutter",
|
|
argNames: ["config"],
|
|
);
|
|
|
|
@override
|
|
Future<(String, String)>
|
|
crateBridgeWrapperBackupRustBackupArchiveCreateBackupArchive() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 9,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_record_string_string,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperBackupRustBackupArchiveCreateBackupArchiveConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperBackupRustBackupArchiveCreateBackupArchiveConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_backup_archive_create_backup_archive",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<String?>
|
|
crateBridgeWrapperBackupRustBackupArchiveGetBackupDownloadToken() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 10,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_opt_String,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperBackupRustBackupArchiveGetBackupDownloadTokenConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperBackupRustBackupArchiveGetBackupDownloadTokenConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_backup_archive_get_backup_download_token",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeWrapperBackupRustBackupArchiveRestoreBackupArchive({
|
|
required String filePath,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(filePath, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 11,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperBackupRustBackupArchiveRestoreBackupArchiveConstMeta,
|
|
argValues: [filePath],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperBackupRustBackupArchiveRestoreBackupArchiveConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_backup_archive_restore_backup_archive",
|
|
argNames: ["filePath"],
|
|
);
|
|
|
|
@override
|
|
Future<String?> crateBridgeWrapperBackupRustBackupIdentityGetBackupId() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 12,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_opt_String,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperBackupRustBackupIdentityGetBackupIdConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperBackupRustBackupIdentityGetBackupIdConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_backup_identity_get_backup_id",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<BackupPasswordKeys>
|
|
crateBridgeWrapperBackupRustBackupIdentityGetBackupPasswordKeys({
|
|
required PlatformInt64 userId,
|
|
required String password,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(userId, serializer);
|
|
sse_encode_String(password, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 13,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_backup_password_keys,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperBackupRustBackupIdentityGetBackupPasswordKeysConstMeta,
|
|
argValues: [userId, password],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperBackupRustBackupIdentityGetBackupPasswordKeysConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_backup_identity_get_backup_password_keys",
|
|
argNames: ["userId", "password"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List>
|
|
crateBridgeWrapperBackupRustBackupIdentityGetIdentityBackupBytes() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 14,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperBackupRustBackupIdentityGetIdentityBackupBytesConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperBackupRustBackupIdentityGetIdentityBackupBytesConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_backup_identity_get_identity_backup_bytes",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void>
|
|
crateBridgeWrapperBackupRustBackupIdentityImportBackupPasswordKeys({
|
|
required List<int> backupId,
|
|
required List<int> encryptionKey,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_prim_u_8_loose(backupId, serializer);
|
|
sse_encode_list_prim_u_8_loose(encryptionKey, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 15,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperBackupRustBackupIdentityImportBackupPasswordKeysConstMeta,
|
|
argValues: [backupId, encryptionKey],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperBackupRustBackupIdentityImportBackupPasswordKeysConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_backup_identity_import_backup_password_keys",
|
|
argNames: ["backupId", "encryptionKey"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeWrapperBackupRustBackupIdentityRestoreIdentityBackup({
|
|
required BackupPasswordKeys keys,
|
|
required List<int> encryptedBytes,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_box_autoadd_backup_password_keys(keys, serializer);
|
|
sse_encode_list_prim_u_8_loose(encryptedBytes, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 16,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperBackupRustBackupIdentityRestoreIdentityBackupConstMeta,
|
|
argValues: [keys, encryptedBytes],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperBackupRustBackupIdentityRestoreIdentityBackupConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_backup_identity_restore_identity_backup",
|
|
argNames: ["keys", "encryptedBytes"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeWrapperBackupRustBackupIdentitySetBackupPasswordKeys({
|
|
required PlatformInt64 userId,
|
|
required String password,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(userId, serializer);
|
|
sse_encode_String(password, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 17,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperBackupRustBackupIdentitySetBackupPasswordKeysConstMeta,
|
|
argValues: [userId, password],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperBackupRustBackupIdentitySetBackupPasswordKeysConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_backup_identity_set_backup_password_keys",
|
|
argNames: ["userId", "password"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeWrapperKeyManagerRustKeyManagerGetLoginToken() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 18,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerGetLoginTokenConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerGetLoginTokenConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_get_login_token",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<(Uint8List, PlatformInt64)>
|
|
crateBridgeWrapperKeyManagerRustKeyManagerGetSignalIdentity() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 19,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_record_list_prim_u_8_strict_i_64,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerGetSignalIdentityConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerGetSignalIdentityConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_get_signal_identity",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<PlatformInt64?> crateBridgeWrapperKeyManagerRustKeyManagerGetUserId() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 20,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_opt_box_autoadd_i_64,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerGetUserIdConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerGetUserIdConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_get_user_id",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerImportSignalIdentity({
|
|
required List<int> identityKeyPairStructure,
|
|
required PlatformInt64 registrationId,
|
|
required Map<PlatformInt64, Uint8List> signedPreKeyStore,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_prim_u_8_loose(identityKeyPairStructure, serializer);
|
|
sse_encode_i_64(registrationId, serializer);
|
|
sse_encode_Map_i_64_list_prim_u_8_strict_None(
|
|
signedPreKeyStore,
|
|
serializer,
|
|
);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 21,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerImportSignalIdentityConstMeta,
|
|
argValues: [
|
|
identityKeyPairStructure,
|
|
registrationId,
|
|
signedPreKeyStore,
|
|
],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerImportSignalIdentityConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_import_signal_identity",
|
|
argNames: [
|
|
"identityKeyPairStructure",
|
|
"registrationId",
|
|
"signedPreKeyStore",
|
|
],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List?>
|
|
crateBridgeWrapperKeyManagerRustKeyManagerLoadSignedPrekey({
|
|
required PlatformInt64 signedPreKeyId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(signedPreKeyId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 22,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_opt_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerLoadSignedPrekeyConstMeta,
|
|
argValues: [signedPreKeyId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerLoadSignedPrekeyConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_load_signed_prekey",
|
|
argNames: ["signedPreKeyId"],
|
|
);
|
|
|
|
@override
|
|
Future<Map<PlatformInt64, Uint8List>>
|
|
crateBridgeWrapperKeyManagerRustKeyManagerLoadSignedPrekeys() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 23,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_Map_i_64_list_prim_u_8_strict_None,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerLoadSignedPrekeysConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerLoadSignedPrekeysConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_load_signed_prekeys",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerRemoveKeyManager() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 24,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerRemoveKeyManagerConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerRemoveKeyManagerConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_remove_key_manager",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerRemoveSignedPrekey({
|
|
required PlatformInt64 signedPreKeyId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(signedPreKeyId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 25,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerRemoveSignedPrekeyConstMeta,
|
|
argValues: [signedPreKeyId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerRemoveSignedPrekeyConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_remove_signed_prekey",
|
|
argNames: ["signedPreKeyId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerSetUserId({
|
|
required PlatformInt64 userId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(userId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 26,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerSetUserIdConstMeta,
|
|
argValues: [userId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerSetUserIdConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_set_user_id",
|
|
argNames: ["userId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerStoreSignedPrekey({
|
|
required PlatformInt64 signedPreKeyId,
|
|
required List<int> record,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(signedPreKeyId, serializer);
|
|
sse_encode_list_prim_u_8_loose(record, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 27,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerStoreSignedPrekeyConstMeta,
|
|
argValues: [signedPreKeyId, record],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerStoreSignedPrekeyConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_store_signed_prekey",
|
|
argNames: ["signedPreKeyId", "record"],
|
|
);
|
|
|
|
Future<void> Function(
|
|
int,
|
|
)
|
|
encode_DartFn_Inputs__Output_StreamSink_String_Sse_AnyhowException(
|
|
FutureOr<RustStreamSink<String>> Function() raw,
|
|
) {
|
|
return (
|
|
callId,
|
|
) async {
|
|
Box<RustStreamSink<String>>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw());
|
|
} catch (e, s) {
|
|
rawError = Box(AnyhowException("$e\n\n$s"));
|
|
}
|
|
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
assert((rawOutput != null) ^ (rawError != null));
|
|
if (rawOutput != null) {
|
|
serializer.buffer.putUint8(0);
|
|
sse_encode_StreamSink_String_Sse(rawOutput.value, serializer);
|
|
} else {
|
|
serializer.buffer.putUint8(1);
|
|
sse_encode_AnyhowException(rawError!.value, serializer);
|
|
}
|
|
final output = serializer.intoRaw();
|
|
|
|
generalizedFrbRustBinding.dartFnDeliverOutput(
|
|
callId: callId,
|
|
ptr: output.ptr,
|
|
rustVecLen: output.rustVecLen,
|
|
dataLen: output.dataLen,
|
|
);
|
|
};
|
|
}
|
|
|
|
Future<void> Function(int, dynamic)
|
|
encode_DartFn_Inputs_i_64_Output_opt_box_autoadd_announced_user_AnyhowException(
|
|
FutureOr<AnnouncedUser?> Function(PlatformInt64) raw,
|
|
) {
|
|
return (callId, rawArg0) async {
|
|
final arg0 = dco_decode_i_64(rawArg0);
|
|
|
|
Box<AnnouncedUser?>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw(arg0));
|
|
} catch (e, s) {
|
|
rawError = Box(AnyhowException("$e\n\n$s"));
|
|
}
|
|
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
assert((rawOutput != null) ^ (rawError != null));
|
|
if (rawOutput != null) {
|
|
serializer.buffer.putUint8(0);
|
|
sse_encode_opt_box_autoadd_announced_user(rawOutput.value, serializer);
|
|
} else {
|
|
serializer.buffer.putUint8(1);
|
|
sse_encode_AnyhowException(rawError!.value, serializer);
|
|
}
|
|
final output = serializer.intoRaw();
|
|
|
|
generalizedFrbRustBinding.dartFnDeliverOutput(
|
|
callId: callId,
|
|
ptr: output.ptr,
|
|
rustVecLen: output.rustVecLen,
|
|
dataLen: output.dataLen,
|
|
);
|
|
};
|
|
}
|
|
|
|
Future<void> Function(int, dynamic)
|
|
encode_DartFn_Inputs_i_64_Output_opt_list_list_prim_u_8_strict_AnyhowException(
|
|
FutureOr<List<Uint8List>?> Function(PlatformInt64) raw,
|
|
) {
|
|
return (callId, rawArg0) async {
|
|
final arg0 = dco_decode_i_64(rawArg0);
|
|
|
|
Box<List<Uint8List>?>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw(arg0));
|
|
} catch (e, s) {
|
|
rawError = Box(AnyhowException("$e\n\n$s"));
|
|
}
|
|
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
assert((rawOutput != null) ^ (rawError != null));
|
|
if (rawOutput != null) {
|
|
serializer.buffer.putUint8(0);
|
|
sse_encode_opt_list_list_prim_u_8_strict(rawOutput.value, serializer);
|
|
} else {
|
|
serializer.buffer.putUint8(1);
|
|
sse_encode_AnyhowException(rawError!.value, serializer);
|
|
}
|
|
final output = serializer.intoRaw();
|
|
|
|
generalizedFrbRustBinding.dartFnDeliverOutput(
|
|
callId: callId,
|
|
ptr: output.ptr,
|
|
rustVecLen: output.rustVecLen,
|
|
dataLen: output.dataLen,
|
|
);
|
|
};
|
|
}
|
|
|
|
Future<void> Function(int, dynamic)
|
|
encode_DartFn_Inputs_i_64_Output_opt_list_other_promotion_AnyhowException(
|
|
FutureOr<List<OtherPromotion>?> Function(PlatformInt64) raw,
|
|
) {
|
|
return (callId, rawArg0) async {
|
|
final arg0 = dco_decode_i_64(rawArg0);
|
|
|
|
Box<List<OtherPromotion>?>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw(arg0));
|
|
} catch (e, s) {
|
|
rawError = Box(AnyhowException("$e\n\n$s"));
|
|
}
|
|
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
assert((rawOutput != null) ^ (rawError != null));
|
|
if (rawOutput != null) {
|
|
serializer.buffer.putUint8(0);
|
|
sse_encode_opt_list_other_promotion(rawOutput.value, serializer);
|
|
} else {
|
|
serializer.buffer.putUint8(1);
|
|
sse_encode_AnyhowException(rawError!.value, serializer);
|
|
}
|
|
final output = serializer.intoRaw();
|
|
|
|
generalizedFrbRustBinding.dartFnDeliverOutput(
|
|
callId: callId,
|
|
ptr: output.ptr,
|
|
rustVecLen: output.rustVecLen,
|
|
dataLen: output.dataLen,
|
|
);
|
|
};
|
|
}
|
|
|
|
Future<void> Function(int, dynamic)
|
|
encode_DartFn_Inputs_i_64_Output_opt_list_prim_u_8_strict_AnyhowException(
|
|
FutureOr<Uint8List?> Function(PlatformInt64) raw,
|
|
) {
|
|
return (callId, rawArg0) async {
|
|
final arg0 = dco_decode_i_64(rawArg0);
|
|
|
|
Box<Uint8List?>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw(arg0));
|
|
} catch (e, s) {
|
|
rawError = Box(AnyhowException("$e\n\n$s"));
|
|
}
|
|
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
assert((rawOutput != null) ^ (rawError != null));
|
|
if (rawOutput != null) {
|
|
serializer.buffer.putUint8(0);
|
|
sse_encode_opt_list_prim_u_8_strict(rawOutput.value, serializer);
|
|
} else {
|
|
serializer.buffer.putUint8(1);
|
|
sse_encode_AnyhowException(rawError!.value, serializer);
|
|
}
|
|
final output = serializer.intoRaw();
|
|
|
|
generalizedFrbRustBinding.dartFnDeliverOutput(
|
|
callId: callId,
|
|
ptr: output.ptr,
|
|
rustVecLen: output.rustVecLen,
|
|
dataLen: output.dataLen,
|
|
);
|
|
};
|
|
}
|
|
|
|
Future<void> Function(int, dynamic, dynamic, dynamic)
|
|
encode_DartFn_Inputs_i_64_announced_user_opt_box_autoadd_i_64_Output_bool_AnyhowException(
|
|
FutureOr<bool> Function(PlatformInt64, AnnouncedUser, PlatformInt64?) raw,
|
|
) {
|
|
return (callId, rawArg0, rawArg1, rawArg2) async {
|
|
final arg0 = dco_decode_i_64(rawArg0);
|
|
final arg1 = dco_decode_announced_user(rawArg1);
|
|
final arg2 = dco_decode_opt_box_autoadd_i_64(rawArg2);
|
|
|
|
Box<bool>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw(arg0, arg1, arg2));
|
|
} catch (e, s) {
|
|
rawError = Box(AnyhowException("$e\n\n$s"));
|
|
}
|
|
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
assert((rawOutput != null) ^ (rawError != null));
|
|
if (rawOutput != null) {
|
|
serializer.buffer.putUint8(0);
|
|
sse_encode_bool(rawOutput.value, serializer);
|
|
} else {
|
|
serializer.buffer.putUint8(1);
|
|
sse_encode_AnyhowException(rawError!.value, serializer);
|
|
}
|
|
final output = serializer.intoRaw();
|
|
|
|
generalizedFrbRustBinding.dartFnDeliverOutput(
|
|
callId: callId,
|
|
ptr: output.ptr,
|
|
rustVecLen: output.rustVecLen,
|
|
dataLen: output.dataLen,
|
|
);
|
|
};
|
|
}
|
|
|
|
Future<void> Function(int, dynamic, dynamic, dynamic)
|
|
encode_DartFn_Inputs_i_64_i_64_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
FutureOr<bool> Function(PlatformInt64, PlatformInt64, Uint8List) raw,
|
|
) {
|
|
return (callId, rawArg0, rawArg1, rawArg2) async {
|
|
final arg0 = dco_decode_i_64(rawArg0);
|
|
final arg1 = dco_decode_i_64(rawArg1);
|
|
final arg2 = dco_decode_list_prim_u_8_strict(rawArg2);
|
|
|
|
Box<bool>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw(arg0, arg1, arg2));
|
|
} catch (e, s) {
|
|
rawError = Box(AnyhowException("$e\n\n$s"));
|
|
}
|
|
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
assert((rawOutput != null) ^ (rawError != null));
|
|
if (rawOutput != null) {
|
|
serializer.buffer.putUint8(0);
|
|
sse_encode_bool(rawOutput.value, serializer);
|
|
} else {
|
|
serializer.buffer.putUint8(1);
|
|
sse_encode_AnyhowException(rawError!.value, serializer);
|
|
}
|
|
final output = serializer.intoRaw();
|
|
|
|
generalizedFrbRustBinding.dartFnDeliverOutput(
|
|
callId: callId,
|
|
ptr: output.ptr,
|
|
rustVecLen: output.rustVecLen,
|
|
dataLen: output.dataLen,
|
|
);
|
|
};
|
|
}
|
|
|
|
Future<void> Function(int, dynamic, dynamic)
|
|
encode_DartFn_Inputs_i_64_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
FutureOr<bool> Function(PlatformInt64, Uint8List) raw,
|
|
) {
|
|
return (callId, rawArg0, rawArg1) async {
|
|
final arg0 = dco_decode_i_64(rawArg0);
|
|
final arg1 = dco_decode_list_prim_u_8_strict(rawArg1);
|
|
|
|
Box<bool>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw(arg0, arg1));
|
|
} catch (e, s) {
|
|
rawError = Box(AnyhowException("$e\n\n$s"));
|
|
}
|
|
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
assert((rawOutput != null) ^ (rawError != null));
|
|
if (rawOutput != null) {
|
|
serializer.buffer.putUint8(0);
|
|
sse_encode_bool(rawOutput.value, serializer);
|
|
} else {
|
|
serializer.buffer.putUint8(1);
|
|
sse_encode_AnyhowException(rawError!.value, serializer);
|
|
}
|
|
final output = serializer.intoRaw();
|
|
|
|
generalizedFrbRustBinding.dartFnDeliverOutput(
|
|
callId: callId,
|
|
ptr: output.ptr,
|
|
rustVecLen: output.rustVecLen,
|
|
dataLen: output.dataLen,
|
|
);
|
|
};
|
|
}
|
|
|
|
Future<void> Function(int, dynamic)
|
|
encode_DartFn_Inputs_list_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
FutureOr<bool> Function(List<Uint8List>) raw,
|
|
) {
|
|
return (callId, rawArg0) async {
|
|
final arg0 = dco_decode_list_list_prim_u_8_strict(rawArg0);
|
|
|
|
Box<bool>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw(arg0));
|
|
} catch (e, s) {
|
|
rawError = Box(AnyhowException("$e\n\n$s"));
|
|
}
|
|
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
assert((rawOutput != null) ^ (rawError != null));
|
|
if (rawOutput != null) {
|
|
serializer.buffer.putUint8(0);
|
|
sse_encode_bool(rawOutput.value, serializer);
|
|
} else {
|
|
serializer.buffer.putUint8(1);
|
|
sse_encode_AnyhowException(rawError!.value, serializer);
|
|
}
|
|
final output = serializer.intoRaw();
|
|
|
|
generalizedFrbRustBinding.dartFnDeliverOutput(
|
|
callId: callId,
|
|
ptr: output.ptr,
|
|
rustVecLen: output.rustVecLen,
|
|
dataLen: output.dataLen,
|
|
);
|
|
};
|
|
}
|
|
|
|
Future<void> Function(int, dynamic)
|
|
encode_DartFn_Inputs_list_prim_u_8_strict_Output_opt_list_prim_u_8_strict_AnyhowException(
|
|
FutureOr<Uint8List?> Function(Uint8List) raw,
|
|
) {
|
|
return (callId, rawArg0) async {
|
|
final arg0 = dco_decode_list_prim_u_8_strict(rawArg0);
|
|
|
|
Box<Uint8List?>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw(arg0));
|
|
} catch (e, s) {
|
|
rawError = Box(AnyhowException("$e\n\n$s"));
|
|
}
|
|
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
assert((rawOutput != null) ^ (rawError != null));
|
|
if (rawOutput != null) {
|
|
serializer.buffer.putUint8(0);
|
|
sse_encode_opt_list_prim_u_8_strict(rawOutput.value, serializer);
|
|
} else {
|
|
serializer.buffer.putUint8(1);
|
|
sse_encode_AnyhowException(rawError!.value, serializer);
|
|
}
|
|
final output = serializer.intoRaw();
|
|
|
|
generalizedFrbRustBinding.dartFnDeliverOutput(
|
|
callId: callId,
|
|
ptr: output.ptr,
|
|
rustVecLen: output.rustVecLen,
|
|
dataLen: output.dataLen,
|
|
);
|
|
};
|
|
}
|
|
|
|
Future<void> Function(int, dynamic, dynamic, dynamic)
|
|
encode_DartFn_Inputs_list_prim_u_8_strict_list_prim_u_8_strict_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
FutureOr<bool> Function(Uint8List, Uint8List, Uint8List) raw,
|
|
) {
|
|
return (callId, rawArg0, rawArg1, rawArg2) async {
|
|
final arg0 = dco_decode_list_prim_u_8_strict(rawArg0);
|
|
final arg1 = dco_decode_list_prim_u_8_strict(rawArg1);
|
|
final arg2 = dco_decode_list_prim_u_8_strict(rawArg2);
|
|
|
|
Box<bool>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw(arg0, arg1, arg2));
|
|
} catch (e, s) {
|
|
rawError = Box(AnyhowException("$e\n\n$s"));
|
|
}
|
|
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
assert((rawOutput != null) ^ (rawError != null));
|
|
if (rawOutput != null) {
|
|
serializer.buffer.putUint8(0);
|
|
sse_encode_bool(rawOutput.value, serializer);
|
|
} else {
|
|
serializer.buffer.putUint8(1);
|
|
sse_encode_AnyhowException(rawError!.value, serializer);
|
|
}
|
|
final output = serializer.intoRaw();
|
|
|
|
generalizedFrbRustBinding.dartFnDeliverOutput(
|
|
callId: callId,
|
|
ptr: output.ptr,
|
|
rustVecLen: output.rustVecLen,
|
|
dataLen: output.dataLen,
|
|
);
|
|
};
|
|
}
|
|
|
|
Future<void> Function(int, dynamic)
|
|
encode_DartFn_Inputs_other_promotion_Output_bool_AnyhowException(
|
|
FutureOr<bool> Function(OtherPromotion) raw,
|
|
) {
|
|
return (callId, rawArg0) async {
|
|
final arg0 = dco_decode_other_promotion(rawArg0);
|
|
|
|
Box<bool>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw(arg0));
|
|
} catch (e, s) {
|
|
rawError = Box(AnyhowException("$e\n\n$s"));
|
|
}
|
|
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
assert((rawOutput != null) ^ (rawError != null));
|
|
if (rawOutput != null) {
|
|
serializer.buffer.putUint8(0);
|
|
sse_encode_bool(rawOutput.value, serializer);
|
|
} else {
|
|
serializer.buffer.putUint8(1);
|
|
sse_encode_AnyhowException(rawError!.value, serializer);
|
|
}
|
|
final output = serializer.intoRaw();
|
|
|
|
generalizedFrbRustBinding.dartFnDeliverOutput(
|
|
callId: callId,
|
|
ptr: output.ptr,
|
|
rustVecLen: output.rustVecLen,
|
|
dataLen: output.dataLen,
|
|
);
|
|
};
|
|
}
|
|
|
|
@protected
|
|
AnyhowException dco_decode_AnyhowException(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return AnyhowException(raw as String);
|
|
}
|
|
|
|
@protected
|
|
FutureOr<RustStreamSink<String>> Function()
|
|
dco_decode_DartFn_Inputs__Output_StreamSink_String_Sse_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<AnnouncedUser?> Function(PlatformInt64)
|
|
dco_decode_DartFn_Inputs_i_64_Output_opt_box_autoadd_announced_user_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<List<Uint8List>?> Function(PlatformInt64)
|
|
dco_decode_DartFn_Inputs_i_64_Output_opt_list_list_prim_u_8_strict_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<List<OtherPromotion>?> Function(PlatformInt64)
|
|
dco_decode_DartFn_Inputs_i_64_Output_opt_list_other_promotion_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<Uint8List?> Function(PlatformInt64)
|
|
dco_decode_DartFn_Inputs_i_64_Output_opt_list_prim_u_8_strict_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<bool> Function(PlatformInt64, AnnouncedUser, PlatformInt64?)
|
|
dco_decode_DartFn_Inputs_i_64_announced_user_opt_box_autoadd_i_64_Output_bool_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<bool> Function(PlatformInt64, PlatformInt64, Uint8List)
|
|
dco_decode_DartFn_Inputs_i_64_i_64_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<bool> Function(PlatformInt64, Uint8List)
|
|
dco_decode_DartFn_Inputs_i_64_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<bool> Function(List<Uint8List>)
|
|
dco_decode_DartFn_Inputs_list_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<Uint8List?> Function(Uint8List)
|
|
dco_decode_DartFn_Inputs_list_prim_u_8_strict_Output_opt_list_prim_u_8_strict_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<bool> Function(Uint8List, Uint8List, Uint8List)
|
|
dco_decode_DartFn_Inputs_list_prim_u_8_strict_list_prim_u_8_strict_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<bool> Function(OtherPromotion)
|
|
dco_decode_DartFn_Inputs_other_promotion_Output_bool_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
Object dco_decode_DartOpaque(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return decodeDartOpaque(raw, generalizedFrbRustBinding);
|
|
}
|
|
|
|
@protected
|
|
Map<PlatformInt64, Uint8List> dco_decode_Map_i_64_list_prim_u_8_strict_None(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return Map.fromEntries(
|
|
dco_decode_list_record_i_64_list_prim_u_8_strict(
|
|
raw,
|
|
).map((e) => MapEntry(e.$1, e.$2)),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
RustStreamSink<String> dco_decode_StreamSink_String_Sse(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError();
|
|
}
|
|
|
|
@protected
|
|
String dco_decode_String(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as String;
|
|
}
|
|
|
|
@protected
|
|
AnnouncedUser dco_decode_announced_user(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 3)
|
|
throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
|
|
return AnnouncedUser(
|
|
userId: dco_decode_i_64(arr[0]),
|
|
publicKey: dco_decode_list_prim_u_8_strict(arr[1]),
|
|
publicId: dco_decode_i_64(arr[2]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
BackupPasswordKeys dco_decode_backup_password_keys(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 2)
|
|
throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
|
|
return BackupPasswordKeys(
|
|
backupId: dco_decode_u_8_array_32(arr[0]),
|
|
encryptionKey: dco_decode_u_8_array_32(arr[1]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
bool dco_decode_bool(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as bool;
|
|
}
|
|
|
|
@protected
|
|
AnnouncedUser dco_decode_box_autoadd_announced_user(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_announced_user(raw);
|
|
}
|
|
|
|
@protected
|
|
BackupPasswordKeys dco_decode_box_autoadd_backup_password_keys(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_backup_password_keys(raw);
|
|
}
|
|
|
|
@protected
|
|
PlatformInt64 dco_decode_box_autoadd_i_64(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_i_64(raw);
|
|
}
|
|
|
|
@protected
|
|
InitConfig dco_decode_box_autoadd_init_config(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_init_config(raw);
|
|
}
|
|
|
|
@protected
|
|
FlutterUserDiscovery dco_decode_flutter_user_discovery(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 0)
|
|
throw Exception('unexpected arr length: expect 0 but see ${arr.length}');
|
|
return FlutterUserDiscovery();
|
|
}
|
|
|
|
@protected
|
|
PlatformInt64 dco_decode_i_64(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dcoDecodeI64(raw);
|
|
}
|
|
|
|
@protected
|
|
InitConfig dco_decode_init_config(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 2)
|
|
throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
|
|
return InitConfig(
|
|
databaseDir: dco_decode_String(arr[0]),
|
|
dataDir: dco_decode_String(arr[1]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
PlatformInt64 dco_decode_isize(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dcoDecodeI64(raw);
|
|
}
|
|
|
|
@protected
|
|
List<Uint8List> dco_decode_list_list_prim_u_8_strict(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>).map(dco_decode_list_prim_u_8_strict).toList();
|
|
}
|
|
|
|
@protected
|
|
List<OtherPromotion> dco_decode_list_other_promotion(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>).map(dco_decode_other_promotion).toList();
|
|
}
|
|
|
|
@protected
|
|
List<int> dco_decode_list_prim_u_8_loose(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as List<int>;
|
|
}
|
|
|
|
@protected
|
|
Uint8List dco_decode_list_prim_u_8_strict(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as Uint8List;
|
|
}
|
|
|
|
@protected
|
|
List<(PlatformInt64, Uint8List)>
|
|
dco_decode_list_record_i_64_list_prim_u_8_strict(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>)
|
|
.map(dco_decode_record_i_64_list_prim_u_8_strict)
|
|
.toList();
|
|
}
|
|
|
|
@protected
|
|
String? dco_decode_opt_String(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_String(raw);
|
|
}
|
|
|
|
@protected
|
|
AnnouncedUser? dco_decode_opt_box_autoadd_announced_user(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_box_autoadd_announced_user(raw);
|
|
}
|
|
|
|
@protected
|
|
PlatformInt64? dco_decode_opt_box_autoadd_i_64(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_box_autoadd_i_64(raw);
|
|
}
|
|
|
|
@protected
|
|
List<Uint8List>? dco_decode_opt_list_list_prim_u_8_strict(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_list_list_prim_u_8_strict(raw);
|
|
}
|
|
|
|
@protected
|
|
List<OtherPromotion>? dco_decode_opt_list_other_promotion(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_list_other_promotion(raw);
|
|
}
|
|
|
|
@protected
|
|
Uint8List? dco_decode_opt_list_prim_u_8_strict(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_list_prim_u_8_strict(raw);
|
|
}
|
|
|
|
@protected
|
|
OtherPromotion dco_decode_other_promotion(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 6)
|
|
throw Exception('unexpected arr length: expect 6 but see ${arr.length}');
|
|
return OtherPromotion(
|
|
promotionId: dco_decode_u_32(arr[0]),
|
|
publicId: dco_decode_i_64(arr[1]),
|
|
fromContactId: dco_decode_i_64(arr[2]),
|
|
threshold: dco_decode_u_8(arr[3]),
|
|
announcementShare: dco_decode_list_prim_u_8_strict(arr[4]),
|
|
publicKeyVerifiedTimestamp: dco_decode_opt_box_autoadd_i_64(arr[5]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
(PlatformInt64, Uint8List) dco_decode_record_i_64_list_prim_u_8_strict(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 2) {
|
|
throw Exception('Expected 2 elements, got ${arr.length}');
|
|
}
|
|
return (
|
|
dco_decode_i_64(arr[0]),
|
|
dco_decode_list_prim_u_8_strict(arr[1]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
(Uint8List, PlatformInt64) dco_decode_record_list_prim_u_8_strict_i_64(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 2) {
|
|
throw Exception('Expected 2 elements, got ${arr.length}');
|
|
}
|
|
return (
|
|
dco_decode_list_prim_u_8_strict(arr[0]),
|
|
dco_decode_i_64(arr[1]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
(String, String) dco_decode_record_string_string(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 2) {
|
|
throw Exception('Expected 2 elements, got ${arr.length}');
|
|
}
|
|
return (
|
|
dco_decode_String(arr[0]),
|
|
dco_decode_String(arr[1]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
RustBackupArchive dco_decode_rust_backup_archive(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 0)
|
|
throw Exception('unexpected arr length: expect 0 but see ${arr.length}');
|
|
return RustBackupArchive();
|
|
}
|
|
|
|
@protected
|
|
RustBackupIdentity dco_decode_rust_backup_identity(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 0)
|
|
throw Exception('unexpected arr length: expect 0 but see ${arr.length}');
|
|
return RustBackupIdentity();
|
|
}
|
|
|
|
@protected
|
|
RustKeyManager dco_decode_rust_key_manager(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 0)
|
|
throw Exception('unexpected arr length: expect 0 but see ${arr.length}');
|
|
return RustKeyManager();
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_u_32(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_u_8(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@protected
|
|
U8Array32 dco_decode_u_8_array_32(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return U8Array32(dco_decode_list_prim_u_8_strict(raw));
|
|
}
|
|
|
|
@protected
|
|
void dco_decode_unit(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return;
|
|
}
|
|
|
|
@protected
|
|
BigInt dco_decode_usize(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dcoDecodeU64(raw);
|
|
}
|
|
|
|
@protected
|
|
AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_String(deserializer);
|
|
return AnyhowException(inner);
|
|
}
|
|
|
|
@protected
|
|
Object sse_decode_DartOpaque(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_isize(deserializer);
|
|
return decodeDartOpaque(inner, generalizedFrbRustBinding);
|
|
}
|
|
|
|
@protected
|
|
Map<PlatformInt64, Uint8List> sse_decode_Map_i_64_list_prim_u_8_strict_None(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_list_record_i_64_list_prim_u_8_strict(deserializer);
|
|
return Map.fromEntries(inner.map((e) => MapEntry(e.$1, e.$2)));
|
|
}
|
|
|
|
@protected
|
|
RustStreamSink<String> sse_decode_StreamSink_String_Sse(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
throw UnimplementedError('Unreachable ()');
|
|
}
|
|
|
|
@protected
|
|
String sse_decode_String(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_list_prim_u_8_strict(deserializer);
|
|
return utf8.decoder.convert(inner);
|
|
}
|
|
|
|
@protected
|
|
AnnouncedUser sse_decode_announced_user(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_userId = sse_decode_i_64(deserializer);
|
|
var var_publicKey = sse_decode_list_prim_u_8_strict(deserializer);
|
|
var var_publicId = sse_decode_i_64(deserializer);
|
|
return AnnouncedUser(
|
|
userId: var_userId,
|
|
publicKey: var_publicKey,
|
|
publicId: var_publicId,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
BackupPasswordKeys sse_decode_backup_password_keys(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_backupId = sse_decode_u_8_array_32(deserializer);
|
|
var var_encryptionKey = sse_decode_u_8_array_32(deserializer);
|
|
return BackupPasswordKeys(
|
|
backupId: var_backupId,
|
|
encryptionKey: var_encryptionKey,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
bool sse_decode_bool(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint8() != 0;
|
|
}
|
|
|
|
@protected
|
|
AnnouncedUser sse_decode_box_autoadd_announced_user(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_announced_user(deserializer));
|
|
}
|
|
|
|
@protected
|
|
BackupPasswordKeys sse_decode_box_autoadd_backup_password_keys(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_backup_password_keys(deserializer));
|
|
}
|
|
|
|
@protected
|
|
PlatformInt64 sse_decode_box_autoadd_i_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_i_64(deserializer));
|
|
}
|
|
|
|
@protected
|
|
InitConfig sse_decode_box_autoadd_init_config(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_init_config(deserializer));
|
|
}
|
|
|
|
@protected
|
|
FlutterUserDiscovery sse_decode_flutter_user_discovery(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return FlutterUserDiscovery();
|
|
}
|
|
|
|
@protected
|
|
PlatformInt64 sse_decode_i_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getPlatformInt64();
|
|
}
|
|
|
|
@protected
|
|
InitConfig sse_decode_init_config(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_databaseDir = sse_decode_String(deserializer);
|
|
var var_dataDir = sse_decode_String(deserializer);
|
|
return InitConfig(databaseDir: var_databaseDir, dataDir: var_dataDir);
|
|
}
|
|
|
|
@protected
|
|
PlatformInt64 sse_decode_isize(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getPlatformInt64();
|
|
}
|
|
|
|
@protected
|
|
List<Uint8List> sse_decode_list_list_prim_u_8_strict(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <Uint8List>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_list_prim_u_8_strict(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
List<OtherPromotion> sse_decode_list_other_promotion(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <OtherPromotion>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_other_promotion(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
List<int> sse_decode_list_prim_u_8_loose(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
return deserializer.buffer.getUint8List(len_);
|
|
}
|
|
|
|
@protected
|
|
Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
return deserializer.buffer.getUint8List(len_);
|
|
}
|
|
|
|
@protected
|
|
List<(PlatformInt64, Uint8List)>
|
|
sse_decode_list_record_i_64_list_prim_u_8_strict(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <(PlatformInt64, Uint8List)>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_record_i_64_list_prim_u_8_strict(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
String? sse_decode_opt_String(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_String(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
AnnouncedUser? sse_decode_opt_box_autoadd_announced_user(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_box_autoadd_announced_user(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
PlatformInt64? sse_decode_opt_box_autoadd_i_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_box_autoadd_i_64(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
List<Uint8List>? sse_decode_opt_list_list_prim_u_8_strict(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_list_list_prim_u_8_strict(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
List<OtherPromotion>? sse_decode_opt_list_other_promotion(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_list_other_promotion(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
Uint8List? sse_decode_opt_list_prim_u_8_strict(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_list_prim_u_8_strict(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
OtherPromotion sse_decode_other_promotion(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_promotionId = sse_decode_u_32(deserializer);
|
|
var var_publicId = sse_decode_i_64(deserializer);
|
|
var var_fromContactId = sse_decode_i_64(deserializer);
|
|
var var_threshold = sse_decode_u_8(deserializer);
|
|
var var_announcementShare = sse_decode_list_prim_u_8_strict(deserializer);
|
|
var var_publicKeyVerifiedTimestamp = sse_decode_opt_box_autoadd_i_64(
|
|
deserializer,
|
|
);
|
|
return OtherPromotion(
|
|
promotionId: var_promotionId,
|
|
publicId: var_publicId,
|
|
fromContactId: var_fromContactId,
|
|
threshold: var_threshold,
|
|
announcementShare: var_announcementShare,
|
|
publicKeyVerifiedTimestamp: var_publicKeyVerifiedTimestamp,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
(PlatformInt64, Uint8List) sse_decode_record_i_64_list_prim_u_8_strict(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_field0 = sse_decode_i_64(deserializer);
|
|
var var_field1 = sse_decode_list_prim_u_8_strict(deserializer);
|
|
return (var_field0, var_field1);
|
|
}
|
|
|
|
@protected
|
|
(Uint8List, PlatformInt64) sse_decode_record_list_prim_u_8_strict_i_64(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_field0 = sse_decode_list_prim_u_8_strict(deserializer);
|
|
var var_field1 = sse_decode_i_64(deserializer);
|
|
return (var_field0, var_field1);
|
|
}
|
|
|
|
@protected
|
|
(String, String) sse_decode_record_string_string(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_field0 = sse_decode_String(deserializer);
|
|
var var_field1 = sse_decode_String(deserializer);
|
|
return (var_field0, var_field1);
|
|
}
|
|
|
|
@protected
|
|
RustBackupArchive sse_decode_rust_backup_archive(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return RustBackupArchive();
|
|
}
|
|
|
|
@protected
|
|
RustBackupIdentity sse_decode_rust_backup_identity(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return RustBackupIdentity();
|
|
}
|
|
|
|
@protected
|
|
RustKeyManager sse_decode_rust_key_manager(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return RustKeyManager();
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_u_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint32();
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_u_8(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint8();
|
|
}
|
|
|
|
@protected
|
|
U8Array32 sse_decode_u_8_array_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_list_prim_u_8_strict(deserializer);
|
|
return U8Array32(inner);
|
|
}
|
|
|
|
@protected
|
|
void sse_decode_unit(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
|
|
@protected
|
|
BigInt sse_decode_usize(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getBigUint64();
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_i_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getInt32();
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_AnyhowException(
|
|
AnyhowException self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.message, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_DartFn_Inputs__Output_StreamSink_String_Sse_AnyhowException(
|
|
FutureOr<RustStreamSink<String>> Function() self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs__Output_StreamSink_String_Sse_AnyhowException(self),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void
|
|
sse_encode_DartFn_Inputs_i_64_Output_opt_box_autoadd_announced_user_AnyhowException(
|
|
FutureOr<AnnouncedUser?> Function(PlatformInt64) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_i_64_Output_opt_box_autoadd_announced_user_AnyhowException(
|
|
self,
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void
|
|
sse_encode_DartFn_Inputs_i_64_Output_opt_list_list_prim_u_8_strict_AnyhowException(
|
|
FutureOr<List<Uint8List>?> Function(PlatformInt64) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_i_64_Output_opt_list_list_prim_u_8_strict_AnyhowException(
|
|
self,
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void
|
|
sse_encode_DartFn_Inputs_i_64_Output_opt_list_other_promotion_AnyhowException(
|
|
FutureOr<List<OtherPromotion>?> Function(PlatformInt64) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_i_64_Output_opt_list_other_promotion_AnyhowException(
|
|
self,
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void
|
|
sse_encode_DartFn_Inputs_i_64_Output_opt_list_prim_u_8_strict_AnyhowException(
|
|
FutureOr<Uint8List?> Function(PlatformInt64) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_i_64_Output_opt_list_prim_u_8_strict_AnyhowException(
|
|
self,
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void
|
|
sse_encode_DartFn_Inputs_i_64_announced_user_opt_box_autoadd_i_64_Output_bool_AnyhowException(
|
|
FutureOr<bool> Function(PlatformInt64, AnnouncedUser, PlatformInt64?) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_i_64_announced_user_opt_box_autoadd_i_64_Output_bool_AnyhowException(
|
|
self,
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void
|
|
sse_encode_DartFn_Inputs_i_64_i_64_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
FutureOr<bool> Function(PlatformInt64, PlatformInt64, Uint8List) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_i_64_i_64_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
self,
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void
|
|
sse_encode_DartFn_Inputs_i_64_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
FutureOr<bool> Function(PlatformInt64, Uint8List) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_i_64_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
self,
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void
|
|
sse_encode_DartFn_Inputs_list_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
FutureOr<bool> Function(List<Uint8List>) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_list_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
self,
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void
|
|
sse_encode_DartFn_Inputs_list_prim_u_8_strict_Output_opt_list_prim_u_8_strict_AnyhowException(
|
|
FutureOr<Uint8List?> Function(Uint8List) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_list_prim_u_8_strict_Output_opt_list_prim_u_8_strict_AnyhowException(
|
|
self,
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void
|
|
sse_encode_DartFn_Inputs_list_prim_u_8_strict_list_prim_u_8_strict_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
FutureOr<bool> Function(Uint8List, Uint8List, Uint8List) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_list_prim_u_8_strict_list_prim_u_8_strict_list_prim_u_8_strict_Output_bool_AnyhowException(
|
|
self,
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_DartFn_Inputs_other_promotion_Output_bool_AnyhowException(
|
|
FutureOr<bool> Function(OtherPromotion) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_other_promotion_Output_bool_AnyhowException(self),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_DartOpaque(Object self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_isize(
|
|
PlatformPointerUtil.ptrToPlatformInt64(
|
|
encodeDartOpaque(
|
|
self,
|
|
portManager.dartHandlerPort,
|
|
generalizedFrbRustBinding,
|
|
),
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_Map_i_64_list_prim_u_8_strict_None(
|
|
Map<PlatformInt64, Uint8List> self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_list_record_i_64_list_prim_u_8_strict(
|
|
self.entries.map((e) => (e.key, e.value)).toList(),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_StreamSink_String_Sse(
|
|
RustStreamSink<String> self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(
|
|
self.setupAndSerialize(
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_String,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_String(String self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_list_prim_u_8_strict(utf8.encoder.convert(self), serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_announced_user(AnnouncedUser self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_64(self.userId, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.publicKey, serializer);
|
|
sse_encode_i_64(self.publicId, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_backup_password_keys(
|
|
BackupPasswordKeys self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_u_8_array_32(self.backupId, serializer);
|
|
sse_encode_u_8_array_32(self.encryptionKey, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_bool(bool self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putUint8(self ? 1 : 0);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_announced_user(
|
|
AnnouncedUser self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_announced_user(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_backup_password_keys(
|
|
BackupPasswordKeys self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_backup_password_keys(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_i_64(
|
|
PlatformInt64 self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_64(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_init_config(
|
|
InitConfig self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_init_config(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_flutter_user_discovery(
|
|
FlutterUserDiscovery self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_i_64(PlatformInt64 self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putPlatformInt64(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_init_config(InitConfig self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.databaseDir, serializer);
|
|
sse_encode_String(self.dataDir, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_isize(PlatformInt64 self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putPlatformInt64(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_list_prim_u_8_strict(
|
|
List<Uint8List> self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
for (final item in self) {
|
|
sse_encode_list_prim_u_8_strict(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_other_promotion(
|
|
List<OtherPromotion> self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
for (final item in self) {
|
|
sse_encode_other_promotion(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_prim_u_8_loose(
|
|
List<int> self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
serializer.buffer.putUint8List(
|
|
self is Uint8List ? self : Uint8List.fromList(self),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_prim_u_8_strict(
|
|
Uint8List self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
serializer.buffer.putUint8List(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_record_i_64_list_prim_u_8_strict(
|
|
List<(PlatformInt64, Uint8List)> self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
for (final item in self) {
|
|
sse_encode_record_i_64_list_prim_u_8_strict(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_String(String? self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
sse_encode_bool(self != null, serializer);
|
|
if (self != null) {
|
|
sse_encode_String(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_box_autoadd_announced_user(
|
|
AnnouncedUser? self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
sse_encode_bool(self != null, serializer);
|
|
if (self != null) {
|
|
sse_encode_box_autoadd_announced_user(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_box_autoadd_i_64(
|
|
PlatformInt64? self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
sse_encode_bool(self != null, serializer);
|
|
if (self != null) {
|
|
sse_encode_box_autoadd_i_64(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_list_list_prim_u_8_strict(
|
|
List<Uint8List>? self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
sse_encode_bool(self != null, serializer);
|
|
if (self != null) {
|
|
sse_encode_list_list_prim_u_8_strict(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_list_other_promotion(
|
|
List<OtherPromotion>? self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
sse_encode_bool(self != null, serializer);
|
|
if (self != null) {
|
|
sse_encode_list_other_promotion(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_list_prim_u_8_strict(
|
|
Uint8List? self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
sse_encode_bool(self != null, serializer);
|
|
if (self != null) {
|
|
sse_encode_list_prim_u_8_strict(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_other_promotion(
|
|
OtherPromotion self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_u_32(self.promotionId, serializer);
|
|
sse_encode_i_64(self.publicId, serializer);
|
|
sse_encode_i_64(self.fromContactId, serializer);
|
|
sse_encode_u_8(self.threshold, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.announcementShare, serializer);
|
|
sse_encode_opt_box_autoadd_i_64(
|
|
self.publicKeyVerifiedTimestamp,
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_record_i_64_list_prim_u_8_strict(
|
|
(PlatformInt64, Uint8List) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_64(self.$1, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.$2, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_record_list_prim_u_8_strict_i_64(
|
|
(Uint8List, PlatformInt64) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_list_prim_u_8_strict(self.$1, serializer);
|
|
sse_encode_i_64(self.$2, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_record_string_string(
|
|
(String, String) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.$1, serializer);
|
|
sse_encode_String(self.$2, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_rust_backup_archive(
|
|
RustBackupArchive self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_rust_backup_identity(
|
|
RustBackupIdentity self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_rust_key_manager(
|
|
RustKeyManager self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_u_32(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putUint32(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_u_8(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putUint8(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_u_8_array_32(U8Array32 self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_list_prim_u_8_strict(self.inner, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_unit(void self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_usize(BigInt self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putBigUint64(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_i_32(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putInt32(self);
|
|
}
|
|
}
|