@procivis/react-native-one-core 1.33398.0 → 1.41710.0

package/ios/UBQKit.xcframework/ios-arm64/UBQKit.framework/Modules/UBQKit.swiftmodule/arm64-apple-ios.private.swiftinterface

@@ -0,0 +1,1099 @@
+// swift-interface-format-version: 1.0
+// swift-compiler-version: Apple Swift version 6.0.2 effective-5.10 (swiftlang-6.0.2.1.2 clang-1600.0.26.4)
+// swift-module-flags: -target arm64-apple-ios13.6 -enable-objc-interop -enable-library-evolution -swift-version 5 -enforce-exclusivity=checked -Onone -enable-bare-slash-regex -module-name UBQKit
+// swift-module-flags-ignorable: -no-verify-emitted-module-interface
+import CommonCrypto
+import CryptoKit
+import DeveloperToolsSupport
+import Foundation
+import LocalAuthentication
+import Swift
+import SwiftUI
+@_exported import UBQKit
+import UIKit
+import _Concurrency
+import _StringProcessing
+import _SwiftConcurrencyShims
+import os.log
+import os
+public struct UBQSubscription {
+  public static func start(_ nonce: Swift.String, _ puk: Swift.String? = nil, onStarted: @escaping (_ flow: UBQKit.UbqSubscribe) -> Swift.Void, onStartFailure: @escaping (_ error: UBQKit.UbqKitError) -> Swift.Void)
+}
+@_hasMissingDesignatedInitializers public class UbqSubscribe {
+  public enum SubscribeState {
+    case AWAITING_PUK
+    case AWAITING_FIRST_PIN
+    case AWAITING_CONFIRMATION_PIN
+    case AWAITING_FINISH
+    case SUCCESS
+    case FAILURE
+    public static func == (a: UBQKit.UbqSubscribe.SubscribeState, b: UBQKit.UbqSubscribe.SubscribeState) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public var state: UBQKit.UbqSubscribe.SubscribeState {
+    get
+  }
+  public func setUiProtocol(i: any UBQKit.SubscribeUiProtocol)
+  final public let asset: UBQKit.UbqAsset
+  public func setPuk(to puk: Swift.String)
+  public func finish(subscribeFinishProtocol: any UBQKit.SubscribeFinishProtocol)
+  @objc deinit
+}
+public enum CryptoTypes : Swift.CaseIterable {
+  case EdDSA_25519
+  case BBS_BLS12_381
+  case BBS_BLS12_461
+  case BBS_BN_446
+  case BBS_BN_462
+  case EdDSA_448
+  case ECDSA_P256
+  case ECDSA_P384
+  case ECDSA_P521
+  case RSA_2048
+  case RSA_3072
+  case RSA_4096
+  public var name: Swift.String {
+    get
+  }
+  public static func == (a: UBQKit.CryptoTypes, b: UBQKit.CryptoTypes) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public typealias AllCases = [UBQKit.CryptoTypes]
+  nonisolated public static var allCases: [UBQKit.CryptoTypes] {
+    get
+  }
+  public var hashValue: Swift.Int {
+    get
+  }
+}
+@_inheritsConvenienceInitializers @objc final public class RSA : ObjectiveC.NSObject {
+  @objc public static func encrypt(_ data: Foundation.Data, publicKeyData keyData: Foundation.Data) -> Foundation.Data?
+  @objc override dynamic public init()
+  @objc deinit
+}
+@_inheritsConvenienceInitializers @objc public class DomainManager : ObjectiveC.NSObject {
+  @objc public static var standard: UBQKit.DomainManager
+  @objc final public let securityModule: UBQKit.DomainSecurityModule
+  @objc public func createChannel() -> UBQKit.DomainChannel?
+  @objc public func add(channelState state: UBQKit.ChannelState)
+  @objc public func channel(forChannelToken token: UBQKit.Token) -> UBQKit.DomainChannel?
+  @objc public func save()
+  @objc override dynamic public init()
+  @objc deinit
+}
+@objc public class IdentityProvider : ObjectiveC.NSObject, Swift.Decodable {
+  @objc final public let token: UBQKit.Token
+  @objc final public let name: Swift.String
+  @objc final public let publicKey: Foundation.Data
+  @objc public var urlScheme: Swift.String?
+  @objc final public let theme: Swift.Int
+  @objc public var assets: [UBQKit.Asset] {
+    @objc get
+    @objc set
+  }
+  required public init(from decoder: any Swift.Decoder) throws
+  @objc deinit
+}
+extension UBQKit.IdentityProvider {
+  #warning("Transform to `load` once obj-c is gone")
+}
+@_inheritsConvenienceInitializers @objc public class SecKeyDelegateTags : ObjectiveC.NSObject {
+  @objc public static let assets: Swift.String
+  @objc public static let secureState: Swift.String
+  @objc public static let secureStateOld: Swift.String
+  @objc public static let channelState: Swift.String
+  @objc public static let channelStateOld: Swift.String
+  @objc public static let wrapper: Swift.String
+  @objc override dynamic public init()
+  @objc deinit
+}
+@_inheritsConvenienceInitializers @objc public class SecKeyDelegate : ObjectiveC.NSObject {
+  @objc public static func secretKey(alias: Swift.String, overwrite: Swift.Bool) -> Foundation.Data
+  @objc public static func getSymmetricKey(identifier: Swift.String) -> Foundation.Data?
+  @objc public static func storeSymmetricKey(identifier: Swift.String, key: Foundation.Data)
+  @objc public static func deleteSymmetricKey(identifier: Swift.String)
+  @objc public static func wrap(key: Foundation.Data, with wrapperKey: Foundation.Data) -> Foundation.Data?
+  @objc public static func unwrap(key: Foundation.Data, with wrapperKey: Foundation.Data) -> Foundation.Data?
+  @objc override dynamic public init()
+  @objc deinit
+}
+@available(iOS 13.0.0, *)
+@_Concurrency.MainActor @preconcurrency public struct TransactionTitle : SwiftUI.UIViewRepresentable {
+  @_Concurrency.MainActor @preconcurrency public init()
+  @_Concurrency.MainActor @preconcurrency public func makeUIView(context: UBQKit.TransactionTitle.Context) -> UBQKit.UITransactionTitle
+  @_Concurrency.MainActor @preconcurrency public func updateUIView(_ uiView: UBQKit.UITransactionTitle, context: UBQKit.TransactionTitle.Context)
+  @available(iOS 13.0.0, *)
+  public typealias Body = Swift.Never
+  @available(iOS 13.0.0, *)
+  public typealias Coordinator = Swift.Void
+  @available(iOS 13.0.0, *)
+  public typealias UIViewType = UBQKit.UITransactionTitle
+}
+@objc @_Concurrency.MainActor @preconcurrency public class UITransactionTitle : UIKit.UILabel {
+  @_Concurrency.MainActor @preconcurrency @objc required dynamic public init?(coder: Foundation.NSCoder)
+  @_Concurrency.MainActor @preconcurrency @objc dynamic public init()
+  @objc deinit
+}
+public enum UbqKitError : Swift.Error {
+  case serverUnreachable(description: Swift.String = "The server is currently unreachable. Please check your internet connection.")
+  case invalidArgument(description: Swift.String)
+  case internalError(description: Swift.String = "An internal error occured.", identifier: Swift.String)
+  case canNotFinish(description: Swift.String)
+  case unsupportedOperation(description: Swift.String)
+  case assetLocked(description: Swift.String = "Asset is locked or in incorrect state for request.")
+  case assetRevoked(description: Swift.String = "Asset is revoked and cannot be used anymore.")
+  case assetCouldNotBeUpgraded(description: Swift.String)
+  case invalidConfigurationFile(description: Swift.String = "The configuration file you supplied is invalid.")
+  case notInitialzedError(description: Swift.String = "You first need to initialzed the SDK before you can use this functionality.")
+  case invalidPinPolicy(description: Swift.String)
+  case nonceNotFound(description: Swift.String = "The supplied nonce can not be found on the server.")
+  case noProviderAvailable(description: Swift.String = "No identity provider available for nonce")
+  case invalidPuk(description: Swift.String = "The supplied PUK is invalid.")
+  case noTransactionAvailable(description: Swift.String = "Currently there is no transaction available for assets on this device.")
+  case noAssetsOnDeviceError(description: Swift.String = "There are no assets on this device which is required for this functionality.")
+  case transactionExpired(description: Swift.String = "The transaction of this flow is expired.")
+  case transactionCancelled(description: Swift.String = "The transaction of this flow is cancelled by the user.")
+  case invalidPin(description: Swift.String = "Invalid PIN entered by user")
+  case noImageAvailable(description: Swift.String = "No transaction image found")
+  case biometricsNotSupported(description: Swift.String = "Biometrics are not supported by this device.")
+  case biometricsNotEnabled(description: Swift.String = "Biometrics are not enabled on this device. ")
+  case biometricsError(description: Swift.String = "Error occurred during biometrics.")
+}
+@_hasMissingDesignatedInitializers public class UbqSdkSettings {
+  public static let shared: UBQKit.UbqSdkSettings
+  public var pinPolicy: [Swift.String] {
+    get
+  }
+  public func setPinPolicy(_ notAllowedPins: [Swift.String]) throws
+  @objc deinit
+}
+@_inheritsConvenienceInitializers @objc public class SecureEnclaveManager : ObjectiveC.NSObject {
+  public static func encrypt(key: Security.SecKey, plainText: Foundation.Data) throws -> Foundation.Data
+  public static func decrypt(key: Security.SecKey, cipherText: Foundation.Data) throws -> Foundation.Data
+  @objc public static func sign(key: Security.SecKey, data: Foundation.Data) throws -> Foundation.Data
+  @objc public static func getPublicKeyDerFormatted(_ privateKeyReference: Security.SecKey) throws -> Foundation.Data
+  @objc override dynamic public init()
+  @objc deinit
+}
+public protocol UBQKeyPadReporting {
+  func digitEntered(digit: Swift.Int)
+  func backSpacePressed()
+  func completed(result: Swift.String)
+}
+extension UBQKit.ASN1 {
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class OctetString : UBQKit.ASN1.Item {
+    convenience public init(_ bytes: Foundation.Data)
+    convenience public init(_ bytes: [Swift.UInt8])
+    @objc deinit
+  }
+}
+@_hasMissingDesignatedInitializers @objc public class Token : ObjectiveC.NSObject, Foundation.NSCoding, Swift.Codable {
+  @objc final public let data: Foundation.Data
+  @objc public var hexValue: Swift.String {
+    @objc get
+  }
+  @objc override dynamic public var description: Swift.String {
+    @objc get
+  }
+  @objc public static func token(withHexString hex: Swift.String) -> UBQKit.Token?
+  @objc public static func token(withData data: Foundation.Data) -> UBQKit.Token?
+  @objc convenience public init?(hexString: Swift.String)
+  @objc public func isEqual(to token: UBQKit.Token) -> Swift.Bool
+  @objc required public init?(coder: Foundation.NSCoder)
+  @objc public func encode(with coder: Foundation.NSCoder)
+  required public init(from decoder: any Swift.Decoder) throws
+  public func encode(to encoder: any Swift.Encoder) throws
+  @objc deinit
+}
+extension UBQKit.Token : Foundation.NSCopying {
+  @objc dynamic public func copy(with zone: ObjectiveC.NSZone? = nil) -> Any
+}
+@_hasMissingDesignatedInitializers @objc public class ChannelState : ObjectiveC.NSObject, Foundation.NSCoding {
+  @objc public var token: UBQKit.Token
+  @objc public var domain: UBQKit.Domain
+  @objc public var wrappedMasterKey: Foundation.Data?
+  @objc public var wrappedChannelKey: Foundation.Data?
+  @objc public var apnsRegistrationID: Swift.String?
+  @objc public var svm: Foundation.Data?
+  @objc public var isInitial: Swift.Bool {
+    @objc get
+  }
+  @objc required public init?(coder: Foundation.NSCoder)
+  @objc public func register(forToken token: UBQKit.Token, wrappedChannelKey: Foundation.Data)
+  @objc deinit
+}
+extension UBQKit.ChannelState {
+  @objc dynamic public func encode(with coder: Foundation.NSCoder)
+}
+@objc public class Domain : ObjectiveC.NSObject, Swift.Decodable {
+  @objc public static var current: UBQKit.Domain!
+  @objc final public let publicKeyData: Foundation.Data
+  @objc public var assets: [UBQKit.Asset] {
+    @objc get
+  }
+  required public init(from decoder: any Swift.Decoder) throws
+  @objc public func asset(for token: UBQKit.Token) -> UBQKit.Asset?
+  @objc deinit
+}
+open class XMLDecoder {
+  public enum DateDecodingStrategy {
+    case deferredToDate
+    case secondsSince1970
+    case millisecondsSince1970
+    @available(macOS 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *)
+    case iso8601
+    case formatted(Foundation.DateFormatter)
+    case custom((_ decoder: any Swift.Decoder) throws -> Foundation.Date)
+  }
+  public enum DataDecodingStrategy {
+    case deferredToData
+    case base64
+    case custom((_ decoder: any Swift.Decoder) throws -> Foundation.Data)
+  }
+  public enum NonConformingFloatDecodingStrategy {
+    case `throw`
+    case convertFromString(positiveInfinity: Swift.String, negativeInfinity: Swift.String, nan: Swift.String)
+  }
+  public enum KeyDecodingStrategy {
+    case useDefaultKeys
+    case convertFromSnakeCase
+    case custom((_ codingPath: [any Swift.CodingKey]) -> any Swift.CodingKey)
+  }
+  open var dateDecodingStrategy: UBQKit.XMLDecoder.DateDecodingStrategy
+  open var dataDecodingStrategy: UBQKit.XMLDecoder.DataDecodingStrategy
+  open var nonConformingFloatDecodingStrategy: UBQKit.XMLDecoder.NonConformingFloatDecodingStrategy
+  open var keyDecodingStrategy: UBQKit.XMLDecoder.KeyDecodingStrategy
+  open var userInfo: [Swift.CodingUserInfoKey : Any]
+  public init()
+  open func decode<T>(_ type: T.Type, from data: Foundation.Data) throws -> T where T : Swift.Decodable
+  @objc deinit
+}
+extension Foundation.NSString {
+  @objc dynamic public var isHexString: Swift.Bool {
+    @objc get
+  }
+  @objc dynamic public func insert(separator: Foundation.NSString, every n: Swift.Int) -> Foundation.NSString
+}
+public protocol ChangePinFinishProtocol {
+  func onChangePinCompleted()
+  func onChangePinFinishFailure(error: UBQKit.UbqKitError)
+  func onChangePinIncorrectPinEntered(pinAttemptsLeft: Swift.Int8)
+}
+@objc @_hasMissingDesignatedInitializers @_Concurrency.MainActor @preconcurrency public class UBQInternalPad : UIKit.UIView {
+  @_Concurrency.MainActor @preconcurrency public init(biometricsButtonShown: Swift.Bool)
+  @_Concurrency.MainActor @preconcurrency @objc dynamic public init()
+  @_Concurrency.MainActor @preconcurrency public func clear(makeVisible: Swift.Bool = true)
+  @_Concurrency.MainActor @preconcurrency public func updateClickablity(isClickable: Swift.Bool)
+  @objc deinit
+}
+@_hasMissingDesignatedInitializers @objc public class FMVersion : ObjectiveC.NSObject, Swift.Decodable {
+  public enum Feature {
+    case biometricAuthentication
+    case deviceKey
+    case svmToAesUpgrade
+    public static func == (a: UBQKit.FMVersion.Feature, b: UBQKit.FMVersion.Feature) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  @objc deinit
+  required public init(from decoder: any Swift.Decoder) throws
+}
+@_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers @objc public class UBQSecurityStrategy : ObjectiveC.NSObject {
+  @objc public static var standard: UBQKit.UBQSecurityStrategy
+  @objc public func verify(_ message: Foundation.Data, signature: Foundation.Data, publicSlotGroupKey: Foundation.Data) -> Swift.Bool
+  @objc public func createTransportKeys(providerID: Foundation.Data, cardUUID: Foundation.Data, hashes: Foundation.Data) -> Foundation.Data?
+  @objc public func encryptedPhoneRandom(_ publicSlotGroupKey: Foundation.Data) -> Foundation.Data?
+  @objc public func aesEncryptedBindResponse(providerID: Foundation.Data, cardUUID: Foundation.Data, hashes: Foundation.Data, hsmRandom: Foundation.Data) -> Foundation.Data?
+  @objc public func aesEncryptedBindResponse(providerID: Foundation.Data, cardUUID: Foundation.Data, hashes: Foundation.Data, hsmRandom: Foundation.Data, devicePublicKey: Foundation.Data) -> Foundation.Data?
+  @objc public func decrypt(withDisplayKey providerId: Foundation.Data, cardUUID: Foundation.Data, hash: Foundation.Data, cipherText: Foundation.Data, svm svmKey: Foundation.Data? = nil) -> Foundation.Data?
+  @objc public func encrypt(withEntryKey providerId: Foundation.Data, cardUUID: Foundation.Data, hash: Foundation.Data, plainText: Foundation.Data, svm svmKey: Foundation.Data? = nil) -> Foundation.Data?
+  @objc deinit
+}
+extension Foundation.NSData {
+  @objc public static func random(ofSize size: Swift.Int) -> Foundation.NSData
+}
+extension UBQKit.ASN1 {
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class Integer : UBQKit.ASN1.Item {
+    convenience public init(_ uint64: Swift.UInt64)
+    convenience public init(_ uint8: Swift.UInt8)
+    convenience public init(_ uint16: Swift.UInt16)
+    convenience public init(_ uint32: Swift.UInt32)
+    convenience public init(_ uint: Swift.UInt)
+    convenience public init(_ int64: Swift.Int64)
+    convenience public init(_ int8: Swift.Int8)
+    convenience public init(_ int16: Swift.Int16)
+    convenience public init(_ int32: Swift.Int32)
+    convenience public init(_ int: Swift.Int)
+    public var uint: Swift.UInt {
+      get
+      set
+    }
+    public var int: Swift.Int {
+      get
+      set
+    }
+    @objc deinit
+  }
+}
+@_hasMissingDesignatedInitializers public class UBQTransaction {
+  public var asset: UBQKit.UbqAsset {
+    get
+  }
+  public var parameters: UBQKit.UBQTransactionParameters {
+    get
+  }
+  final public let title: Swift.String
+  public var attemptsLeft: Swift.Int8? {
+    get
+  }
+  public var timeoutUntil: Foundation.Date? {
+    get
+  }
+  final public let type: UBQKit.TransactionType
+  final public let transactionId: Foundation.UUID?
+  public var created: Foundation.Date {
+    get
+  }
+  public static func load(asset: UBQKit.UbqAsset? = nil, transactionID: Foundation.UUID? = nil, onStarted: @escaping (_ flow: UBQKit.UbqTransaction) -> Swift.Void, onStartFailure: @escaping (_ error: UBQKit.UbqKitError) -> Swift.Void)
+  public func downloadImage(size: CoreFoundation.CGSize, success: @escaping (_ image: UIKit.UIImage) -> Swift.Void, failure: @escaping (_ error: UBQKit.UbqKitError) -> Swift.Void)
+  @objc deinit
+}
+public enum TransactionType {
+  case normal
+  case enableBiometrics
+  public static func == (a: UBQKit.TransactionType, b: UBQKit.TransactionType) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public var hashValue: Swift.Int {
+    get
+  }
+}
+public struct UBQTransactionParameters {
+  public let title: Swift.String?
+  public let caption: Swift.String?
+  public let subtitle: Swift.String?
+  public let time: Foundation.Date?
+  public let confirmeButtonText: Swift.String?
+  public let rejectButtonText: Swift.String?
+  public let otp: Swift.String?
+  public let fingerprint: Swift.String?
+  public let userAgent: Swift.String?
+  public let resourceUri: Swift.String?
+  public let ipAddress: Swift.String?
+  public let secureDataHash: Foundation.Data?
+  public let secureDataKey: Foundation.Data?
+  public let secureDataUrl: Swift.String?
+  public let profileName: Swift.String?
+}
+@_hasMissingDesignatedInitializers public class UbqTransaction {
+  public enum TransactionState {
+    case AWAITING_PIN
+    case AWAITING_FINISH
+    case SUCCESS
+    case FAILURE
+    public static func == (a: UBQKit.UbqTransaction.TransactionState, b: UBQKit.UbqTransaction.TransactionState) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public var state: UBQKit.UbqTransaction.TransactionState {
+    get
+  }
+  public func setUiProtocol(i: any UBQKit.TransactionUiProtocol)
+  public func setRejectProtocol(i: any UBQKit.TransactionRejectProtocol)
+  public var transaction: UBQKit.UBQTransaction
+  public func start()
+  public func cancel()
+  public func finish(transactionFinishProtocol: any UBQKit.TransactionFinishProtocol)
+  @objc deinit
+}
+public protocol ResetPinUiProtocol {
+  func onResetPinNewPinEntered()
+  func onResetPinUnallowedPinEntered()
+  func onResetPinPinNotConfirmed()
+  func onResetPinPinConfirmed()
+  func onResetPinUiError(error: UBQKit.UbqKitError)
+}
+extension Foundation.NSData {
+  @objc convenience dynamic public init?(hexString: Swift.String)
+  @objc dynamic public var hexadecimal: Swift.String {
+    @objc get
+  }
+  @objc public static func xor(bytes lhs: Foundation.NSData, with rhs: Foundation.NSData) -> Foundation.NSData
+}
+@_inheritsConvenienceInitializers @objc public class AssetManager : ObjectiveC.NSObject {
+  @objc public static var standard: UBQKit.AssetManager
+  @discardableResult
+  @objc public func removeAsset(forToken assetToken: UBQKit.Token) -> Swift.Bool
+  #warning("Required by objective-c still")
+  @objc public func save()
+  @objc override dynamic public init()
+  @objc deinit
+}
+@_inheritsConvenienceInitializers @objc public class UbqSdk : ObjectiveC.NSObject {
+  @objc public static var sdkHeader: Swift.String? {
+    get
+  }
+  public static var settings: UBQKit.UbqSdkSettings
+  public static var loggingEnabled: Swift.Bool {
+    get
+  }
+  public static var idps: [UBQKit.UbqIdentityProvider] {
+    get
+  }
+  public static var assets: [UBQKit.UbqAsset] {
+    get
+  }
+  @objc override dynamic public init()
+  @objc deinit
+}
+extension UBQKit.UbqSdk {
+  public static func setup(with configurationData: Foundation.Data, loggingEnabled: Swift.Bool) throws
+  public static func subscribe(_ nonce: Swift.String, _ puk: Swift.String? = nil, onStarted: @escaping (_ flow: UBQKit.UbqSubscribe) -> Swift.Void, onStartFailure: @escaping (_ error: UBQKit.UbqKitError) -> Swift.Void)
+}
+public struct MD5 {
+}
+extension UBQKit.ASN1 {
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class Boolean : UBQKit.ASN1.Item {
+    convenience public init(bool: Swift.Bool)
+    @objc deinit
+  }
+}
+extension UBQKit.ASN1 {
+  public typealias SequenceOf = UBQKit.ASN1.Sequence
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class Sequence : UBQKit.ASN1.ConstructedItem {
+    convenience public init(_ items: [UBQKit.ASN1.Item])
+    @objc deinit
+  }
+}
+public protocol UBQPinPadReporting {
+  func amountOfDigitsDidChange(newAmount: Swift.Int)
+}
+extension UBQKit.ASN1 {
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class BitString : UBQKit.ASN1.Item {
+    convenience public init(bitString: Swift.String)
+    public var bitString: Swift.String {
+      get
+      set
+    }
+    @objc deinit
+  }
+}
+open class XMLEncoder {
+  public struct OutputFormatting : Swift.OptionSet {
+    public let rawValue: Swift.UInt
+    public init(rawValue: Swift.UInt)
+    public static let prettyPrinted: UBQKit.XMLEncoder.OutputFormatting
+    @available(macOS 10.13, iOS 11.0, watchOS 4.0, tvOS 11.0, *)
+    public static let sortedKeys: UBQKit.XMLEncoder.OutputFormatting
+    public typealias ArrayLiteralElement = UBQKit.XMLEncoder.OutputFormatting
+    public typealias Element = UBQKit.XMLEncoder.OutputFormatting
+    public typealias RawValue = Swift.UInt
+  }
+  public enum DateEncodingStrategy {
+    case deferredToDate
+    case secondsSince1970
+    case millisecondsSince1970
+    @available(macOS 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *)
+    case iso8601
+    case formatted(Foundation.DateFormatter)
+    case custom((Foundation.Date, any Swift.Encoder) throws -> Swift.Void)
+  }
+  public enum StringEncodingStrategy {
+    case deferredToString
+    case cdata
+    public static func == (a: UBQKit.XMLEncoder.StringEncodingStrategy, b: UBQKit.XMLEncoder.StringEncodingStrategy) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public enum DataEncodingStrategy {
+    case deferredToData
+    case base64
+    case custom((Foundation.Data, any Swift.Encoder) throws -> Swift.Void)
+  }
+  public enum NonConformingFloatEncodingStrategy {
+    case `throw`
+    case convertToString(positiveInfinity: Swift.String, negativeInfinity: Swift.String, nan: Swift.String)
+  }
+  public enum KeyEncodingStrategy {
+    case useDefaultKeys
+    case convertToSnakeCase
+    case custom((_ codingPath: [any Swift.CodingKey]) -> any Swift.CodingKey)
+  }
+  public enum AttributeEncodingStrategy {
+    case deferredToEncoder
+    case custom((any Swift.Encoder) -> Swift.Bool)
+  }
+  open var outputFormatting: UBQKit.XMLEncoder.OutputFormatting
+  open var dateEncodingStrategy: UBQKit.XMLEncoder.DateEncodingStrategy
+  open var dataEncodingStrategy: UBQKit.XMLEncoder.DataEncodingStrategy
+  open var nonConformingFloatEncodingStrategy: UBQKit.XMLEncoder.NonConformingFloatEncodingStrategy
+  open var keyEncodingStrategy: UBQKit.XMLEncoder.KeyEncodingStrategy
+  open var attributeEncodingStrategy: UBQKit.XMLEncoder.AttributeEncodingStrategy
+  open var stringEncodingStrategy: UBQKit.XMLEncoder.StringEncodingStrategy
+  open var userInfo: [Swift.CodingUserInfoKey : Any]
+  public init()
+  open func encode<T>(_ value: T, withRootKey rootKey: Swift.String, header: UBQKit.XMLHeader? = nil) throws -> Foundation.Data where T : Swift.Encodable
+  @objc deinit
+}
+@objc public class DomainChannel : ObjectiveC.NSObject {
+  @objc final public let securityModule: UBQKit.DomainSecurityModule
+  @objc final public let channelState: UBQKit.ChannelState
+  @objc public init(withDomainSecurityModule dsm: UBQKit.DomainSecurityModule, channelState: UBQKit.ChannelState)
+  @objc public func send(_ msg: UBQKit.ApplicationMessage, priority: Swift.Bool, success: @escaping (_ msg: UBQKit.ApplicationMessage) -> Swift.Void, failure: @escaping (_ error: any Swift.Error) -> Swift.Void)
+  @objc public func send(_ msg: UBQKit.ApplicationMessage, success: @escaping (_ msg: UBQKit.ApplicationMessage) -> Swift.Void, failure: @escaping (_ error: any Swift.Error) -> Swift.Void)
+  #warning("Dispatch semaphore, no no no!")
+  @objc public func setBlock() -> Dispatch.DispatchSemaphore
+  @objc public func createSignedPacket(fromPayload payload: Swift.String) -> UBQKit.UBQPacket
+  @objc deinit
+}
+#warning("Used to temporarily test ")
+@_inheritsConvenienceInitializers @objc public class TemporaryHelper : ObjectiveC.NSObject {
+  @objc public static func decodeCardRequest(_ data: Foundation.Data)
+  @objc override dynamic public init()
+  @objc deinit
+}
+#warning("These might need its own extension files")
+public struct XMLHeader {
+}
+@objc @_hasMissingDesignatedInitializers @_Concurrency.MainActor @preconcurrency public class UBQKeyPad : UBQKit.UBQInternalPad {
+  @_Concurrency.MainActor @preconcurrency public var listener: (any UBQKit.UBQKeyPadReporting)?
+  @_Concurrency.MainActor @preconcurrency public init(maxLength: Swift.Int)
+  @_Concurrency.MainActor @preconcurrency public func updateMaxLength(to length: Swift.Int)
+  @_Concurrency.MainActor @preconcurrency override public func clear(makeVisible: Swift.Bool = true)
+  @objc deinit
+}
+public protocol TransactionUiProtocol {
+  func onTransactionPinEntered()
+  func onTransactionBiometricsEntered()
+  func onTransactionUiError(error: UBQKit.UbqKitError)
+}
+@objc public class ApplicationMessage : ObjectiveC.NSObject {
+  @objc final public let command: Swift.UInt
+  @objc final public let payload: Swift.String?
+  @objc final public let wrappedVerificationKey: Foundation.Data?
+  @objc override dynamic public var description: Swift.String {
+    @objc get
+  }
+  @objc public init(command: Swift.UInt, payload: Swift.String?, wrappedVerificationKey: Foundation.Data?)
+  @objc convenience public init(command: Swift.UInt, payload: Swift.String?)
+  @objc convenience public init(command: Swift.UInt)
+  @objc convenience public init(string: Swift.String)
+  @objc public func validate(command: Swift.UInt) -> Swift.Bool
+  @objc public func validate(commands: [Swift.UInt]) -> Swift.Bool
+  @objc deinit
+}
+extension UBQKit.ASN1 {
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class BMPString : UBQKit.ASN1.Item {
+    convenience public init(_ bmpString: Swift.String)
+    public var bmpString: Swift.String {
+      get
+      set
+    }
+    @objc deinit
+  }
+}
+public protocol SubscribeUiProtocol {
+  func onSubscribePukEntered()
+  func onSubscribeFirstPinEntered()
+  func onSubscribeUnallowedPinEntered()
+  func onSubscribePinNotConfirmed()
+  func onSubscribePinConfirmed()
+  func onSubscribeUiError(error: UBQKit.UbqKitError)
+}
+public protocol ChangePinUiProtocol {
+  func onChangePinPinEntered()
+  func onChangePinNewPinEntered()
+  func onChangePinUnallowedPinEntered()
+  func onChangePinPinNotConfirmed()
+  func onChangePinPinConfirmed()
+  func onChangePinUiError(error: UBQKit.UbqKitError)
+}
+@objc public class Asset : ObjectiveC.NSObject {
+  @objc public enum AssetState : Swift.Int {
+    case normal = 0
+    case locked = 1
+    case revoked = 2
+    public init?(rawValue: Swift.Int)
+    public typealias RawValue = Swift.Int
+    public var rawValue: Swift.Int {
+      get
+    }
+  }
+  @objc final public let channelToken: UBQKit.Token
+  @objc unowned public var identityProvider: UBQKit.IdentityProvider!
+  @objc public var idpToken: UBQKit.Token {
+    @objc get
+  }
+  @objc public var badgeNumber: Swift.Int
+  @objc public var biometricAuthentication: Swift.Bool
+  @objc public var deviceKeyUsed: Swift.Bool
+  @objc public var usesSVM: Swift.Bool
+  @objc public var label: Swift.String
+  @objc public var state: UBQKit.Asset.AssetState {
+    @objc get
+    @objc set
+  }
+  @objc public init(withChannelToken channelToken: UBQKit.Token, identityProvider: UBQKit.IdentityProvider)
+  @objc required public init?(coder: Foundation.NSCoder)
+  @discardableResult
+  @objc public init(token: UBQKit.Token, provider: UBQKit.IdentityProvider)
+  @objc public func revoke(completionBlock: ((Swift.Bool, (any Swift.Error)?) -> Swift.Void)?)
+  @objc override dynamic public var description: Swift.String {
+    @objc get
+  }
+  @objc public func getSVM(key: Swift.Int, direction: Swift.Int) -> Foundation.Data?
+  @objc public func getSVM(cardRequest: UBQKit.UBQCardRequest, direction: Swift.Int) -> Foundation.Data?
+  @objc deinit
+}
+extension UBQKit.Asset : Foundation.NSCoding {
+  @objc dynamic public func encode(with coder: Foundation.NSCoder)
+}
+@_hasMissingDesignatedInitializers public class UBQBiometricTransaction {
+  public var asset: UBQKit.UbqAsset {
+    get
+  }
+  public var parameters: UBQKit.UBQTransactionParameters {
+    get
+  }
+  final public let title: Swift.String
+  public var attemptsLeft: Swift.Int8? {
+    get
+  }
+  public var timeoutUntil: Foundation.Date? {
+    get
+  }
+  final public let type: UBQKit.TransactionType
+  public var created: Foundation.Date {
+    get
+  }
+  @objc deinit
+}
+@_hasMissingDesignatedInitializers public class UbqAddBiometrics {
+  public enum AddBiometricsState {
+    case AWAITING_PIN
+    case AWAITING_FINISH
+    case SUCCESS
+    case FAILURE
+    public static func == (a: UBQKit.UbqAddBiometrics.AddBiometricsState, b: UBQKit.UbqAddBiometrics.AddBiometricsState) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public var state: UBQKit.UbqAddBiometrics.AddBiometricsState {
+    get
+  }
+  public func setUiProtocol(i: any UBQKit.AddBiometricsUiProtocol)
+  public var transaction: UBQKit.UBQBiometricTransaction
+  public func start()
+  public func finish(addBiometricsFinishProtocol: any UBQKit.AddBiometricsFinishProtocol)
+  @objc deinit
+}
+extension UBQKit.ASN1 {
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class PrintableString : UBQKit.ASN1.Item {
+    convenience public init(_ printableString: Swift.String)
+    public var printableString: Swift.String {
+      get
+      set
+    }
+    @objc deinit
+  }
+}
+@_hasMissingDesignatedInitializers public class UbqDerivedAsset : Swift.Decodable {
+  final public let uuid: Foundation.UUID
+  final public let publicKey: Swift.String?
+  public var cryptoType: UBQKit.CryptoTypes {
+    get
+  }
+  required public init(from decoder: any Swift.Decoder) throws
+  public var asset: UBQKit.UbqAsset!
+  @objc deinit
+}
+extension UBQKit.UbqDerivedAsset {
+  public func use(header: Swift.String, messageScalars: [Swift.String], generators: [Swift.String], success: @escaping (_ flow: UBQKit.UbqTransaction) -> Swift.Void, failure: @escaping (_ error: UBQKit.UbqKitError) -> Swift.Void)
+  public func use(toBeSignedData: Swift.String, success: @escaping (_ flow: UBQKit.UbqTransaction) -> Swift.Void, failure: @escaping (_ error: UBQKit.UbqKitError) -> Swift.Void)
+  public func decrypt(toBeDecryptedData: Swift.String, success: @escaping (_ flow: UBQKit.UbqTransaction) -> Swift.Void, failure: @escaping (_ error: UBQKit.UbqKitError) -> Swift.Void)
+}
+extension Foundation.NSDate {
+  @objc dynamic public var hexTimeStamp: Foundation.NSString {
+    @objc get
+  }
+}
+public enum ASN1 {
+}
+extension UBQKit.ASN1 {
+  public class Tag {
+    public enum Class : Swift.UInt8 {
+      case universal
+      case application
+      case contextSpecific
+      case `private`
+      public init?(rawValue: Swift.UInt8)
+      public typealias RawValue = Swift.UInt8
+      public var rawValue: Swift.UInt8 {
+        get
+      }
+    }
+    public enum Form : Swift.UInt8 {
+      case primitive
+      case constructed
+      public init?(rawValue: Swift.UInt8)
+      public typealias RawValue = Swift.UInt8
+      public var rawValue: Swift.UInt8 {
+        get
+      }
+    }
+    public enum Value : Swift.UInt8 {
+      case endOfContent
+      case boolean
+      case integer
+      case bitString
+      case octetString
+      case null
+      case objectIdentifier
+      case objectDescriptor
+      case external
+      case real
+      case enumerated
+      case embeddedPDV
+      case utf8String
+      case relativeOID
+      case time
+      case sequence
+      case set
+      case numericString
+      case printableString
+      case t61String
+      case videotexString
+      case ia5String
+      case utcTime
+      case generalizedTime
+      case graphicString
+      case visibleString
+      case generalString
+      case universalString
+      case characterString
+      case bmpString
+      case date
+      public init?(rawValue: Swift.UInt8)
+      public typealias RawValue = Swift.UInt8
+      public var rawValue: Swift.UInt8 {
+        get
+      }
+    }
+    final public let `class`: UBQKit.ASN1.Tag.Class
+    final public let form: UBQKit.ASN1.Tag.Form
+    final public let value: UBQKit.ASN1.Tag.Value
+    public var data: Foundation.Data {
+      get
+      set
+    }
+    public var isPrimitive: Swift.Bool {
+      get
+      set
+    }
+    public var isConstructed: Swift.Bool {
+      get
+      set
+    }
+    public init(_ rawValue: Swift.UInt8)
+    convenience public init(class c: UBQKit.ASN1.Tag.Class, form: UBQKit.ASN1.Tag.Form, tagValue: UBQKit.ASN1.Tag.Value)
+    convenience public init(class c: UBQKit.ASN1.Tag.Class, form: UBQKit.ASN1.Tag.Form, tagValue: Swift.UInt8)
+    @objc deinit
+  }
+}
+extension UBQKit.ASN1.Tag {
+  public static let boolean: UBQKit.ASN1.Tag
+  public static let integer: UBQKit.ASN1.Tag
+  public static let bitString: UBQKit.ASN1.Tag
+  public static let octetString: UBQKit.ASN1.Tag
+  public static let null: UBQKit.ASN1.Tag
+  public static let objectIdentifier: UBQKit.ASN1.Tag
+  public static let utf8String: UBQKit.ASN1.Tag
+  public static let sequence: UBQKit.ASN1.Tag
+  public static let set: UBQKit.ASN1.Tag
+  public static let printableString: UBQKit.ASN1.Tag
+  public static let ia5String: UBQKit.ASN1.Tag
+  public static let bmpString: UBQKit.ASN1.Tag
+}
+extension UBQKit.ASN1.Tag : Swift.Equatable {
+  public static func == (lhs: UBQKit.ASN1.Tag, rhs: UBQKit.ASN1.Tag) -> Swift.Bool
+}
+extension UBQKit.ASN1.Tag : Swift.Comparable {
+  public static func < (lhs: UBQKit.ASN1.Tag, rhs: UBQKit.ASN1.Tag) -> Swift.Bool
+}
+extension UBQKit.ASN1 {
+  @_hasMissingDesignatedInitializers public class Item {
+    final public let tag: UBQKit.ASN1.Tag
+    public var length: Swift.Int {
+      get
+    }
+    final public let value: Foundation.Data
+    weak public var parent: UBQKit.ASN1.ConstructedItem?
+    public static func decode(data: Foundation.Data) -> UBQKit.ASN1.Item
+    @objc deinit
+  }
+}
+extension UBQKit.ASN1.Item {
+  public var data: Foundation.Data {
+    get
+  }
+}
+extension UBQKit.ASN1.Item {
+  public func first(where predicate: (UBQKit.ASN1.Item) -> Swift.Bool) -> UBQKit.ASN1.Item?
+  public func filter(_ isIncluded: (UBQKit.ASN1.Item) throws -> Swift.Bool) rethrows -> [UBQKit.ASN1.Item]
+}
+extension UBQKit.ASN1 {
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class ConstructedItem : UBQKit.ASN1.Item {
+    public var children: [UBQKit.ASN1.Item] {
+      get
+    }
+    @objc deinit
+  }
+}
+extension UBQKit.ASN1 {
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class UTF8String : UBQKit.ASN1.Item {
+    convenience public init(_ utf8String: Swift.String)
+    public var utf8String: Swift.String {
+      get
+      set
+    }
+    @objc deinit
+  }
+}
+@objc @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers @_Concurrency.MainActor @preconcurrency public class UBQPinPad : UBQKit.UBQInternalPad {
+  @_Concurrency.MainActor @preconcurrency public var listener: (any UBQKit.UBQPinPadReporting)?
+  @_Concurrency.MainActor @preconcurrency public func biometricsTapped()
+  @_Concurrency.MainActor @preconcurrency override public func clear(makeVisible: Swift.Bool = true)
+  @_Concurrency.MainActor @preconcurrency override public init(biometricsButtonShown: Swift.Bool)
+  @_Concurrency.MainActor @preconcurrency @objc override dynamic public init()
+  @objc deinit
+}
+extension UBQKit.ASN1 {
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class Null : UBQKit.ASN1.Item {
+    convenience public init()
+    @objc deinit
+  }
+}
+extension UBQKit.ASN1 {
+  public typealias SetOf = UBQKit.ASN1.Set
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class Set : UBQKit.ASN1.ConstructedItem {
+    convenience public init(_ items: [UBQKit.ASN1.Item])
+    @objc deinit
+  }
+}
+public protocol TransactionRejectProtocol {
+  func onTransactionRejected()
+  func onTransactionRejectFailure(error: UBQKit.UbqKitError)
+}
+public protocol TransactionFinishProtocol {
+  func onTransactionCompleted(result: Swift.String?)
+  func onTransactionFinishFailure(error: UBQKit.UbqKitError)
+  func onTransactionIncorrectPinEntered(pinAttemptsLeft: Swift.Int8)
+}
+public protocol ResetPinFinishProtocol {
+  func onResetPinCompleted()
+  func onResetPinFinishFailure(error: UBQKit.UbqKitError)
+  func onResetPinIncorrectPukEntered(pinAttemptsLeft: Swift.Int8)
+}
+@_hasMissingDesignatedInitializers public class UbqAsset : Swift.CustomDebugStringConvertible {
+  final public let uuid: Foundation.UUID
+  public var state: UBQKit.Asset.AssetState {
+    get
+  }
+  @available(*, deprecated, message: "This property will be removed in future releases. Profile names should be stored by app host.")
+  public var profileName: Swift.String {
+    get
+  }
+  public var biometricAuthenticationEnabled: Swift.Bool {
+    get
+  }
+  final public let idp: UBQKit.UbqIdentityProvider
+  public var derivedAssets: [UBQKit.UbqDerivedAsset]
+  public var debugDescription: Swift.String {
+    get
+  }
+  public var shouldBeMarkedAsAes: Swift.Bool {
+    get
+  }
+  public var canBeUpgraded: Swift.Bool {
+    get
+  }
+  public func identify(withNonce nonce: Swift.String, success: @escaping () -> Swift.Void, failure: @escaping (UBQKit.UbqKitError) -> Swift.Void)
+  public func createDa(cryptoTypes: UBQKit.CryptoTypes, success: @escaping (UBQKit.UbqDerivedAsset) -> Swift.Void, failure: @escaping (UBQKit.UbqKitError) -> Swift.Void)
+  public func refreshDerivedAssets(success: @escaping () -> Swift.Void, failure: @escaping (UBQKit.UbqKitError) -> Swift.Void)
+  public func loadTransaction(transactionID: Foundation.UUID? = nil, success: @escaping (_ flow: UBQKit.UbqTransaction) -> Swift.Void, failure: @escaping (_ error: UBQKit.UbqKitError) -> Swift.Void)
+  public func revoke(success: @escaping () -> Swift.Void, failure: @escaping (UBQKit.UbqKitError) -> Swift.Void)
+  public func delete(success: @escaping () -> Swift.Void, failure: @escaping (UBQKit.UbqKitError) -> Swift.Void)
+  public func addBiometrics(onStarted: @escaping (_ flow: UBQKit.UbqAddBiometrics) -> Swift.Void, onStartFailure: @escaping (_ error: UBQKit.UbqKitError) -> Swift.Void)
+  public func changePin(success: @escaping (_ flow: UBQKit.UbqChangePin) -> Swift.Void, failure: @escaping (_ error: UBQKit.UbqKitError) -> Swift.Void)
+  public func resetPin(_ puk: Swift.String, success: @escaping (_ flow: UBQKit.UbqResetPin) -> Swift.Void, failure: @escaping (_ error: UBQKit.UbqKitError) -> Swift.Void)
+  public func addBiometrics(success: @escaping () -> Swift.Void, failure: @escaping (UBQKit.UbqKitError) -> Swift.Void)
+  public func removeBiometrics()
+  public func upgradeAsset() async throws
+  public func isAesAsset(completion: @escaping (Swift.Bool) -> Swift.Void, failure: @escaping (UBQKit.UbqKitError) -> Swift.Void)
+  public func setIsAesAsset(isAes: Swift.Bool, completion: @escaping () -> Swift.Void, failure: @escaping (UBQKit.UbqKitError) -> Swift.Void)
+  public func registerPushToken(token: Swift.String) async throws
+  @objc deinit
+}
+extension UBQKit.UbqAsset {
+  public static func getAmountOfTransactions(completion: @escaping ([UBQKit.UbqAsset : Swift.Int]) -> Swift.Void, failure: @escaping (UBQKit.UbqKitError) -> Swift.Void)
+}
+extension UBQKit.UbqAsset : Swift.Equatable, Swift.Hashable {
+  public func hash(into hasher: inout Swift.Hasher)
+  public static func == (lhs: UBQKit.UbqAsset, rhs: UBQKit.UbqAsset) -> Swift.Bool
+  public var hashValue: Swift.Int {
+    get
+  }
+}
+public struct UbqIdentityProvider : Swift.CustomDebugStringConvertible {
+  public let name: Swift.String
+  public let uuid: Foundation.UUID
+  public var themeID: Swift.Int {
+    get
+  }
+  public var urlScheme: Swift.String? {
+    get
+  }
+  public var debugDescription: Swift.String {
+    get
+  }
+  public func supportsBiometrics() -> Swift.Bool
+  public static func getIdentityProvider(forNonce nonce: Swift.String, completion: @escaping (UBQKit.UbqIdentityProvider) -> Swift.Void, failure: @escaping (UBQKit.UbqKitError) -> Swift.Void)
+}
+@_inheritsConvenienceInitializers @objc final public class AESCBC : ObjectiveC.NSObject {
+  @objc public static func encrypt(_ data: Foundation.Data, using key: Foundation.Data) -> Foundation.Data?
+  @objc public static func decrypt(_ data: Foundation.Data, using key: Foundation.Data) -> Foundation.Data?
+  @objc public static func encryptNoPadding(_ data: Foundation.Data, key: Foundation.Data) -> Foundation.Data?
+  @objc public static func decryptNoPadding(_ data: Foundation.Data, key: Foundation.Data) -> Foundation.Data?
+  @objc public static func decryptNoPaddingNoIV(_ data: Foundation.Data, key: Foundation.Data) -> Foundation.Data?
+  @objc override dynamic public init()
+  @objc deinit
+}
+@_inheritsConvenienceInitializers @objc final public class AESKeyWrap : ObjectiveC.NSObject {
+  @objc public static func wrap(key: Foundation.Data, using wrapperKey: Foundation.Data) -> Foundation.Data?
+  @objc public static func unwrap(wrappedKey: Foundation.Data, using wrapperKey: Foundation.Data) -> Foundation.Data?
+  @objc override dynamic public init()
+  @objc deinit
+}
+extension UBQKit.ASN1 {
+  public typealias OID = UBQKit.ASN1.ObjectIdentifier
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class ObjectIdentifier : UBQKit.ASN1.Item {
+    convenience public init(oidString string: Swift.String)
+    public var oidString: Swift.String {
+      get
+      set
+    }
+    @objc deinit
+  }
+}
+@_hasMissingDesignatedInitializers public class UbqResetPin {
+  public enum ResetPinState {
+    case AWAITING_NEW_PIN
+    case AWAITING_CONFIRMATION_PIN
+    case AWAITING_FINISH
+    case SUCCESS
+    case FAILURE
+    public static func == (a: UBQKit.UbqResetPin.ResetPinState, b: UBQKit.UbqResetPin.ResetPinState) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public var state: UBQKit.UbqResetPin.ResetPinState {
+    get
+  }
+  public func setUiProtocol(i: any UBQKit.ResetPinUiProtocol)
+  public func finish(resetPinFinishProtocol: any UBQKit.ResetPinFinishProtocol)
+  @objc deinit
+}
+@_inheritsConvenienceInitializers @objc final public class HMACSHA256 : ObjectiveC.NSObject {
+  @objc public static func mac(_ data: Foundation.Data, key: Foundation.Data) -> Foundation.Data
+  @objc override dynamic public init()
+  @objc deinit
+}
+@_hasMissingDesignatedInitializers public class UbqChangePin {
+  public enum ChangePinState {
+    case AWAITING_PIN
+    case AWAITING_NEW_PIN
+    case AWAITING_CONFIRMATION_PIN
+    case AWAITING_FINISH
+    case SUCCESS
+    case FAILURE
+    public static func == (a: UBQKit.UbqChangePin.ChangePinState, b: UBQKit.UbqChangePin.ChangePinState) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public var state: UBQKit.UbqChangePin.ChangePinState {
+    get
+  }
+  public func setUiProtocol(i: any UBQKit.ChangePinUiProtocol)
+  public func finish(changePinFinishProtocol: any UBQKit.ChangePinFinishProtocol)
+  @objc deinit
+}
+extension UBQKit.ASN1 {
+  @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class IA5String : UBQKit.ASN1.Item {
+    convenience public init(_ ia5String: Swift.String)
+    public var ia5String: Swift.String {
+      get
+      set
+    }
+    @objc deinit
+  }
+}
+public protocol AddBiometricsFinishProtocol {
+  func onAddBiometricsCompleted()
+  func onAddBiometricsFinishFailure(error: UBQKit.UbqKitError)
+  func onAddBiometricsIncorrectPinEntered(pinAttemptsLeft: Swift.Int8)
+}
+public protocol SubscribeFinishProtocol {
+  func onSubscribeCompleted(ubqAsset: UBQKit.UbqAsset)
+  func onSubscribeFinishFailure(error: UBQKit.UbqKitError)
+  func onSubscribeIncorrectPukEntered(ubqAsset: UBQKit.UbqAsset)
+}
+public protocol AddBiometricsUiProtocol {
+  func onAddBiometricsPinEntered()
+  func onAddBiometricsIncorrectBiometricsEntered()
+  func onAddBiometricsUiError(error: UBQKit.UbqKitError)
+}
+extension UBQKit.UbqSubscribe.SubscribeState : Swift.Equatable {}
+extension UBQKit.UbqSubscribe.SubscribeState : Swift.Hashable {}
+extension UBQKit.CryptoTypes : Swift.Equatable {}
+extension UBQKit.CryptoTypes : Swift.Hashable {}
+@available(iOS 13.0.0, *)
+extension UBQKit.TransactionTitle : Swift.Sendable {}
+extension UBQKit.FMVersion.Feature : Swift.Equatable {}
+extension UBQKit.FMVersion.Feature : Swift.Hashable {}
+extension UBQKit.TransactionType : Swift.Equatable {}
+extension UBQKit.TransactionType : Swift.Hashable {}
+extension UBQKit.UbqTransaction.TransactionState : Swift.Equatable {}
+extension UBQKit.UbqTransaction.TransactionState : Swift.Hashable {}
+extension UBQKit.XMLEncoder.StringEncodingStrategy : Swift.Equatable {}
+extension UBQKit.XMLEncoder.StringEncodingStrategy : Swift.Hashable {}
+extension UBQKit.Asset.AssetState : Swift.Equatable {}
+extension UBQKit.Asset.AssetState : Swift.Hashable {}
+extension UBQKit.Asset.AssetState : Swift.RawRepresentable {}
+extension UBQKit.UbqAddBiometrics.AddBiometricsState : Swift.Equatable {}
+extension UBQKit.UbqAddBiometrics.AddBiometricsState : Swift.Hashable {}
+extension UBQKit.ASN1.Tag.Class : Swift.Equatable {}
+extension UBQKit.ASN1.Tag.Class : Swift.Hashable {}
+extension UBQKit.ASN1.Tag.Class : Swift.RawRepresentable {}
+extension UBQKit.ASN1.Tag.Form : Swift.Equatable {}
+extension UBQKit.ASN1.Tag.Form : Swift.Hashable {}
+extension UBQKit.ASN1.Tag.Form : Swift.RawRepresentable {}
+extension UBQKit.ASN1.Tag.Value : Swift.Equatable {}
+extension UBQKit.ASN1.Tag.Value : Swift.Hashable {}
+extension UBQKit.ASN1.Tag.Value : Swift.RawRepresentable {}
+extension UBQKit.UbqResetPin.ResetPinState : Swift.Equatable {}
+extension UBQKit.UbqResetPin.ResetPinState : Swift.Hashable {}
+extension UBQKit.UbqChangePin.ChangePinState : Swift.Equatable {}
+extension UBQKit.UbqChangePin.ChangePinState : Swift.Hashable {}