twonly-app/lib/core/bridge/api.dart

// This file is automatically generated, so please do not edit it.
// @generated by `flutter_rust_bridge`@ 2.12.0.

// ignore_for_file: invalid_use_of_internal_member, unused_import, unnecessary_import

import '../api/server/prekeys.dart';
import '../frb_generated.dart';

import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart';
import 'package:freezed_annotation/freezed_annotation.dart' hide protected;
part 'api.freezed.dart';

// These functions are ignored because they are not marked as `pub`: `from_rust_state`
// These types are ignored because they are neither used by any `pub` functions nor (for structs and enums) marked `#[frb(unignore)]`: `ApiConfig`, `ServerResult`
// These function are ignored because they are on traits that is not defined in current crate (put an empty `#[frb]` on it to unignore): `assert_fields_are_eq`, `assert_fields_are_eq`, `clone`, `clone`, `clone`, `clone`, `eq`, `eq`, `fmt`, `fmt`, `fmt`, `fmt`
// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `into_bridge`, `into_bridge`, `into_bridge`, `into_bridge`, `into_bridge`, `into_bridge`, `into_bridge`, `into_bridge`

enum ApiConnectionState {
  stopped,
  connecting,
  connected,
  authenticating,
  authenticated,
  reconnecting,
  suspended,
  permanentlyRejected,
}

class ApiEvent {
  final ApiEventKind kind;
  final ApiConnectionState? state;
  final String? message;

  const ApiEvent({
    required this.kind,
    this.state,
    this.message,
  });

  @override
  int get hashCode => kind.hashCode ^ state.hashCode ^ message.hashCode;

  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      other is ApiEvent &&
          runtimeType == other.runtimeType &&
          kind == other.kind &&
          state == other.state &&
          message == other.message;
}

enum ApiEventKind {
  connectionStateChanged,
  transportError,
  authenticated,
  planUpdated,
  appOutdated,
  newDeviceRegistered,
  loginTokenMigrated,
}

class PreparedOutgoingMessage {
  final Uint8List message;
  final Uint8List? pushData;

  const PreparedOutgoingMessage({
    required this.message,
    this.pushData,
  });

  @override
  int get hashCode => message.hashCode ^ pushData.hashCode;

  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      other is PreparedOutgoingMessage &&
          runtimeType == other.runtimeType &&
          message == other.message &&
          pushData == other.pushData;
}

/// Flutter-facing facade for the Rust-owned API runtime.
class RustApi {
  const RustApi();

  static Future<ServerResultEmpty> addAdditionalUser({
    required PlatformInt64 userId,
  }) => RustLib.instance.api.crateBridgeApiRustApiAddAdditionalUser(
    userId: userId,
  );

  static Future<BigInt> allocateSequence() =>
      RustLib.instance.api.crateBridgeApiRustApiAllocateSequence();

  static String apiBaseUrl({required String protocol}) =>
      RustLib.instance.api.crateBridgeApiRustApiApiBaseUrl(protocol: protocol);

  static Future<ServerResultEmpty> changeUsername({required String username}) =>
      RustLib.instance.api.crateBridgeApiRustApiChangeUsername(
        username: username,
      );

  static Future<void> checkForDeletedUsernames() =>
      RustLib.instance.api.crateBridgeApiRustApiCheckForDeletedUsernames();

  static Future<ServerResultVecU8> checkForPasswordlessNotification({
    required String notificationId,
    required List<int> downloadAuthToken,
    required Int64List alreadyReceivedMessageIds,
  }) => RustLib.instance.api
      .crateBridgeApiRustApiCheckForPasswordlessNotification(
        notificationId: notificationId,
        downloadAuthToken: downloadAuthToken,
        alreadyReceivedMessageIds: alreadyReceivedMessageIds,
      );

  static Future<void> close() =>
      RustLib.instance.api.crateBridgeApiRustApiClose();

  static Future<ServerResultEmpty> confirmMemoriesUpload({
    required String mediaId,
  }) => RustLib.instance.api.crateBridgeApiRustApiConfirmMemoriesUpload(
    mediaId: mediaId,
  );

  static Future<void> connect() =>
      RustLib.instance.api.crateBridgeApiRustApiConnect();

  static Future<ApiConnectionState> connectionState() =>
      RustLib.instance.api.crateBridgeApiRustApiConnectionState();

