// Autogenerated from Pigeon (v17.3.0), do not edit directly.
// See also: https://pub.dev/packages/pigeon

import Foundation

#if os(iOS)
  import Flutter
#elseif os(macOS)
  import FlutterMacOS
#else
  #error("Unsupported platform.")
#endif

private func wrapResult(_ result: Any?) -> [Any?] {
  return [result]
}

private func wrapError(_ error: Any) -> [Any?] {
  if let flutterError = error as? FlutterError {
    return [
      flutterError.code,
      flutterError.message,
      flutterError.details,
    ]
  }
  return [
    "\(error)",
    "\(type(of: error))",
    "Stacktrace: \(Thread.callStackSymbols)",
  ]
}

private func isNullish(_ value: Any?) -> Bool {
  return value is NSNull || value == nil
}

private func nilOrValue<T>(_ value: Any?) -> T? {
  if value is NSNull { return nil }
  return value as! T?
}

enum MobileKeysScanMode: Int {
  case optimizePerformance = 0
  case optimizePowerConsumption = 1
}

enum OpeningType: Int {
  case unknown = 0
  case proximity = 1
  case motion = 2
  case seamless = 3
  case applicationSpecific = 4
  case enhancedTap = 5
}

enum MobileKeysInfoType: Int {
  /// Bluetooth services is not authorized by user. Recommended user action is to change permissions.
  case bleNotSupported = 0
  /// Bluetooth services is not authorized by this device. Recommended user action is to change device.
  case bleTurnedOff = 1
  /// Location services is not enabled in app project settings. Recommended developer action is to change project settings.
  case locationServicesNotEnabled = 2
  /// Location services authorization is not determined by user. Recommended developer action is to call requestAlwaysAuthorization.
  case locationServicesNotDetermined = 3
  /// Location services is not authorized by user. Recommended user action is to change permissions.
  case locationServicesTurnedOff = 4
  /// CLBeaconRegion monitoring or ranging is not supported by this device. Recommended user action is to change device.
  case locationMonitoringNotSupported = 5
  /// CLBeaconRegion monitoring or ranging is not authorized by the user. Recommended user action is to change permissions.
  case locationMonitoringTurnedOff = 6
  /// Passcode may be turned off. This cannot be verified 100% reliably, but this could be an indication that the phone is not protected by a password.
  case passcodeWarning = 7
  /// Bluetooth sharing authorization for BLE Peripheral mode has not been granted. This should only happen when using Enhanced Tap. Recommended user action is to go to App System Settings and enable Bluetooth Sharing.
  case bleSharingTurnedOff = 8
}

enum MobileKeysEnvironmentType: Int {
  case prod = 0
  case demo = 1
  case test = 2
  case dev = 3
  case local = 4
  case staging = 5
  case acceptance = 6
  case unknown = 7
}

enum MobileKeysReaderType: Int {
  case blePeripheral = 0
  case bleCentral = 1
  case httpRest = 2
}

enum BleProtocol: Int {
  case legacy = 0
  case v1 = 1
  case unknown = 2
}

/// Generated class from Pigeon that represents data sent in messages.
struct MobileKeysOpeningType {
  var openingType: OpeningType

