mirror of
https://github.com/twonlyapp/twonly-app.git
synced 2026-09-01 08:04:07 +00:00
7663 lines
235 KiB
Dart
7663 lines
235 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 'api/server/prekeys.dart';
|
|
import 'bridge.dart';
|
|
import 'bridge/api.dart';
|
|
import 'bridge/callbacks.dart';
|
|
import 'bridge/groups.dart';
|
|
import 'bridge/user_config.dart';
|
|
import 'bridge/wrapper.dart';
|
|
import 'bridge/wrapper/app_database.dart';
|
|
import 'bridge/wrapper/backup.dart';
|
|
import 'bridge/wrapper/key_manager.dart';
|
|
import 'bridge/wrapper/signal.dart';
|
|
import 'bridge/wrapper/user_discovery.dart';
|
|
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'database/app.dart';
|
|
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';
|
|
import 'signal/engine.dart';
|
|
import 'user_config.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 => -1286774374;
|
|
|
|
static const kDefaultExternalLibraryLoaderConfig =
|
|
ExternalLibraryLoaderConfig(
|
|
stem: 'rust_lib_twonly',
|
|
ioDirectory: 'rust/target/release/',
|
|
webPrefix: 'pkg/',
|
|
wasmBindgenName: 'wasm_bindgen',
|
|
);
|
|
}
|
|
|
|
abstract class RustLibApi extends BaseApi {
|
|
Future<bool> crateBridgeGroupsAddHiddenContact({
|
|
required PlatformInt64 contactId,
|
|
});
|
|
|
|
Future<bool> crateBridgeGroupsAddNewGroupMembers({
|
|
required String groupId,
|
|
required Int64List memberIds,
|
|
});
|
|
|
|
Future<bool> crateBridgeGroupsCreateNewGroup({
|
|
required String groupName,
|
|
required Int64List memberIds,
|
|
});
|
|
|
|
Future<bool> crateBridgeGroupsFetchGroupState({required String groupId});
|
|
|
|
Future<void> crateBridgeGroupsFetchGroupStatesForUnjoinedGroups();
|
|
|
|
Future<void> crateBridgeGroupsFetchMissingGroupPublicKeys();
|
|
|
|
Future<void>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryChangeExclusionForContact({
|
|
required int callbackId,
|
|
required PlatformInt64 contactId,
|
|
required bool exclude,
|
|
});
|
|
|
|
Future<Uint8List>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryGetCurrentVersion({
|
|
required int callbackId,
|
|
});
|
|
|
|
Future<void>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryUpdateVerificationStateForUser({
|
|
required int callbackId,
|
|
required PlatformInt64 contactId,
|
|
PlatformInt64? publicKeyVerifiedTimestamp,
|
|
});
|
|
|
|
Future<void> crateBridgeCallbacksInitFlutterCallbacks({
|
|
required int callbackId,
|
|
required FutureOr<RustStreamSink<String>> Function() loggingGetStreamSink,
|
|
required FutureOr<void> Function(String, String, PlatformInt64, String)
|
|
apiMediaAction,
|
|
required FutureOr<void> Function(PlatformInt64, Uint8List)
|
|
apiVerificationProof,
|
|
required FutureOr<void> Function(PlatformInt64) apiCreatePushAvatars,
|
|
required FutureOr<void> Function(String, PlatformInt64) apiMediaReceived,
|
|
required FutureOr<void> Function(UserConfig) apiUserConfigChanged,
|
|
});
|
|
|
|
Future<void> crateBridgeInitializeTwonlyFlutter({required InitConfig config});
|
|
|
|
Future<void> crateBridgeInitializeTwonlyStandalone({
|
|
required InitConfig config,
|
|
});
|
|
|
|
Future<bool> crateBridgeGroupsLeaveGroup({required String groupId});
|
|
|
|
Future<bool> crateBridgeGroupsManageAdminState({
|
|
required String groupId,
|
|
required List<int> groupPublicKey,
|
|
required PlatformInt64 contactId,
|
|
required bool remove,
|
|
});
|
|
|
|
Future<bool> crateBridgeGroupsRemoveMemberFromGroup({
|
|
required String groupId,
|
|
required List<int> groupPublicKey,
|
|
required PlatformInt64 contactId,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiAddAdditionalUser({
|
|
required PlatformInt64 userId,
|
|
});
|
|
|
|
Future<BigInt> crateBridgeApiRustApiAllocateSequence();
|
|
|
|
String crateBridgeApiRustApiApiBaseUrl({required String protocol});
|
|
|
|
Future<void> crateBridgeApiRustApiChangeUsername({required String username});
|
|
|
|
Future<void> crateBridgeApiRustApiCheckForDeletedUsernames();
|
|
|
|
Future<Uint8List> crateBridgeApiRustApiCheckForPasswordlessNotification({
|
|
required String notificationId,
|
|
required List<int> downloadAuthToken,
|
|
required Int64List alreadyReceivedMessageIds,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiClose();
|
|
|
|
Future<void> crateBridgeApiRustApiConfirmMemoriesUpload({
|
|
required String mediaId,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiConnect();
|
|
|
|
Future<ApiConnectionState> crateBridgeApiRustApiConnectionState();
|
|
|
|
Future<void> crateBridgeApiRustApiDeleteAccount();
|
|
|
|
Future<void> crateBridgeApiRustApiDeleteMemory({required String mediaId});
|
|
|
|
Future<void> crateBridgeApiRustApiDisableMemoriesBackup();
|
|
|
|
Future<void> crateBridgeApiRustApiDownloadDone({required List<int> token});
|
|
|
|
Future<void> crateBridgeApiRustApiDownloadMedia({required String mediaId});
|
|
|
|
Future<void> crateBridgeApiRustApiDownloadPendingMedia();
|
|
|
|
Future<void> crateBridgeApiRustApiEstablishSignalSession({
|
|
required PlatformInt64 contactId,
|
|
Uint8List? expectedPublicKey,
|
|
});
|
|
|
|
Stream<ApiEvent> crateBridgeApiRustApiEvents();
|
|
|
|
Future<void> crateBridgeApiRustApiForceIpaCheck();
|
|
|
|
Future<Uint8List> crateBridgeApiRustApiGetMemoriesUrl({
|
|
required String mediaId,
|
|
required bool thumbnail,
|
|
});
|
|
|
|
Future<Uint8List> crateBridgeApiRustApiGetMemoriesUsage();
|
|
|
|
Future<Uint8List> crateBridgeApiRustApiGetPlanBalance();
|
|
|
|
Future<Uint8List> crateBridgeApiRustApiGetProofOfWork();
|
|
|
|
Future<Uint8List> crateBridgeApiRustApiGetServerKeyForPasswordlessRecovery({
|
|
required PlatformInt64 userId,
|
|
required List<int> serverKeyProtection,
|
|
Uint8List? pinUnlockToken,
|
|
Uint8List? pinProtectionKey,
|
|
String? email,
|
|
});
|
|
|
|
Future<Uint8List> crateBridgeApiRustApiGetUserById({
|
|
required PlatformInt64 userId,
|
|
});
|
|
|
|
Future<Uint8List> crateBridgeApiRustApiGetUserData({
|
|
required String username,
|
|
});
|
|
|
|
Future<PlatformInt64> crateBridgeApiRustApiGetUserIdFromUsername({
|
|
required String username,
|
|
});
|
|
|
|
Future<String> crateBridgeApiRustApiInsertAndSendAdditionalData({
|
|
required String groupId,
|
|
required String messageType,
|
|
required List<int> additionalData,
|
|
});
|
|
|
|
Future<String> crateBridgeApiRustApiInsertAndSendAskAboutUser({
|
|
required PlatformInt64 contactId,
|
|
required PlatformInt64 askAboutUserId,
|
|
});
|
|
|
|
Future<String> crateBridgeApiRustApiInsertAndSendContactShare({
|
|
required String groupId,
|
|
required Int64List contactIds,
|
|
});
|
|
|
|
Future<String> crateBridgeApiRustApiInsertAndSendText({
|
|
required String groupId,
|
|
required String text,
|
|
String? quoteMessageId,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiIpaPurchase({
|
|
required String productId,
|
|
required String source,
|
|
required String verificationData,
|
|
});
|
|
|
|
Future<Uint8List> crateBridgeApiRustApiLoadPlanBalance();
|
|
|
|
Future<void> crateBridgeApiRustApiNotifyMessagesOpened({
|
|
required PlatformInt64 contactId,
|
|
required List<String> messageIds,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiPerformPasswordlessRecoveryHeartbeat();
|
|
|
|
Future<Uint8List?> crateBridgeApiRustApiPrepareQueuedMessage({
|
|
required String receiptId,
|
|
});
|
|
|
|
Future<PlatformInt64> crateBridgeApiRustApiRegister({
|
|
required String username,
|
|
required PlatformInt64 proofOfWork,
|
|
required String langCode,
|
|
required bool isIos,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiRegisterPasswordlessNotification({
|
|
required String notificationId,
|
|
required List<int> downloadAuthToken,
|
|
required String langCode,
|
|
String? googleFcm,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiRegisterPasswordlessRecovery({
|
|
required List<int> encryptedServerKey,
|
|
Uint8List? pinUnlockToken,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiReloadConfiguration();
|
|
|
|
Future<void> crateBridgeApiRustApiRemoveAdditionalUser({
|
|
required PlatformInt64 userId,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiReportUser({
|
|
required PlatformInt64 userId,
|
|
required String reason,
|
|
});
|
|
|
|
Future<Uint8List> crateBridgeApiRustApiRequestBinary({
|
|
required List<int> bytes,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiRequestContactByUsername({
|
|
required String username,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiRequestMediaReupload({
|
|
required String mediaId,
|
|
});
|
|
|
|
Future<Uint8List> crateBridgeApiRustApiRequestMemoriesUpload({
|
|
required PlatformInt64 size,
|
|
required PlatformInt64 originalDate,
|
|
required String mediaId,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiRetransmitAllMessages();
|
|
|
|
Future<void> crateBridgeApiRustApiSendBinary({required List<int> bytes});
|
|
|
|
Future<void> crateBridgeApiRustApiSendContactProfile({
|
|
required PlatformInt64 contactId,
|
|
});
|
|
|
|
Future<Uint8List?> crateBridgeApiRustApiSendEncryptedContent({
|
|
required PlatformInt64 contactId,
|
|
required List<int> content,
|
|
String? messageId,
|
|
bool? onlySendIfNoReceiptsAreOpen,
|
|
bool? onlyReturnEncryptedData,
|
|
bool? blocking,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiSendEncryptedContentToGroup({
|
|
required String groupId,
|
|
required List<int> content,
|
|
String? messageId,
|
|
bool? onlySendIfNoReceiptsAreOpen,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiSendQueuedMessage({
|
|
required String receiptId,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiSendTextMessage({
|
|
required PlatformInt64 userId,
|
|
required List<int> body,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiSendTyping({
|
|
required String groupId,
|
|
required bool isTyping,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiSetBackground({required bool inBackground});
|
|
|
|
Future<void> crateBridgeApiRustApiSetLoginToken({required List<int> token});
|
|
|
|
Future<void> crateBridgeApiRustApiSetNetworkAvailable({
|
|
required bool available,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiSubmitRecoveryShare({
|
|
required String notificationId,
|
|
required List<int> encryptedMessage,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiUpdateFcmToken({required String token});
|
|
|
|
Future<void> crateBridgeApiRustApiUpdateSignedPreKey({
|
|
required PlatformInt64 id,
|
|
required List<int> key,
|
|
required List<int> signature,
|
|
});
|
|
|
|
Future<void> crateBridgeApiRustApiUploadPqcPreKeys({
|
|
required List<int> publicIdentityKey,
|
|
required PlatformInt64 registrationId,
|
|
required PlatformInt64 eccSignedPrekeyId,
|
|
required List<int> eccSignedPrekey,
|
|
required List<int> eccSignedPrekeySignature,
|
|
required PlatformInt64 kyberSignedPrekeyId,
|
|
required List<int> kyberSignedPrekey,
|
|
required List<int> kyberSignedPrekeySignature,
|
|
required List<PqcPreKeyInput> prekeys,
|
|
});
|
|
|
|
Future<SqlExecutionResult>
|
|
crateBridgeWrapperAppDatabaseRustAppDatabaseExecute({
|
|
required String statement,
|
|
required List<SqlValue> arguments,
|
|
});
|
|
|
|
Future<bool>
|
|
crateBridgeWrapperAppDatabaseRustAppDatabaseLegacyImportComplete();
|
|
|
|
Future<LegacyMigrationReport>
|
|
crateBridgeWrapperAppDatabaseRustAppDatabaseMigrateLegacyDatabase();
|
|
|
|
Future<SqlRows> crateBridgeWrapperAppDatabaseRustAppDatabaseSelect({
|
|
required String statement,
|
|
required List<SqlValue> arguments,
|
|
});
|
|
|
|
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>
|
|
crateBridgeWrapperKeyManagerRustKeyManagerDecryptCloudMediaKey({
|
|
required List<int> encryptedMediaKey,
|
|
required String addition,
|
|
});
|
|
|
|
Future<Uint8List>
|
|
crateBridgeWrapperKeyManagerRustKeyManagerEncryptCloudMediaKey({
|
|
required List<int> mediaKey,
|
|
required String addition,
|
|
});
|
|
|
|
Future<Uint8List> crateBridgeWrapperKeyManagerRustKeyManagerGetLoginToken();
|
|
|
|
Future<(Uint8List, PlatformInt64)>
|
|
crateBridgeWrapperKeyManagerRustKeyManagerGetSignalIdentity();
|
|
|
|
Future<PlatformInt64?> crateBridgeWrapperKeyManagerRustKeyManagerGetUserId();
|
|
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerImportSerialized({
|
|
required List<int> serializedBytes,
|
|
});
|
|
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerImportSignalIdentity({
|
|
required List<int> identityKeyPairStructure,
|
|
required PlatformInt64 registrationId,
|
|
});
|
|
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerRemoveKeyManager();
|
|
|
|
Future<Uint8List> crateBridgeWrapperKeyManagerRustKeyManagerSerialize();
|
|
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerSetUserId({
|
|
required PlatformInt64 userId,
|
|
});
|
|
|
|
Future<Uint8List> crateBridgeWrapperSignalRustSignalDecrypt({
|
|
required String name,
|
|
required int deviceId,
|
|
required List<int> ciphertext,
|
|
});
|
|
|
|
Future<Uint8List> crateBridgeWrapperSignalRustSignalEncrypt({
|
|
required String name,
|
|
required int deviceId,
|
|
required List<int> plaintext,
|
|
});
|
|
|
|
Future<FrbPreKeyBundle> crateBridgeWrapperSignalRustSignalGenerateBundle();
|
|
|
|
Future<List<FrbPqcPreKey>>
|
|
crateBridgeWrapperSignalRustSignalGeneratePqcPrekeys();
|
|
|
|
Future<Uint8List?> crateBridgeWrapperSignalRustSignalGetContactPublicKey({
|
|
required PlatformInt64 contactId,
|
|
});
|
|
|
|
Future<Uint8List> crateBridgeWrapperSignalRustSignalGetUserPublicKey();
|
|
|
|
Future<void> crateBridgeWrapperSignalRustSignalProcessPrekeyBundle({
|
|
required String name,
|
|
required int deviceId,
|
|
required FrbPreKeyBundle bundle,
|
|
});
|
|
|
|
Future<List<Uint8List>> crateBridgeWrapperRustUtilsGenerateShares({
|
|
required List<int> secret,
|
|
required int total,
|
|
required int threshold,
|
|
});
|
|
|
|
Future<Uint8List> crateBridgeWrapperRustUtilsRecoverSecret({
|
|
required List<Uint8List> shares,
|
|
required int threshold,
|
|
});
|
|
|
|
Future<bool> crateBridgeGroupsUpdateChatDeletionTime({
|
|
required String groupId,
|
|
required PlatformInt64 deleteMessagesAfterMilliseconds,
|
|
});
|
|
|
|
Future<bool> crateBridgeGroupsUpdateGroupName({
|
|
required String groupId,
|
|
required String groupName,
|
|
});
|
|
|
|
UserConfig crateBridgeUserConfigUserConfigApiClone({
|
|
required UserConfig config,
|
|
});
|
|
|
|
Future<UserConfig> crateBridgeUserConfigUserConfigApiCreate({
|
|
required PlatformInt64 userId,
|
|
required String username,
|
|
required String displayName,
|
|
String? currentSetupPage,
|
|
required PlatformInt64 appVersion,
|
|
});
|
|
|
|
Future<UserConfig> crateBridgeUserConfigUserConfigApiImportJson({
|
|
required String json,
|
|
});
|
|
|
|
Future<UserConfig?> crateBridgeUserConfigUserConfigApiLoad();
|
|
|
|
Future<UserConfig> crateBridgeUserConfigUserConfigApiSave({
|
|
required UserConfig config,
|
|
});
|
|
|
|
Future<UserConfig> crateBridgeUserConfigUserConfigApiUpdate({
|
|
required UserConfig base,
|
|
required UserConfig config,
|
|
});
|
|
}
|
|
|
|
class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
|
|
RustLibApiImpl({
|
|
required super.handler,
|
|
required super.wire,
|
|
required super.generalizedFrbRustBinding,
|
|
required super.portManager,
|
|
});
|
|
|
|
@override
|
|
Future<bool> crateBridgeGroupsAddHiddenContact({
|
|
required PlatformInt64 contactId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(contactId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 1,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeGroupsAddHiddenContactConstMeta,
|
|
argValues: [contactId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeGroupsAddHiddenContactConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "add_hidden_contact",
|
|
argNames: ["contactId"],
|
|
);
|
|
|
|
@override
|
|
Future<bool> crateBridgeGroupsAddNewGroupMembers({
|
|
required String groupId,
|
|
required Int64List memberIds,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupId, serializer);
|
|
sse_encode_list_prim_i_64_strict(memberIds, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 2,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeGroupsAddNewGroupMembersConstMeta,
|
|
argValues: [groupId, memberIds],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeGroupsAddNewGroupMembersConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "add_new_group_members",
|
|
argNames: ["groupId", "memberIds"],
|
|
);
|
|
|
|
@override
|
|
Future<bool> crateBridgeGroupsCreateNewGroup({
|
|
required String groupName,
|
|
required Int64List memberIds,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupName, serializer);
|
|
sse_encode_list_prim_i_64_strict(memberIds, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 3,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeGroupsCreateNewGroupConstMeta,
|
|
argValues: [groupName, memberIds],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeGroupsCreateNewGroupConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "create_new_group",
|
|
argNames: ["groupName", "memberIds"],
|
|
);
|
|
|
|
@override
|
|
Future<bool> crateBridgeGroupsFetchGroupState({required String groupId}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 4,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeGroupsFetchGroupStateConstMeta,
|
|
argValues: [groupId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeGroupsFetchGroupStateConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "fetch_group_state",
|
|
argNames: ["groupId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeGroupsFetchGroupStatesForUnjoinedGroups() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 5,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeGroupsFetchGroupStatesForUnjoinedGroupsConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeGroupsFetchGroupStatesForUnjoinedGroupsConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "fetch_group_states_for_unjoined_groups",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeGroupsFetchMissingGroupPublicKeys() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 6,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeGroupsFetchMissingGroupPublicKeysConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeGroupsFetchMissingGroupPublicKeysConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "fetch_missing_group_public_keys",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryChangeExclusionForContact({
|
|
required int callbackId,
|
|
required PlatformInt64 contactId,
|
|
required bool exclude,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_32(callbackId, serializer);
|
|
sse_encode_i_64(contactId, serializer);
|
|
sse_encode_bool(exclude, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 7,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryChangeExclusionForContactConstMeta,
|
|
argValues: [callbackId, contactId, exclude],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryChangeExclusionForContactConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "flutter_user_discovery_change_exclusion_for_contact",
|
|
argNames: ["callbackId", "contactId", "exclude"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryGetCurrentVersion({
|
|
required int callbackId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_32(callbackId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 8,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryGetCurrentVersionConstMeta,
|
|
argValues: [callbackId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryGetCurrentVersionConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "flutter_user_discovery_get_current_version",
|
|
argNames: ["callbackId"],
|
|
);
|
|
|
|
@override
|
|
Future<void>
|
|
crateBridgeWrapperUserDiscoveryFlutterUserDiscoveryUpdateVerificationStateForUser({
|
|
required int callbackId,
|
|
required PlatformInt64 contactId,
|
|
PlatformInt64? publicKeyVerifiedTimestamp,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_32(callbackId, serializer);
|
|
sse_encode_i_64(contactId, serializer);
|
|
sse_encode_opt_box_autoadd_i_64(
|
|
publicKeyVerifiedTimestamp,
|
|
serializer,
|
|
);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 9,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryUpdateVerificationStateForUserConstMeta,
|
|
argValues: [callbackId, contactId, publicKeyVerifiedTimestamp],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperUserDiscoveryFlutterUserDiscoveryUpdateVerificationStateForUserConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "flutter_user_discovery_update_verification_state_for_user",
|
|
argNames: ["callbackId", "contactId", "publicKeyVerifiedTimestamp"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeCallbacksInitFlutterCallbacks({
|
|
required int callbackId,
|
|
required FutureOr<RustStreamSink<String>> Function() loggingGetStreamSink,
|
|
required FutureOr<void> Function(String, String, PlatformInt64, String)
|
|
apiMediaAction,
|
|
required FutureOr<void> Function(PlatformInt64, Uint8List)
|
|
apiVerificationProof,
|
|
required FutureOr<void> Function(PlatformInt64) apiCreatePushAvatars,
|
|
required FutureOr<void> Function(String, PlatformInt64) apiMediaReceived,
|
|
required FutureOr<void> Function(UserConfig) apiUserConfigChanged,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_32(callbackId, serializer);
|
|
sse_encode_DartFn_Inputs__Output_StreamSink_String_Sse_AnyhowException(
|
|
loggingGetStreamSink,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_String_String_i_64_String_Output_unit_AnyhowException(
|
|
apiMediaAction,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_i_64_list_prim_u_8_strict_Output_unit_AnyhowException(
|
|
apiVerificationProof,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_i_64_Output_unit_AnyhowException(
|
|
apiCreatePushAvatars,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_String_i_64_Output_unit_AnyhowException(
|
|
apiMediaReceived,
|
|
serializer,
|
|
);
|
|
sse_encode_DartFn_Inputs_user_config_Output_unit_AnyhowException(
|
|
apiUserConfigChanged,
|
|
serializer,
|
|
);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 10,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateBridgeCallbacksInitFlutterCallbacksConstMeta,
|
|
argValues: [
|
|
callbackId,
|
|
loggingGetStreamSink,
|
|
apiMediaAction,
|
|
apiVerificationProof,
|
|
apiCreatePushAvatars,
|
|
apiMediaReceived,
|
|
apiUserConfigChanged,
|
|
],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeCallbacksInitFlutterCallbacksConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "init_flutter_callbacks",
|
|
argNames: [
|
|
"callbackId",
|
|
"loggingGetStreamSink",
|
|
"apiMediaAction",
|
|
"apiVerificationProof",
|
|
"apiCreatePushAvatars",
|
|
"apiMediaReceived",
|
|
"apiUserConfigChanged",
|
|
],
|
|
);
|
|
|
|
@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: 11,
|
|
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<void> crateBridgeInitializeTwonlyStandalone({
|
|
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: 12,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeInitializeTwonlyStandaloneConstMeta,
|
|
argValues: [config],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeInitializeTwonlyStandaloneConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "initialize_twonly_standalone",
|
|
argNames: ["config"],
|
|
);
|
|
|
|
@override
|
|
Future<bool> crateBridgeGroupsLeaveGroup({required String groupId}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 13,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeGroupsLeaveGroupConstMeta,
|
|
argValues: [groupId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeGroupsLeaveGroupConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "leave_group",
|
|
argNames: ["groupId"],
|
|
);
|
|
|
|
@override
|
|
Future<bool> crateBridgeGroupsManageAdminState({
|
|
required String groupId,
|
|
required List<int> groupPublicKey,
|
|
required PlatformInt64 contactId,
|
|
required bool remove,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupId, serializer);
|
|
sse_encode_list_prim_u_8_loose(groupPublicKey, serializer);
|
|
sse_encode_i_64(contactId, serializer);
|
|
sse_encode_bool(remove, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 14,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeGroupsManageAdminStateConstMeta,
|
|
argValues: [groupId, groupPublicKey, contactId, remove],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeGroupsManageAdminStateConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "manage_admin_state",
|
|
argNames: ["groupId", "groupPublicKey", "contactId", "remove"],
|
|
);
|
|
|
|
@override
|
|
Future<bool> crateBridgeGroupsRemoveMemberFromGroup({
|
|
required String groupId,
|
|
required List<int> groupPublicKey,
|
|
required PlatformInt64 contactId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupId, serializer);
|
|
sse_encode_list_prim_u_8_loose(groupPublicKey, serializer);
|
|
sse_encode_i_64(contactId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 15,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeGroupsRemoveMemberFromGroupConstMeta,
|
|
argValues: [groupId, groupPublicKey, contactId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeGroupsRemoveMemberFromGroupConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "remove_member_from_group",
|
|
argNames: ["groupId", "groupPublicKey", "contactId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiAddAdditionalUser({
|
|
required PlatformInt64 userId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(userId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 16,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiAddAdditionalUserConstMeta,
|
|
argValues: [userId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiAddAdditionalUserConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_add_additional_user",
|
|
argNames: ["userId"],
|
|
);
|
|
|
|
@override
|
|
Future<BigInt> crateBridgeApiRustApiAllocateSequence() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 17,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_u_64,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiAllocateSequenceConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiAllocateSequenceConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_allocate_sequence",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
String crateBridgeApiRustApiApiBaseUrl({required String protocol}) {
|
|
return handler.executeSync(
|
|
SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(protocol, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 18)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_String,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiApiBaseUrlConstMeta,
|
|
argValues: [protocol],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiApiBaseUrlConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_api_base_url",
|
|
argNames: ["protocol"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiChangeUsername({required String username}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(username, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 19,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiChangeUsernameConstMeta,
|
|
argValues: [username],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiChangeUsernameConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_change_username",
|
|
argNames: ["username"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiCheckForDeletedUsernames() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 20,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiCheckForDeletedUsernamesConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiCheckForDeletedUsernamesConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_check_for_deleted_usernames",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeApiRustApiCheckForPasswordlessNotification({
|
|
required String notificationId,
|
|
required List<int> downloadAuthToken,
|
|
required Int64List alreadyReceivedMessageIds,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(notificationId, serializer);
|
|
sse_encode_list_prim_u_8_loose(downloadAuthToken, serializer);
|
|
sse_encode_list_prim_i_64_strict(
|
|
alreadyReceivedMessageIds,
|
|
serializer,
|
|
);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 21,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeApiRustApiCheckForPasswordlessNotificationConstMeta,
|
|
argValues: [
|
|
notificationId,
|
|
downloadAuthToken,
|
|
alreadyReceivedMessageIds,
|
|
],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeApiRustApiCheckForPasswordlessNotificationConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_check_for_passwordless_notification",
|
|
argNames: [
|
|
"notificationId",
|
|
"downloadAuthToken",
|
|
"alreadyReceivedMessageIds",
|
|
],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiClose() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 22,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiCloseConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiCloseConstMeta => const TaskConstMeta(
|
|
debugName: "rust_api_close",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiConfirmMemoriesUpload({
|
|
required String mediaId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(mediaId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 23,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiConfirmMemoriesUploadConstMeta,
|
|
argValues: [mediaId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiConfirmMemoriesUploadConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_confirm_memories_upload",
|
|
argNames: ["mediaId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiConnect() {
|
|
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: kCrateBridgeApiRustApiConnectConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiConnectConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_connect",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<ApiConnectionState> crateBridgeApiRustApiConnectionState() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 25,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_api_connection_state,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiConnectionStateConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiConnectionStateConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_connection_state",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiDeleteAccount() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 26,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiDeleteAccountConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiDeleteAccountConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_delete_account",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiDeleteMemory({required String mediaId}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(mediaId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 27,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiDeleteMemoryConstMeta,
|
|
argValues: [mediaId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiDeleteMemoryConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_delete_memory",
|
|
argNames: ["mediaId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiDisableMemoriesBackup() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 28,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiDisableMemoriesBackupConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiDisableMemoriesBackupConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_disable_memories_backup",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiDownloadDone({required List<int> token}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_prim_u_8_loose(token, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 29,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiDownloadDoneConstMeta,
|
|
argValues: [token],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiDownloadDoneConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_download_done",
|
|
argNames: ["token"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiDownloadMedia({required String mediaId}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(mediaId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 30,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiDownloadMediaConstMeta,
|
|
argValues: [mediaId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiDownloadMediaConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_download_media",
|
|
argNames: ["mediaId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiDownloadPendingMedia() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 31,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiDownloadPendingMediaConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiDownloadPendingMediaConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_download_pending_media",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiEstablishSignalSession({
|
|
required PlatformInt64 contactId,
|
|
Uint8List? expectedPublicKey,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(contactId, serializer);
|
|
sse_encode_opt_list_prim_u_8_strict(expectedPublicKey, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 32,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiEstablishSignalSessionConstMeta,
|
|
argValues: [contactId, expectedPublicKey],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiEstablishSignalSessionConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_establish_signal_session",
|
|
argNames: ["contactId", "expectedPublicKey"],
|
|
);
|
|
|
|
@override
|
|
Stream<ApiEvent> crateBridgeApiRustApiEvents() {
|
|
final sink = RustStreamSink<ApiEvent>();
|
|
unawaited(
|
|
handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_StreamSink_api_event_Sse(sink, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 33,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiEventsConstMeta,
|
|
argValues: [sink],
|
|
apiImpl: this,
|
|
),
|
|
),
|
|
);
|
|
return sink.stream;
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiEventsConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_events",
|
|
argNames: ["sink"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiForceIpaCheck() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 34,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiForceIpaCheckConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiForceIpaCheckConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_force_ipa_check",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeApiRustApiGetMemoriesUrl({
|
|
required String mediaId,
|
|
required bool thumbnail,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(mediaId, serializer);
|
|
sse_encode_bool(thumbnail, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 35,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiGetMemoriesUrlConstMeta,
|
|
argValues: [mediaId, thumbnail],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiGetMemoriesUrlConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_get_memories_url",
|
|
argNames: ["mediaId", "thumbnail"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeApiRustApiGetMemoriesUsage() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 36,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiGetMemoriesUsageConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiGetMemoriesUsageConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_get_memories_usage",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeApiRustApiGetPlanBalance() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 37,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiGetPlanBalanceConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiGetPlanBalanceConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_get_plan_balance",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeApiRustApiGetProofOfWork() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 38,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiGetProofOfWorkConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiGetProofOfWorkConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_get_proof_of_work",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeApiRustApiGetServerKeyForPasswordlessRecovery({
|
|
required PlatformInt64 userId,
|
|
required List<int> serverKeyProtection,
|
|
Uint8List? pinUnlockToken,
|
|
Uint8List? pinProtectionKey,
|
|
String? email,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(userId, serializer);
|
|
sse_encode_list_prim_u_8_loose(serverKeyProtection, serializer);
|
|
sse_encode_opt_list_prim_u_8_strict(pinUnlockToken, serializer);
|
|
sse_encode_opt_list_prim_u_8_strict(pinProtectionKey, serializer);
|
|
sse_encode_opt_String(email, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 39,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeApiRustApiGetServerKeyForPasswordlessRecoveryConstMeta,
|
|
argValues: [
|
|
userId,
|
|
serverKeyProtection,
|
|
pinUnlockToken,
|
|
pinProtectionKey,
|
|
email,
|
|
],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeApiRustApiGetServerKeyForPasswordlessRecoveryConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_get_server_key_for_passwordless_recovery",
|
|
argNames: [
|
|
"userId",
|
|
"serverKeyProtection",
|
|
"pinUnlockToken",
|
|
"pinProtectionKey",
|
|
"email",
|
|
],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeApiRustApiGetUserById({
|
|
required PlatformInt64 userId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(userId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 40,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiGetUserByIdConstMeta,
|
|
argValues: [userId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiGetUserByIdConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_get_user_by_id",
|
|
argNames: ["userId"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeApiRustApiGetUserData({
|
|
required String username,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(username, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 41,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiGetUserDataConstMeta,
|
|
argValues: [username],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiGetUserDataConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_get_user_data",
|
|
argNames: ["username"],
|
|
);
|
|
|
|
@override
|
|
Future<PlatformInt64> crateBridgeApiRustApiGetUserIdFromUsername({
|
|
required String username,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(username, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 42,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_i_64,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiGetUserIdFromUsernameConstMeta,
|
|
argValues: [username],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiGetUserIdFromUsernameConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_get_user_id_from_username",
|
|
argNames: ["username"],
|
|
);
|
|
|
|
@override
|
|
Future<String> crateBridgeApiRustApiInsertAndSendAdditionalData({
|
|
required String groupId,
|
|
required String messageType,
|
|
required List<int> additionalData,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupId, serializer);
|
|
sse_encode_String(messageType, serializer);
|
|
sse_encode_list_prim_u_8_loose(additionalData, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 43,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_String,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiInsertAndSendAdditionalDataConstMeta,
|
|
argValues: [groupId, messageType, additionalData],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeApiRustApiInsertAndSendAdditionalDataConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_insert_and_send_additional_data",
|
|
argNames: ["groupId", "messageType", "additionalData"],
|
|
);
|
|
|
|
@override
|
|
Future<String> crateBridgeApiRustApiInsertAndSendAskAboutUser({
|
|
required PlatformInt64 contactId,
|
|
required PlatformInt64 askAboutUserId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(contactId, serializer);
|
|
sse_encode_i_64(askAboutUserId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 44,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_String,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiInsertAndSendAskAboutUserConstMeta,
|
|
argValues: [contactId, askAboutUserId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiInsertAndSendAskAboutUserConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_insert_and_send_ask_about_user",
|
|
argNames: ["contactId", "askAboutUserId"],
|
|
);
|
|
|
|
@override
|
|
Future<String> crateBridgeApiRustApiInsertAndSendContactShare({
|
|
required String groupId,
|
|
required Int64List contactIds,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupId, serializer);
|
|
sse_encode_list_prim_i_64_strict(contactIds, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 45,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_String,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiInsertAndSendContactShareConstMeta,
|
|
argValues: [groupId, contactIds],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiInsertAndSendContactShareConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_insert_and_send_contact_share",
|
|
argNames: ["groupId", "contactIds"],
|
|
);
|
|
|
|
@override
|
|
Future<String> crateBridgeApiRustApiInsertAndSendText({
|
|
required String groupId,
|
|
required String text,
|
|
String? quoteMessageId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupId, serializer);
|
|
sse_encode_String(text, serializer);
|
|
sse_encode_opt_String(quoteMessageId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 46,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_String,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiInsertAndSendTextConstMeta,
|
|
argValues: [groupId, text, quoteMessageId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiInsertAndSendTextConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_insert_and_send_text",
|
|
argNames: ["groupId", "text", "quoteMessageId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiIpaPurchase({
|
|
required String productId,
|
|
required String source,
|
|
required String verificationData,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(productId, serializer);
|
|
sse_encode_String(source, serializer);
|
|
sse_encode_String(verificationData, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 47,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiIpaPurchaseConstMeta,
|
|
argValues: [productId, source, verificationData],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiIpaPurchaseConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_ipa_purchase",
|
|
argNames: ["productId", "source", "verificationData"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeApiRustApiLoadPlanBalance() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 48,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiLoadPlanBalanceConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiLoadPlanBalanceConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_load_plan_balance",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiNotifyMessagesOpened({
|
|
required PlatformInt64 contactId,
|
|
required List<String> messageIds,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(contactId, serializer);
|
|
sse_encode_list_String(messageIds, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 49,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiNotifyMessagesOpenedConstMeta,
|
|
argValues: [contactId, messageIds],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiNotifyMessagesOpenedConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_notify_messages_opened",
|
|
argNames: ["contactId", "messageIds"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiPerformPasswordlessRecoveryHeartbeat() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 50,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeApiRustApiPerformPasswordlessRecoveryHeartbeatConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeApiRustApiPerformPasswordlessRecoveryHeartbeatConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_perform_passwordless_recovery_heartbeat",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List?> crateBridgeApiRustApiPrepareQueuedMessage({
|
|
required String receiptId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(receiptId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 51,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_opt_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiPrepareQueuedMessageConstMeta,
|
|
argValues: [receiptId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiPrepareQueuedMessageConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_prepare_queued_message",
|
|
argNames: ["receiptId"],
|
|
);
|
|
|
|
@override
|
|
Future<PlatformInt64> crateBridgeApiRustApiRegister({
|
|
required String username,
|
|
required PlatformInt64 proofOfWork,
|
|
required String langCode,
|
|
required bool isIos,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(username, serializer);
|
|
sse_encode_i_64(proofOfWork, serializer);
|
|
sse_encode_String(langCode, serializer);
|
|
sse_encode_bool(isIos, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 52,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_i_64,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiRegisterConstMeta,
|
|
argValues: [username, proofOfWork, langCode, isIos],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiRegisterConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_register",
|
|
argNames: ["username", "proofOfWork", "langCode", "isIos"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiRegisterPasswordlessNotification({
|
|
required String notificationId,
|
|
required List<int> downloadAuthToken,
|
|
required String langCode,
|
|
String? googleFcm,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(notificationId, serializer);
|
|
sse_encode_list_prim_u_8_loose(downloadAuthToken, serializer);
|
|
sse_encode_String(langCode, serializer);
|
|
sse_encode_opt_String(googleFcm, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 53,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeApiRustApiRegisterPasswordlessNotificationConstMeta,
|
|
argValues: [notificationId, downloadAuthToken, langCode, googleFcm],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeApiRustApiRegisterPasswordlessNotificationConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_register_passwordless_notification",
|
|
argNames: [
|
|
"notificationId",
|
|
"downloadAuthToken",
|
|
"langCode",
|
|
"googleFcm",
|
|
],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiRegisterPasswordlessRecovery({
|
|
required List<int> encryptedServerKey,
|
|
Uint8List? pinUnlockToken,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_prim_u_8_loose(encryptedServerKey, serializer);
|
|
sse_encode_opt_list_prim_u_8_strict(pinUnlockToken, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 54,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiRegisterPasswordlessRecoveryConstMeta,
|
|
argValues: [encryptedServerKey, pinUnlockToken],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeApiRustApiRegisterPasswordlessRecoveryConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_register_passwordless_recovery",
|
|
argNames: ["encryptedServerKey", "pinUnlockToken"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiReloadConfiguration() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 55,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiReloadConfigurationConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiReloadConfigurationConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_reload_configuration",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiRemoveAdditionalUser({
|
|
required PlatformInt64 userId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(userId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 56,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiRemoveAdditionalUserConstMeta,
|
|
argValues: [userId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiRemoveAdditionalUserConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_remove_additional_user",
|
|
argNames: ["userId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiReportUser({
|
|
required PlatformInt64 userId,
|
|
required String reason,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(userId, serializer);
|
|
sse_encode_String(reason, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 57,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiReportUserConstMeta,
|
|
argValues: [userId, reason],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiReportUserConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_report_user",
|
|
argNames: ["userId", "reason"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeApiRustApiRequestBinary({
|
|
required List<int> bytes,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_prim_u_8_loose(bytes, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 58,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiRequestBinaryConstMeta,
|
|
argValues: [bytes],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiRequestBinaryConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_request_binary",
|
|
argNames: ["bytes"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiRequestContactByUsername({
|
|
required String username,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(username, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 59,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiRequestContactByUsernameConstMeta,
|
|
argValues: [username],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiRequestContactByUsernameConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_request_contact_by_username",
|
|
argNames: ["username"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiRequestMediaReupload({
|
|
required String mediaId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(mediaId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 60,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiRequestMediaReuploadConstMeta,
|
|
argValues: [mediaId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiRequestMediaReuploadConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_request_media_reupload",
|
|
argNames: ["mediaId"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeApiRustApiRequestMemoriesUpload({
|
|
required PlatformInt64 size,
|
|
required PlatformInt64 originalDate,
|
|
required String mediaId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(size, serializer);
|
|
sse_encode_i_64(originalDate, serializer);
|
|
sse_encode_String(mediaId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 61,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiRequestMemoriesUploadConstMeta,
|
|
argValues: [size, originalDate, mediaId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiRequestMemoriesUploadConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_request_memories_upload",
|
|
argNames: ["size", "originalDate", "mediaId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiRetransmitAllMessages() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 62,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiRetransmitAllMessagesConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiRetransmitAllMessagesConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_retransmit_all_messages",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiSendBinary({required List<int> bytes}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_prim_u_8_loose(bytes, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 63,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiSendBinaryConstMeta,
|
|
argValues: [bytes],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiSendBinaryConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_send_binary",
|
|
argNames: ["bytes"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiSendContactProfile({
|
|
required PlatformInt64 contactId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(contactId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 64,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiSendContactProfileConstMeta,
|
|
argValues: [contactId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiSendContactProfileConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_send_contact_profile",
|
|
argNames: ["contactId"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List?> crateBridgeApiRustApiSendEncryptedContent({
|
|
required PlatformInt64 contactId,
|
|
required List<int> content,
|
|
String? messageId,
|
|
bool? onlySendIfNoReceiptsAreOpen,
|
|
bool? onlyReturnEncryptedData,
|
|
bool? blocking,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(contactId, serializer);
|
|
sse_encode_list_prim_u_8_loose(content, serializer);
|
|
sse_encode_opt_String(messageId, serializer);
|
|
sse_encode_opt_box_autoadd_bool(
|
|
onlySendIfNoReceiptsAreOpen,
|
|
serializer,
|
|
);
|
|
sse_encode_opt_box_autoadd_bool(onlyReturnEncryptedData, serializer);
|
|
sse_encode_opt_box_autoadd_bool(blocking, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 65,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_opt_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiSendEncryptedContentConstMeta,
|
|
argValues: [
|
|
contactId,
|
|
content,
|
|
messageId,
|
|
onlySendIfNoReceiptsAreOpen,
|
|
onlyReturnEncryptedData,
|
|
blocking,
|
|
],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiSendEncryptedContentConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_send_encrypted_content",
|
|
argNames: [
|
|
"contactId",
|
|
"content",
|
|
"messageId",
|
|
"onlySendIfNoReceiptsAreOpen",
|
|
"onlyReturnEncryptedData",
|
|
"blocking",
|
|
],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiSendEncryptedContentToGroup({
|
|
required String groupId,
|
|
required List<int> content,
|
|
String? messageId,
|
|
bool? onlySendIfNoReceiptsAreOpen,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupId, serializer);
|
|
sse_encode_list_prim_u_8_loose(content, serializer);
|
|
sse_encode_opt_String(messageId, serializer);
|
|
sse_encode_opt_box_autoadd_bool(
|
|
onlySendIfNoReceiptsAreOpen,
|
|
serializer,
|
|
);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 66,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiSendEncryptedContentToGroupConstMeta,
|
|
argValues: [groupId, content, messageId, onlySendIfNoReceiptsAreOpen],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeApiRustApiSendEncryptedContentToGroupConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_send_encrypted_content_to_group",
|
|
argNames: [
|
|
"groupId",
|
|
"content",
|
|
"messageId",
|
|
"onlySendIfNoReceiptsAreOpen",
|
|
],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiSendQueuedMessage({
|
|
required String receiptId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(receiptId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 67,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiSendQueuedMessageConstMeta,
|
|
argValues: [receiptId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiSendQueuedMessageConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_send_queued_message",
|
|
argNames: ["receiptId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiSendTextMessage({
|
|
required PlatformInt64 userId,
|
|
required List<int> body,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(userId, serializer);
|
|
sse_encode_list_prim_u_8_loose(body, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 68,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiSendTextMessageConstMeta,
|
|
argValues: [userId, body],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiSendTextMessageConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_send_text_message",
|
|
argNames: ["userId", "body"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiSendTyping({
|
|
required String groupId,
|
|
required bool isTyping,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupId, serializer);
|
|
sse_encode_bool(isTyping, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 69,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiSendTypingConstMeta,
|
|
argValues: [groupId, isTyping],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiSendTypingConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_send_typing",
|
|
argNames: ["groupId", "isTyping"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiSetBackground({
|
|
required bool inBackground,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_bool(inBackground, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 70,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiSetBackgroundConstMeta,
|
|
argValues: [inBackground],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiSetBackgroundConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_set_background",
|
|
argNames: ["inBackground"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiSetLoginToken({required List<int> token}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_prim_u_8_loose(token, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 71,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiSetLoginTokenConstMeta,
|
|
argValues: [token],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiSetLoginTokenConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_set_login_token",
|
|
argNames: ["token"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiSetNetworkAvailable({
|
|
required bool available,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_bool(available, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 72,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiSetNetworkAvailableConstMeta,
|
|
argValues: [available],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiSetNetworkAvailableConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_set_network_available",
|
|
argNames: ["available"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiSubmitRecoveryShare({
|
|
required String notificationId,
|
|
required List<int> encryptedMessage,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(notificationId, serializer);
|
|
sse_encode_list_prim_u_8_loose(encryptedMessage, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 73,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiSubmitRecoveryShareConstMeta,
|
|
argValues: [notificationId, encryptedMessage],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiSubmitRecoveryShareConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_submit_recovery_share",
|
|
argNames: ["notificationId", "encryptedMessage"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiUpdateFcmToken({required String token}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(token, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 74,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiUpdateFcmTokenConstMeta,
|
|
argValues: [token],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiUpdateFcmTokenConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_update_fcm_token",
|
|
argNames: ["token"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiUpdateSignedPreKey({
|
|
required PlatformInt64 id,
|
|
required List<int> key,
|
|
required List<int> signature,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(id, serializer);
|
|
sse_encode_list_prim_u_8_loose(key, serializer);
|
|
sse_encode_list_prim_u_8_loose(signature, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 75,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiUpdateSignedPreKeyConstMeta,
|
|
argValues: [id, key, signature],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiUpdateSignedPreKeyConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_update_signed_pre_key",
|
|
argNames: ["id", "key", "signature"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeApiRustApiUploadPqcPreKeys({
|
|
required List<int> publicIdentityKey,
|
|
required PlatformInt64 registrationId,
|
|
required PlatformInt64 eccSignedPrekeyId,
|
|
required List<int> eccSignedPrekey,
|
|
required List<int> eccSignedPrekeySignature,
|
|
required PlatformInt64 kyberSignedPrekeyId,
|
|
required List<int> kyberSignedPrekey,
|
|
required List<int> kyberSignedPrekeySignature,
|
|
required List<PqcPreKeyInput> prekeys,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_prim_u_8_loose(publicIdentityKey, serializer);
|
|
sse_encode_i_64(registrationId, serializer);
|
|
sse_encode_i_64(eccSignedPrekeyId, serializer);
|
|
sse_encode_list_prim_u_8_loose(eccSignedPrekey, serializer);
|
|
sse_encode_list_prim_u_8_loose(eccSignedPrekeySignature, serializer);
|
|
sse_encode_i_64(kyberSignedPrekeyId, serializer);
|
|
sse_encode_list_prim_u_8_loose(kyberSignedPrekey, serializer);
|
|
sse_encode_list_prim_u_8_loose(
|
|
kyberSignedPrekeySignature,
|
|
serializer,
|
|
);
|
|
sse_encode_list_pqc_pre_key_input(prekeys, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 76,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeApiRustApiUploadPqcPreKeysConstMeta,
|
|
argValues: [
|
|
publicIdentityKey,
|
|
registrationId,
|
|
eccSignedPrekeyId,
|
|
eccSignedPrekey,
|
|
eccSignedPrekeySignature,
|
|
kyberSignedPrekeyId,
|
|
kyberSignedPrekey,
|
|
kyberSignedPrekeySignature,
|
|
prekeys,
|
|
],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeApiRustApiUploadPqcPreKeysConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_api_upload_pqc_pre_keys",
|
|
argNames: [
|
|
"publicIdentityKey",
|
|
"registrationId",
|
|
"eccSignedPrekeyId",
|
|
"eccSignedPrekey",
|
|
"eccSignedPrekeySignature",
|
|
"kyberSignedPrekeyId",
|
|
"kyberSignedPrekey",
|
|
"kyberSignedPrekeySignature",
|
|
"prekeys",
|
|
],
|
|
);
|
|
|
|
@override
|
|
Future<SqlExecutionResult>
|
|
crateBridgeWrapperAppDatabaseRustAppDatabaseExecute({
|
|
required String statement,
|
|
required List<SqlValue> arguments,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(statement, serializer);
|
|
sse_encode_list_sql_value(arguments, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 77,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_sql_execution_result,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperAppDatabaseRustAppDatabaseExecuteConstMeta,
|
|
argValues: [statement, arguments],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperAppDatabaseRustAppDatabaseExecuteConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_app_database_execute",
|
|
argNames: ["statement", "arguments"],
|
|
);
|
|
|
|
@override
|
|
Future<bool>
|
|
crateBridgeWrapperAppDatabaseRustAppDatabaseLegacyImportComplete() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 78,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperAppDatabaseRustAppDatabaseLegacyImportCompleteConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperAppDatabaseRustAppDatabaseLegacyImportCompleteConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_app_database_legacy_import_complete",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<LegacyMigrationReport>
|
|
crateBridgeWrapperAppDatabaseRustAppDatabaseMigrateLegacyDatabase() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 79,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_legacy_migration_report,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperAppDatabaseRustAppDatabaseMigrateLegacyDatabaseConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperAppDatabaseRustAppDatabaseMigrateLegacyDatabaseConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_app_database_migrate_legacy_database",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<SqlRows> crateBridgeWrapperAppDatabaseRustAppDatabaseSelect({
|
|
required String statement,
|
|
required List<SqlValue> arguments,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(statement, serializer);
|
|
sse_encode_list_sql_value(arguments, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 80,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_sql_rows,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeWrapperAppDatabaseRustAppDatabaseSelectConstMeta,
|
|
argValues: [statement, arguments],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperAppDatabaseRustAppDatabaseSelectConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_app_database_select",
|
|
argNames: ["statement", "arguments"],
|
|
);
|
|
|
|
@override
|
|
Future<(String, String)>
|
|
crateBridgeWrapperBackupRustBackupArchiveCreateBackupArchive() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 81,
|
|
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: 82,
|
|
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: 83,
|
|
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: 84,
|
|
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: 85,
|
|
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: 86,
|
|
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: 87,
|
|
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: 88,
|
|
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: 89,
|
|
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>
|
|
crateBridgeWrapperKeyManagerRustKeyManagerDecryptCloudMediaKey({
|
|
required List<int> encryptedMediaKey,
|
|
required String addition,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_prim_u_8_loose(encryptedMediaKey, serializer);
|
|
sse_encode_String(addition, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 90,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerDecryptCloudMediaKeyConstMeta,
|
|
argValues: [encryptedMediaKey, addition],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerDecryptCloudMediaKeyConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_decrypt_cloud_media_key",
|
|
argNames: ["encryptedMediaKey", "addition"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List>
|
|
crateBridgeWrapperKeyManagerRustKeyManagerEncryptCloudMediaKey({
|
|
required List<int> mediaKey,
|
|
required String addition,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_prim_u_8_loose(mediaKey, serializer);
|
|
sse_encode_String(addition, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 91,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerEncryptCloudMediaKeyConstMeta,
|
|
argValues: [mediaKey, addition],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerEncryptCloudMediaKeyConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_encrypt_cloud_media_key",
|
|
argNames: ["mediaKey", "addition"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeWrapperKeyManagerRustKeyManagerGetLoginToken() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 92,
|
|
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: 93,
|
|
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: 94,
|
|
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> crateBridgeWrapperKeyManagerRustKeyManagerImportSerialized({
|
|
required List<int> serializedBytes,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_prim_u_8_loose(serializedBytes, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 95,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerImportSerializedConstMeta,
|
|
argValues: [serializedBytes],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerImportSerializedConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_import_serialized",
|
|
argNames: ["serializedBytes"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerImportSignalIdentity({
|
|
required List<int> identityKeyPairStructure,
|
|
required PlatformInt64 registrationId,
|
|
}) {
|
|
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);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 96,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerImportSignalIdentityConstMeta,
|
|
argValues: [identityKeyPairStructure, registrationId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerImportSignalIdentityConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_import_signal_identity",
|
|
argNames: ["identityKeyPairStructure", "registrationId"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeWrapperKeyManagerRustKeyManagerRemoveKeyManager() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 97,
|
|
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<Uint8List> crateBridgeWrapperKeyManagerRustKeyManagerSerialize() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 98,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperKeyManagerRustKeyManagerSerializeConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperKeyManagerRustKeyManagerSerializeConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_key_manager_serialize",
|
|
argNames: [],
|
|
);
|
|
|
|
@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: 99,
|
|
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<Uint8List> crateBridgeWrapperSignalRustSignalDecrypt({
|
|
required String name,
|
|
required int deviceId,
|
|
required List<int> ciphertext,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(name, serializer);
|
|
sse_encode_u_32(deviceId, serializer);
|
|
sse_encode_list_prim_u_8_loose(ciphertext, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 100,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeWrapperSignalRustSignalDecryptConstMeta,
|
|
argValues: [name, deviceId, ciphertext],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeWrapperSignalRustSignalDecryptConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_signal_decrypt",
|
|
argNames: ["name", "deviceId", "ciphertext"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeWrapperSignalRustSignalEncrypt({
|
|
required String name,
|
|
required int deviceId,
|
|
required List<int> plaintext,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(name, serializer);
|
|
sse_encode_u_32(deviceId, serializer);
|
|
sse_encode_list_prim_u_8_loose(plaintext, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 101,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeWrapperSignalRustSignalEncryptConstMeta,
|
|
argValues: [name, deviceId, plaintext],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeWrapperSignalRustSignalEncryptConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_signal_encrypt",
|
|
argNames: ["name", "deviceId", "plaintext"],
|
|
);
|
|
|
|
@override
|
|
Future<FrbPreKeyBundle> crateBridgeWrapperSignalRustSignalGenerateBundle() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 102,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_frb_pre_key_bundle,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeWrapperSignalRustSignalGenerateBundleConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperSignalRustSignalGenerateBundleConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_signal_generate_bundle",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<List<FrbPqcPreKey>>
|
|
crateBridgeWrapperSignalRustSignalGeneratePqcPrekeys() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 103,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_frb_pqc_pre_key,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperSignalRustSignalGeneratePqcPrekeysConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperSignalRustSignalGeneratePqcPrekeysConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_signal_generate_pqc_prekeys",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List?> crateBridgeWrapperSignalRustSignalGetContactPublicKey({
|
|
required PlatformInt64 contactId,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(contactId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 104,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_opt_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperSignalRustSignalGetContactPublicKeyConstMeta,
|
|
argValues: [contactId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperSignalRustSignalGetContactPublicKeyConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_signal_get_contact_public_key",
|
|
argNames: ["contactId"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeWrapperSignalRustSignalGetUserPublicKey() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 105,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeWrapperSignalRustSignalGetUserPublicKeyConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperSignalRustSignalGetUserPublicKeyConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_signal_get_user_public_key",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateBridgeWrapperSignalRustSignalProcessPrekeyBundle({
|
|
required String name,
|
|
required int deviceId,
|
|
required FrbPreKeyBundle bundle,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(name, serializer);
|
|
sse_encode_u_32(deviceId, serializer);
|
|
sse_encode_box_autoadd_frb_pre_key_bundle(bundle, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 106,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta:
|
|
kCrateBridgeWrapperSignalRustSignalProcessPrekeyBundleConstMeta,
|
|
argValues: [name, deviceId, bundle],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta
|
|
get kCrateBridgeWrapperSignalRustSignalProcessPrekeyBundleConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_signal_process_prekey_bundle",
|
|
argNames: ["name", "deviceId", "bundle"],
|
|
);
|
|
|
|
@override
|
|
Future<List<Uint8List>> crateBridgeWrapperRustUtilsGenerateShares({
|
|
required List<int> secret,
|
|
required int total,
|
|
required int threshold,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_prim_u_8_loose(secret, serializer);
|
|
sse_encode_u_8(total, serializer);
|
|
sse_encode_u_8(threshold, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 107,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeWrapperRustUtilsGenerateSharesConstMeta,
|
|
argValues: [secret, total, threshold],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeWrapperRustUtilsGenerateSharesConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_utils_generate_shares",
|
|
argNames: ["secret", "total", "threshold"],
|
|
);
|
|
|
|
@override
|
|
Future<Uint8List> crateBridgeWrapperRustUtilsRecoverSecret({
|
|
required List<Uint8List> shares,
|
|
required int threshold,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_list_list_prim_u_8_strict(shares, serializer);
|
|
sse_encode_u_8(threshold, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 108,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_prim_u_8_strict,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeWrapperRustUtilsRecoverSecretConstMeta,
|
|
argValues: [shares, threshold],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeWrapperRustUtilsRecoverSecretConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "rust_utils_recover_secret",
|
|
argNames: ["shares", "threshold"],
|
|
);
|
|
|
|
@override
|
|
Future<bool> crateBridgeGroupsUpdateChatDeletionTime({
|
|
required String groupId,
|
|
required PlatformInt64 deleteMessagesAfterMilliseconds,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupId, serializer);
|
|
sse_encode_i_64(deleteMessagesAfterMilliseconds, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 109,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeGroupsUpdateChatDeletionTimeConstMeta,
|
|
argValues: [groupId, deleteMessagesAfterMilliseconds],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeGroupsUpdateChatDeletionTimeConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "update_chat_deletion_time",
|
|
argNames: ["groupId", "deleteMessagesAfterMilliseconds"],
|
|
);
|
|
|
|
@override
|
|
Future<bool> crateBridgeGroupsUpdateGroupName({
|
|
required String groupId,
|
|
required String groupName,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(groupId, serializer);
|
|
sse_encode_String(groupName, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 110,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeGroupsUpdateGroupNameConstMeta,
|
|
argValues: [groupId, groupName],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeGroupsUpdateGroupNameConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "update_group_name",
|
|
argNames: ["groupId", "groupName"],
|
|
);
|
|
|
|
@override
|
|
UserConfig crateBridgeUserConfigUserConfigApiClone({
|
|
required UserConfig config,
|
|
}) {
|
|
return handler.executeSync(
|
|
SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_box_autoadd_user_config(config, serializer);
|
|
return pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 111,
|
|
)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_user_config,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateBridgeUserConfigUserConfigApiCloneConstMeta,
|
|
argValues: [config],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeUserConfigUserConfigApiCloneConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "user_config_api_clone",
|
|
argNames: ["config"],
|
|
);
|
|
|
|
@override
|
|
Future<UserConfig> crateBridgeUserConfigUserConfigApiCreate({
|
|
required PlatformInt64 userId,
|
|
required String username,
|
|
required String displayName,
|
|
String? currentSetupPage,
|
|
required PlatformInt64 appVersion,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_i_64(userId, serializer);
|
|
sse_encode_String(username, serializer);
|
|
sse_encode_String(displayName, serializer);
|
|
sse_encode_opt_String(currentSetupPage, serializer);
|
|
sse_encode_i_64(appVersion, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 112,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_user_config,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeUserConfigUserConfigApiCreateConstMeta,
|
|
argValues: [
|
|
userId,
|
|
username,
|
|
displayName,
|
|
currentSetupPage,
|
|
appVersion,
|
|
],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeUserConfigUserConfigApiCreateConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "user_config_api_create",
|
|
argNames: [
|
|
"userId",
|
|
"username",
|
|
"displayName",
|
|
"currentSetupPage",
|
|
"appVersion",
|
|
],
|
|
);
|
|
|
|
@override
|
|
Future<UserConfig> crateBridgeUserConfigUserConfigApiImportJson({
|
|
required String json,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(json, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 113,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_user_config,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeUserConfigUserConfigApiImportJsonConstMeta,
|
|
argValues: [json],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeUserConfigUserConfigApiImportJsonConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "user_config_api_import_json",
|
|
argNames: ["json"],
|
|
);
|
|
|
|
@override
|
|
Future<UserConfig?> crateBridgeUserConfigUserConfigApiLoad() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 114,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_opt_box_autoadd_user_config,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeUserConfigUserConfigApiLoadConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeUserConfigUserConfigApiLoadConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "user_config_api_load",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
Future<UserConfig> crateBridgeUserConfigUserConfigApiSave({
|
|
required UserConfig config,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_box_autoadd_user_config(config, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 115,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_user_config,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeUserConfigUserConfigApiSaveConstMeta,
|
|
argValues: [config],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeUserConfigUserConfigApiSaveConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "user_config_api_save",
|
|
argNames: ["config"],
|
|
);
|
|
|
|
@override
|
|
Future<UserConfig> crateBridgeUserConfigUserConfigApiUpdate({
|
|
required UserConfig base,
|
|
required UserConfig config,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_box_autoadd_user_config(base, serializer);
|
|
sse_encode_box_autoadd_user_config(config, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 116,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_user_config,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
),
|
|
constMeta: kCrateBridgeUserConfigUserConfigApiUpdateConstMeta,
|
|
argValues: [base, config],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateBridgeUserConfigUserConfigApiUpdateConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "user_config_api_update",
|
|
argNames: ["base", "config"],
|
|
);
|
|
|
|
Future<void> Function(int, dynamic, dynamic, dynamic, dynamic)
|
|
encode_DartFn_Inputs_String_String_i_64_String_Output_unit_AnyhowException(
|
|
FutureOr<void> Function(String, String, PlatformInt64, String) raw,
|
|
) {
|
|
return (callId, rawArg0, rawArg1, rawArg2, rawArg3) async {
|
|
final arg0 = dco_decode_String(rawArg0);
|
|
final arg1 = dco_decode_String(rawArg1);
|
|
final arg2 = dco_decode_i_64(rawArg2);
|
|
final arg3 = dco_decode_String(rawArg3);
|
|
|
|
Box<void>? rawOutput;
|
|
Box<AnyhowException>? rawError;
|
|
try {
|
|
rawOutput = Box(await raw(arg0, arg1, arg2, arg3));
|
|
} 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_unit(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_String_i_64_Output_unit_AnyhowException(
|
|
FutureOr<void> Function(String, PlatformInt64) raw,
|
|
) {
|
|
return (callId, rawArg0, rawArg1) async {
|
|
final arg0 = dco_decode_String(rawArg0);
|
|
final arg1 = dco_decode_i_64(rawArg1);
|
|
|
|
Box<void>? 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_unit(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,
|
|
)
|
|
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_unit_AnyhowException(
|
|
FutureOr<void> Function(PlatformInt64) raw,
|
|
) {
|
|
return (callId, rawArg0) async {
|
|
final arg0 = dco_decode_i_64(rawArg0);
|
|
|
|
Box<void>? 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_unit(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_unit_AnyhowException(
|
|
FutureOr<void> 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<void>? 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_unit(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_user_config_Output_unit_AnyhowException(
|
|
FutureOr<void> Function(UserConfig) raw,
|
|
) {
|
|
return (callId, rawArg0) async {
|
|
final arg0 = dco_decode_user_config(rawArg0);
|
|
|
|
Box<void>? 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_unit(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
|
|
DateTime dco_decode_Chrono_Utc(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dcoDecodeTimestamp(ts: dco_decode_i_64(raw).toInt(), isUtc: true);
|
|
}
|
|
|
|
@protected
|
|
FutureOr<void> Function(String, String, PlatformInt64, String)
|
|
dco_decode_DartFn_Inputs_String_String_i_64_String_Output_unit_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<void> Function(String, PlatformInt64)
|
|
dco_decode_DartFn_Inputs_String_i_64_Output_unit_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@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<void> Function(PlatformInt64)
|
|
dco_decode_DartFn_Inputs_i_64_Output_unit_AnyhowException(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<void> Function(PlatformInt64, Uint8List)
|
|
dco_decode_DartFn_Inputs_i_64_list_prim_u_8_strict_Output_unit_AnyhowException(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError('');
|
|
}
|
|
|
|
@protected
|
|
FutureOr<void> Function(UserConfig)
|
|
dco_decode_DartFn_Inputs_user_config_Output_unit_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<String, List<String>> dco_decode_Map_String_list_String_None(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return Map.fromEntries(
|
|
dco_decode_list_record_string_list_string(
|
|
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
|
|
RustStreamSink<ApiEvent> dco_decode_StreamSink_api_event_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
|
|
ApiConnectionState dco_decode_api_connection_state(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return ApiConnectionState.values[raw as int];
|
|
}
|
|
|
|
@protected
|
|
ApiEvent dco_decode_api_event(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 ApiEvent(
|
|
kind: dco_decode_api_event_kind(arr[0]),
|
|
state: dco_decode_opt_box_autoadd_api_connection_state(arr[1]),
|
|
message: dco_decode_opt_String(arr[2]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
ApiEventKind dco_decode_api_event_kind(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return ApiEventKind.values[raw as int];
|
|
}
|
|
|
|
@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
|
|
DateTime dco_decode_box_autoadd_Chrono_Utc(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_Chrono_Utc(raw);
|
|
}
|
|
|
|
@protected
|
|
ApiConnectionState dco_decode_box_autoadd_api_connection_state(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_api_connection_state(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
|
|
bool dco_decode_box_autoadd_bool(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as bool;
|
|
}
|
|
|
|
@protected
|
|
double dco_decode_box_autoadd_f_64(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as double;
|
|
}
|
|
|
|
@protected
|
|
FrbPreKeyBundle dco_decode_box_autoadd_frb_pre_key_bundle(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_frb_pre_key_bundle(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
|
|
PasswordlessRecoveryConfig
|
|
dco_decode_box_autoadd_passwordless_recovery_config(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_passwordless_recovery_config(raw);
|
|
}
|
|
|
|
@protected
|
|
TwonlySafeBackup dco_decode_box_autoadd_twonly_safe_backup(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_twonly_safe_backup(raw);
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_box_autoadd_u_32(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@protected
|
|
UserConfig dco_decode_box_autoadd_user_config(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_user_config(raw);
|
|
}
|
|
|
|
@protected
|
|
double dco_decode_f_64(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as double;
|
|
}
|
|
|
|
@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
|
|
FrbPqcPreKey dco_decode_frb_pqc_pre_key(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 5)
|
|
throw Exception('unexpected arr length: expect 5 but see ${arr.length}');
|
|
return FrbPqcPreKey(
|
|
eccPreKeyId: dco_decode_u_32(arr[0]),
|
|
eccPreKey: dco_decode_list_prim_u_8_strict(arr[1]),
|
|
kyberPreKeyId: dco_decode_u_32(arr[2]),
|
|
kyberPreKey: dco_decode_list_prim_u_8_strict(arr[3]),
|
|
kyberPreKeySignature: dco_decode_list_prim_u_8_strict(arr[4]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
FrbPreKeyBundle dco_decode_frb_pre_key_bundle(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 11)
|
|
throw Exception('unexpected arr length: expect 11 but see ${arr.length}');
|
|
return FrbPreKeyBundle(
|
|
registrationId: dco_decode_u_32(arr[0]),
|
|
deviceId: dco_decode_u_32(arr[1]),
|
|
preKeyId: dco_decode_opt_box_autoadd_u_32(arr[2]),
|
|
preKeyPublic: dco_decode_opt_list_prim_u_8_strict(arr[3]),
|
|
signedPreKeyId: dco_decode_u_32(arr[4]),
|
|
signedPreKeyPublic: dco_decode_list_prim_u_8_strict(arr[5]),
|
|
signedPreKeySignature: dco_decode_list_prim_u_8_strict(arr[6]),
|
|
kyberPreKeyId: dco_decode_u_32(arr[7]),
|
|
kyberPreKeyPublic: dco_decode_list_prim_u_8_strict(arr[8]),
|
|
kyberPreKeySignature: dco_decode_list_prim_u_8_strict(arr[9]),
|
|
identityKey: dco_decode_list_prim_u_8_strict(arr[10]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_i_32(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@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
|
|
LastBackupUploadState dco_decode_last_backup_upload_state(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return LastBackupUploadState.values[raw as int];
|
|
}
|
|
|
|
@protected
|
|
LegacyMigrationReport dco_decode_legacy_migration_report(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 LegacyMigrationReport(
|
|
legacyVersion: dco_decode_i_64(arr[0]),
|
|
tables: dco_decode_list_legacy_table_migration_count(arr[1]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
LegacyTableMigrationCount dco_decode_legacy_table_migration_count(
|
|
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 LegacyTableMigrationCount(
|
|
table: dco_decode_String(arr[0]),
|
|
rows: dco_decode_i_64(arr[1]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
List<String> dco_decode_list_String(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>).map(dco_decode_String).toList();
|
|
}
|
|
|
|
@protected
|
|
List<FrbPqcPreKey> dco_decode_list_frb_pqc_pre_key(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>).map(dco_decode_frb_pqc_pre_key).toList();
|
|
}
|
|
|
|
@protected
|
|
List<LegacyTableMigrationCount> dco_decode_list_legacy_table_migration_count(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>)
|
|
.map(dco_decode_legacy_table_migration_count)
|
|
.toList();
|
|
}
|
|
|
|
@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<PqcPreKeyInput> dco_decode_list_pqc_pre_key_input(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>).map(dco_decode_pqc_pre_key_input).toList();
|
|
}
|
|
|
|
@protected
|
|
Int64List dco_decode_list_prim_i_64_strict(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dcoDecodeInt64List(raw);
|
|
}
|
|
|
|
@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<(String, List<String>)> dco_decode_list_record_string_list_string(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>)
|
|
.map(dco_decode_record_string_list_string)
|
|
.toList();
|
|
}
|
|
|
|
@protected
|
|
List<SqlRow> dco_decode_list_sql_row(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>).map(dco_decode_sql_row).toList();
|
|
}
|
|
|
|
@protected
|
|
List<SqlValue> dco_decode_list_sql_value(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>).map(dco_decode_sql_value).toList();
|
|
}
|
|
|
|
@protected
|
|
Map<String, List<String>>? dco_decode_opt_Map_String_list_String_None(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_Map_String_list_String_None(raw);
|
|
}
|
|
|
|
@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
|
|
DateTime? dco_decode_opt_box_autoadd_Chrono_Utc(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_box_autoadd_Chrono_Utc(raw);
|
|
}
|
|
|
|
@protected
|
|
ApiConnectionState? dco_decode_opt_box_autoadd_api_connection_state(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null
|
|
? null
|
|
: dco_decode_box_autoadd_api_connection_state(raw);
|
|
}
|
|
|
|
@protected
|
|
bool? dco_decode_opt_box_autoadd_bool(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_box_autoadd_bool(raw);
|
|
}
|
|
|
|
@protected
|
|
double? dco_decode_opt_box_autoadd_f_64(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_box_autoadd_f_64(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
|
|
PasswordlessRecoveryConfig?
|
|
dco_decode_opt_box_autoadd_passwordless_recovery_config(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null
|
|
? null
|
|
: dco_decode_box_autoadd_passwordless_recovery_config(raw);
|
|
}
|
|
|
|
@protected
|
|
TwonlySafeBackup? dco_decode_opt_box_autoadd_twonly_safe_backup(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_box_autoadd_twonly_safe_backup(raw);
|
|
}
|
|
|
|
@protected
|
|
int? dco_decode_opt_box_autoadd_u_32(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_box_autoadd_u_32(raw);
|
|
}
|
|
|
|
@protected
|
|
UserConfig? dco_decode_opt_box_autoadd_user_config(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_box_autoadd_user_config(raw);
|
|
}
|
|
|
|
@protected
|
|
List<String>? dco_decode_opt_list_String(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw == null ? null : dco_decode_list_String(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
|
|
PasswordlessRecoveryConfig dco_decode_passwordless_recovery_config(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 7)
|
|
throw Exception('unexpected arr length: expect 7 but see ${arr.length}');
|
|
return PasswordlessRecoveryConfig(
|
|
email: dco_decode_opt_String(arr[0]),
|
|
threshold: dco_decode_i_64(arr[1]),
|
|
serverKeyProtection: dco_decode_opt_list_prim_u_8_strict(arr[2]),
|
|
pinUnlockToken: dco_decode_opt_list_prim_u_8_strict(arr[3]),
|
|
lastServerHeartbeat: dco_decode_opt_box_autoadd_Chrono_Utc(arr[4]),
|
|
lastContactHeartbeat: dco_decode_opt_box_autoadd_Chrono_Utc(arr[5]),
|
|
encryptedServerKey: dco_decode_opt_list_prim_u_8_strict(arr[6]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
PqcPreKeyInput dco_decode_pqc_pre_key_input(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 5)
|
|
throw Exception('unexpected arr length: expect 5 but see ${arr.length}');
|
|
return PqcPreKeyInput(
|
|
eccPreKeyId: dco_decode_i_64(arr[0]),
|
|
eccPreKey: dco_decode_list_prim_u_8_strict(arr[1]),
|
|
kyberPreKeyId: dco_decode_i_64(arr[2]),
|
|
kyberPreKey: dco_decode_list_prim_u_8_strict(arr[3]),
|
|
kyberPreKeySignature: dco_decode_list_prim_u_8_strict(arr[4]),
|
|
);
|
|
}
|
|
|
|
@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, List<String>) dco_decode_record_string_list_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_list_String(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
|
|
RustApi dco_decode_rust_api(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 RustApi();
|
|
}
|
|
|
|
@protected
|
|
RustAppDatabase dco_decode_rust_app_database(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 RustAppDatabase();
|
|
}
|
|
|
|
@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
|
|
RustSignal dco_decode_rust_signal(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 RustSignal();
|
|
}
|
|
|
|
@protected
|
|
RustUtils dco_decode_rust_utils(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 RustUtils();
|
|
}
|
|
|
|
@protected
|
|
SetupProfile dco_decode_setup_profile(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return SetupProfile.values[raw as int];
|
|
}
|
|
|
|
@protected
|
|
SqlExecutionResult dco_decode_sql_execution_result(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 SqlExecutionResult(
|
|
affectedRows: dco_decode_i_64(arr[0]),
|
|
lastInsertRowId: dco_decode_i_64(arr[1]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
SqlRow dco_decode_sql_row(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 1)
|
|
throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
|
|
return SqlRow(
|
|
values: dco_decode_list_sql_value(arr[0]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
SqlRows dco_decode_sql_rows(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 SqlRows(
|
|
columns: dco_decode_list_String(arr[0]),
|
|
rows: dco_decode_list_sql_row(arr[1]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
SqlValue dco_decode_sql_value(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 5)
|
|
throw Exception('unexpected arr length: expect 5 but see ${arr.length}');
|
|
return SqlValue(
|
|
kind: dco_decode_u_8(arr[0]),
|
|
integerValue: dco_decode_opt_box_autoadd_i_64(arr[1]),
|
|
realValue: dco_decode_opt_box_autoadd_f_64(arr[2]),
|
|
textValue: dco_decode_opt_String(arr[3]),
|
|
blobValue: dco_decode_opt_list_prim_u_8_strict(arr[4]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
ThemeMode dco_decode_theme_mode(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return ThemeMode.values[raw as int];
|
|
}
|
|
|
|
@protected
|
|
TwonlySafeBackup dco_decode_twonly_safe_backup(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 5)
|
|
throw Exception('unexpected arr length: expect 5 but see ${arr.length}');
|
|
return TwonlySafeBackup(
|
|
lastBackupSize: dco_decode_i_64(arr[0]),
|
|
backupUploadState: dco_decode_last_backup_upload_state(arr[1]),
|
|
lastBackupDone: dco_decode_opt_box_autoadd_Chrono_Utc(arr[2]),
|
|
backupId: dco_decode_list_prim_u_8_strict(arr[3]),
|
|
encryptionKey: dco_decode_list_prim_u_8_strict(arr[4]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_u_32(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@protected
|
|
BigInt dco_decode_u_64(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dcoDecodeU64(raw);
|
|
}
|
|
|
|
@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
|
|
UserConfig dco_decode_user_config(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 58)
|
|
throw Exception('unexpected arr length: expect 58 but see ${arr.length}');
|
|
return UserConfig(
|
|
userId: dco_decode_i_64(arr[0]),
|
|
username: dco_decode_String(arr[1]),
|
|
displayName: dco_decode_String(arr[2]),
|
|
avatarSvg: dco_decode_opt_String(arr[3]),
|
|
appVersion: dco_decode_i_64(arr[4]),
|
|
avatarCounter: dco_decode_i_64(arr[5]),
|
|
videoStabilizationEnabled: dco_decode_bool(arr[6]),
|
|
isDeveloper: dco_decode_bool(arr[7]),
|
|
deviceId: dco_decode_i_64(arr[8]),
|
|
setupProfile: dco_decode_setup_profile(arr[9]),
|
|
subscriptionPlan: dco_decode_String(arr[10]),
|
|
subscriptionPlanIdStore: dco_decode_opt_String(arr[11]),
|
|
lastImageSend: dco_decode_opt_box_autoadd_Chrono_Utc(arr[12]),
|
|
todaysImageCounter: dco_decode_opt_box_autoadd_i_64(arr[13]),
|
|
lastPlanBallance: dco_decode_opt_String(arr[14]),
|
|
additionalUserInvites: dco_decode_opt_String(arr[15]),
|
|
themeMode: dco_decode_theme_mode(arr[16]),
|
|
primaryColorValue: dco_decode_opt_box_autoadd_i_64(arr[17]),
|
|
defaultShowTime: dco_decode_opt_box_autoadd_i_64(arr[18]),
|
|
requestedAudioPermission: dco_decode_bool(arr[19]),
|
|
enableDatabaseLogging: dco_decode_bool(arr[20]),
|
|
automaticallyMarkEqualMediaFilesAsOpened: dco_decode_bool(arr[21]),
|
|
showNewsShortcut: dco_decode_bool(arr[22]),
|
|
showShowImagePreviewWhenSending: dco_decode_bool(arr[23]),
|
|
startWithCameraOpen: dco_decode_bool(arr[24]),
|
|
preSelectedEmojies: dco_decode_opt_list_String(arr[25]),
|
|
autoDownloadOptions: dco_decode_opt_Map_String_list_String_None(arr[26]),
|
|
storeMediaFilesInGallery: dco_decode_bool(arr[27]),
|
|
autoStoreAllSendUnlimitedMediaFiles: dco_decode_bool(arr[28]),
|
|
typingIndicators: dco_decode_bool(arr[29]),
|
|
showRestoreFlame: dco_decode_bool(arr[30]),
|
|
myBestFriendGroupId: dco_decode_opt_String(arr[31]),
|
|
signalLastSignedPreKeyUpdated: dco_decode_opt_box_autoadd_Chrono_Utc(
|
|
arr[32],
|
|
),
|
|
signalLastPqcPreKeysUploaded: dco_decode_opt_box_autoadd_Chrono_Utc(
|
|
arr[33],
|
|
),
|
|
allowErrorTrackingViaSentry: dco_decode_bool(arr[34]),
|
|
screenLockEnabled: dco_decode_bool(arr[35]),
|
|
isCloudBackupEnabled: dco_decode_bool(arr[36]),
|
|
isUserDiscoveryEnabled: dco_decode_bool(arr[37]),
|
|
requiredSendImages: dco_decode_i_64(arr[38]),
|
|
userDiscoveryThreshold: dco_decode_u_8(arr[39]),
|
|
userDiscoveryRequiresManualApproval: dco_decode_bool(arr[40]),
|
|
userDiscoverySharePromotion: dco_decode_bool(arr[41]),
|
|
userDiscoveryInitializationError: dco_decode_bool(arr[42]),
|
|
askForFriendPromotions: dco_decode_bool(arr[43]),
|
|
currentPreKeyIndexStart: dco_decode_i_64(arr[44]),
|
|
currentSignedPreKeyIndexStart: dco_decode_i_64(arr[45]),
|
|
lastChangeLogHash: dco_decode_opt_list_prim_u_8_strict(arr[46]),
|
|
hideChangeLog: dco_decode_bool(arr[47]),
|
|
hideMemoriesBackupPromo: dco_decode_bool(arr[48]),
|
|
updateFcmToken: dco_decode_bool(arr[49]),
|
|
canUseLoginTokenForAuth: dco_decode_bool(arr[50]),
|
|
twonlySafeBackup: dco_decode_opt_box_autoadd_twonly_safe_backup(arr[51]),
|
|
isBackupEnabled: dco_decode_bool(arr[52]),
|
|
passwordLessRecovery:
|
|
dco_decode_opt_box_autoadd_passwordless_recovery_config(arr[53]),
|
|
fcmToken: dco_decode_opt_String(arr[54]),
|
|
currentSetupPage: dco_decode_opt_String(arr[55]),
|
|
skipSetupPages: dco_decode_bool(arr[56]),
|
|
hasZoomed: dco_decode_bool(arr[57]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
UserConfigApi dco_decode_user_config_api(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 UserConfigApi();
|
|
}
|
|
|
|
@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
|
|
DateTime sse_decode_Chrono_Utc(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_i_64(deserializer);
|
|
return DateTime.fromMicrosecondsSinceEpoch(inner.toInt(), isUtc: true);
|
|
}
|
|
|
|
@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<String, List<String>> sse_decode_Map_String_list_String_None(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_list_record_string_list_string(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
|
|
RustStreamSink<ApiEvent> sse_decode_StreamSink_api_event_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
|
|
ApiConnectionState sse_decode_api_connection_state(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_i_32(deserializer);
|
|
return ApiConnectionState.values[inner];
|
|
}
|
|
|
|
@protected
|
|
ApiEvent sse_decode_api_event(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_kind = sse_decode_api_event_kind(deserializer);
|
|
var var_state = sse_decode_opt_box_autoadd_api_connection_state(
|
|
deserializer,
|
|
);
|
|
var var_message = sse_decode_opt_String(deserializer);
|
|
return ApiEvent(kind: var_kind, state: var_state, message: var_message);
|
|
}
|
|
|
|
@protected
|
|
ApiEventKind sse_decode_api_event_kind(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_i_32(deserializer);
|
|
return ApiEventKind.values[inner];
|
|
}
|
|
|
|
@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
|
|
DateTime sse_decode_box_autoadd_Chrono_Utc(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_Chrono_Utc(deserializer));
|
|
}
|
|
|
|
@protected
|
|
ApiConnectionState sse_decode_box_autoadd_api_connection_state(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_api_connection_state(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
|
|
bool sse_decode_box_autoadd_bool(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_bool(deserializer));
|
|
}
|
|
|
|
@protected
|
|
double sse_decode_box_autoadd_f_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_f_64(deserializer));
|
|
}
|
|
|
|
@protected
|
|
FrbPreKeyBundle sse_decode_box_autoadd_frb_pre_key_bundle(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_frb_pre_key_bundle(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
|
|
PasswordlessRecoveryConfig
|
|
sse_decode_box_autoadd_passwordless_recovery_config(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_passwordless_recovery_config(deserializer));
|
|
}
|
|
|
|
@protected
|
|
TwonlySafeBackup sse_decode_box_autoadd_twonly_safe_backup(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_twonly_safe_backup(deserializer));
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_box_autoadd_u_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_u_32(deserializer));
|
|
}
|
|
|
|
@protected
|
|
UserConfig sse_decode_box_autoadd_user_config(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_user_config(deserializer));
|
|
}
|
|
|
|
@protected
|
|
double sse_decode_f_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getFloat64();
|
|
}
|
|
|
|
@protected
|
|
FlutterUserDiscovery sse_decode_flutter_user_discovery(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return FlutterUserDiscovery();
|
|
}
|
|
|
|
@protected
|
|
FrbPqcPreKey sse_decode_frb_pqc_pre_key(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_eccPreKeyId = sse_decode_u_32(deserializer);
|
|
var var_eccPreKey = sse_decode_list_prim_u_8_strict(deserializer);
|
|
var var_kyberPreKeyId = sse_decode_u_32(deserializer);
|
|
var var_kyberPreKey = sse_decode_list_prim_u_8_strict(deserializer);
|
|
var var_kyberPreKeySignature = sse_decode_list_prim_u_8_strict(
|
|
deserializer,
|
|
);
|
|
return FrbPqcPreKey(
|
|
eccPreKeyId: var_eccPreKeyId,
|
|
eccPreKey: var_eccPreKey,
|
|
kyberPreKeyId: var_kyberPreKeyId,
|
|
kyberPreKey: var_kyberPreKey,
|
|
kyberPreKeySignature: var_kyberPreKeySignature,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
FrbPreKeyBundle sse_decode_frb_pre_key_bundle(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_registrationId = sse_decode_u_32(deserializer);
|
|
var var_deviceId = sse_decode_u_32(deserializer);
|
|
var var_preKeyId = sse_decode_opt_box_autoadd_u_32(deserializer);
|
|
var var_preKeyPublic = sse_decode_opt_list_prim_u_8_strict(deserializer);
|
|
var var_signedPreKeyId = sse_decode_u_32(deserializer);
|
|
var var_signedPreKeyPublic = sse_decode_list_prim_u_8_strict(deserializer);
|
|
var var_signedPreKeySignature = sse_decode_list_prim_u_8_strict(
|
|
deserializer,
|
|
);
|
|
var var_kyberPreKeyId = sse_decode_u_32(deserializer);
|
|
var var_kyberPreKeyPublic = sse_decode_list_prim_u_8_strict(deserializer);
|
|
var var_kyberPreKeySignature = sse_decode_list_prim_u_8_strict(
|
|
deserializer,
|
|
);
|
|
var var_identityKey = sse_decode_list_prim_u_8_strict(deserializer);
|
|
return FrbPreKeyBundle(
|
|
registrationId: var_registrationId,
|
|
deviceId: var_deviceId,
|
|
preKeyId: var_preKeyId,
|
|
preKeyPublic: var_preKeyPublic,
|
|
signedPreKeyId: var_signedPreKeyId,
|
|
signedPreKeyPublic: var_signedPreKeyPublic,
|
|
signedPreKeySignature: var_signedPreKeySignature,
|
|
kyberPreKeyId: var_kyberPreKeyId,
|
|
kyberPreKeyPublic: var_kyberPreKeyPublic,
|
|
kyberPreKeySignature: var_kyberPreKeySignature,
|
|
identityKey: var_identityKey,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_i_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getInt32();
|
|
}
|
|
|
|
@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
|
|
LastBackupUploadState sse_decode_last_backup_upload_state(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_i_32(deserializer);
|
|
return LastBackupUploadState.values[inner];
|
|
}
|
|
|
|
@protected
|
|
LegacyMigrationReport sse_decode_legacy_migration_report(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_legacyVersion = sse_decode_i_64(deserializer);
|
|
var var_tables = sse_decode_list_legacy_table_migration_count(deserializer);
|
|
return LegacyMigrationReport(
|
|
legacyVersion: var_legacyVersion,
|
|
tables: var_tables,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
LegacyTableMigrationCount sse_decode_legacy_table_migration_count(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_table = sse_decode_String(deserializer);
|
|
var var_rows = sse_decode_i_64(deserializer);
|
|
return LegacyTableMigrationCount(table: var_table, rows: var_rows);
|
|
}
|
|
|
|
@protected
|
|
List<String> sse_decode_list_String(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <String>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_String(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
List<FrbPqcPreKey> sse_decode_list_frb_pqc_pre_key(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <FrbPqcPreKey>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_frb_pqc_pre_key(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
List<LegacyTableMigrationCount> sse_decode_list_legacy_table_migration_count(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <LegacyTableMigrationCount>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_legacy_table_migration_count(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@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<PqcPreKeyInput> sse_decode_list_pqc_pre_key_input(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <PqcPreKeyInput>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_pqc_pre_key_input(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
Int64List sse_decode_list_prim_i_64_strict(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
return deserializer.buffer.getInt64List(len_);
|
|
}
|
|
|
|
@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<(String, List<String>)> sse_decode_list_record_string_list_string(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <(String, List<String>)>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_record_string_list_string(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
List<SqlRow> sse_decode_list_sql_row(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <SqlRow>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_sql_row(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
List<SqlValue> sse_decode_list_sql_value(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <SqlValue>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_sql_value(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
Map<String, List<String>>? sse_decode_opt_Map_String_list_String_None(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_Map_String_list_String_None(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@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
|
|
DateTime? sse_decode_opt_box_autoadd_Chrono_Utc(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_box_autoadd_Chrono_Utc(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
ApiConnectionState? sse_decode_opt_box_autoadd_api_connection_state(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_box_autoadd_api_connection_state(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
bool? sse_decode_opt_box_autoadd_bool(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_box_autoadd_bool(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
double? sse_decode_opt_box_autoadd_f_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_box_autoadd_f_64(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
|
|
PasswordlessRecoveryConfig?
|
|
sse_decode_opt_box_autoadd_passwordless_recovery_config(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_box_autoadd_passwordless_recovery_config(
|
|
deserializer,
|
|
));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
TwonlySafeBackup? sse_decode_opt_box_autoadd_twonly_safe_backup(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_box_autoadd_twonly_safe_backup(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
int? sse_decode_opt_box_autoadd_u_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_box_autoadd_u_32(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
UserConfig? sse_decode_opt_box_autoadd_user_config(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_box_autoadd_user_config(deserializer));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@protected
|
|
List<String>? sse_decode_opt_list_String(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
if (sse_decode_bool(deserializer)) {
|
|
return (sse_decode_list_String(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
|
|
PasswordlessRecoveryConfig sse_decode_passwordless_recovery_config(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_email = sse_decode_opt_String(deserializer);
|
|
var var_threshold = sse_decode_i_64(deserializer);
|
|
var var_serverKeyProtection = sse_decode_opt_list_prim_u_8_strict(
|
|
deserializer,
|
|
);
|
|
var var_pinUnlockToken = sse_decode_opt_list_prim_u_8_strict(deserializer);
|
|
var var_lastServerHeartbeat = sse_decode_opt_box_autoadd_Chrono_Utc(
|
|
deserializer,
|
|
);
|
|
var var_lastContactHeartbeat = sse_decode_opt_box_autoadd_Chrono_Utc(
|
|
deserializer,
|
|
);
|
|
var var_encryptedServerKey = sse_decode_opt_list_prim_u_8_strict(
|
|
deserializer,
|
|
);
|
|
return PasswordlessRecoveryConfig(
|
|
email: var_email,
|
|
threshold: var_threshold,
|
|
serverKeyProtection: var_serverKeyProtection,
|
|
pinUnlockToken: var_pinUnlockToken,
|
|
lastServerHeartbeat: var_lastServerHeartbeat,
|
|
lastContactHeartbeat: var_lastContactHeartbeat,
|
|
encryptedServerKey: var_encryptedServerKey,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
PqcPreKeyInput sse_decode_pqc_pre_key_input(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_eccPreKeyId = sse_decode_i_64(deserializer);
|
|
var var_eccPreKey = sse_decode_list_prim_u_8_strict(deserializer);
|
|
var var_kyberPreKeyId = sse_decode_i_64(deserializer);
|
|
var var_kyberPreKey = sse_decode_list_prim_u_8_strict(deserializer);
|
|
var var_kyberPreKeySignature = sse_decode_list_prim_u_8_strict(
|
|
deserializer,
|
|
);
|
|
return PqcPreKeyInput(
|
|
eccPreKeyId: var_eccPreKeyId,
|
|
eccPreKey: var_eccPreKey,
|
|
kyberPreKeyId: var_kyberPreKeyId,
|
|
kyberPreKey: var_kyberPreKey,
|
|
kyberPreKeySignature: var_kyberPreKeySignature,
|
|
);
|
|
}
|
|
|
|
@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, List<String>) sse_decode_record_string_list_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_list_String(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
|
|
RustApi sse_decode_rust_api(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return RustApi();
|
|
}
|
|
|
|
@protected
|
|
RustAppDatabase sse_decode_rust_app_database(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return RustAppDatabase();
|
|
}
|
|
|
|
@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
|
|
RustSignal sse_decode_rust_signal(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return RustSignal();
|
|
}
|
|
|
|
@protected
|
|
RustUtils sse_decode_rust_utils(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return RustUtils();
|
|
}
|
|
|
|
@protected
|
|
SetupProfile sse_decode_setup_profile(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_i_32(deserializer);
|
|
return SetupProfile.values[inner];
|
|
}
|
|
|
|
@protected
|
|
SqlExecutionResult sse_decode_sql_execution_result(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_affectedRows = sse_decode_i_64(deserializer);
|
|
var var_lastInsertRowId = sse_decode_i_64(deserializer);
|
|
return SqlExecutionResult(
|
|
affectedRows: var_affectedRows,
|
|
lastInsertRowId: var_lastInsertRowId,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
SqlRow sse_decode_sql_row(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_values = sse_decode_list_sql_value(deserializer);
|
|
return SqlRow(values: var_values);
|
|
}
|
|
|
|
@protected
|
|
SqlRows sse_decode_sql_rows(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_columns = sse_decode_list_String(deserializer);
|
|
var var_rows = sse_decode_list_sql_row(deserializer);
|
|
return SqlRows(columns: var_columns, rows: var_rows);
|
|
}
|
|
|
|
@protected
|
|
SqlValue sse_decode_sql_value(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_kind = sse_decode_u_8(deserializer);
|
|
var var_integerValue = sse_decode_opt_box_autoadd_i_64(deserializer);
|
|
var var_realValue = sse_decode_opt_box_autoadd_f_64(deserializer);
|
|
var var_textValue = sse_decode_opt_String(deserializer);
|
|
var var_blobValue = sse_decode_opt_list_prim_u_8_strict(deserializer);
|
|
return SqlValue(
|
|
kind: var_kind,
|
|
integerValue: var_integerValue,
|
|
realValue: var_realValue,
|
|
textValue: var_textValue,
|
|
blobValue: var_blobValue,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
ThemeMode sse_decode_theme_mode(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_i_32(deserializer);
|
|
return ThemeMode.values[inner];
|
|
}
|
|
|
|
@protected
|
|
TwonlySafeBackup sse_decode_twonly_safe_backup(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_lastBackupSize = sse_decode_i_64(deserializer);
|
|
var var_backupUploadState = sse_decode_last_backup_upload_state(
|
|
deserializer,
|
|
);
|
|
var var_lastBackupDone = sse_decode_opt_box_autoadd_Chrono_Utc(
|
|
deserializer,
|
|
);
|
|
var var_backupId = sse_decode_list_prim_u_8_strict(deserializer);
|
|
var var_encryptionKey = sse_decode_list_prim_u_8_strict(deserializer);
|
|
return TwonlySafeBackup(
|
|
lastBackupSize: var_lastBackupSize,
|
|
backupUploadState: var_backupUploadState,
|
|
lastBackupDone: var_lastBackupDone,
|
|
backupId: var_backupId,
|
|
encryptionKey: var_encryptionKey,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_u_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint32();
|
|
}
|
|
|
|
@protected
|
|
BigInt sse_decode_u_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getBigUint64();
|
|
}
|
|
|
|
@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
|
|
UserConfig sse_decode_user_config(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_userId = sse_decode_i_64(deserializer);
|
|
var var_username = sse_decode_String(deserializer);
|
|
var var_displayName = sse_decode_String(deserializer);
|
|
var var_avatarSvg = sse_decode_opt_String(deserializer);
|
|
var var_appVersion = sse_decode_i_64(deserializer);
|
|
var var_avatarCounter = sse_decode_i_64(deserializer);
|
|
var var_videoStabilizationEnabled = sse_decode_bool(deserializer);
|
|
var var_isDeveloper = sse_decode_bool(deserializer);
|
|
var var_deviceId = sse_decode_i_64(deserializer);
|
|
var var_setupProfile = sse_decode_setup_profile(deserializer);
|
|
var var_subscriptionPlan = sse_decode_String(deserializer);
|
|
var var_subscriptionPlanIdStore = sse_decode_opt_String(deserializer);
|
|
var var_lastImageSend = sse_decode_opt_box_autoadd_Chrono_Utc(deserializer);
|
|
var var_todaysImageCounter = sse_decode_opt_box_autoadd_i_64(deserializer);
|
|
var var_lastPlanBallance = sse_decode_opt_String(deserializer);
|
|
var var_additionalUserInvites = sse_decode_opt_String(deserializer);
|
|
var var_themeMode = sse_decode_theme_mode(deserializer);
|
|
var var_primaryColorValue = sse_decode_opt_box_autoadd_i_64(deserializer);
|
|
var var_defaultShowTime = sse_decode_opt_box_autoadd_i_64(deserializer);
|
|
var var_requestedAudioPermission = sse_decode_bool(deserializer);
|
|
var var_enableDatabaseLogging = sse_decode_bool(deserializer);
|
|
var var_automaticallyMarkEqualMediaFilesAsOpened = sse_decode_bool(
|
|
deserializer,
|
|
);
|
|
var var_showNewsShortcut = sse_decode_bool(deserializer);
|
|
var var_showShowImagePreviewWhenSending = sse_decode_bool(deserializer);
|
|
var var_startWithCameraOpen = sse_decode_bool(deserializer);
|
|
var var_preSelectedEmojies = sse_decode_opt_list_String(deserializer);
|
|
var var_autoDownloadOptions = sse_decode_opt_Map_String_list_String_None(
|
|
deserializer,
|
|
);
|
|
var var_storeMediaFilesInGallery = sse_decode_bool(deserializer);
|
|
var var_autoStoreAllSendUnlimitedMediaFiles = sse_decode_bool(deserializer);
|
|
var var_typingIndicators = sse_decode_bool(deserializer);
|
|
var var_showRestoreFlame = sse_decode_bool(deserializer);
|
|
var var_myBestFriendGroupId = sse_decode_opt_String(deserializer);
|
|
var var_signalLastSignedPreKeyUpdated =
|
|
sse_decode_opt_box_autoadd_Chrono_Utc(deserializer);
|
|
var var_signalLastPqcPreKeysUploaded =
|
|
sse_decode_opt_box_autoadd_Chrono_Utc(deserializer);
|
|
var var_allowErrorTrackingViaSentry = sse_decode_bool(deserializer);
|
|
var var_screenLockEnabled = sse_decode_bool(deserializer);
|
|
var var_isCloudBackupEnabled = sse_decode_bool(deserializer);
|
|
var var_isUserDiscoveryEnabled = sse_decode_bool(deserializer);
|
|
var var_requiredSendImages = sse_decode_i_64(deserializer);
|
|
var var_userDiscoveryThreshold = sse_decode_u_8(deserializer);
|
|
var var_userDiscoveryRequiresManualApproval = sse_decode_bool(deserializer);
|
|
var var_userDiscoverySharePromotion = sse_decode_bool(deserializer);
|
|
var var_userDiscoveryInitializationError = sse_decode_bool(deserializer);
|
|
var var_askForFriendPromotions = sse_decode_bool(deserializer);
|
|
var var_currentPreKeyIndexStart = sse_decode_i_64(deserializer);
|
|
var var_currentSignedPreKeyIndexStart = sse_decode_i_64(deserializer);
|
|
var var_lastChangeLogHash = sse_decode_opt_list_prim_u_8_strict(
|
|
deserializer,
|
|
);
|
|
var var_hideChangeLog = sse_decode_bool(deserializer);
|
|
var var_hideMemoriesBackupPromo = sse_decode_bool(deserializer);
|
|
var var_updateFcmToken = sse_decode_bool(deserializer);
|
|
var var_canUseLoginTokenForAuth = sse_decode_bool(deserializer);
|
|
var var_twonlySafeBackup = sse_decode_opt_box_autoadd_twonly_safe_backup(
|
|
deserializer,
|
|
);
|
|
var var_isBackupEnabled = sse_decode_bool(deserializer);
|
|
var var_passwordLessRecovery =
|
|
sse_decode_opt_box_autoadd_passwordless_recovery_config(deserializer);
|
|
var var_fcmToken = sse_decode_opt_String(deserializer);
|
|
var var_currentSetupPage = sse_decode_opt_String(deserializer);
|
|
var var_skipSetupPages = sse_decode_bool(deserializer);
|
|
var var_hasZoomed = sse_decode_bool(deserializer);
|
|
return UserConfig(
|
|
userId: var_userId,
|
|
username: var_username,
|
|
displayName: var_displayName,
|
|
avatarSvg: var_avatarSvg,
|
|
appVersion: var_appVersion,
|
|
avatarCounter: var_avatarCounter,
|
|
videoStabilizationEnabled: var_videoStabilizationEnabled,
|
|
isDeveloper: var_isDeveloper,
|
|
deviceId: var_deviceId,
|
|
setupProfile: var_setupProfile,
|
|
subscriptionPlan: var_subscriptionPlan,
|
|
subscriptionPlanIdStore: var_subscriptionPlanIdStore,
|
|
lastImageSend: var_lastImageSend,
|
|
todaysImageCounter: var_todaysImageCounter,
|
|
lastPlanBallance: var_lastPlanBallance,
|
|
additionalUserInvites: var_additionalUserInvites,
|
|
themeMode: var_themeMode,
|
|
primaryColorValue: var_primaryColorValue,
|
|
defaultShowTime: var_defaultShowTime,
|
|
requestedAudioPermission: var_requestedAudioPermission,
|
|
enableDatabaseLogging: var_enableDatabaseLogging,
|
|
automaticallyMarkEqualMediaFilesAsOpened:
|
|
var_automaticallyMarkEqualMediaFilesAsOpened,
|
|
showNewsShortcut: var_showNewsShortcut,
|
|
showShowImagePreviewWhenSending: var_showShowImagePreviewWhenSending,
|
|
startWithCameraOpen: var_startWithCameraOpen,
|
|
preSelectedEmojies: var_preSelectedEmojies,
|
|
autoDownloadOptions: var_autoDownloadOptions,
|
|
storeMediaFilesInGallery: var_storeMediaFilesInGallery,
|
|
autoStoreAllSendUnlimitedMediaFiles:
|
|
var_autoStoreAllSendUnlimitedMediaFiles,
|
|
typingIndicators: var_typingIndicators,
|
|
showRestoreFlame: var_showRestoreFlame,
|
|
myBestFriendGroupId: var_myBestFriendGroupId,
|
|
signalLastSignedPreKeyUpdated: var_signalLastSignedPreKeyUpdated,
|
|
signalLastPqcPreKeysUploaded: var_signalLastPqcPreKeysUploaded,
|
|
allowErrorTrackingViaSentry: var_allowErrorTrackingViaSentry,
|
|
screenLockEnabled: var_screenLockEnabled,
|
|
isCloudBackupEnabled: var_isCloudBackupEnabled,
|
|
isUserDiscoveryEnabled: var_isUserDiscoveryEnabled,
|
|
requiredSendImages: var_requiredSendImages,
|
|
userDiscoveryThreshold: var_userDiscoveryThreshold,
|
|
userDiscoveryRequiresManualApproval:
|
|
var_userDiscoveryRequiresManualApproval,
|
|
userDiscoverySharePromotion: var_userDiscoverySharePromotion,
|
|
userDiscoveryInitializationError: var_userDiscoveryInitializationError,
|
|
askForFriendPromotions: var_askForFriendPromotions,
|
|
currentPreKeyIndexStart: var_currentPreKeyIndexStart,
|
|
currentSignedPreKeyIndexStart: var_currentSignedPreKeyIndexStart,
|
|
lastChangeLogHash: var_lastChangeLogHash,
|
|
hideChangeLog: var_hideChangeLog,
|
|
hideMemoriesBackupPromo: var_hideMemoriesBackupPromo,
|
|
updateFcmToken: var_updateFcmToken,
|
|
canUseLoginTokenForAuth: var_canUseLoginTokenForAuth,
|
|
twonlySafeBackup: var_twonlySafeBackup,
|
|
isBackupEnabled: var_isBackupEnabled,
|
|
passwordLessRecovery: var_passwordLessRecovery,
|
|
fcmToken: var_fcmToken,
|
|
currentSetupPage: var_currentSetupPage,
|
|
skipSetupPages: var_skipSetupPages,
|
|
hasZoomed: var_hasZoomed,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
UserConfigApi sse_decode_user_config_api(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return UserConfigApi();
|
|
}
|
|
|
|
@protected
|
|
BigInt sse_decode_usize(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getBigUint64();
|
|
}
|
|
|
|
@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_Chrono_Utc(DateTime self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_64(
|
|
PlatformInt64Util.from(self.microsecondsSinceEpoch),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void
|
|
sse_encode_DartFn_Inputs_String_String_i_64_String_Output_unit_AnyhowException(
|
|
FutureOr<void> Function(String, String, PlatformInt64, String) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_String_String_i_64_String_Output_unit_AnyhowException(
|
|
self,
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_DartFn_Inputs_String_i_64_Output_unit_AnyhowException(
|
|
FutureOr<void> Function(String, PlatformInt64) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_String_i_64_Output_unit_AnyhowException(self),
|
|
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_unit_AnyhowException(
|
|
FutureOr<void> Function(PlatformInt64) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_i_64_Output_unit_AnyhowException(self),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void
|
|
sse_encode_DartFn_Inputs_i_64_list_prim_u_8_strict_Output_unit_AnyhowException(
|
|
FutureOr<void> 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_unit_AnyhowException(
|
|
self,
|
|
),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_DartFn_Inputs_user_config_Output_unit_AnyhowException(
|
|
FutureOr<void> Function(UserConfig) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_DartOpaque(
|
|
encode_DartFn_Inputs_user_config_Output_unit_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_String_list_String_None(
|
|
Map<String, List<String>> self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_list_record_string_list_string(
|
|
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_StreamSink_api_event_Sse(
|
|
RustStreamSink<ApiEvent> self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(
|
|
self.setupAndSerialize(
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_api_event,
|
|
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_api_connection_state(
|
|
ApiConnectionState self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.index, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_api_event(ApiEvent self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_api_event_kind(self.kind, serializer);
|
|
sse_encode_opt_box_autoadd_api_connection_state(self.state, serializer);
|
|
sse_encode_opt_String(self.message, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_api_event_kind(ApiEventKind self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.index, 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_Chrono_Utc(
|
|
DateTime self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_Chrono_Utc(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_api_connection_state(
|
|
ApiConnectionState self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_api_connection_state(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_bool(bool self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_bool(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_f_64(double self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_f_64(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_frb_pre_key_bundle(
|
|
FrbPreKeyBundle self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_frb_pre_key_bundle(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_box_autoadd_passwordless_recovery_config(
|
|
PasswordlessRecoveryConfig self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_passwordless_recovery_config(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_twonly_safe_backup(
|
|
TwonlySafeBackup self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_twonly_safe_backup(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_u_32(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_u_32(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_user_config(
|
|
UserConfig self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_user_config(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_f_64(double self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putFloat64(self);
|
|
}
|
|
|
|
@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_frb_pqc_pre_key(FrbPqcPreKey self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_u_32(self.eccPreKeyId, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.eccPreKey, serializer);
|
|
sse_encode_u_32(self.kyberPreKeyId, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.kyberPreKey, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.kyberPreKeySignature, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_frb_pre_key_bundle(
|
|
FrbPreKeyBundle self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_u_32(self.registrationId, serializer);
|
|
sse_encode_u_32(self.deviceId, serializer);
|
|
sse_encode_opt_box_autoadd_u_32(self.preKeyId, serializer);
|
|
sse_encode_opt_list_prim_u_8_strict(self.preKeyPublic, serializer);
|
|
sse_encode_u_32(self.signedPreKeyId, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.signedPreKeyPublic, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.signedPreKeySignature, serializer);
|
|
sse_encode_u_32(self.kyberPreKeyId, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.kyberPreKeyPublic, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.kyberPreKeySignature, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.identityKey, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_i_32(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putInt32(self);
|
|
}
|
|
|
|
@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_last_backup_upload_state(
|
|
LastBackupUploadState self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.index, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_legacy_migration_report(
|
|
LegacyMigrationReport self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_64(self.legacyVersion, serializer);
|
|
sse_encode_list_legacy_table_migration_count(self.tables, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_legacy_table_migration_count(
|
|
LegacyTableMigrationCount self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.table, serializer);
|
|
sse_encode_i_64(self.rows, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_String(List<String> 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_String(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_frb_pqc_pre_key(
|
|
List<FrbPqcPreKey> 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_frb_pqc_pre_key(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_legacy_table_migration_count(
|
|
List<LegacyTableMigrationCount> 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_legacy_table_migration_count(item, serializer);
|
|
}
|
|
}
|
|
|
|
@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_pqc_pre_key_input(
|
|
List<PqcPreKeyInput> 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_pqc_pre_key_input(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_prim_i_64_strict(
|
|
Int64List self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
serializer.buffer.putInt64List(self);
|
|
}
|
|
|
|
@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_string_list_string(
|
|
List<(String, List<String>)> 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_string_list_string(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_sql_row(List<SqlRow> 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_sql_row(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_sql_value(
|
|
List<SqlValue> 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_sql_value(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_Map_String_list_String_None(
|
|
Map<String, List<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_Map_String_list_String_None(self, 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_Chrono_Utc(
|
|
DateTime? 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_Chrono_Utc(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_box_autoadd_api_connection_state(
|
|
ApiConnectionState? 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_api_connection_state(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_box_autoadd_bool(bool? 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_bool(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_box_autoadd_f_64(double? 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_f_64(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_box_autoadd_passwordless_recovery_config(
|
|
PasswordlessRecoveryConfig? 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_passwordless_recovery_config(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_box_autoadd_twonly_safe_backup(
|
|
TwonlySafeBackup? 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_twonly_safe_backup(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_box_autoadd_u_32(int? 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_u_32(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_box_autoadd_user_config(
|
|
UserConfig? 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_user_config(self, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_opt_list_String(
|
|
List<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_list_String(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_passwordless_recovery_config(
|
|
PasswordlessRecoveryConfig self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_opt_String(self.email, serializer);
|
|
sse_encode_i_64(self.threshold, serializer);
|
|
sse_encode_opt_list_prim_u_8_strict(self.serverKeyProtection, serializer);
|
|
sse_encode_opt_list_prim_u_8_strict(self.pinUnlockToken, serializer);
|
|
sse_encode_opt_box_autoadd_Chrono_Utc(self.lastServerHeartbeat, serializer);
|
|
sse_encode_opt_box_autoadd_Chrono_Utc(
|
|
self.lastContactHeartbeat,
|
|
serializer,
|
|
);
|
|
sse_encode_opt_list_prim_u_8_strict(self.encryptedServerKey, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_pqc_pre_key_input(
|
|
PqcPreKeyInput self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_64(self.eccPreKeyId, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.eccPreKey, serializer);
|
|
sse_encode_i_64(self.kyberPreKeyId, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.kyberPreKey, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.kyberPreKeySignature, 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_list_string(
|
|
(String, List<String>) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.$1, serializer);
|
|
sse_encode_list_String(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_api(RustApi self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_rust_app_database(
|
|
RustAppDatabase self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
|
|
@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_rust_signal(RustSignal self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_rust_utils(RustUtils self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_setup_profile(SetupProfile self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.index, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_sql_execution_result(
|
|
SqlExecutionResult self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_64(self.affectedRows, serializer);
|
|
sse_encode_i_64(self.lastInsertRowId, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_sql_row(SqlRow self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_list_sql_value(self.values, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_sql_rows(SqlRows self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_list_String(self.columns, serializer);
|
|
sse_encode_list_sql_row(self.rows, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_sql_value(SqlValue self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_u_8(self.kind, serializer);
|
|
sse_encode_opt_box_autoadd_i_64(self.integerValue, serializer);
|
|
sse_encode_opt_box_autoadd_f_64(self.realValue, serializer);
|
|
sse_encode_opt_String(self.textValue, serializer);
|
|
sse_encode_opt_list_prim_u_8_strict(self.blobValue, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_theme_mode(ThemeMode self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.index, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_twonly_safe_backup(
|
|
TwonlySafeBackup self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_64(self.lastBackupSize, serializer);
|
|
sse_encode_last_backup_upload_state(self.backupUploadState, serializer);
|
|
sse_encode_opt_box_autoadd_Chrono_Utc(self.lastBackupDone, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.backupId, serializer);
|
|
sse_encode_list_prim_u_8_strict(self.encryptionKey, serializer);
|
|
}
|
|
|
|
@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_64(BigInt self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putBigUint64(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_user_config(UserConfig self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_64(self.userId, serializer);
|
|
sse_encode_String(self.username, serializer);
|
|
sse_encode_String(self.displayName, serializer);
|
|
sse_encode_opt_String(self.avatarSvg, serializer);
|
|
sse_encode_i_64(self.appVersion, serializer);
|
|
sse_encode_i_64(self.avatarCounter, serializer);
|
|
sse_encode_bool(self.videoStabilizationEnabled, serializer);
|
|
sse_encode_bool(self.isDeveloper, serializer);
|
|
sse_encode_i_64(self.deviceId, serializer);
|
|
sse_encode_setup_profile(self.setupProfile, serializer);
|
|
sse_encode_String(self.subscriptionPlan, serializer);
|
|
sse_encode_opt_String(self.subscriptionPlanIdStore, serializer);
|
|
sse_encode_opt_box_autoadd_Chrono_Utc(self.lastImageSend, serializer);
|
|
sse_encode_opt_box_autoadd_i_64(self.todaysImageCounter, serializer);
|
|
sse_encode_opt_String(self.lastPlanBallance, serializer);
|
|
sse_encode_opt_String(self.additionalUserInvites, serializer);
|
|
sse_encode_theme_mode(self.themeMode, serializer);
|
|
sse_encode_opt_box_autoadd_i_64(self.primaryColorValue, serializer);
|
|
sse_encode_opt_box_autoadd_i_64(self.defaultShowTime, serializer);
|
|
sse_encode_bool(self.requestedAudioPermission, serializer);
|
|
sse_encode_bool(self.enableDatabaseLogging, serializer);
|
|
sse_encode_bool(self.automaticallyMarkEqualMediaFilesAsOpened, serializer);
|
|
sse_encode_bool(self.showNewsShortcut, serializer);
|
|
sse_encode_bool(self.showShowImagePreviewWhenSending, serializer);
|
|
sse_encode_bool(self.startWithCameraOpen, serializer);
|
|
sse_encode_opt_list_String(self.preSelectedEmojies, serializer);
|
|
sse_encode_opt_Map_String_list_String_None(
|
|
self.autoDownloadOptions,
|
|
serializer,
|
|
);
|
|
sse_encode_bool(self.storeMediaFilesInGallery, serializer);
|
|
sse_encode_bool(self.autoStoreAllSendUnlimitedMediaFiles, serializer);
|
|
sse_encode_bool(self.typingIndicators, serializer);
|
|
sse_encode_bool(self.showRestoreFlame, serializer);
|
|
sse_encode_opt_String(self.myBestFriendGroupId, serializer);
|
|
sse_encode_opt_box_autoadd_Chrono_Utc(
|
|
self.signalLastSignedPreKeyUpdated,
|
|
serializer,
|
|
);
|
|
sse_encode_opt_box_autoadd_Chrono_Utc(
|
|
self.signalLastPqcPreKeysUploaded,
|
|
serializer,
|
|
);
|
|
sse_encode_bool(self.allowErrorTrackingViaSentry, serializer);
|
|
sse_encode_bool(self.screenLockEnabled, serializer);
|
|
sse_encode_bool(self.isCloudBackupEnabled, serializer);
|
|
sse_encode_bool(self.isUserDiscoveryEnabled, serializer);
|
|
sse_encode_i_64(self.requiredSendImages, serializer);
|
|
sse_encode_u_8(self.userDiscoveryThreshold, serializer);
|
|
sse_encode_bool(self.userDiscoveryRequiresManualApproval, serializer);
|
|
sse_encode_bool(self.userDiscoverySharePromotion, serializer);
|
|
sse_encode_bool(self.userDiscoveryInitializationError, serializer);
|
|
sse_encode_bool(self.askForFriendPromotions, serializer);
|
|
sse_encode_i_64(self.currentPreKeyIndexStart, serializer);
|
|
sse_encode_i_64(self.currentSignedPreKeyIndexStart, serializer);
|
|
sse_encode_opt_list_prim_u_8_strict(self.lastChangeLogHash, serializer);
|
|
sse_encode_bool(self.hideChangeLog, serializer);
|
|
sse_encode_bool(self.hideMemoriesBackupPromo, serializer);
|
|
sse_encode_bool(self.updateFcmToken, serializer);
|
|
sse_encode_bool(self.canUseLoginTokenForAuth, serializer);
|
|
sse_encode_opt_box_autoadd_twonly_safe_backup(
|
|
self.twonlySafeBackup,
|
|
serializer,
|
|
);
|
|
sse_encode_bool(self.isBackupEnabled, serializer);
|
|
sse_encode_opt_box_autoadd_passwordless_recovery_config(
|
|
self.passwordLessRecovery,
|
|
serializer,
|
|
);
|
|
sse_encode_opt_String(self.fcmToken, serializer);
|
|
sse_encode_opt_String(self.currentSetupPage, serializer);
|
|
sse_encode_bool(self.skipSetupPages, serializer);
|
|
sse_encode_bool(self.hasZoomed, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_user_config_api(
|
|
UserConfigApi 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);
|
|
}
|
|
}
|