  static Future<ServerResultEmpty> deleteAccount() =>
      RustLib.instance.api.crateBridgeApiRustApiDeleteAccount();

  static Future<ServerResultEmpty> deleteMemory({required String mediaId}) =>
      RustLib.instance.api.crateBridgeApiRustApiDeleteMemory(mediaId: mediaId);

  static Future<ServerResultEmpty> disableMemoriesBackup() =>
      RustLib.instance.api.crateBridgeApiRustApiDisableMemoriesBackup();

  static Future<ServerResultEmpty> downloadDone({required List<int> token}) =>
      RustLib.instance.api.crateBridgeApiRustApiDownloadDone(token: token);

  static Stream<ApiEvent> events() =>
      RustLib.instance.api.crateBridgeApiRustApiEvents();

  static Future<ServerResultEmpty> forceIpaCheck() =>
      RustLib.instance.api.crateBridgeApiRustApiForceIpaCheck();

  static Future<ServerResultVecU8> getMemoriesUrl({
    required String mediaId,
    required bool thumbnail,
  }) => RustLib.instance.api.crateBridgeApiRustApiGetMemoriesUrl(
    mediaId: mediaId,
    thumbnail: thumbnail,
  );

  static Future<ServerResultVecU8> getMemoriesUsage() =>
      RustLib.instance.api.crateBridgeApiRustApiGetMemoriesUsage();

  static Future<Uint8List> getPlanBalance() =>
      RustLib.instance.api.crateBridgeApiRustApiGetPlanBalance();

  static Future<ServerResultVecU8> getProofOfWork() =>
      RustLib.instance.api.crateBridgeApiRustApiGetProofOfWork();

  static Future<ServerResultVecU8> getServerKeyForPasswordlessRecovery({
    required PlatformInt64 userId,
    required List<int> serverKeyProtection,
    Uint8List? pinUnlockToken,
    Uint8List? pinProtectionKey,
    String? email,
  }) => RustLib.instance.api
      .crateBridgeApiRustApiGetServerKeyForPasswordlessRecovery(
        userId: userId,
        serverKeyProtection: serverKeyProtection,
        pinUnlockToken: pinUnlockToken,
        pinProtectionKey: pinProtectionKey,
        email: email,
      );

  static Future<ServerResultVecU8> getUserById({
    required PlatformInt64 userId,
  }) => RustLib.instance.api.crateBridgeApiRustApiGetUserById(userId: userId);

  static Future<ServerResultVecU8> getUserData({required String username}) =>
      RustLib.instance.api.crateBridgeApiRustApiGetUserData(username: username);

  static Future<ServerResultI64> getUserIdFromUsername({
    required String username,
  }) => RustLib.instance.api.crateBridgeApiRustApiGetUserIdFromUsername(
    username: username,
  );

  static Future<String> insertAndSendAdditionalData({
    required String groupId,
    required String messageType,
    required List<int> additionalData,
  }) => RustLib.instance.api.crateBridgeApiRustApiInsertAndSendAdditionalData(
    groupId: groupId,
    messageType: messageType,
    additionalData: additionalData,
  );

  static Future<String> insertAndSendAskAboutUser({
    required PlatformInt64 contactId,
    required PlatformInt64 askAboutUserId,
  }) => RustLib.instance.api.crateBridgeApiRustApiInsertAndSendAskAboutUser(
    contactId: contactId,
    askAboutUserId: askAboutUserId,
  );

  static Future<String> insertAndSendContactShare({
    required String groupId,
    required Int64List contactIds,
  }) => RustLib.instance.api.crateBridgeApiRustApiInsertAndSendContactShare(
    groupId: groupId,
    contactIds: contactIds,
  );

  static Future<String> insertAndSendText({
    required String groupId,
    required String text,
    String? quoteMessageId,
  }) => RustLib.instance.api.crateBridgeApiRustApiInsertAndSendText(
    groupId: groupId,
    text: text,
    quoteMessageId: quoteMessageId,
  );

  static Future<Uint8List> ipaPurchase({
    required String productId,
    required String source,
    required String verificationData,
  }) => RustLib.instance.api.crateBridgeApiRustApiIpaPurchase(
    productId: productId,
    source: source,
    verificationData: verificationData,
  );