  static func fromList(_ list: [Any?]) -> MobileKeysOpeningType? {
    let openingType = OpeningType(rawValue: list[0] as! Int)!

    return MobileKeysOpeningType(
      openingType: openingType
    )
  }
  func toList() -> [Any?] {
    return [
      openingType.rawValue
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct DataTypeDate {
  var date: String
  var format: String

  static func fromList(_ list: [Any?]) -> DataTypeDate? {
    let date = list[0] as! String
    let format = list[1] as! String

    return DataTypeDate(
      date: date,
      format: format
    )
  }
  func toList() -> [Any?] {
    return [
      date,
      format,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MobileKeysKey {
  var credentialType: Int64
  var beginDate: DataTypeDate? = nil
  var endDate: DataTypeDate? = nil
  var keyId: String? = nil
  var externalId: String? = nil
  var label: String? = nil
  var configUrl: String? = nil
  var readbackUrl: String? = nil
  var issuer: String? = nil
  var keyType: String? = nil
  var cardNumber: String? = nil
  var active: Bool

  static func fromList(_ list: [Any?]) -> MobileKeysKey? {
    let credentialType = list[0] is Int64 ? list[0] as! Int64 : Int64(list[0] as! Int32)
    var beginDate: DataTypeDate? = nil
    if let beginDateList: [Any?] = nilOrValue(list[1]) {
      beginDate = DataTypeDate.fromList(beginDateList)
    }
    var endDate: DataTypeDate? = nil
    if let endDateList: [Any?] = nilOrValue(list[2]) {
      endDate = DataTypeDate.fromList(endDateList)
    }
    let keyId: String? = nilOrValue(list[3])
    let externalId: String? = nilOrValue(list[4])
    let label: String? = nilOrValue(list[5])
    let configUrl: String? = nilOrValue(list[6])
    let readbackUrl: String? = nilOrValue(list[7])
    let issuer: String? = nilOrValue(list[8])
    let keyType: String? = nilOrValue(list[9])
    let cardNumber: String? = nilOrValue(list[10])
    let active = list[11] as! Bool

    return MobileKeysKey(
      credentialType: credentialType,
      beginDate: beginDate,
      endDate: endDate,
      keyId: keyId,
      externalId: externalId,
      label: label,
      configUrl: configUrl,
      readbackUrl: readbackUrl,
      issuer: issuer,
      keyType: keyType,
      cardNumber: cardNumber,
      active: active
    )
  }
  func toList() -> [Any?] {
    return [
      credentialType,
      beginDate?.toList(),
      endDate?.toList(),
      keyId,
      externalId,
      label,
      configUrl,
      readbackUrl,
      issuer,
      keyType,
      cardNumber,
      active,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MobileKeysEndpointInfo {
  var endpointId: Int64
  var mobileKeysEnvironmentType: MobileKeysEnvironmentType
  var seosAppletVersion: String
  var fileSystemAppletVersion: String
  var toolsAppletVersion: String
  var javaCardVersion: String
  var optionFlags: String
  var allocatedFileSystemSize: Int64
  var currentTopOfFileSystem: Int64
  var snmpBufferSize: Int64
  var remainingEPROMSize: Int64
  var remainingTransientObjectSpace: Int64
  var hashAlg: Int64? = nil
  var encAlg: Int64? = nil
  var lastServerSyncDate: DataTypeDate? = nil

  static func fromList(_ list: [Any?]) -> MobileKeysEndpointInfo? {
    let endpointId = list[0] is Int64 ? list[0] as! Int64 : Int64(list[0] as! Int32)
    let mobileKeysEnvironmentType = MobileKeysEnvironmentType(rawValue: list[1] as! Int)!
    let seosAppletVersion = list[2] as! String
    let fileSystemAppletVersion = list[3] as! String
    let toolsAppletVersion = list[4] as! String
    let javaCardVersion = list[5] as! String
    let optionFlags = list[6] as! String
    let allocatedFileSystemSize = list[7] is Int64 ? list[7] as! Int64 : Int64(list[7] as! Int32)
    let currentTopOfFileSystem = list[8] is Int64 ? list[8] as! Int64 : Int64(list[8] as! Int32)
    let snmpBufferSize = list[9] is Int64 ? list[9] as! Int64 : Int64(list[9] as! Int32)
    let remainingEPROMSize = list[10] is Int64 ? list[10] as! Int64 : Int64(list[10] as! Int32)
    let remainingTransientObjectSpace = list[11] is Int64 ? list[11] as! Int64 : Int64(list[11] as! Int32)
    let hashAlg: Int64? = isNullish(list[12]) ? nil : (list[12] is Int64? ? list[12] as! Int64? : Int64(list[12] as! Int32))
    let encAlg: Int64? = isNullish(list[13]) ? nil : (list[13] is Int64? ? list[13] as! Int64? : Int64(list[13] as! Int32))
    var lastServerSyncDate: DataTypeDate? = nil
    if let lastServerSyncDateList: [Any?] = nilOrValue(list[14]) {
      lastServerSyncDate = DataTypeDate.fromList(lastServerSyncDateList)
    }

    return MobileKeysEndpointInfo(
      endpointId: endpointId,
      mobileKeysEnvironmentType: mobileKeysEnvironmentType,
      seosAppletVersion: seosAppletVersion,
      fileSystemAppletVersion: fileSystemAppletVersion,
      toolsAppletVersion: toolsAppletVersion,
      javaCardVersion: javaCardVersion,
      optionFlags: optionFlags,
      allocatedFileSystemSize: allocatedFileSystemSize,
      currentTopOfFileSystem: currentTopOfFileSystem,
      snmpBufferSize: snmpBufferSize,
      remainingEPROMSize: remainingEPROMSize,
      remainingTransientObjectSpace: remainingTransientObjectSpace,
      hashAlg: hashAlg,
      encAlg: encAlg,
      lastServerSyncDate: lastServerSyncDate
    )
  }
  func toList() -> [Any?] {
    return [
      endpointId,
      mobileKeysEnvironmentType.rawValue,
      seosAppletVersion,
      fileSystemAppletVersion,
      toolsAppletVersion,
      javaCardVersion,
      optionFlags,
      allocatedFileSystemSize,
      currentTopOfFileSystem,
      snmpBufferSize,
      remainingEPROMSize,
      remainingTransientObjectSpace,
      hashAlg,
      encAlg,
      lastServerSyncDate?.toList(),
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MobileKeysLastAuthenticationInfo {
  var lastAuthenticatedMobileKey: MobileKeysKey
  var isModified: Bool
  var authenticationCounter: Int64

  static func fromList(_ list: [Any?]) -> MobileKeysLastAuthenticationInfo? {
    let lastAuthenticatedMobileKey = MobileKeysKey.fromList(list[0] as! [Any?])!
    let isModified = list[1] as! Bool
    let authenticationCounter = list[2] is Int64 ? list[2] as! Int64 : Int64(list[2] as! Int32)

    return MobileKeysLastAuthenticationInfo(
      lastAuthenticatedMobileKey: lastAuthenticatedMobileKey,
      isModified: isModified,
      authenticationCounter: authenticationCounter
    )
  }
  func toList() -> [Any?] {
    return [
      lastAuthenticatedMobileKey.toList(),
      isModified,
      authenticationCounter,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MobileKeysTimeoutConfiguration {
  var maxTimeBetweenFragments: Double
  var maxTimeBetweenApdus: Double
  var maxConnectionTime: Double

  static func fromList(_ list: [Any?]) -> MobileKeysTimeoutConfiguration? {
    let maxTimeBetweenFragments = list[0] as! Double
    let maxTimeBetweenApdus = list[1] as! Double
    let maxConnectionTime = list[2] as! Double

    return MobileKeysTimeoutConfiguration(
      maxTimeBetweenFragments: maxTimeBetweenFragments,
      maxTimeBetweenApdus: maxTimeBetweenApdus,
      maxConnectionTime: maxConnectionTime
    )
  }
  func toList() -> [Any?] {
    return [
      maxTimeBetweenFragments,
      maxTimeBetweenApdus,
      maxConnectionTime,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MobileKeysRssiMeasurement {
  var rssiValue: Int64
  var measuredAtIntervalSince1970: Double

  static func fromList(_ list: [Any?]) -> MobileKeysRssiMeasurement? {
    let rssiValue = list[0] is Int64 ? list[0] as! Int64 : Int64(list[0] as! Int32)
    let measuredAtIntervalSince1970 = list[1] as! Double

    return MobileKeysRssiMeasurement(
      rssiValue: rssiValue,
      measuredAtIntervalSince1970: measuredAtIntervalSince1970
    )
  }
  func toList() -> [Any?] {
    return [
      rssiValue,
      measuredAtIntervalSince1970,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MobileKeysReader {
  var rssiValueLimitsForOpeningTypeKeys: [Int64?: Int64?]
  var uuid: String? = nil
  var readerCanConnect: Bool
  var latestRssiMeasurement: MobileKeysRssiMeasurement? = nil
  var lastSuccessfulConnection: DataTypeDate? = nil
  var name: String? = nil
  var localName: String? = nil
  var supportedOpeningTypes: [Int64?]
  var lastRSSIUpdate: DataTypeDate? = nil
  var readerType: MobileKeysReaderType
  var optionalScanResponseData: FlutterStandardTypedData? = nil
  var serialNumberData: FlutterStandardTypedData? = nil
  var appSpecificData: FlutterStandardTypedData? = nil
  var protocolVersion: BleProtocol
  var txPowerLevel: Int64

  static func fromList(_ list: [Any?]) -> MobileKeysReader? {
    let rssiValueLimitsForOpeningTypeKeys = list[0] as! [Int64?: Int64?]
    let uuid: String? = nilOrValue(list[1])
    let readerCanConnect = list[2] as! Bool
    var latestRssiMeasurement: MobileKeysRssiMeasurement? = nil
    if let latestRssiMeasurementList: [Any?] = nilOrValue(list[3]) {
      latestRssiMeasurement = MobileKeysRssiMeasurement.fromList(latestRssiMeasurementList)
    }
    var lastSuccessfulConnection: DataTypeDate? = nil
    if let lastSuccessfulConnectionList: [Any?] = nilOrValue(list[4]) {
      lastSuccessfulConnection = DataTypeDate.fromList(lastSuccessfulConnectionList)
    }
    let name: String? = nilOrValue(list[5])
    let localName: String? = nilOrValue(list[6])
    let supportedOpeningTypes = list[7] as! [Int64?]
    var lastRSSIUpdate: DataTypeDate? = nil
    if let lastRSSIUpdateList: [Any?] = nilOrValue(list[8]) {
      lastRSSIUpdate = DataTypeDate.fromList(lastRSSIUpdateList)
    }
    let readerType = MobileKeysReaderType(rawValue: list[9] as! Int)!
    let optionalScanResponseData: FlutterStandardTypedData? = nilOrValue(list[10])
    let serialNumberData: FlutterStandardTypedData? = nilOrValue(list[11])
    let appSpecificData: FlutterStandardTypedData? = nilOrValue(list[12])
    let protocolVersion = BleProtocol(rawValue: list[13] as! Int)!
    let txPowerLevel = list[14] is Int64 ? list[14] as! Int64 : Int64(list[14] as! Int32)

    return MobileKeysReader(
      rssiValueLimitsForOpeningTypeKeys: rssiValueLimitsForOpeningTypeKeys,
      uuid: uuid,
      readerCanConnect: readerCanConnect,
      latestRssiMeasurement: latestRssiMeasurement,
      lastSuccessfulConnection: lastSuccessfulConnection,
      name: name,
      localName: localName,
      supportedOpeningTypes: supportedOpeningTypes,
      lastRSSIUpdate: lastRSSIUpdate,
      readerType: readerType,
      optionalScanResponseData: optionalScanResponseData,
      serialNumberData: serialNumberData,
      appSpecificData: appSpecificData,
      protocolVersion: protocolVersion,
      txPowerLevel: txPowerLevel
    )
  }
  func toList() -> [Any?] {
    return [
      rssiValueLimitsForOpeningTypeKeys,
      uuid,
      readerCanConnect,
      latestRssiMeasurement?.toList(),
      lastSuccessfulConnection?.toList(),
      name,
      localName,
      supportedOpeningTypes,
      lastRSSIUpdate?.toList(),
      readerType.rawValue,
      optionalScanResponseData,
      serialNumberData,
      appSpecificData,
      protocolVersion.rawValue,
      txPowerLevel,
    ]
  }
}

private class AppUsageAPICodecReader: FlutterStandardReader {
  override func readValue(ofType type: UInt8) -> Any? {
    switch type {
    case 128:
      return DataTypeDate.fromList(self.readValue() as! [Any?])
    case 129:
      return MobileKeysEndpointInfo.fromList(self.readValue() as! [Any?])
    case 130:
      return MobileKeysKey.fromList(self.readValue() as! [Any?])
    case 131:
      return MobileKeysLastAuthenticationInfo.fromList(self.readValue() as! [Any?])
    case 132:
      return MobileKeysOpeningType.fromList(self.readValue() as! [Any?])
    case 133:
      return MobileKeysReader.fromList(self.readValue() as! [Any?])
    case 134:
      return MobileKeysRssiMeasurement.fromList(self.readValue() as! [Any?])
    case 135:
      return MobileKeysTimeoutConfiguration.fromList(self.readValue() as! [Any?])
    default:
      return super.readValue(ofType: type)
    }
  }
}

private class AppUsageAPICodecWriter: FlutterStandardWriter {
  override func writeValue(_ value: Any) {
    if let value = value as? DataTypeDate {
      super.writeByte(128)
      super.writeValue(value.toList())
    } else if let value = value as? MobileKeysEndpointInfo {
      super.writeByte(129)
      super.writeValue(value.toList())
    } else if let value = value as? MobileKeysKey {
      super.writeByte(130)
      super.writeValue(value.toList())
    } else if let value = value as? MobileKeysLastAuthenticationInfo {
      super.writeByte(131)
      super.writeValue(value.toList())
    } else if let value = value as? MobileKeysOpeningType {
      super.writeByte(132)
      super.writeValue(value.toList())
    } else if let value = value as? MobileKeysReader {
      super.writeByte(133)
      super.writeValue(value.toList())
    } else if let value = value as? MobileKeysRssiMeasurement {
      super.writeByte(134)
      super.writeValue(value.toList())
    } else if let value = value as? MobileKeysTimeoutConfiguration {
      super.writeByte(135)
      super.writeValue(value.toList())
    } else {
      super.writeValue(value)
    }
  }
}

private class AppUsageAPICodecReaderWriter: FlutterStandardReaderWriter {
  override func reader(with data: Data) -> FlutterStandardReader {
    return AppUsageAPICodecReader(data: data)
  }

  override func writer(with data: NSMutableData) -> FlutterStandardWriter {
    return AppUsageAPICodecWriter(data: data)
  }
}

class AppUsageAPICodec: FlutterStandardMessageCodec {
  static let shared = AppUsageAPICodec(readerWriter: AppUsageAPICodecReaderWriter())
}

/// Generated protocol from Pigeon that represents a handler of messages from Flutter.
protocol AppUsageAPI {
  func startUp(options: [String?: Any?], completion: @escaping (Result<Void, Error>) -> Void)
  func deviceHasBluetoothTurnedOn(completion: @escaping (Result<Bool, Error>) -> Void)
  func deviceSupportsBluetoothLowEnergy(completion: @escaping (Result<Bool, Error>) -> Void)
  func isEndpointSetup(completion: @escaping (Result<Bool, Error>) -> Void)
  func setupEndpoint(invitationCode: String, completion: @escaping (Result<Void, Error>) -> Void)
  func updateEndpoint(completion: @escaping (Result<Void, Error>) -> Void)
  func terminateEndpoint(completion: @escaping (Result<Void, Error>) -> Void)
  func listMobileKeys(completion: @escaping (Result<[MobileKeysKey], Error>) -> Void)
  func activateMobileKey(key: MobileKeysKey, completion: @escaping (Result<Bool, Error>) -> Void)
  func deactivateMobileKey(key: MobileKeysKey, completion: @escaping (Result<Bool, Error>) -> Void)
  func generateOTPForKey(key: MobileKeysKey, completion: @escaping (Result<String, Error>) -> Void)
  func otpCounterForKey(key: MobileKeysKey, completion: @escaping (Result<Int64, Error>) -> Void)
  func endpointInfo(completion: @escaping (Result<MobileKeysEndpointInfo, Error>) -> Void)
  func healthCheck(completion: @escaping (Result<[MobileKeysInfoType], Error>) -> Void)
  func apiVersion(completion: @escaping (Result<String, Error>) -> Void)
  func isScanning(completion: @escaping (Result<Bool, Error>) -> Void)
  func startReaderScan(mode: MobileKeysScanMode, supportedOpeningTypes: [MobileKeysOpeningType], lockServiceCodes: [Int64], completion: @escaping (Result<Void, Error>) -> Void)
  func setSupportedOpeningTypes(supportedOpeningTypes: [MobileKeysOpeningType], completion: @escaping (Result<Void, Error>) -> Void)
  func setTimeoutConfiguration(timeoutConfiguration: MobileKeysTimeoutConfiguration, completion: @escaping (Result<Void, Error>) -> Void)
  func stopReaderScan(completion: @escaping (Result<Void, Error>) -> Void)
  func lastAuthenticationInfo(completion: @escaping (Result<MobileKeysLastAuthenticationInfo, Error>) -> Void)
  func listReaders(completion: @escaping (Result<[MobileKeysReader], Error>) -> Void)
  func closestReaderWithinRangeOfOpeningType(type: MobileKeysOpeningType, completion: @escaping (Result<MobileKeysReader?, Error>) -> Void)
  func connect(reader: MobileKeysReader, openingType: MobileKeysOpeningType, completion: @escaping (Result<Void, Error>) -> Void)
  func forceConnect(reader: MobileKeysReader, openingType: MobileKeysOpeningType, completion: @escaping (Result<Void, Error>) -> Void)
  func cancelReaderConnection(reader: MobileKeysReader, completion: @escaping (Result<Void, Error>) -> Void)
  func openClosestReader(completion: @escaping (Result<Void, Error>) -> Void)
  func setRootOpeningTrigger(completion: @escaping (Result<Void, Error>) -> Void)
  func removeRootOpeningTrigger(completion: @escaping (Result<Void, Error>) -> Void)
  func isAnalyticsEnabled(completion: @escaping (Result<Bool, Error>) -> Void)
  func analytics(enable: Bool, completion: @escaping (Result<Void, Error>) -> Void)
}

/// Generated setup class from Pigeon to handle messages through the `binaryMessenger`.
class AppUsageAPISetup {
  /// The codec used by AppUsageAPI.
  static var codec: FlutterStandardMessageCodec { AppUsageAPICodec.shared }
  /// Sets up an instance of `AppUsageAPI` to handle messages through the `binaryMessenger`.
  static func setUp(binaryMessenger: FlutterBinaryMessenger, api: AppUsageAPI?) {
    let startUpChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.startUp", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      startUpChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let optionsArg = args[0] as! [String?: Any?]
        api.startUp(options: optionsArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      startUpChannel.setMessageHandler(nil)
    }
    let deviceHasBluetoothTurnedOnChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.deviceHasBluetoothTurnedOn", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      deviceHasBluetoothTurnedOnChannel.setMessageHandler { _, reply in
        api.deviceHasBluetoothTurnedOn { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      deviceHasBluetoothTurnedOnChannel.setMessageHandler(nil)
    }
    let deviceSupportsBluetoothLowEnergyChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.deviceSupportsBluetoothLowEnergy", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      deviceSupportsBluetoothLowEnergyChannel.setMessageHandler { _, reply in
        api.deviceSupportsBluetoothLowEnergy { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      deviceSupportsBluetoothLowEnergyChannel.setMessageHandler(nil)
    }
    let isEndpointSetupChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.isEndpointSetup", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      isEndpointSetupChannel.setMessageHandler { _, reply in
        api.isEndpointSetup { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      isEndpointSetupChannel.setMessageHandler(nil)
    }
    let setupEndpointChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.setupEndpoint", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      setupEndpointChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let invitationCodeArg = args[0] as! String
        api.setupEndpoint(invitationCode: invitationCodeArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      setupEndpointChannel.setMessageHandler(nil)
    }
    let updateEndpointChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.updateEndpoint", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      updateEndpointChannel.setMessageHandler { _, reply in
        api.updateEndpoint { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      updateEndpointChannel.setMessageHandler(nil)
    }
    let terminateEndpointChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.terminateEndpoint", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      terminateEndpointChannel.setMessageHandler { _, reply in
        api.terminateEndpoint { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      terminateEndpointChannel.setMessageHandler(nil)
    }
    let listMobileKeysChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.listMobileKeys", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      listMobileKeysChannel.setMessageHandler { _, reply in
        api.listMobileKeys { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      listMobileKeysChannel.setMessageHandler(nil)
    }
    let activateMobileKeyChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.activateMobileKey", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      activateMobileKeyChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let keyArg = args[0] as! MobileKeysKey
        api.activateMobileKey(key: keyArg) { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      activateMobileKeyChannel.setMessageHandler(nil)
    }
    let deactivateMobileKeyChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.deactivateMobileKey", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      deactivateMobileKeyChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let keyArg = args[0] as! MobileKeysKey
        api.deactivateMobileKey(key: keyArg) { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      deactivateMobileKeyChannel.setMessageHandler(nil)
    }
    let generateOTPForKeyChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.generateOTPForKey", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      generateOTPForKeyChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let keyArg = args[0] as! MobileKeysKey
        api.generateOTPForKey(key: keyArg) { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      generateOTPForKeyChannel.setMessageHandler(nil)
    }
    let otpCounterForKeyChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.otpCounterForKey", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      otpCounterForKeyChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let keyArg = args[0] as! MobileKeysKey
        api.otpCounterForKey(key: keyArg) { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      otpCounterForKeyChannel.setMessageHandler(nil)
    }
    let endpointInfoChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.endpointInfo", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      endpointInfoChannel.setMessageHandler { _, reply in
        api.endpointInfo { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      endpointInfoChannel.setMessageHandler(nil)
    }
    let healthCheckChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.healthCheck", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      healthCheckChannel.setMessageHandler { _, reply in
        api.healthCheck { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      healthCheckChannel.setMessageHandler(nil)
    }
    let apiVersionChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.apiVersion", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      apiVersionChannel.setMessageHandler { _, reply in
        api.apiVersion { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      apiVersionChannel.setMessageHandler(nil)
    }
    let isScanningChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.isScanning", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      isScanningChannel.setMessageHandler { _, reply in
        api.isScanning { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      isScanningChannel.setMessageHandler(nil)
    }
    let startReaderScanChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.startReaderScan", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      startReaderScanChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let modeArg = MobileKeysScanMode(rawValue: args[0] as! Int)!
        let supportedOpeningTypesArg = args[1] as! [MobileKeysOpeningType]
        let lockServiceCodesArg = args[2] as! [Int64]
        api.startReaderScan(mode: modeArg, supportedOpeningTypes: supportedOpeningTypesArg, lockServiceCodes: lockServiceCodesArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      startReaderScanChannel.setMessageHandler(nil)
    }
    let setSupportedOpeningTypesChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.setSupportedOpeningTypes", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      setSupportedOpeningTypesChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let supportedOpeningTypesArg = args[0] as! [MobileKeysOpeningType]
        api.setSupportedOpeningTypes(supportedOpeningTypes: supportedOpeningTypesArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      setSupportedOpeningTypesChannel.setMessageHandler(nil)
    }
    let setTimeoutConfigurationChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.setTimeoutConfiguration", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      setTimeoutConfigurationChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let timeoutConfigurationArg = args[0] as! MobileKeysTimeoutConfiguration
        api.setTimeoutConfiguration(timeoutConfiguration: timeoutConfigurationArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      setTimeoutConfigurationChannel.setMessageHandler(nil)
    }
    let stopReaderScanChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.stopReaderScan", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      stopReaderScanChannel.setMessageHandler { _, reply in
        api.stopReaderScan { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      stopReaderScanChannel.setMessageHandler(nil)
    }
    let lastAuthenticationInfoChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.lastAuthenticationInfo", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      lastAuthenticationInfoChannel.setMessageHandler { _, reply in
        api.lastAuthenticationInfo { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      lastAuthenticationInfoChannel.setMessageHandler(nil)
    }
    let listReadersChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.listReaders", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      listReadersChannel.setMessageHandler { _, reply in
        api.listReaders { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      listReadersChannel.setMessageHandler(nil)
    }
    let closestReaderWithinRangeOfOpeningTypeChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.closestReaderWithinRangeOfOpeningType", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      closestReaderWithinRangeOfOpeningTypeChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let typeArg = args[0] as! MobileKeysOpeningType
        api.closestReaderWithinRangeOfOpeningType(type: typeArg) { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      closestReaderWithinRangeOfOpeningTypeChannel.setMessageHandler(nil)
    }
    let connectChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.connect", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      connectChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let readerArg = args[0] as! MobileKeysReader
        let openingTypeArg = args[1] as! MobileKeysOpeningType
        api.connect(reader: readerArg, openingType: openingTypeArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      connectChannel.setMessageHandler(nil)
    }
    let forceConnectChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.forceConnect", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      forceConnectChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let readerArg = args[0] as! MobileKeysReader
        let openingTypeArg = args[1] as! MobileKeysOpeningType
        api.forceConnect(reader: readerArg, openingType: openingTypeArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      forceConnectChannel.setMessageHandler(nil)
    }
    let cancelReaderConnectionChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.cancelReaderConnection", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      cancelReaderConnectionChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let readerArg = args[0] as! MobileKeysReader
        api.cancelReaderConnection(reader: readerArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      cancelReaderConnectionChannel.setMessageHandler(nil)
    }
    let openClosestReaderChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.openClosestReader", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      openClosestReaderChannel.setMessageHandler { _, reply in
        api.openClosestReader { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      openClosestReaderChannel.setMessageHandler(nil)
    }
    let setRootOpeningTriggerChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.setRootOpeningTrigger", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      setRootOpeningTriggerChannel.setMessageHandler { _, reply in
        api.setRootOpeningTrigger { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      setRootOpeningTriggerChannel.setMessageHandler(nil)
    }
    let removeRootOpeningTriggerChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.removeRootOpeningTrigger", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      removeRootOpeningTriggerChannel.setMessageHandler { _, reply in
        api.removeRootOpeningTrigger { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      removeRootOpeningTriggerChannel.setMessageHandler(nil)
    }
    let isAnalyticsEnabledChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.isAnalyticsEnabled", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      isAnalyticsEnabledChannel.setMessageHandler { _, reply in
        api.isAnalyticsEnabled { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      isAnalyticsEnabledChannel.setMessageHandler(nil)
    }
    let analyticsChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.seos_mobile_keys_plugin.AppUsageAPI.analytics", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      analyticsChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let enableArg = args[0] as! Bool
        api.analytics(enable: enableArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      analyticsChannel.setMessageHandler(nil)
    }
  }
}