  static Future<Uint8List> loadPlanBalance({required bool useCache}) => RustLib
      .instance
      .api
      .crateBridgeApiRustApiLoadPlanBalance(useCache: useCache);

  static Future<void> notifyMessagesOpened({
    required PlatformInt64 contactId,
    required List<String> messageIds,
  }) => RustLib.instance.api.crateBridgeApiRustApiNotifyMessagesOpened(
    contactId: contactId,
    messageIds: messageIds,
  );

  static Future<PreparedOutgoingMessage?> prepareQueuedMessage({
    required String receiptId,
  }) => RustLib.instance.api.crateBridgeApiRustApiPrepareQueuedMessage(
    receiptId: receiptId,
  );

  static Future<ServerResultI64> register({
    required String username,
    required PlatformInt64 proofOfWork,
    required String langCode,
    required bool isIos,
  }) => RustLib.instance.api.crateBridgeApiRustApiRegister(
    username: username,
    proofOfWork: proofOfWork,
    langCode: langCode,
    isIos: isIos,
  );

  static Future<ServerResultEmpty> registerPasswordlessNotification({
    required String notificationId,
    required List<int> downloadAuthToken,
    required String langCode,
    String? googleFcm,
  }) => RustLib.instance.api
      .crateBridgeApiRustApiRegisterPasswordlessNotification(
        notificationId: notificationId,
        downloadAuthToken: downloadAuthToken,
        langCode: langCode,
        googleFcm: googleFcm,
      );

  static Future<ServerResultEmpty> registerPasswordlessRecovery({
    required List<int> encryptedServerKey,
    Uint8List? pinUnlockToken,
  }) => RustLib.instance.api.crateBridgeApiRustApiRegisterPasswordlessRecovery(
    encryptedServerKey: encryptedServerKey,
    pinUnlockToken: pinUnlockToken,
  );

  /// Reloads identity and authentication settings from Rust-owned storage.
  /// No configuration values are accepted from the caller.
  static Future<void> reloadConfiguration() =>
      RustLib.instance.api.crateBridgeApiRustApiReloadConfiguration();

  static Future<ServerResultEmpty> removeAdditionalUser({
    required PlatformInt64 userId,
  }) => RustLib.instance.api.crateBridgeApiRustApiRemoveAdditionalUser(
    userId: userId,
  );

  static Future<ServerResultEmpty> reportUser({
    required PlatformInt64 userId,
    required String reason,
  }) => RustLib.instance.api.crateBridgeApiRustApiReportUser(
    userId: userId,
    reason: reason,
  );

  /// Sends a protobuf ClientToServer envelope. Rust assigns the sequence ID
  /// and resolves this future with the matching ServerToClient response.
  static Future<Uint8List> requestBinary({required List<int> bytes}) =>
      RustLib.instance.api.crateBridgeApiRustApiRequestBinary(bytes: bytes);

  static Future<void> requestContactByUsername({required String username}) =>
      RustLib.instance.api.crateBridgeApiRustApiRequestContactByUsername(
        username: username,
      );

  static Future<ServerResultVecU8> requestMemoriesUpload({
    required PlatformInt64 size,
    required PlatformInt64 originalDate,
    required String mediaId,
  }) => RustLib.instance.api.crateBridgeApiRustApiRequestMemoriesUpload(
    size: size,
    originalDate: originalDate,
    mediaId: mediaId,
  );

  static Future<void> retransmitAllMessages() =>
      RustLib.instance.api.crateBridgeApiRustApiRetransmitAllMessages();

  static Future<void> sendBinary({required List<int> bytes}) =>
      RustLib.instance.api.crateBridgeApiRustApiSendBinary(bytes: bytes);

  static Future<void> sendContactProfile({required PlatformInt64 contactId}) =>
      RustLib.instance.api.crateBridgeApiRustApiSendContactProfile(
        contactId: contactId,
      );

  static Future<PreparedOutgoingMessage?> sendEncryptedContent({
    required PlatformInt64 contactId,
    required List<int> content,
    String? messageId,
    required bool onlySendIfNoReceiptsAreOpen,
    required bool onlyReturnEncryptedData,
    required bool blocking,
  }) => RustLib.instance.api.crateBridgeApiRustApiSendEncryptedContent(
    contactId: contactId,
    content: content,
    messageId: messageId,
    onlySendIfNoReceiptsAreOpen: onlySendIfNoReceiptsAreOpen,
    onlyReturnEncryptedData: onlyReturnEncryptedData,
    blocking: blocking,
  );

  static Future<void> sendEncryptedContentToGroup({
    required String groupId,
    required List<int> content,
    String? messageId,
    required bool onlySendIfNoReceiptsAreOpen,
  }) => RustLib.instance.api.crateBridgeApiRustApiSendEncryptedContentToGroup(
    groupId: groupId,
    content: content,
    messageId: messageId,
    onlySendIfNoReceiptsAreOpen: onlySendIfNoReceiptsAreOpen,
  );

  static Future<void> sendQueuedMessage({required String receiptId}) => RustLib
      .instance
      .api
      .crateBridgeApiRustApiSendQueuedMessage(receiptId: receiptId);

  static Future<ServerResultEmpty> sendTextMessage({
    required PlatformInt64 userId,
    required List<int> body,
    Uint8List? pushData,
  }) => RustLib.instance.api.crateBridgeApiRustApiSendTextMessage(
    userId: userId,
    body: body,
    pushData: pushData,
  );

  static Future<void> sendTyping({
    required String groupId,
    required bool isTyping,
  }) => RustLib.instance.api.crateBridgeApiRustApiSendTyping(
    groupId: groupId,
    isTyping: isTyping,
  );

  static Future<void> setBackground({required bool inBackground}) => RustLib
      .instance
      .api
      .crateBridgeApiRustApiSetBackground(inBackground: inBackground);

  static Future<ServerResultEmpty> setLoginToken({required List<int> token}) =>
      RustLib.instance.api.crateBridgeApiRustApiSetLoginToken(token: token);

  static Future<void> setNetworkAvailable({required bool available}) => RustLib
      .instance
      .api
      .crateBridgeApiRustApiSetNetworkAvailable(available: available);

  static Future<ServerResultEmpty> submitRecoveryShare({
    required String notificationId,
    required List<int> encryptedMessage,
  }) => RustLib.instance.api.crateBridgeApiRustApiSubmitRecoveryShare(
    notificationId: notificationId,
    encryptedMessage: encryptedMessage,
  );

  static Future<ServerResultEmpty> updateFcmToken({required String token}) =>
      RustLib.instance.api.crateBridgeApiRustApiUpdateFcmToken(token: token);

  static Future<Uint8List> updateSignedPreKey({
    required PlatformInt64 id,
    required List<int> key,
    required List<int> signature,
  }) => RustLib.instance.api.crateBridgeApiRustApiUpdateSignedPreKey(
    id: id,
    key: key,
    signature: signature,
  );

  static Future<Uint8List> uploadPqcPreKeys({
    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,
  }) => RustLib.instance.api.crateBridgeApiRustApiUploadPqcPreKeys(
    eccSignedPrekeyId: eccSignedPrekeyId,
    eccSignedPrekey: eccSignedPrekey,
    eccSignedPrekeySignature: eccSignedPrekeySignature,
    kyberSignedPrekeyId: kyberSignedPrekeyId,
    kyberSignedPrekey: kyberSignedPrekey,
    kyberSignedPrekeySignature: kyberSignedPrekeySignature,
    prekeys: prekeys,
  );

  @override
  int get hashCode => 0;

  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      other is RustApi && runtimeType == other.runtimeType;
}

@freezed
sealed class ServerResultEmpty with _$ServerResultEmpty {
  const ServerResultEmpty._();

  const factory ServerResultEmpty.ok() = ServerResultEmpty_Ok;
  const factory ServerResultEmpty.errorCode(
    int field0,
  ) = ServerResultEmpty_ErrorCode;
}

@freezed
sealed class ServerResultI64 with _$ServerResultI64 {
  const ServerResultI64._();

  const factory ServerResultI64.ok(
    PlatformInt64 field0,
  ) = ServerResultI64_Ok;
  const factory ServerResultI64.errorCode(
    int field0,
  ) = ServerResultI64_ErrorCode;
}

@freezed
sealed class ServerResultVecU8 with _$ServerResultVecU8 {
  const ServerResultVecU8._();

  const factory ServerResultVecU8.ok(
    Uint8List field0,
  ) = ServerResultVecU8_Ok;
  const factory ServerResultVecU8.errorCode(
    int field0,
  ) = ServerResultVecU8_ErrorCode;
}