@oiti/rn-liveness3d 0.1.1

package/ios/Pods/FaceCaptcha/Framework/FaceCaptcha.xcframework/ios-arm64_armv7/FaceCaptcha.framework/Modules/FaceCaptcha.swiftmodule/arm64-apple-ios.swiftinterface

@@ -0,0 +1,2187 @@
+// swift-interface-format-version: 1.0
+// swift-compiler-version: Apple Swift version 5.6.1 effective-4.2 (swiftlang-5.6.0.323.66 clang-1316.0.20.12)
+// swift-module-flags: -target arm64-apple-ios10.0 -enable-objc-interop -enable-library-evolution -swift-version 4.2 -enforce-exclusivity=checked -O -module-name FaceCaptcha
+import AVFoundation
+import CallKit
+import Combine
+import CoreGraphics
+import CoreTelephony
+import Darwin
+@_exported import FaceCaptcha
+import Foundation
+import Network
+import Swift
+import SystemConfiguration
+import UIKit.UIButton
+import UIKit.UIImage
+import UIKit
+import UIKit.UIView
+import _Concurrency
+public enum DocumentscopyFocusIndicator {
+  case frontIndicator
+  case backIndicator
+  public static func == (a: FaceCaptcha.DocumentscopyFocusIndicator, b: FaceCaptcha.DocumentscopyFocusIndicator) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public var hashValue: Swift.Int {
+    get
+  }
+}
+extension FaceCaptcha.AES : FaceCaptcha.Cryptors {
+  @inlinable final public func makeEncryptor() throws -> FaceCaptcha.Cryptor & FaceCaptcha.Updatable {
+    let blockSize = blockMode.customBlockSize ?? AES.blockSize
+    let worker = try blockMode.worker(blockSize: blockSize, cipherOperation: encrypt, encryptionOperation: encrypt)
+    if worker is StreamModeWorker {
+      return try StreamEncryptor(blockSize: blockSize, padding: padding, worker)
+    }
+    return try BlockEncryptor(blockSize: blockSize, padding: padding, worker)
+  }
+  @inlinable final public func makeDecryptor() throws -> FaceCaptcha.Cryptor & FaceCaptcha.Updatable {
+    let blockSize = blockMode.customBlockSize ?? AES.blockSize
+    let cipherOperation: CipherOperationOnBlock = blockMode.options.contains(.useEncryptToDecrypt) == true ? encrypt : decrypt
+    let worker = try blockMode.worker(blockSize: blockSize, cipherOperation: cipherOperation, encryptionOperation: encrypt)
+    if worker is StreamModeWorker {
+      return try StreamDecryptor(blockSize: blockSize, padding: padding, worker)
+    }
+    return try BlockDecryptor(blockSize: blockSize, padding: padding, worker)
+  }
+}
+extension UIKit.UIImage {
+  public func cropToRect(rect: CoreGraphics.CGRect) -> UIKit.UIImage
+}
+public protocol FaceCaptchaDelegate : AnyObject {
+  func handleFaceCaptchaValidation(validateModel: FaceCaptcha.FCValidCaptchaModel)
+  func handleFaceCaptchaError(error: FaceCaptcha.FaceCaptchaError)
+  func handleFaceCaptchaCanceled()
+}
+@objc @_inheritsConvenienceInitializers @_Concurrency.MainActor(unsafe) public class FaceCaptchaViewController : UIKit.UIViewController {
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public var shouldAutorotate: Swift.Bool {
+    @_Concurrency.MainActor(unsafe) @objc get
+  }
+  @_Concurrency.MainActor(unsafe) convenience public init(appKey: Swift.String, baseURL: Swift.String, delegate: FaceCaptcha.FaceCaptchaDelegate, cameraOverlay: UIKit.UIImage? = nil, customView: FaceCaptcha.FaceCaptchaView? = nil)
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public func loadView()
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public func viewDidLoad()
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public func viewDidAppear(_ animated: Swift.Bool)
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public func viewWillDisappear(_ animated: Swift.Bool)
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public init(nibName nibNameOrNil: Swift.String?, bundle nibBundleOrNil: Foundation.Bundle?)
+  @_Concurrency.MainActor(unsafe) @objc required dynamic public init?(coder: Foundation.NSCoder)
+  @objc deinit
+}
+extension FaceCaptcha.FaceCaptchaViewController : AVFoundation.AVCapturePhotoCaptureDelegate {
+  @available(iOS 11.0, *)
+  @_Concurrency.MainActor(unsafe) @objc dynamic public func photoOutput(_ output: AVFoundation.AVCapturePhotoOutput, didFinishProcessingPhoto photo: AVFoundation.AVCapturePhoto, error: Swift.Error?)
+  @_Concurrency.MainActor(unsafe) @objc dynamic public func photoOutput(_ output: AVFoundation.AVCapturePhotoOutput, didFinishProcessingPhoto photoSampleBuffer: CoreMedia.CMSampleBuffer?, previewPhoto previewPhotoSampleBuffer: CoreMedia.CMSampleBuffer?, resolvedSettings: AVFoundation.AVCaptureResolvedPhotoSettings, bracketSettings: AVFoundation.AVCaptureBracketedStillImageSettings?, error: Swift.Error?)
+}
+@_inheritsConvenienceInitializers final public class CBCMAC : FaceCaptcha.CMAC {
+  override final public func authenticate(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+  override public init(key: Swift.Array<Swift.UInt8>) throws
+  @objc deinit
+}
+final public class SHA2 {
+  @usableFromInline
+  final internal let variant: FaceCaptcha.SHA2.Variant
+  @usableFromInline
+  final internal let size: Swift.Int
+  @usableFromInline
+  final internal let blockSize: Swift.Int
+  @usableFromInline
+  final internal let digestLength: Swift.Int
+  @usableFromInline
+  final internal var accumulated: [Swift.UInt8]
+  @usableFromInline
+  final internal var processedBytesTotalCount: Swift.Int
+  @usableFromInline
+  final internal var accumulatedHash32: [Swift.UInt32]
+  @usableFromInline
+  final internal var accumulatedHash64: [Swift.UInt64]
+  public enum Variant : Swift.RawRepresentable {
+    case sha224, sha256, sha384, sha512
+    public var digestLength: Swift.Int {
+      get
+    }
+    public var blockSize: Swift.Int {
+      get
+    }
+    public typealias RawValue = Swift.Int
+    public var rawValue: FaceCaptcha.SHA2.Variant.RawValue {
+      get
+    }
+    public init?(rawValue: FaceCaptcha.SHA2.Variant.RawValue)
+    @usableFromInline
+    internal var h: Swift.Array<Swift.UInt64> {
+      get
+    }
+    @usableFromInline
+    internal var finalLength: Swift.Int {
+      get
+    }
+  }
+  public init(variant: FaceCaptcha.SHA2.Variant)
+  @inlinable final public func calculate(for bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8> {
+    do {
+      return try update(withBytes: bytes.slice, isLast: true)
+    } catch {
+      return []
+    }
+  }
+  @usableFromInline
+  final internal func process64(block chunk: Swift.ArraySlice<Swift.UInt8>, currentHash hh: inout Swift.Array<Swift.UInt64>)
+  @usableFromInline
+  final internal func process32(block chunk: Swift.ArraySlice<Swift.UInt8>, currentHash hh: inout Swift.Array<Swift.UInt32>)
+  @objc deinit
+}
+extension FaceCaptcha.SHA2 : FaceCaptcha.Updatable {
+  @inlinable final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8> {
+    self.accumulated += bytes
+
+    if isLast {
+      let lengthInBits = (processedBytesTotalCount + self.accumulated.count) * 8
+      let lengthBytes = lengthInBits.bytes(totalBytes: self.blockSize / 8) // A 64-bit/128-bit representation of b. blockSize fit by accident.
+
+      // Step 1. Append padding
+      bitPadding(to: &self.accumulated, blockSize: self.blockSize, allowance: self.blockSize / 8)
+
+      // Step 2. Append Length a 64-bit representation of lengthInBits
+      self.accumulated += lengthBytes
+    }
+
+    var processedBytes = 0
+    for chunk in self.accumulated.batched(by: self.blockSize) {
+      if isLast || (self.accumulated.count - processedBytes) >= self.blockSize {
+        switch self.variant {
+          case .sha224, .sha256:
+            self.process32(block: chunk, currentHash: &self.accumulatedHash32)
+          case .sha384, .sha512:
+            self.process64(block: chunk, currentHash: &self.accumulatedHash64)
+          @unknown default:
+            preconditionFailure()
+          }
+        processedBytes += chunk.count
+      }
+    }
+    self.accumulated.removeFirst(processedBytes)
+    self.processedBytesTotalCount += processedBytes
+
+    // output current hash
+    var result = Array<UInt8>(repeating: 0, count: variant.digestLength)
+    switch self.variant {
+      case .sha224, .sha256:
+        var pos = 0
+        for idx in 0..<self.accumulatedHash32.count where idx < self.variant.finalLength {
+          let h = accumulatedHash32[idx]
+          result[pos + 0] = UInt8((h >> 24) & 0xff)
+          result[pos + 1] = UInt8((h >> 16) & 0xff)
+          result[pos + 2] = UInt8((h >> 8) & 0xff)
+          result[pos + 3] = UInt8(h & 0xff)
+          pos += 4
+        }
+      case .sha384, .sha512:
+        var pos = 0
+        for idx in 0..<self.accumulatedHash64.count where idx < self.variant.finalLength {
+          let h = accumulatedHash64[idx]
+          result[pos + 0] = UInt8((h >> 56) & 0xff)
+          result[pos + 1] = UInt8((h >> 48) & 0xff)
+          result[pos + 2] = UInt8((h >> 40) & 0xff)
+          result[pos + 3] = UInt8((h >> 32) & 0xff)
+          result[pos + 4] = UInt8((h >> 24) & 0xff)
+          result[pos + 5] = UInt8((h >> 16) & 0xff)
+          result[pos + 6] = UInt8((h >> 8) & 0xff)
+          result[pos + 7] = UInt8(h & 0xff)
+          pos += 8
+        }
+      @unknown default:
+          preconditionFailure()
+    }
+
+    // reset hash value for instance
+    if isLast {
+      switch self.variant {
+        case .sha224, .sha256:
+          self.accumulatedHash32 = self.variant.h.lazy.map { UInt32($0) } // FIXME: UInt64 for process64
+        case .sha384, .sha512:
+          self.accumulatedHash64 = self.variant.h
+        @unknown default:
+          preconditionFailure()
+      }
+    }
+
+    return result
+  }
+}
+final public class Blowfish {
+  public enum Error : Swift.Error {
+    case dataPaddingRequired
+    case invalidKeyOrInitializationVector
+    case invalidInitializationVector
+    case invalidBlockMode
+    public static func == (a: FaceCaptcha.Blowfish.Error, b: FaceCaptcha.Blowfish.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public static let blockSize: Swift.Int
+  final public let keySize: Swift.Int
+  public init(key: Swift.Array<Swift.UInt8>, blockMode: FaceCaptcha.BlockMode = CBC(iv: Array<UInt8>(repeating: 0, count: Blowfish.blockSize)), padding: FaceCaptcha.Padding) throws
+  @objc deinit
+}
+extension FaceCaptcha.Blowfish : FaceCaptcha.Cipher {
+  final public func encrypt<C>(_ bytes: C) throws -> Swift.Array<Swift.UInt8> where C : Swift.Collection, C.Element == Swift.UInt8, C.Index == Swift.Int
+  final public func decrypt<C>(_ bytes: C) throws -> Swift.Array<Swift.UInt8> where C : Swift.Collection, C.Element == Swift.UInt8, C.Index == Swift.Int
+}
+public struct FCPrivateKeyModel {
+  public var token: Swift.String?
+  public var expires: Swift.String?
+}
+extension Swift.UInt64 {
+  @_specialize(exported: false, kind: full, where T == Swift.ArraySlice<Swift.UInt8>)
+  @inlinable internal init<T>(bytes: T, fromIndex index: T.Index) where T : Swift.Collection, T.Element == Swift.UInt8, T.Index == Swift.Int {
+    if bytes.isEmpty {
+      self = 0
+      return
+    }
+
+    let count = bytes.count
+
+    let val0 = count > 0 ? UInt64(bytes[index.advanced(by: 0)]) << 56 : 0
+    let val1 = count > 1 ? UInt64(bytes[index.advanced(by: 1)]) << 48 : 0
+    let val2 = count > 2 ? UInt64(bytes[index.advanced(by: 2)]) << 40 : 0
+    let val3 = count > 3 ? UInt64(bytes[index.advanced(by: 3)]) << 32 : 0
+    let val4 = count > 4 ? UInt64(bytes[index.advanced(by: 4)]) << 24 : 0
+    let val5 = count > 5 ? UInt64(bytes[index.advanced(by: 5)]) << 16 : 0
+    let val6 = count > 6 ? UInt64(bytes[index.advanced(by: 6)]) << 8 : 0
+    let val7 = count > 7 ? UInt64(bytes[index.advanced(by: 7)]) : 0
+
+    self = val0 | val1 | val2 | val3 | val4 | val5 | val6 | val7
+  }
+}
+public class CMAC : FaceCaptcha.Authenticator {
+  public enum Error : Swift.Error {
+    case wrongKeyLength
+    public static func == (a: FaceCaptcha.CMAC.Error, b: FaceCaptcha.CMAC.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public init(key: Swift.Array<Swift.UInt8>) throws
+  public func authenticate(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+  public func authenticate(_ bytes: Swift.Array<Swift.UInt8>, cipher: FaceCaptcha.Cipher) throws -> Swift.Array<Swift.UInt8>
+  @objc deinit
+}
+extension Swift.Array where Element == Swift.UInt8 {
+  public func toBase64() -> Swift.String?
+  public init(base64: Swift.String)
+}
+@objc @_inheritsConvenienceInitializers @_Concurrency.MainActor(unsafe) public class DocumentscopyCameraPreviewView : UIKit.UIView {
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public class var layerClass: Swift.AnyClass {
+    @_Concurrency.MainActor(unsafe) @objc get
+  }
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public init(frame: CoreGraphics.CGRect)
+  @_Concurrency.MainActor(unsafe) @objc required dynamic public init?(coder: Foundation.NSCoder)
+  @objc deinit
+}
+extension Swift.String {
+  @inlinable public var bytes: Swift.Array<Swift.UInt8> {
+    get {
+    data(using: String.Encoding.utf8, allowLossyConversion: true)?.bytes ?? Array(utf8)
+  }
+  }
+  @inlinable public func md5() -> Swift.String {
+    self.bytes.md5().toHexString()
+  }
+  @inlinable public func sha1() -> Swift.String {
+    self.bytes.sha1().toHexString()
+  }
+  @inlinable public func sha224() -> Swift.String {
+    self.bytes.sha224().toHexString()
+  }
+  @inlinable public func sha256() -> Swift.String {
+    self.bytes.sha256().toHexString()
+  }
+  @inlinable public func sha384() -> Swift.String {
+    self.bytes.sha384().toHexString()
+  }
+  @inlinable public func sha512() -> Swift.String {
+    self.bytes.sha512().toHexString()
+  }
+  @inlinable public func sha3(_ variant: FaceCaptcha.SHA3.Variant) -> Swift.String {
+    self.bytes.sha3(variant).toHexString()
+  }
+  @inlinable public func crc32(seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.String {
+    self.bytes.crc32(seed: seed, reflect: reflect).bytes().toHexString()
+  }
+  @inlinable public func crc32c(seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.String {
+    self.bytes.crc32c(seed: seed, reflect: reflect).bytes().toHexString()
+  }
+  @inlinable public func crc16(seed: Swift.UInt16? = nil) -> Swift.String {
+    self.bytes.crc16(seed: seed).bytes().toHexString()
+  }
+  @inlinable public func encrypt(cipher: FaceCaptcha.Cipher) throws -> Swift.String {
+    try self.bytes.encrypt(cipher: cipher).toHexString()
+  }
+  @inlinable public func encryptToBase64(cipher: FaceCaptcha.Cipher) throws -> Swift.String? {
+    try self.bytes.encrypt(cipher: cipher).toBase64()
+  }
+  @inlinable public func authenticate<A>(with authenticator: A) throws -> Swift.String where A : FaceCaptcha.Authenticator {
+    try self.bytes.authenticate(with: authenticator).toHexString()
+  }
+}
+public protocol CustomInstructionView : UIKit.UIView {
+  var backButton: UIKit.UIButton! { get }
+  var continueButton: UIKit.UIButton! { get }
+  func changeLoadingVisibility(to visibility: FaceCaptcha.LoadingVisibility)
+}
+final public class HMAC : FaceCaptcha.Authenticator {
+  public enum Error : Swift.Error {
+    case authenticateError
+    case invalidInput
+    public static func == (a: FaceCaptcha.HMAC.Error, b: FaceCaptcha.HMAC.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public enum Variant {
+    case sha1, sha256, sha384, sha512, md5
+    public static func == (a: FaceCaptcha.HMAC.Variant, b: FaceCaptcha.HMAC.Variant) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public init(key: Swift.Array<Swift.UInt8>, variant: FaceCaptcha.HMAC.Variant = .md5)
+  final public func authenticate(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+  @objc deinit
+}
+final public class GCM : FaceCaptcha.BlockMode {
+  public enum Mode {
+    case combined
+    case detached
+    public static func == (a: FaceCaptcha.GCM.Mode, b: FaceCaptcha.GCM.Mode) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  final public let options: FaceCaptcha.BlockModeOption
+  public enum Error : Swift.Error {
+    case invalidInitializationVector
+    case fail
+    public static func == (a: FaceCaptcha.GCM.Error, b: FaceCaptcha.GCM.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  final public let customBlockSize: Swift.Int?
+  final public var authenticationTag: Swift.Array<Swift.UInt8>?
+  public init(iv: Swift.Array<Swift.UInt8>, additionalAuthenticatedData: Swift.Array<Swift.UInt8>? = nil, tagLength: Swift.Int = 16, mode: FaceCaptcha.GCM.Mode = .detached)
+  convenience public init(iv: Swift.Array<Swift.UInt8>, authenticationTag: Swift.Array<Swift.UInt8>, additionalAuthenticatedData: Swift.Array<Swift.UInt8>? = nil, mode: FaceCaptcha.GCM.Mode = .detached)
+  final public func worker(blockSize: Swift.Int, cipherOperation: @escaping FaceCaptcha.CipherOperationOnBlock, encryptionOperation: @escaping FaceCaptcha.CipherOperationOnBlock) throws -> FaceCaptcha.CipherModeWorker
+  @objc deinit
+}
+final public class AES {
+  public enum Error : Swift.Error {
+    case invalidKeySize
+    case dataPaddingRequired
+    case invalidData
+    public static func == (a: FaceCaptcha.AES.Error, b: FaceCaptcha.AES.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public enum Variant : Swift.Int {
+    case aes128, aes192, aes256
+    public init?(rawValue: Swift.Int)
+    public typealias RawValue = Swift.Int
+    public var rawValue: Swift.Int {
+      get
+    }
+  }
+  @usableFromInline
+  final internal let variantNr: Swift.Int
+  @usableFromInline
+  final internal let variantNb: Swift.Int
+  @usableFromInline
+  final internal let variantNk: Swift.Int
+  public static let blockSize: Swift.Int
+  final public let keySize: Swift.Int
+  final public let variant: FaceCaptcha.AES.Variant
+  @usableFromInline
+  final internal let blockMode: FaceCaptcha.BlockMode
+  @usableFromInline
+  final internal let padding: FaceCaptcha.Padding
+  @usableFromInline
+  final internal var expandedKey: Swift.Array<Swift.Array<Swift.UInt32>> {
+    get
+    set
+  }
+  @usableFromInline
+  final internal var expandedKeyInv: Swift.Array<Swift.Array<Swift.UInt32>> {
+    get
+    set
+  }
+  @usableFromInline
+  internal static let T0: [Swift.UInt32]
+  @usableFromInline
+  internal static let T0_INV: [Swift.UInt32]
+  @usableFromInline
+  internal static let T1: [Swift.UInt32]
+  @usableFromInline
+  internal static let T1_INV: [Swift.UInt32]
+  @usableFromInline
+  internal static let T2: [Swift.UInt32]
+  @usableFromInline
+  internal static let T2_INV: [Swift.UInt32]
+  @usableFromInline
+  internal static let T3: [Swift.UInt32]
+  @usableFromInline
+  internal static let T3_INV: [Swift.UInt32]
+  @usableFromInline
+  internal static let U1: [Swift.UInt32]
+  @usableFromInline
+  internal static let U2: [Swift.UInt32]
+  @usableFromInline
+  internal static let U3: [Swift.UInt32]
+  @usableFromInline
+  internal static let U4: [Swift.UInt32]
+  public init(key: Swift.Array<Swift.UInt8>, blockMode: FaceCaptcha.BlockMode, padding: FaceCaptcha.Padding = .pkcs7) throws
+  @inlinable final internal func encrypt(block: Swift.ArraySlice<Swift.UInt8>) -> Swift.Array<Swift.UInt8>? {
+    if self.blockMode.options.contains(.paddingRequired) && block.count != AES.blockSize {
+      return Array(block)
+    }
+
+    let rounds = self.variantNr
+    let rk = self.expandedKey
+
+    let b00 = UInt32(block[block.startIndex.advanced(by: 0)])
+    let b01 = UInt32(block[block.startIndex.advanced(by: 1)]) << 8
+    let b02 = UInt32(block[block.startIndex.advanced(by: 2)]) << 16
+    let b03 = UInt32(block[block.startIndex.advanced(by: 3)]) << 24
+    var b0 = b00 | b01 | b02 | b03
+
+    let b10 = UInt32(block[block.startIndex.advanced(by: 4)])
+    let b11 = UInt32(block[block.startIndex.advanced(by: 5)]) << 8
+    let b12 = UInt32(block[block.startIndex.advanced(by: 6)]) << 16
+    let b13 = UInt32(block[block.startIndex.advanced(by: 7)]) << 24
+    var b1 = b10 | b11 | b12 | b13
+
+    let b20 = UInt32(block[block.startIndex.advanced(by: 8)])
+    let b21 = UInt32(block[block.startIndex.advanced(by: 9)]) << 8
+    let b22 = UInt32(block[block.startIndex.advanced(by: 10)]) << 16
+    let b23 = UInt32(block[block.startIndex.advanced(by: 11)]) << 24
+    var b2 = b20 | b21 | b22 | b23
+
+    let b30 = UInt32(block[block.startIndex.advanced(by: 12)])
+    let b31 = UInt32(block[block.startIndex.advanced(by: 13)]) << 8
+    let b32 = UInt32(block[block.startIndex.advanced(by: 14)]) << 16
+    let b33 = UInt32(block[block.startIndex.advanced(by: 15)]) << 24
+    var b3 = b30 | b31 | b32 | b33
+
+    let tLength = 4
+    let t = UnsafeMutablePointer<UInt32>.allocate(capacity: tLength)
+    t.initialize(repeating: 0, count: tLength)
+    defer {
+      t.deinitialize(count: tLength)
+      t.deallocate()
+    }
+
+    for r in 0..<rounds - 1 {
+      t[0] = b0 ^ rk[r][0]
+      t[1] = b1 ^ rk[r][1]
+      t[2] = b2 ^ rk[r][2]
+      t[3] = b3 ^ rk[r][3]
+
+      let lb00 = AES.T0[Int(t[0] & 0xff)]
+      let lb01 = AES.T1[Int((t[1] >> 8) & 0xff)]
+      let lb02 = AES.T2[Int((t[2] >> 16) & 0xff)]
+      let lb03 = AES.T3[Int(t[3] >> 24)]
+      b0 = lb00 ^ lb01 ^ lb02 ^ lb03
+
+      let lb10 = AES.T0[Int(t[1] & 0xff)]
+      let lb11 = AES.T1[Int((t[2] >> 8) & 0xff)]
+      let lb12 = AES.T2[Int((t[3] >> 16) & 0xff)]
+      let lb13 = AES.T3[Int(t[0] >> 24)]
+      b1 = lb10 ^ lb11 ^ lb12 ^ lb13
+
+      let lb20 = AES.T0[Int(t[2] & 0xff)]
+      let lb21 = AES.T1[Int((t[3] >> 8) & 0xff)]
+      let lb22 = AES.T2[Int((t[0] >> 16) & 0xff)]
+      let lb23 = AES.T3[Int(t[1] >> 24)]
+      b2 = lb20 ^ lb21 ^ lb22 ^ lb23
+
+      let lb30 = AES.T0[Int(t[3] & 0xff)]
+      let lb31 = AES.T1[Int((t[0] >> 8) & 0xff)]
+      let lb32 = AES.T2[Int((t[1] >> 16) & 0xff)]
+      let lb33 = AES.T3[Int(t[2] >> 24)]
+      b3 = lb30 ^ lb31 ^ lb32 ^ lb33
+    }
+
+    // last round
+    let r = rounds - 1
+
+    t[0] = b0 ^ rk[r][0]
+    t[1] = b1 ^ rk[r][1]
+    t[2] = b2 ^ rk[r][2]
+    t[3] = b3 ^ rk[r][3]
+
+    // rounds
+    b0 = F1(t[0], t[1], t[2], t[3]) ^ rk[rounds][0]
+    b1 = F1(t[1], t[2], t[3], t[0]) ^ rk[rounds][1]
+    b2 = F1(t[2], t[3], t[0], t[1]) ^ rk[rounds][2]
+    b3 = F1(t[3], t[0], t[1], t[2]) ^ rk[rounds][3]
+
+    let encrypted: Array<UInt8> = [
+      UInt8(b0 & 0xff), UInt8((b0 >> 8) & 0xff), UInt8((b0 >> 16) & 0xff), UInt8((b0 >> 24) & 0xff),
+      UInt8(b1 & 0xff), UInt8((b1 >> 8) & 0xff), UInt8((b1 >> 16) & 0xff), UInt8((b1 >> 24) & 0xff),
+      UInt8(b2 & 0xff), UInt8((b2 >> 8) & 0xff), UInt8((b2 >> 16) & 0xff), UInt8((b2 >> 24) & 0xff),
+      UInt8(b3 & 0xff), UInt8((b3 >> 8) & 0xff), UInt8((b3 >> 16) & 0xff), UInt8((b3 >> 24) & 0xff)
+    ]
+    return encrypted
+  }
+  @usableFromInline
+  final internal func decrypt(block: Swift.ArraySlice<Swift.UInt8>) -> Swift.Array<Swift.UInt8>?
+  @objc deinit
+}
+extension FaceCaptcha.AES {
+  @usableFromInline
+  @inline(__always) final internal func F1(_ x0: Swift.UInt32, _ x1: Swift.UInt32, _ x2: Swift.UInt32, _ x3: Swift.UInt32) -> Swift.UInt32
+}
+extension FaceCaptcha.AES : FaceCaptcha.Cipher {
+  @inlinable final public func encrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8> {
+    let blockSize = self.blockMode.customBlockSize ?? AES.blockSize
+    let chunks = bytes.batched(by: blockSize)
+
+    var oneTimeCryptor = try makeEncryptor()
+    var out = Array<UInt8>(reserveCapacity: bytes.count)
+    for chunk in chunks {
+      out += try oneTimeCryptor.update(withBytes: chunk, isLast: false)
+    }
+    // Padding may be added at the very end
+    out += try oneTimeCryptor.finish()
+
+    if self.blockMode.options.contains(.paddingRequired) && (out.count % AES.blockSize != 0) {
+      throw Error.dataPaddingRequired
+    }
+
+    return out
+  }
+  @inlinable final public func decrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8> {
+    if self.blockMode.options.contains(.paddingRequired) && (bytes.count % AES.blockSize != 0) {
+      throw Error.dataPaddingRequired
+    }
+
+    var oneTimeCryptor = try makeDecryptor()
+    let chunks = bytes.batched(by: AES.blockSize)
+    if chunks.isEmpty {
+      throw Error.invalidData
+    }
+
+    var out = Array<UInt8>(reserveCapacity: bytes.count)
+
+    var lastIdx = chunks.startIndex
+    chunks.indices.formIndex(&lastIdx, offsetBy: chunks.count - 1)
+
+    // To properly remove padding, `isLast` has to be known when called with the last chunk of ciphertext
+    // Last chunk of ciphertext may contains padded data so next call to update(..) won't be able to remove it
+    for idx in chunks.indices {
+      out += try oneTimeCryptor.update(withBytes: chunks[idx], isLast: idx == lastIdx)
+    }
+    return out
+  }
+}
+final public class SHA3 {
+  final public let blockSize: Swift.Int
+  final public let digestLength: Swift.Int
+  final public let markByte: Swift.UInt8
+  @usableFromInline
+  final internal var accumulated: [Swift.UInt8]
+  @usableFromInline
+  final internal var accumulatedHash: Swift.Array<Swift.UInt64>
+  public enum Variant {
+    case sha224, sha256, sha384, sha512, keccak224, keccak256, keccak384, keccak512
+    public var outputLength: Swift.Int {
+      get
+    }
+    public static func == (a: FaceCaptcha.SHA3.Variant, b: FaceCaptcha.SHA3.Variant) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public init(variant: FaceCaptcha.SHA3.Variant)
+  @inlinable final public func calculate(for bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8> {
+    do {
+      return try update(withBytes: bytes.slice, isLast: true)
+    } catch {
+      return []
+    }
+  }
+  @usableFromInline
+  final internal func process(block chunk: Swift.ArraySlice<Swift.UInt64>, currentHash hh: inout Swift.Array<Swift.UInt64>)
+  @objc deinit
+}
+extension FaceCaptcha.SHA3 : FaceCaptcha.Updatable {
+  @inlinable final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8> {
+    self.accumulated += bytes
+
+    if isLast {
+      // Add padding
+      let markByteIndex = self.accumulated.count
+
+      // We need to always pad the input. Even if the input is a multiple of blockSize.
+      let r = self.blockSize * 8
+      let q = (r / 8) - (accumulated.count % (r / 8))
+      self.accumulated += Array<UInt8>(repeating: 0, count: q)
+
+      self.accumulated[markByteIndex] |= self.markByte
+      self.accumulated[self.accumulated.count - 1] |= 0x80
+    }
+
+    var processedBytes = 0
+    for chunk in self.accumulated.batched(by: self.blockSize) {
+      if isLast || (self.accumulated.count - processedBytes) >= self.blockSize {
+        self.process(block: chunk.toUInt64Array().slice, currentHash: &self.accumulatedHash)
+        processedBytes += chunk.count
+      }
+    }
+    self.accumulated.removeFirst(processedBytes)
+
+    // TODO: verify performance, reduce vs for..in
+    let result = self.accumulatedHash.reduce(into: Array<UInt8>()) { (result, value) in
+      result += value.bigEndian.bytes()
+    }
+
+    // reset hash value for instance
+    if isLast {
+      self.accumulatedHash = Array<UInt64>(repeating: 0, count: self.digestLength)
+    }
+
+    return Array(result[0..<self.digestLength])
+  }
+}
+extension UIKit.UIViewController {
+  @_Concurrency.MainActor(unsafe) public func showAlert(title: Swift.String?, message: Swift.String)
+}
+final public class Scrypt {
+  public init(password: Swift.Array<Swift.UInt8>, salt: Swift.Array<Swift.UInt8>, dkLen: Swift.Int, N: Swift.Int, r: Swift.Int, p: Swift.Int) throws
+  final public func calculate() throws -> [Swift.UInt8]
+  @objc deinit
+}
+extension FaceCaptcha.PKCS5 {
+  public struct PBKDF1 {
+    public enum Error : Swift.Error {
+      case invalidInput
+      case derivedKeyTooLong
+      public static func == (a: FaceCaptcha.PKCS5.PBKDF1.Error, b: FaceCaptcha.PKCS5.PBKDF1.Error) -> Swift.Bool
+      public func hash(into hasher: inout Swift.Hasher)
+      public var hashValue: Swift.Int {
+        get
+      }
+    }
+    public enum Variant {
+      case md5, sha1
+      @usableFromInline
+      internal var size: Swift.Int {
+        get
+      }
+      @usableFromInline
+      internal func calculateHash(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
+      public static func == (a: FaceCaptcha.PKCS5.PBKDF1.Variant, b: FaceCaptcha.PKCS5.PBKDF1.Variant) -> Swift.Bool
+      public func hash(into hasher: inout Swift.Hasher)
+      public var hashValue: Swift.Int {
+        get
+      }
+    }
+    @usableFromInline
+    internal let iterations: Swift.Int
+    @usableFromInline
+    internal let variant: FaceCaptcha.PKCS5.PBKDF1.Variant
+    @usableFromInline
+    internal let keyLength: Swift.Int
+    @usableFromInline
+    internal let t1: Swift.Array<Swift.UInt8>
+    public init(password: Swift.Array<Swift.UInt8>, salt: Swift.Array<Swift.UInt8>, variant: FaceCaptcha.PKCS5.PBKDF1.Variant = .sha1, iterations: Swift.Int = 4096, keyLength: Swift.Int? = nil) throws
+    @inlinable public func calculate() -> Swift.Array<Swift.UInt8> {
+      var t = self.t1
+      for _ in 2...self.iterations {
+        t = self.variant.calculateHash(t)
+      }
+      return Array(t[0..<self.keyLength])
+    }
+  }
+}
+final public class Rabbit {
+  public enum Error : Swift.Error {
+    case invalidKeyOrInitializationVector
+    public static func == (a: FaceCaptcha.Rabbit.Error, b: FaceCaptcha.Rabbit.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public static let ivSize: Swift.Int
+  public static let keySize: Swift.Int
+  public static let blockSize: Swift.Int
+  final public var keySize: Swift.Int {
+    get
+  }
+  convenience public init(key: Swift.Array<Swift.UInt8>) throws
+  public init(key: Swift.Array<Swift.UInt8>, iv: Swift.Array<Swift.UInt8>?) throws
+  @objc deinit
+}
+extension FaceCaptcha.Rabbit : FaceCaptcha.Cipher {
+  final public func encrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+  final public func decrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+}
+public enum DocumentscopyError {
+  case invalidAppKey
+  case certifaceOff
+  case cameraSetupFailed
+  case noCameraPermission
+  case errorCapturePicture
+  case noInternetConnection
+  case validationError
+  case faceCaptchaNotExecuted
+  public static func == (a: FaceCaptcha.DocumentscopyError, b: FaceCaptcha.DocumentscopyError) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public var hashValue: Swift.Int {
+    get
+  }
+}
+public struct CBC : FaceCaptcha.BlockMode {
+  public enum Error : Swift.Error {
+    case invalidInitializationVector
+    public static func == (a: FaceCaptcha.CBC.Error, b: FaceCaptcha.CBC.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public let options: FaceCaptcha.BlockModeOption
+  public let customBlockSize: Swift.Int?
+  public init(iv: Swift.Array<Swift.UInt8>)
+  public func worker(blockSize: Swift.Int, cipherOperation: @escaping FaceCaptcha.CipherOperationOnBlock, encryptionOperation: @escaping FaceCaptcha.CipherOperationOnBlock) throws -> FaceCaptcha.CipherModeWorker
+}
+public struct FCResultModel {
+}
+public protocol PaddingProtocol {
+  func add(to: Swift.Array<Swift.UInt8>, blockSize: Swift.Int) -> Swift.Array<Swift.UInt8>
+  func remove(from: Swift.Array<Swift.UInt8>, blockSize: Swift.Int?) -> Swift.Array<Swift.UInt8>
+}
+public enum Padding : FaceCaptcha.PaddingProtocol {
+  case noPadding, zeroPadding, pkcs7, pkcs5, iso78164
+  public func add(to: Swift.Array<Swift.UInt8>, blockSize: Swift.Int) -> Swift.Array<Swift.UInt8>
+  public func remove(from: Swift.Array<Swift.UInt8>, blockSize: Swift.Int?) -> Swift.Array<Swift.UInt8>
+  public static func == (a: FaceCaptcha.Padding, b: FaceCaptcha.Padding) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public var hashValue: Swift.Int {
+    get
+  }
+}
+public struct FCUserModel {
+  public var user: Swift.String?
+  public var pass: Swift.String?
+  public var cpf: Swift.String?
+  public var name: Swift.String?
+  public var birth: Swift.String?
+  public var privateKey: Swift.String?
+  public var image: UIKit.UIImage?
+  public init(_ user: Swift.String, _ pass: Swift.String, _ cpf: Swift.String, _ name: Swift.String, _ birth: Swift.String, _ overlapImage: UIKit.UIImage? = nil)
+}
+public typealias DocumentscopyCustomLoadingView = UIKit.UIView
+@_hasMissingDesignatedInitializers public class FCStringAPI {
+  public static let K_BASE_URL: Swift.String
+  public static let K_CHECK_AUTH: Swift.String
+  public static let K_CHALLENGE: Swift.String
+  public static let K_CAPTCHA: Swift.String
+  public static let K_SERVER: Swift.String
+  public static let K_API_KEY: Swift.String
+  @objc deinit
+}
+public struct Liveness3DError {
+  public let errorCode: Swift.Int
+  public let errorMessage: Swift.String
+}
+public enum Liveness3DErrorCode : Swift.Int {
+  case INVALID_APP_KEY
+  case NO_CAMERA_PERMISSION
+  case NO_INTERNET_CONNECTION
+  case LIVENESS_NOT_COMPLETED
+  case LIVENESS_NOT_INITIALIZED
+  public init?(rawValue: Swift.Int)
+  public typealias RawValue = Swift.Int
+  public var rawValue: Swift.Int {
+    get
+  }
+}
+public struct Liveness3DSuccess {
+  public var valid: Swift.Bool?
+  public var codID: Swift.Double?
+  public var cause: Swift.String?
+  public var protocolo: Swift.String?
+  public var scanResultBlob: Swift.String?
+}
+public struct BlockModeOption : Swift.OptionSet {
+  public let rawValue: Swift.Int
+  public init(rawValue: Swift.Int)
+  @usableFromInline
+  internal static let none: FaceCaptcha.BlockModeOption
+  @usableFromInline
+  internal static let initializationVectorRequired: FaceCaptcha.BlockModeOption
+  @usableFromInline
+  internal static let paddingRequired: FaceCaptcha.BlockModeOption
+  @usableFromInline
+  internal static let useEncryptToDecrypt: FaceCaptcha.BlockModeOption
+  public typealias ArrayLiteralElement = FaceCaptcha.BlockModeOption
+  public typealias Element = FaceCaptcha.BlockModeOption
+  public typealias RawValue = Swift.Int
+}
+public protocol CipherModeWorker {
+  var cipherOperation: FaceCaptcha.CipherOperationOnBlock { get }
+  var additionalBufferSize: Swift.Int { get }
+  @inlinable mutating func encrypt(block plaintext: Swift.ArraySlice<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
+  @inlinable mutating func decrypt(block ciphertext: Swift.ArraySlice<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
+}
+public protocol BlockModeWorker : FaceCaptcha.CipherModeWorker {
+  var blockSize: Swift.Int { get }
+}
+public protocol CounterModeWorker : FaceCaptcha.CipherModeWorker {
+  associatedtype Counter
+  var counter: Self.Counter { get set }
+}
+public protocol SeekableModeWorker : FaceCaptcha.CipherModeWorker {
+  mutating func seek(to position: Swift.Int) throws
+}
+public protocol StreamModeWorker : FaceCaptcha.CipherModeWorker {
+}
+public protocol FinalizingEncryptModeWorker : FaceCaptcha.CipherModeWorker {
+  mutating func finalize(encrypt ciphertext: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.ArraySlice<Swift.UInt8>
+}
+public protocol FinalizingDecryptModeWorker : FaceCaptcha.CipherModeWorker {
+  @discardableResult
+  mutating func willDecryptLast(bytes ciphertext: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.ArraySlice<Swift.UInt8>
+  mutating func didDecryptLast(bytes plaintext: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.ArraySlice<Swift.UInt8>
+  mutating func finalize(decrypt plaintext: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.ArraySlice<Swift.UInt8>
+}
+extension FaceCaptcha.Rabbit {
+  convenience public init(key: Swift.String) throws
+  convenience public init(key: Swift.String, iv: Swift.String) throws
+}
+@_hasMissingDesignatedInitializers final public class AEADChaCha20Poly1305 : FaceCaptcha.AEAD {
+  public static let kLen: Swift.Int
+  public static var ivRange: Swift.Range<Swift.Int>
+  public static func encrypt(_ plainText: Swift.Array<Swift.UInt8>, key: Swift.Array<Swift.UInt8>, iv: Swift.Array<Swift.UInt8>, authenticationHeader: Swift.Array<Swift.UInt8>) throws -> (cipherText: Swift.Array<Swift.UInt8>, authenticationTag: Swift.Array<Swift.UInt8>)
+  public static func decrypt(_ cipherText: Swift.Array<Swift.UInt8>, key: Swift.Array<Swift.UInt8>, iv: Swift.Array<Swift.UInt8>, authenticationHeader: Swift.Array<Swift.UInt8>, authenticationTag: Swift.Array<Swift.UInt8>) throws -> (plainText: Swift.Array<Swift.UInt8>, success: Swift.Bool)
+  @objc deinit
+}
+public struct CCM {
+  public enum Error : Swift.Error {
+    case invalidInitializationVector
+    case invalidParameter
+    case fail
+    public static func == (a: FaceCaptcha.CCM.Error, b: FaceCaptcha.CCM.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public let options: FaceCaptcha.BlockModeOption
+  public let customBlockSize: Swift.Int?
+  public var authenticationTag: Swift.Array<Swift.UInt8>?
+  public init(iv: Swift.Array<Swift.UInt8>, tagLength: Swift.Int, messageLength: Swift.Int, additionalAuthenticatedData: Swift.Array<Swift.UInt8>? = nil)
+  public init(iv: Swift.Array<Swift.UInt8>, tagLength: Swift.Int, messageLength: Swift.Int, authenticationTag: Swift.Array<Swift.UInt8>, additionalAuthenticatedData: Swift.Array<Swift.UInt8>? = nil)
+  public func worker(blockSize: Swift.Int, cipherOperation: @escaping FaceCaptcha.CipherOperationOnBlock, encryptionOperation: @escaping FaceCaptcha.CipherOperationOnBlock) throws -> FaceCaptcha.CipherModeWorker
+}
+public protocol CustomCameraPermissionView : UIKit.UIView {
+  var backButton: UIKit.UIButton! { get }
+  var checkPermissionButton: UIKit.UIButton! { get }
+  var openSettingsButton: UIKit.UIButton! { get }
+  var closeButton: UIKit.UIButton! { get }
+  func showBottomSheet(visibility: FaceCaptcha.Visibility)
+}
+public protocol DocumentscopyCustomInstructionView : UIKit.UIView {
+  var backButton: UIKit.UIButton! { get }
+  var viewCNH: UIKit.UIView! { get }
+  var viewRG: UIKit.UIView! { get }
+}
+public struct FCTypeFaceModel {
+}
+public protocol Cryptors : AnyObject {
+  func makeEncryptor() throws -> FaceCaptcha.Cryptor & FaceCaptcha.Updatable
+  func makeDecryptor() throws -> FaceCaptcha.Cryptor & FaceCaptcha.Updatable
+  static func randomIV(_ blockSize: Swift.Int) -> Swift.Array<Swift.UInt8>
+}
+extension FaceCaptcha.Cryptors {
+  public static func randomIV(_ count: Swift.Int) -> Swift.Array<Swift.UInt8>
+}
+public struct FCValidCaptchaModel {
+  public var valid: Swift.Bool?
+  public var codID: Swift.Double?
+  public var cause: Swift.String?
+  public var uidProtocol: Swift.String?
+}
+public protocol Authenticator {
+  func authenticate(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+}
+@usableFromInline
+internal struct BatchedCollectionIndex<Base> where Base : Swift.Collection {
+}
+extension FaceCaptcha.BatchedCollectionIndex : Swift.Comparable {
+  @usableFromInline
+  internal static func == <Base>(lhs: FaceCaptcha.BatchedCollectionIndex<Base>, rhs: FaceCaptcha.BatchedCollectionIndex<Base>) -> Swift.Bool where Base : Swift.Collection
+  @usableFromInline
+  internal static func < <Base>(lhs: FaceCaptcha.BatchedCollectionIndex<Base>, rhs: FaceCaptcha.BatchedCollectionIndex<Base>) -> Swift.Bool where Base : Swift.Collection
+}
+@usableFromInline
+internal struct BatchedCollection<Base> : Swift.Collection where Base : Swift.Collection {
+  @usableFromInline
+  internal init(base: Base, size: Swift.Int)
+  @usableFromInline
+  internal typealias Index = FaceCaptcha.BatchedCollectionIndex<Base>
+  @usableFromInline
+  internal var startIndex: FaceCaptcha.BatchedCollection<Base>.Index {
+    get
+  }
+  @usableFromInline
+  internal var endIndex: FaceCaptcha.BatchedCollection<Base>.Index {
+    get
+  }
+  @usableFromInline
+  internal func index(after idx: FaceCaptcha.BatchedCollection<Base>.Index) -> FaceCaptcha.BatchedCollection<Base>.Index
+  @usableFromInline
+  internal subscript(idx: FaceCaptcha.BatchedCollection<Base>.Index) -> Base.SubSequence {
+    get
+  }
+  @usableFromInline
+  internal typealias Element = Base.SubSequence
+  @usableFromInline
+  internal typealias Indices = Swift.DefaultIndices<FaceCaptcha.BatchedCollection<Base>>
+  @usableFromInline
+  internal typealias Iterator = Swift.IndexingIterator<FaceCaptcha.BatchedCollection<Base>>
+  @usableFromInline
+  internal typealias SubSequence = Swift.Slice<FaceCaptcha.BatchedCollection<Base>>
+}
+extension Swift.Collection {
+  @inlinable internal func batched(by size: Swift.Int) -> FaceCaptcha.BatchedCollection<Self> {
+    BatchedCollection(base: self, size: size)
+  }
+}
+final public class MD5 {
+  public init()
+  final public func calculate(for bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
+  @objc deinit
+}
+extension FaceCaptcha.MD5 : FaceCaptcha.Updatable {
+  final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8>
+}
+public protocol DocumentscopyDelegate : AnyObject {
+  func handleDocumentscopyCompleted()
+  func handleDocumentscopyError(error: FaceCaptcha.DocumentscopyError)
+  func handleDocumentscopyCanceled()
+}
+final public class ChaCha20 {
+  public enum Error : Swift.Error {
+    case invalidKeyOrInitializationVector
+    case notSupported
+    public static func == (a: FaceCaptcha.ChaCha20.Error, b: FaceCaptcha.ChaCha20.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public static let blockSize: Swift.Int
+  final public let keySize: Swift.Int
+  public init(key: Swift.Array<Swift.UInt8>, iv nonce: Swift.Array<Swift.UInt8>) throws
+  @objc deinit
+}
+extension FaceCaptcha.ChaCha20 : FaceCaptcha.Cipher {
+  final public func encrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+  final public func decrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+}
+extension FaceCaptcha.ChaCha20 {
+  public struct ChaChaEncryptor : FaceCaptcha.Cryptor, FaceCaptcha.Updatable {
+    public mutating func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8>
+    public func seek(to: Swift.Int) throws
+  }
+}
+extension FaceCaptcha.ChaCha20 {
+  public struct ChaChaDecryptor : FaceCaptcha.Cryptor, FaceCaptcha.Updatable {
+    public mutating func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = true) throws -> Swift.Array<Swift.UInt8>
+    public func seek(to: Swift.Int) throws
+  }
+}
+extension FaceCaptcha.ChaCha20 : FaceCaptcha.Cryptors {
+  final public func makeEncryptor() -> FaceCaptcha.Cryptor & FaceCaptcha.Updatable
+  final public func makeDecryptor() -> FaceCaptcha.Cryptor & FaceCaptcha.Updatable
+}
+@objc @_Concurrency.MainActor(unsafe) public class Liveness3DViewController : UIKit.UIViewController {
+  @_Concurrency.MainActor(unsafe) weak public var delegate: FaceCaptcha.Liveness3DDelegate?
+  @_Concurrency.MainActor(unsafe) public init(endpoint: Swift.String, liveness3DUser: FaceCaptcha.Liveness3DUser, debugOn: Swift.Bool, customInstructionView: FaceCaptcha.CustomInstructionView? = nil, customPermissionView: FaceCaptcha.CustomCameraPermissionView? = nil)
+  @_Concurrency.MainActor(unsafe) @objc required dynamic public init?(coder: Foundation.NSCoder)
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public func loadView()
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public func viewDidLoad()
+  @objc deinit
+}
+public struct HybridEcosystemLiveness3DViewAppearance {
+  public init(backgroundColor: UIKit.UIColor, loadingColor: UIKit.UIColor)
+}
+@objc @_Concurrency.MainActor(unsafe) public class HybridEcosystemLiveness3DViewController : UIKit.UIViewController {
+  @_Concurrency.MainActor(unsafe) weak public var delegate: FaceCaptcha.Liveness3DDelegate?
+  @_Concurrency.MainActor(unsafe) public init(liveness3DUser: FaceCaptcha.Liveness3DUser, customAppearance: FaceCaptcha.HybridEcosystemLiveness3DViewAppearance? = nil)
+  @_Concurrency.MainActor(unsafe) @objc required dynamic public init?(coder: Foundation.NSCoder)
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public func loadView()
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public func viewDidLoad()
+  @objc deinit
+}
+extension Swift.FixedWidthInteger {
+  @inlinable internal func bytes(totalBytes: Swift.Int = MemoryLayout<Self>.size) -> Swift.Array<Swift.UInt8> {
+    arrayOfBytes(value: self.littleEndian, length: totalBytes)
+    // TODO: adjust bytes order
+    // var value = self.littleEndian
+    // return withUnsafeBytes(of: &value, Array.init).reversed()
+  }
+}
+@_hasMissingDesignatedInitializers public class Strings {
+  @objc deinit
+}
+final public class Checksum {
+  @usableFromInline
+  internal static let table32: [Swift.UInt32]
+  @usableFromInline
+  internal static let table32c: [Swift.UInt32]
+  @usableFromInline
+  internal static let table16: [Swift.UInt16]
+  @usableFromInline
+  internal init()
+  @inlinable final internal func crc32(_ message: Swift.Array<Swift.UInt8>, seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.UInt32 {
+    var crc: UInt32 = seed != nil ? seed! : 0xFFFF_FFFF
+    for chunk in message.batched(by: 256) {
+      for b in chunk {
+        let idx = Int((crc ^ UInt32(reflect ? b : reversed(b))) & 0xFF)
+        crc = (crc >> 8) ^ Checksum.table32[idx]
+      }
+    }
+    return (reflect ? crc : reversed(crc)) ^ 0xFFFF_FFFF
+  }
+  @inlinable final internal func crc32c(_ message: Swift.Array<Swift.UInt8>, seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.UInt32 {
+    var crc: UInt32 = seed != nil ? seed! : 0xFFFF_FFFF
+    for chunk in message.batched(by: 256) {
+      for b in chunk {
+        let idx = Int((crc ^ UInt32(reflect ? b : reversed(b))) & 0xFF)
+        crc = (crc >> 8) ^ Checksum.table32c[idx]
+      }
+    }
+    return (reflect ? crc : reversed(crc)) ^ 0xFFFF_FFFF
+  }
+  @inlinable final internal func crc16(_ message: Swift.Array<Swift.UInt8>, seed: Swift.UInt16? = nil) -> Swift.UInt16 {
+    var crc: UInt16 = seed != nil ? seed! : 0x0000
+    for chunk in message.batched(by: 256) {
+      for b in chunk {
+        crc = (crc >> 8) ^ Checksum.table16[Int((crc ^ UInt16(b)) & 0xFF)]
+      }
+    }
+    return crc
+  }
+  @objc deinit
+}
+extension FaceCaptcha.Checksum {
+  @inlinable public static func crc32(_ message: Swift.Array<Swift.UInt8>, seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.UInt32 {
+    Checksum().crc32(message, seed: seed, reflect: reflect)
+  }
+  @inlinable public static func crc32c(_ message: Swift.Array<Swift.UInt8>, seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.UInt32 {
+    Checksum().crc32c(message, seed: seed, reflect: reflect)
+  }
+  @inlinable public static func crc16(_ message: Swift.Array<Swift.UInt8>, seed: Swift.UInt16? = nil) -> Swift.UInt16 {
+    Checksum().crc16(message, seed: seed)
+  }
+}
+@available(*, renamed: "Digest")
+public typealias Hash = FaceCaptcha.Digest
+public struct Digest {
+  public static func md5(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
+  public static func sha1(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
+  public static func sha224(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
+  public static func sha256(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
+  public static func sha384(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
+  public static func sha512(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
+  public static func sha2(_ bytes: Swift.Array<Swift.UInt8>, variant: FaceCaptcha.SHA2.Variant) -> Swift.Array<Swift.UInt8>
+  public static func sha3(_ bytes: Swift.Array<Swift.UInt8>, variant: FaceCaptcha.SHA3.Variant) -> Swift.Array<Swift.UInt8>
+}
+extension Swift.String {
+  public func decryptBase64ToString(cipher: FaceCaptcha.Cipher) throws -> Swift.String
+  public func decryptBase64(cipher: FaceCaptcha.Cipher) throws -> Swift.Array<Swift.UInt8>
+}
+public typealias LoadingVisibility = FaceCaptcha.Visibility
+public enum Visibility {
+  case displayed, hidden
+  public static func == (a: FaceCaptcha.Visibility, b: FaceCaptcha.Visibility) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public var hashValue: Swift.Int {
+    get
+  }
+}
+@_hasMissingDesignatedInitializers final public class FCWrapper {
+  final public var ok: Swift.Bool
+  public init(json: Swift.String)
+  final public func map<T>(optional: Swift.Bool = false, withClosure closure: ((FaceCaptcha.FCWrapper) -> (T?))? = nil) -> T?
+  final public func mapArrayOfObjects<T>(optional: Swift.Bool = false, withClosure closure: (FaceCaptcha.FCWrapper) -> (T.Iterator.Element)) -> T? where T : Swift.Collection
+  final public subscript(name: Swift.String) -> FaceCaptcha.FCWrapper {
+    get
+  }
+  @objc deinit
+}
+public enum PKCS7 {
+}
+@usableFromInline
+final internal class BlockEncryptor : FaceCaptcha.Cryptor, FaceCaptcha.Updatable {
+  @usableFromInline
+  internal init(blockSize: Swift.Int, padding: FaceCaptcha.Padding, _ worker: FaceCaptcha.CipherModeWorker) throws
+  final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool) throws -> Swift.Array<Swift.UInt8>
+  @usableFromInline
+  final internal func seek(to: Swift.Int) throws
+  @objc @usableFromInline
+  deinit
+}
+public struct ECB : FaceCaptcha.BlockMode {
+  public let options: FaceCaptcha.BlockModeOption
+  public let customBlockSize: Swift.Int?
+  public init()
+  public func worker(blockSize: Swift.Int, cipherOperation: @escaping FaceCaptcha.CipherOperationOnBlock, encryptionOperation: @escaping FaceCaptcha.CipherOperationOnBlock) throws -> FaceCaptcha.CipherModeWorker
+}
+public struct FCBaseModel {
+  public static let K_APP_KEY: Swift.String
+  public static let K_P: Swift.String
+}
+public typealias CipherOperationOnBlock = (_ block: Swift.ArraySlice<Swift.UInt8>) -> Swift.Array<Swift.UInt8>?
+public protocol BlockMode {
+  var options: FaceCaptcha.BlockModeOption { get }
+  @inlinable func worker(blockSize: Swift.Int, cipherOperation: @escaping FaceCaptcha.CipherOperationOnBlock, encryptionOperation: @escaping FaceCaptcha.CipherOperationOnBlock) throws -> FaceCaptcha.CipherModeWorker
+  var customBlockSize: Swift.Int? { get }
+}
+extension FaceCaptcha.Blowfish {
+  convenience public init(key: Swift.String, iv: Swift.String, padding: FaceCaptcha.Padding = .pkcs7) throws
+}
+public protocol _UInt8Type {
+}
+extension Swift.UInt8 : FaceCaptcha._UInt8Type {
+}
+extension Swift.UInt8 {
+  public func bits() -> [FaceCaptcha.Bit]
+  public func bits() -> Swift.String
+}
+public protocol DocumentscopyCustomResultView : UIKit.UIView {
+  var resultButton: UIKit.UIButton! { get }
+  func display(for resultType: FaceCaptcha.DocumentscopyResultType)
+}
+public func generateAppKey(user: Swift.String, passcode: Swift.String, cpf: Swift.String, nome: Swift.String, dtNasciemnto: Swift.String, completion: @escaping (Swift.String) -> Swift.Void)
+public protocol FaceCaptchaView : UIKit.UIView {
+  var cameraContainer: FaceCaptcha.CameraPreviewView! { get }
+  var startButton: UIKit.UIButton! { get }
+  var closeButton: UIKit.UIButton! { get }
+  var activityIndicatorView: UIKit.UIView! { get }
+  var challengeIcon: UIKit.UIImageView! { get }
+  var challengeText: UIKit.UIImageView! { get }
+  var challengeContainer: UIKit.UIView? { get }
+  var initialInstructionView: UIKit.UIView? { get }
+}
+public protocol Cryptor {
+  mutating func seek(to: Swift.Int) throws
+}
+final public class SHA1 {
+  @usableFromInline
+  internal static let digestLength: Swift.Int
+  @usableFromInline
+  internal static let blockSize: Swift.Int
+  @usableFromInline
+  internal static let hashInitialValue: Swift.ContiguousArray<Swift.UInt32>
+  @usableFromInline
+  final internal var accumulated: [Swift.UInt8]
+  @usableFromInline
+  final internal var processedBytesTotalCount: Swift.Int
+  @usableFromInline
+  final internal var accumulatedHash: Swift.ContiguousArray<Swift.UInt32>
+  public init()
+  @inlinable final public func calculate(for bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8> {
+    do {
+      return try update(withBytes: bytes.slice, isLast: true)
+    } catch {
+      return []
+    }
+  }
+  @usableFromInline
+  final internal func process(block chunk: Swift.ArraySlice<Swift.UInt8>, currentHash hh: inout Swift.ContiguousArray<Swift.UInt32>)
+  @objc deinit
+}
+extension FaceCaptcha.SHA1 : FaceCaptcha.Updatable {
+  @discardableResult
+  @inlinable final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8> {
+    self.accumulated += bytes
+
+    if isLast {
+      let lengthInBits = (processedBytesTotalCount + self.accumulated.count) * 8
+      let lengthBytes = lengthInBits.bytes(totalBytes: 64 / 8) // A 64-bit representation of b
+
+      // Step 1. Append padding
+      bitPadding(to: &self.accumulated, blockSize: SHA1.blockSize, allowance: 64 / 8)
+
+      // Step 2. Append Length a 64-bit representation of lengthInBits
+      self.accumulated += lengthBytes
+    }
+
+    var processedBytes = 0
+    for chunk in self.accumulated.batched(by: SHA1.blockSize) {
+      if isLast || (self.accumulated.count - processedBytes) >= SHA1.blockSize {
+        self.process(block: chunk, currentHash: &self.accumulatedHash)
+        processedBytes += chunk.count
+      }
+    }
+    self.accumulated.removeFirst(processedBytes)
+    self.processedBytesTotalCount += processedBytes
+
+    // output current hash
+    var result = Array<UInt8>(repeating: 0, count: SHA1.digestLength)
+    var pos = 0
+    for idx in 0..<self.accumulatedHash.count {
+      let h = self.accumulatedHash[idx]
+      result[pos + 0] = UInt8((h >> 24) & 0xff)
+      result[pos + 1] = UInt8((h >> 16) & 0xff)
+      result[pos + 2] = UInt8((h >> 8) & 0xff)
+      result[pos + 3] = UInt8(h & 0xff)
+      pos += 4
+    }
+
+    // reset hash value for instance
+    if isLast {
+      self.accumulatedHash = SHA1.hashInitialValue
+    }
+
+    return result
+  }
+}
+public enum CipherError : Swift.Error {
+  case encrypt
+  case decrypt
+  public static func == (a: FaceCaptcha.CipherError, b: FaceCaptcha.CipherError) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public var hashValue: Swift.Int {
+    get
+  }
+}
+public protocol Cipher : AnyObject {
+  var keySize: Swift.Int { get }
+  func encrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+  func encrypt(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+  func decrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+  func decrypt(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+}
+extension FaceCaptcha.Cipher {
+  public func encrypt(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+  public func decrypt(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+}
+@inlinable internal func rotateLeft(_ value: Swift.UInt8, by: Swift.UInt8) -> Swift.UInt8 {
+  ((value << by) & 0xff) | (value >> (8 - by))
+}
+@inlinable internal func rotateLeft(_ value: Swift.UInt16, by: Swift.UInt16) -> Swift.UInt16 {
+  ((value << by) & 0xffff) | (value >> (16 - by))
+}
+@inlinable internal func rotateLeft(_ value: Swift.UInt32, by: Swift.UInt32) -> Swift.UInt32 {
+  ((value << by) & 0xffffffff) | (value >> (32 - by))
+}
+@inlinable internal func rotateLeft(_ value: Swift.UInt64, by: Swift.UInt64) -> Swift.UInt64 {
+  (value << by) | (value >> (64 - by))
+}
+@inlinable internal func rotateRight(_ value: Swift.UInt16, by: Swift.UInt16) -> Swift.UInt16 {
+  (value >> by) | (value << (16 - by))
+}
+@inlinable internal func rotateRight(_ value: Swift.UInt32, by: Swift.UInt32) -> Swift.UInt32 {
+  (value >> by) | (value << (32 - by))
+}
+@inlinable internal func rotateRight(_ value: Swift.UInt64, by: Swift.UInt64) -> Swift.UInt64 {
+  ((value >> by) | (value << (64 - by)))
+}
+@inlinable internal func reversed(_ uint8: Swift.UInt8) -> Swift.UInt8 {
+  var v = uint8
+  v = (v & 0xf0) >> 4 | (v & 0x0f) << 4
+  v = (v & 0xcc) >> 2 | (v & 0x33) << 2
+  v = (v & 0xaa) >> 1 | (v & 0x55) << 1
+  return v
+}
+@inlinable internal func reversed(_ uint32: Swift.UInt32) -> Swift.UInt32 {
+  var v = uint32
+  v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1)
+  v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2)
+  v = ((v >> 4) & 0x0f0f0f0f) | ((v & 0x0f0f0f0f) << 4)
+  v = ((v >> 8) & 0x00ff00ff) | ((v & 0x00ff00ff) << 8)
+  v = ((v >> 16) & 0xffff) | ((v & 0xffff) << 16)
+  return v
+}
+@inlinable internal func xor<T, V>(_ left: T, _ right: V) -> Swift.ArraySlice<Swift.UInt8> where T : Swift.RandomAccessCollection, V : Swift.RandomAccessCollection, T.Element == Swift.UInt8, T.Index == Swift.Int, V.Element == Swift.UInt8, V.Index == Swift.Int {
+  return xor(left, right).slice
+}
+@inlinable internal func xor<T, V>(_ left: T, _ right: V) -> Swift.Array<Swift.UInt8> where T : Swift.RandomAccessCollection, V : Swift.RandomAccessCollection, T.Element == Swift.UInt8, T.Index == Swift.Int, V.Element == Swift.UInt8, V.Index == Swift.Int {
+  let length = Swift.min(left.count, right.count)
+
+  let buf = UnsafeMutablePointer<UInt8>.allocate(capacity: length)
+  buf.initialize(repeating: 0, count: length)
+  defer {
+    buf.deinitialize(count: length)
+    buf.deallocate()
+  }
+
+  // xor
+  for i in 0..<length {
+    buf[i] = left[left.startIndex.advanced(by: i)] ^ right[right.startIndex.advanced(by: i)]
+  }
+
+  return Array(UnsafeBufferPointer(start: buf, count: length))
+}
+@inline(__always) @inlinable internal func bitPadding(to data: inout Swift.Array<Swift.UInt8>, blockSize: Swift.Int, allowance: Swift.Int = 0) {
+  let msgLength = data.count
+  // Step 1. Append Padding Bits
+  // append one bit (UInt8 with one bit) to message
+  data.append(0x80)
+
+  // Step 2. append "0" bit until message length in bits ≡ 448 (mod 512)
+  let max = blockSize - allowance // 448, 986
+  if msgLength % blockSize < max { // 448
+    data += Array<UInt8>(repeating: 0, count: max - 1 - (msgLength % blockSize))
+  } else {
+    data += Array<UInt8>(repeating: 0, count: blockSize + max - 1 - (msgLength % blockSize))
+  }
+}
+final public class Poly1305 : FaceCaptcha.Authenticator {
+  public enum Error : Swift.Error {
+    case authenticateError
+    public static func == (a: FaceCaptcha.Poly1305.Error, b: FaceCaptcha.Poly1305.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public static let blockSize: Swift.Int
+  public init(key: Swift.Array<Swift.UInt8>)
+  final public func authenticate(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
+  @objc deinit
+}
+public protocol Liveness3DDelegate : AnyObject {
+  func handleLiveness3DValidation(validateModel: FaceCaptcha.Liveness3DSuccess)
+  func handleLiveness3DError(error: FaceCaptcha.Liveness3DError)
+}
+extension Swift.Array {
+  @inlinable internal init(reserveCapacity: Swift.Int) {
+    self = Array<Element>()
+    self.reserveCapacity(reserveCapacity)
+  }
+  @inlinable internal var slice: Swift.ArraySlice<Element> {
+    get {
+    self[self.startIndex ..< self.endIndex]
+  }
+  }
+}
+extension Swift.Array where Element == Swift.UInt8 {
+  public init(hex: Swift.String)
+  public func toHexString() -> Swift.String
+}
+extension Swift.Array where Element == Swift.UInt8 {
+  @available(*, deprecated)
+  public func chunks(size chunksize: Swift.Int) -> Swift.Array<Swift.Array<Element>>
+  public func md5() -> [Element]
+  public func sha1() -> [Element]
+  public func sha224() -> [Element]
+  public func sha256() -> [Element]
+  public func sha384() -> [Element]
+  public func sha512() -> [Element]
+  public func sha2(_ variant: FaceCaptcha.SHA2.Variant) -> [Element]
+  public func sha3(_ variant: FaceCaptcha.SHA3.Variant) -> [Element]
+  public func crc32(seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.UInt32
+  public func crc32c(seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.UInt32
+  public func crc16(seed: Swift.UInt16? = nil) -> Swift.UInt16
+  public func encrypt(cipher: FaceCaptcha.Cipher) throws -> [Element]
+  public func decrypt(cipher: FaceCaptcha.Cipher) throws -> [Element]
+  public func authenticate<A>(with authenticator: A) throws -> [Element] where A : FaceCaptcha.Authenticator
+}
+public struct FCCaptchaModel {
+}
+extension Swift.Collection where Self.Element == Swift.UInt8, Self.Index == Swift.Int {
+  @inlinable internal func toUInt32Array() -> Swift.Array<Swift.UInt32> {
+    guard !isEmpty else {
+      return []
+    }
+
+    let c = strideCount(from: startIndex, to: endIndex, by: 4)
+    return Array<UInt32>(unsafeUninitializedCapacity: c) { buf, count in
+      var counter = 0
+      for idx in stride(from: startIndex, to: endIndex, by: 4) {
+        let val = UInt32(bytes: self, fromIndex: idx).bigEndian
+        buf[counter] = val
+        counter += 1
+      }
+      count = counter
+      assert(counter == c)
+    }
+  }
+  @inlinable internal func toUInt64Array() -> Swift.Array<Swift.UInt64> {
+    guard !isEmpty else {
+      return []
+    }
+
+    let c = strideCount(from: startIndex, to: endIndex, by: 8)
+    return Array<UInt64>(unsafeUninitializedCapacity: c) { buf, count in
+      var counter = 0
+      for idx in stride(from: startIndex, to: endIndex, by: 8) {
+        let val = UInt64(bytes: self, fromIndex: idx).bigEndian
+        buf[counter] = val
+        counter += 1
+      }
+      count = counter
+      assert(counter == c)
+    }
+  }
+}
+@usableFromInline
+internal func strideCount(from: Swift.Int, to: Swift.Int, by: Swift.Int) -> Swift.Int
+public struct FCChallengeModel {
+}
+public struct FCSessionModel {
+  public var appkey: Swift.String?
+}
+public struct FCSession3DModel {
+  public let sessionToken: Swift.String?
+}
+public struct FCInitializationModel {
+  public var productionKey: Swift.String?
+}
+@usableFromInline
+final internal class StreamDecryptor : FaceCaptcha.Cryptor, FaceCaptcha.Updatable {
+  @usableFromInline
+  final internal let blockSize: Swift.Int
+  @usableFromInline
+  final internal var worker: FaceCaptcha.CipherModeWorker
+  @usableFromInline
+  final internal let padding: FaceCaptcha.Padding
+  @usableFromInline
+  final internal var accumulated: [Swift.UInt8]
+  @usableFromInline
+  final internal var lastBlockRemainder: Swift.Int
+  @usableFromInline
+  internal init(blockSize: Swift.Int, padding: FaceCaptcha.Padding, _ worker: FaceCaptcha.CipherModeWorker) throws
+  @inlinable final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool) throws -> Swift.Array<Swift.UInt8> {
+    self.accumulated += bytes
+
+    let toProcess = self.accumulated.prefix(max(self.accumulated.count - self.worker.additionalBufferSize, 0))
+
+    if var finalizingWorker = worker as? FinalizingDecryptModeWorker, isLast == true {
+      // will truncate suffix if needed
+      try finalizingWorker.willDecryptLast(bytes: self.accumulated.slice)
+    }
+
+    var processedBytesCount = 0
+    var plaintext = Array<UInt8>(reserveCapacity: bytes.count + self.worker.additionalBufferSize)
+    for chunk in toProcess.batched(by: self.blockSize) {
+      plaintext += self.worker.decrypt(block: chunk)
+      processedBytesCount += chunk.count
+    }
+
+    if var finalizingWorker = worker as? FinalizingDecryptModeWorker, isLast == true {
+      plaintext = Array(try finalizingWorker.didDecryptLast(bytes: plaintext.slice))
+    }
+
+    // omit unecessary calculation if not needed
+    if self.padding != .noPadding {
+      self.lastBlockRemainder = plaintext.count.quotientAndRemainder(dividingBy: self.blockSize).remainder
+    }
+
+    if isLast {
+      // CTR doesn't need padding. Really. Add padding to the last block if really want. but... don't.
+      plaintext = self.padding.remove(from: plaintext, blockSize: self.blockSize - self.lastBlockRemainder)
+    }
+
+    self.accumulated.removeFirst(processedBytesCount) // super-slow
+
+    if var finalizingWorker = worker as? FinalizingDecryptModeWorker, isLast == true {
+      plaintext = Array(try finalizingWorker.finalize(decrypt: plaintext.slice))
+    }
+
+    return plaintext
+  }
+  @inlinable final public func seek(to position: Swift.Int) throws {
+    guard var worker = self.worker as? SeekableModeWorker else {
+      fatalError("Not supported")
+    }
+
+    try worker.seek(to: position)
+    self.worker = worker
+  }
+  @objc @usableFromInline
+  deinit
+}
+@objc @_inheritsConvenienceInitializers @_Concurrency.MainActor(unsafe) public class CameraPreviewView : UIKit.UIView {
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public class var layerClass: Swift.AnyClass {
+    @_Concurrency.MainActor(unsafe) @objc get
+  }
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public init(frame: CoreGraphics.CGRect)
+  @_Concurrency.MainActor(unsafe) @objc required dynamic public init?(coder: Foundation.NSCoder)
+  @objc deinit
+}
+@_specialize(exported: false, kind: full, where T == Swift.Int)
+@_specialize(exported: false, kind: full, where T == Swift.UInt)
+@_specialize(exported: false, kind: full, where T == Swift.UInt8)
+@_specialize(exported: false, kind: full, where T == Swift.UInt16)
+@_specialize(exported: false, kind: full, where T == Swift.UInt32)
+@_specialize(exported: false, kind: full, where T == Swift.UInt64)
+@inlinable internal func arrayOfBytes<T>(value: T, length totalBytes: Swift.Int = MemoryLayout<T>.size) -> Swift.Array<Swift.UInt8> where T : Swift.FixedWidthInteger {
+  let valuePointer = UnsafeMutablePointer<T>.allocate(capacity: 1)
+  valuePointer.pointee = value
+
+  let bytesPointer = UnsafeMutablePointer<UInt8>(OpaquePointer(valuePointer))
+  var bytes = Array<UInt8>(repeating: 0, count: totalBytes)
+  for j in 0..<min(MemoryLayout<T>.size, totalBytes) {
+    bytes[totalBytes - 1 - j] = (bytesPointer + j).pointee
+  }
+
+  valuePointer.deinitialize(count: 1)
+  valuePointer.deallocate()
+
+  return bytes
+}
+extension UIKit.UIColor {
+  public static let backgroundDark: UIKit.UIColor
+  public static let backgroundLight: UIKit.UIColor
+  public static let retryScreenHeaderTextColorLight: UIKit.UIColor
+  public static let retryScreenContentTextColorLight: UIKit.UIColor
+  public static let retryScreenHeaderTextColorDark: UIKit.UIColor
+  public static let resultScreenHeaderTextColorLight: UIKit.UIColor
+  public static let resultScreenHeaderTextColorDark: UIKit.UIColor
+  convenience public init(hex: Swift.String)
+}
+public struct OFB : FaceCaptcha.BlockMode {
+  public enum Error : Swift.Error {
+    case invalidInitializationVector
+    public static func == (a: FaceCaptcha.OFB.Error, b: FaceCaptcha.OFB.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public let options: FaceCaptcha.BlockModeOption
+  public let customBlockSize: Swift.Int?
+  public init(iv: Swift.Array<Swift.UInt8>)
+  public func worker(blockSize: Swift.Int, cipherOperation: @escaping FaceCaptcha.CipherOperationOnBlock, encryptionOperation: @escaping FaceCaptcha.CipherOperationOnBlock) throws -> FaceCaptcha.CipherModeWorker
+}
+extension FaceCaptcha.HMAC {
+  convenience public init(key: Swift.String, variant: FaceCaptcha.HMAC.Variant = .md5) throws
+}
+public enum Bit : Swift.Int {
+  case zero
+  case one
+  public init?(rawValue: Swift.Int)
+  public typealias RawValue = Swift.Int
+  public var rawValue: Swift.Int {
+    get
+  }
+}
+extension FaceCaptcha.Bit {
+  @inlinable internal func inverted() -> FaceCaptcha.Bit {
+    self == .zero ? .one : .zero
+  }
+}
+public protocol AEAD {
+  static var kLen: Swift.Int { get }
+  static var ivRange: Swift.Range<Swift.Int> { get }
+}
+extension FaceCaptcha.AES {
+  convenience public init(key: Swift.String, iv: Swift.String, padding: FaceCaptcha.Padding = .pkcs7) throws
+}
+@_hasMissingDesignatedInitializers public class FCCipher {
+  public static let key: [Swift.UInt8]
+  public static let iv: [Swift.UInt8]
+  public static let key_string: Swift.String
+  public static let key_iv_string: Swift.String
+  public static func padMsg(_ source: Swift.String) -> Swift.String
+  public static func padKey(_ source: Swift.String) -> Swift.String
+  @objc deinit
+}
+extension FaceCaptcha.FCCipher {
+  public static func aesEncrypt(_ str: Swift.String, _ appKey: Swift.String) -> Swift.String
+  public static func aesDecrypt(_ str: Swift.String, _ appKey: Swift.String) -> Swift.String
+}
+extension Swift.UInt32 {
+  @_specialize(exported: false, kind: full, where T == Swift.ArraySlice<Swift.UInt8>)
+  @inlinable internal init<T>(bytes: T, fromIndex index: T.Index) where T : Swift.Collection, T.Element == Swift.UInt8, T.Index == Swift.Int {
+    if bytes.isEmpty {
+      self = 0
+      return
+    }
+
+    let count = bytes.count
+
+    let val0 = count > 0 ? UInt32(bytes[index.advanced(by: 0)]) << 24 : 0
+    let val1 = count > 1 ? UInt32(bytes[index.advanced(by: 1)]) << 16 : 0
+    let val2 = count > 2 ? UInt32(bytes[index.advanced(by: 2)]) << 8 : 0
+    let val3 = count > 3 ? UInt32(bytes[index.advanced(by: 3)]) : 0
+
+    self = val0 | val1 | val2 | val3
+  }
+}
+public typealias DocumentscopyConfirmationSheetVisibility = FaceCaptcha.Visibility
+public protocol DocumentscopyCustomView : UIKit.UIView {
+  var cameraPreview: FaceCaptcha.DocumentscopyCameraPreviewView! { get }
+  var cameraMask: UIKit.UIView! { get }
+  var backButton: UIKit.UIButton! { get }
+  var closeButton: UIKit.UIButton! { get }
+  var backIndicatorView: UIKit.UIView! { get }
+  var frontIndicatorView: UIKit.UIView! { get }
+  var instructionLabel: UIKit.UILabel! { get }
+  var cameraVisualizer: UIKit.UIView! { get }
+  var previewImageView: UIKit.UIImageView! { get }
+  var captureButton: UIKit.UIButton! { get }
+  var usePictureButton: UIKit.UIButton! { get }
+  var takeNewPictureButton: UIKit.UIButton! { get }
+  func displayConfirmationSheet(visibility: FaceCaptcha.DocumentscopyConfirmationSheetVisibility, animated: Swift.Bool)
+  func setFocus(to focusElement: FaceCaptcha.DocumentscopyFocusIndicator, animated: Swift.Bool)
+  func setUsePictureButtonTitle(to newTitle: Swift.String)
+}
+public enum DocumentscopyResultType {
+  case success
+  case tryAgain
+  case error(FaceCaptcha.DocumentscopyError)
+}
+public typealias DocumentscopyCustomCameraPermissionView = FaceCaptcha.CustomCameraPermissionView
+@objc @_hasMissingDesignatedInitializers @_Concurrency.MainActor(unsafe) public class DocumentscopyViewController : UIKit.UINavigationController {
+  @_Concurrency.MainActor(unsafe) public init(appKey: Swift.String, baseURL: Swift.String, delegate: FaceCaptcha.DocumentscopyDelegate, customInstructionView: FaceCaptcha.DocumentscopyCustomInstructionView? = nil, customView: FaceCaptcha.DocumentscopyCustomView? = nil, customCameraPermissionView: FaceCaptcha.DocumentscopyCustomCameraPermissionView? = nil, customLoadingView: FaceCaptcha.DocumentscopyCustomLoadingView? = nil, customResultView: FaceCaptcha.DocumentscopyCustomResultView? = nil)
+  @objc deinit
+}
+extension FaceCaptcha.DocumentscopyViewController : UIKit.UIGestureRecognizerDelegate {
+  @_Concurrency.MainActor(unsafe) @objc dynamic public func gestureRecognizerShouldBegin(_ gestureRecognizer: UIKit.UIGestureRecognizer) -> Swift.Bool
+}
+final public class OCB : FaceCaptcha.BlockMode {
+  public enum Mode {
+    case combined
+    case detached
+    public static func == (a: FaceCaptcha.OCB.Mode, b: FaceCaptcha.OCB.Mode) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  final public let options: FaceCaptcha.BlockModeOption
+  public enum Error : Swift.Error {
+    case invalidNonce
+    case fail
+    public static func == (a: FaceCaptcha.OCB.Error, b: FaceCaptcha.OCB.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  final public let customBlockSize: Swift.Int?
+  final public var authenticationTag: Swift.Array<Swift.UInt8>?
+  public init(nonce N: Swift.Array<Swift.UInt8>, additionalAuthenticatedData: Swift.Array<Swift.UInt8>? = nil, tagLength: Swift.Int = 16, mode: FaceCaptcha.OCB.Mode = .detached)
+  @inlinable convenience public init(nonce N: Swift.Array<Swift.UInt8>, authenticationTag: Swift.Array<Swift.UInt8>, additionalAuthenticatedData: Swift.Array<Swift.UInt8>? = nil, mode: FaceCaptcha.OCB.Mode = .detached) {
+    self.init(nonce: N, additionalAuthenticatedData: additionalAuthenticatedData, tagLength: authenticationTag.count, mode: mode)
+    self.authenticationTag = authenticationTag
+  }
+  final public func worker(blockSize: Swift.Int, cipherOperation: @escaping FaceCaptcha.CipherOperationOnBlock, encryptionOperation: @escaping FaceCaptcha.CipherOperationOnBlock) throws -> FaceCaptcha.CipherModeWorker
+  @objc deinit
+}
+public struct HKDF {
+  public enum Error : Swift.Error {
+    case invalidInput
+    case derivedKeyTooLong
+    public static func == (a: FaceCaptcha.HKDF.Error, b: FaceCaptcha.HKDF.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public init(password: Swift.Array<Swift.UInt8>, salt: Swift.Array<Swift.UInt8>? = nil, info: Swift.Array<Swift.UInt8>? = nil, keyLength: Swift.Int? = nil, variant: FaceCaptcha.HMAC.Variant = .sha256) throws
+  public func calculate() throws -> Swift.Array<Swift.UInt8>
+}
+public struct CFB : FaceCaptcha.BlockMode {
+  public enum Error : Swift.Error {
+    case invalidInitializationVector
+    public static func == (a: FaceCaptcha.CFB.Error, b: FaceCaptcha.CFB.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public enum SegmentSize : Swift.Int {
+    case cfb8
+    case cfb128
+    public init?(rawValue: Swift.Int)
+    public typealias RawValue = Swift.Int
+    public var rawValue: Swift.Int {
+      get
+    }
+  }
+  public let options: FaceCaptcha.BlockModeOption
+  public let customBlockSize: Swift.Int?
+  public init(iv: Swift.Array<Swift.UInt8>, segmentSize: FaceCaptcha.CFB.SegmentSize = .cfb128)
+  public func worker(blockSize: Swift.Int, cipherOperation: @escaping FaceCaptcha.CipherOperationOnBlock, encryptionOperation: @escaping FaceCaptcha.CipherOperationOnBlock) throws -> FaceCaptcha.CipherModeWorker
+}
+extension FaceCaptcha.PKCS5 {
+  public struct PBKDF2 {
+    public enum Error : Swift.Error {
+      case invalidInput
+      case derivedKeyTooLong
+      public static func == (a: FaceCaptcha.PKCS5.PBKDF2.Error, b: FaceCaptcha.PKCS5.PBKDF2.Error) -> Swift.Bool
+      public func hash(into hasher: inout Swift.Hasher)
+      public var hashValue: Swift.Int {
+        get
+      }
+    }
+    public init(password: Swift.Array<Swift.UInt8>, salt: Swift.Array<Swift.UInt8>, iterations: Swift.Int = 4096, keyLength: Swift.Int? = nil, variant: FaceCaptcha.HMAC.Variant = .sha256) throws
+    public func calculate() throws -> Swift.Array<Swift.UInt8>
+  }
+}
+public enum FaceCaptchaError {
+  case invalidAppKey
+  case certifaceOff
+  case noCameraPermission
+  case noInternetConnection
+  case phoneCallInProgress
+  case validationError
+  case challengeInterrupted
+  case requestError
+  case errorCameraSetup
+  case errorCapturePicture
+  public static func == (a: FaceCaptcha.FaceCaptchaError, b: FaceCaptcha.FaceCaptchaError) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public var hashValue: Swift.Int {
+    get
+  }
+}
+public enum PKCS5 {
+}
+public protocol Updatable {
+  mutating func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool) throws -> Swift.Array<Swift.UInt8>
+  mutating func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool, output: (_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Void) throws
+}
+extension FaceCaptcha.Updatable {
+  @inlinable public mutating func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false, output: (_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Void) throws {
+    let processed = try update(withBytes: bytes, isLast: isLast)
+    if !processed.isEmpty {
+      output(processed)
+    }
+  }
+  @inlinable public mutating func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8> {
+    try self.update(withBytes: bytes, isLast: isLast)
+  }
+  @inlinable public mutating func update(withBytes bytes: Swift.Array<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8> {
+    try self.update(withBytes: bytes.slice, isLast: isLast)
+  }
+  @inlinable public mutating func update(withBytes bytes: Swift.Array<Swift.UInt8>, isLast: Swift.Bool = false, output: (_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Void) throws {
+    try self.update(withBytes: bytes.slice, isLast: isLast, output: output)
+  }
+  @inlinable public mutating func finish(withBytes bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8> {
+    try self.update(withBytes: bytes, isLast: true)
+  }
+  @inlinable public mutating func finish(withBytes bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8> {
+    try self.finish(withBytes: bytes.slice)
+  }
+  @inlinable public mutating func finish() throws -> Swift.Array<Swift.UInt8> {
+    try self.update(withBytes: [], isLast: true)
+  }
+  @inlinable public mutating func finish(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, output: (_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Void) throws {
+    let processed = try update(withBytes: bytes, isLast: true)
+    if !processed.isEmpty {
+      output(processed)
+    }
+  }
+  @inlinable public mutating func finish(withBytes bytes: Swift.Array<Swift.UInt8>, output: (_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Void) throws {
+    try self.finish(withBytes: bytes.slice, output: output)
+  }
+  @inlinable public mutating func finish(output: (Swift.Array<Swift.UInt8>) -> Swift.Void) throws {
+    try self.finish(withBytes: [], output: output)
+  }
+}
+public enum ResultAnimationStyle {
+  case blob
+  case spinner(FaceCaptcha.SpinnerAnimationCustomization)
+  case custom(FaceCaptcha.CustomResultAnimationDelegate)
+}
+public protocol CustomResultAnimationDelegate {
+  func createActivityIndicatorView() -> UIKit.UIView?
+  func createSuccessAnimationView() -> UIKit.UIView?
+}
+public struct SpinnerAnimationCustomization {
+  public init(spinnerColor: UIKit.UIColor, indicatorForegroundColor: UIKit.UIColor, indicatorBackgroundColor: UIKit.UIColor)
+}
+extension FaceCaptcha.ChaCha20 {
+  convenience public init(key: Swift.String, iv: Swift.String) throws
+}
+public struct Liveness3DUser {
+  public init(appKey: Swift.String, environment: FaceCaptcha.Environment3D = .HML, defaultTheme: FaceCaptcha.Liveness3DTheme? = nil, lowLightTheme: FaceCaptcha.Liveness3DTheme? = nil, texts: [Swift.String : Swift.String]? = nil)
+}
+public enum Environment3D {
+  case HML
+  case PRD
+  public static func == (a: FaceCaptcha.Environment3D, b: FaceCaptcha.Environment3D) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public var hashValue: Swift.Int {
+    get
+  }
+}
+public enum Liveness3DThemeType : Swift.Int {
+  case light, dark
+  public init?(rawValue: Swift.Int)
+  public typealias RawValue = Swift.Int
+  public var rawValue: Swift.Int {
+    get
+  }
+}
+public struct Liveness3DTheme {
+  public init(_ type: FaceCaptcha.Liveness3DThemeType)
+  public var guidanceCustomizationBackgroundColors: [UIKit.UIColor]?
+  public var guidanceCustomizationForegroundColor: UIKit.UIColor?
+  public var guidanceCustomizationHeaderFont: UIKit.UIFont?
+  public var guidanceCustomizationSubtextFont: UIKit.UIFont?
+  public var guidanceCustomizationReadyScreenHeaderFont: UIKit.UIFont?
+  public var guidanceCustomizationReadyScreenHeaderTextColor: UIKit.UIColor?
+  public var guidanceCustomizationReadyScreenHeaderAttributedString: Foundation.NSAttributedString?
+  public var guidanceCustomizationReadyScreenSubtextFont: UIKit.UIFont?
+  public var guidanceCustomizationReadyScreenSubtextTextColor: UIKit.UIColor?
+  public var guidanceCustomizationReadyScreenSubtextAttributedString: Foundation.NSAttributedString?
+  public var guidanceCustomizationRetryScreenHeaderFont: UIKit.UIFont?
+  public var guidanceCustomizationRetryScreenHeaderTextColor: UIKit.UIColor?
+  public var guidanceCustomizationRetryScreenHeaderAttributedString: Foundation.NSAttributedString?
+  public var guidanceCustomizationRetryScreenSubtextFont: UIKit.UIFont?
+  public var guidanceCustomizationRetryScreenSubtextTextColor: UIKit.UIColor?
+  public var guidanceCustomizationRetryScreenSubtextAttributedString: Foundation.NSAttributedString?
+  public var guidanceCustomizationButtonFont: UIKit.UIFont?
+  public var guidanceCustomizationButtonTextNormalColor: UIKit.UIColor?
+  public var guidanceCustomizationButtonBackgroundNormalColor: UIKit.UIColor
+  public var guidanceCustomizationButtonTextHighlightColor: UIKit.UIColor?
+  public var guidanceCustomizationButtonBackgroundHighlightColor: UIKit.UIColor?
+  public var guidanceCustomizationButtonTextDisabledColor: UIKit.UIColor?
+  public var guidanceCustomizationButtonBackgroundDisabledColor: UIKit.UIColor
+  public var guidanceCustomizationButtonBorderColor: UIKit.UIColor?
+  public var guidanceCustomizationButtonBorderWidth: Swift.Int32?
+  public var guidanceCustomizationButtonCornerRadius: Swift.Int32?
+  public var guidanceCustomizationReadyScreenOvarFillColor: UIKit.UIColor?
+  public var guidanceCustomizationReadyScreenTextBackgroundColor: UIKit.UIColor?
+  public var guidanceCustomizationReadyScreenTextBackgroundCornerRadius: Swift.Int32?
+  public var guidanceCustomizationRetryScreenImageBorderColor: UIKit.UIColor
+  public var guidanceCustomizationRetryScreenImageBorderWidth: Swift.Int32?
+  public var guidanceCustomizationRetryScreenImageCornerRadius: Swift.Int32?
+  public var guidanceCustomizationRetryScreenOvarStrokeColor: UIKit.UIColor?
+  public var resultScreenCustomizationAnimationRelativeScale: Swift.Float
+  public var resultScreenCustomizationForegroundColor: UIKit.UIColor?
+  public var resultScreenCustomizationBackgroundColors: [UIKit.UIColor]?
+  public var resultScreenCustomizationActivityIndicatorColor: UIKit.UIColor
+  public var resultScreenCustomizationCustomActivityIndicatorImage: UIKit.UIImage?
+  public var resultScreenCustomizationCustomActivityIndicatorRotationIntervar: Swift.Int32
+  public var resultScreenCustomizationCustomActivityIndicatorAnimation: Swift.Int
+  public var resultScreenCustomizationShowUploadProgressBar: Swift.Bool
+  public var resultScreenCustomizationUploadProgressFillColor: UIKit.UIColor
+  public var resultScreenCustomizationUploadProgressTrackColor: UIKit.UIColor
+  public var resultScreenCustomizationResultAnimationBackgroundColor: UIKit.UIColor
+  public var resultScreenCustomizationResultAnimationForegroundColor: UIKit.UIColor
+  public var resultScreenCustomizationResultAnimationSuccessBackgroundImage: UIKit.UIImage?
+  public var resultScreenCustomizationResultAnimationUnSuccessBackgroundImage: Swift.Int
+  public var resultScreenCustomizationCustomResultAnimationSuccess: Swift.Int
+  public var resultScreenCustomizationCustomResultAnimationUnSuccess: Swift.Int
+  public var resultScreenCustomizationCustomStaticResultAnimationSuccess: Swift.Int
+  public var resultScreenCustomizationCustomStaticResultAnimationUnSuccess: Swift.Int
+  public var resultScreenCustomizationMessageFont: UIKit.UIFont?
+  public var ovarCustomizationStrokeWidth: Swift.Int32?
+  public var ovarCustomizationStrokeColor: UIKit.UIColor
+  public var ovarCustomizationProgressStrokeWidth: Swift.Int32?
+  public var ovarCustomizationProgressColor1: UIKit.UIColor
+  public var ovarCustomizationProgressColor2: UIKit.UIColor
+  public var ovarCustomizationProgressRadialOffset: Swift.Int32?
+  public var frameCustomizationBorderWidth: Swift.Int32?
+  public var frameCustomizationCornerRadius: Swift.Int32
+  public var frameCustomizationBorderColor: UIKit.UIColor?
+  public var frameCustomizationBackgroundColor: UIKit.UIColor?
+  public var frameCustomizationElevation: Swift.Int32?
+  public var overlayCustomizationBackgroundColor: UIKit.UIColor?
+  public var overlayCustomizationBrandingImage: UIKit.UIImage?
+  public var overlayCustomizationShowBrandingImage: Swift.Bool
+  public var feedbackCustomizationCornerRadius: Swift.Int32?
+  public var feedbackCustomizationBackgroundColor: QuartzCore.CAGradientLayer?
+  public var feedbackCustomizationTextColor: UIKit.UIColor?
+  public var feedbackCustomizationTextFont: UIKit.UIFont?
+  public var feedbackCustomizationEnablePulsatingText: Swift.Bool
+  public var feedbackCustomizationElevation: Swift.Int?
+  public var cancelButtonCustomizationCustomImage: UIKit.UIImage?
+  public var cancelButtonCustomizationLocation: FaceCaptcha.Liveness3DTheme.CancelButtonLocation
+  public var resultAnimationStyle: FaceCaptcha.ResultAnimationStyle
+  public var resultScreenSuccessMessage: Swift.String
+  public enum CancelButtonLocation : Swift.Int {
+    case topLeft, topRight, disabled
+    public init?(rawValue: Swift.Int)
+    public typealias RawValue = Swift.Int
+    public var rawValue: Swift.Int {
+      get
+    }
+  }
+}
+@objc @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers @_Concurrency.MainActor(unsafe) public class DocumentscopyView : UIKit.UIView, FaceCaptcha.DocumentscopyCustomView {
+  @_Concurrency.MainActor(unsafe) public var cameraPreview: FaceCaptcha.DocumentscopyCameraPreviewView!
+  @_Concurrency.MainActor(unsafe) public var captureButton: UIKit.UIButton!
+  @_Concurrency.MainActor(unsafe) public var captureButtonCorner: UIKit.UIView
+  @_Concurrency.MainActor(unsafe) public var previewContainer: UIKit.UIView!
+  @_Concurrency.MainActor(unsafe) public var previewImageView: UIKit.UIImageView!
+  @_Concurrency.MainActor(unsafe) public var usePictureButton: UIKit.UIButton!
+  @_Concurrency.MainActor(unsafe) public var takeNewPictureButton: UIKit.UIButton!
+  @_Concurrency.MainActor(unsafe) public var instructionLabel: UIKit.UILabel!
+  @_Concurrency.MainActor(unsafe) public var closeButton: UIKit.UIButton!
+  @_Concurrency.MainActor(unsafe) public var backButton: UIKit.UIButton!
+  @_Concurrency.MainActor(unsafe) public var containerConfirmation: UIKit.UIView!
+  @_Concurrency.MainActor(unsafe) public var backIndicatorView: UIKit.UIView!
+  @_Concurrency.MainActor(unsafe) public var frontIndicatorView: UIKit.UIView!
+  @_Concurrency.MainActor(unsafe) public var cameraMask: UIKit.UIView!
+  @_Concurrency.MainActor(unsafe) public var cameraVisualizer: UIKit.UIView!
+  @_Concurrency.MainActor(unsafe) public var bottomViewConfirmationTopConstraint: UIKit.NSLayoutConstraint!
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public init(frame: CoreGraphics.CGRect)
+  @objc deinit
+  @_Concurrency.MainActor(unsafe) public func displayConfirmationSheet(visibility: FaceCaptcha.DocumentscopyConfirmationSheetVisibility, animated: Swift.Bool)
+  @_Concurrency.MainActor(unsafe) public func setFocus(to focusElement: FaceCaptcha.DocumentscopyFocusIndicator, animated: Swift.Bool)
+  @_Concurrency.MainActor(unsafe) public func setUsePictureButtonTitle(to newTitle: Swift.String)
+  @_Concurrency.MainActor(unsafe) @objc override dynamic public func layoutSubviews()
+}
+extension Foundation.Data {
+  public func checksum() -> Swift.UInt16
+  public func md5() -> Foundation.Data
+  public func sha1() -> Foundation.Data
+  public func sha224() -> Foundation.Data
+  public func sha256() -> Foundation.Data
+  public func sha384() -> Foundation.Data
+  public func sha512() -> Foundation.Data
+  public func sha3(_ variant: FaceCaptcha.SHA3.Variant) -> Foundation.Data
+  public func crc32(seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Foundation.Data
+  public func crc32c(seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Foundation.Data
+  public func crc16(seed: Swift.UInt16? = nil) -> Foundation.Data
+  public func encrypt(cipher: FaceCaptcha.Cipher) throws -> Foundation.Data
+  public func decrypt(cipher: FaceCaptcha.Cipher) throws -> Foundation.Data
+  public func authenticate(with authenticator: FaceCaptcha.Authenticator) throws -> Foundation.Data
+}
+extension Foundation.Data {
+  public init(hex: Swift.String)
+  public var bytes: Swift.Array<Swift.UInt8> {
+    get
+  }
+  public func toHexString() -> Swift.String
+}
+public struct PCBC : FaceCaptcha.BlockMode {
+  public enum Error : Swift.Error {
+    case invalidInitializationVector
+    public static func == (a: FaceCaptcha.PCBC.Error, b: FaceCaptcha.PCBC.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public let options: FaceCaptcha.BlockModeOption
+  public let customBlockSize: Swift.Int?
+  public init(iv: Swift.Array<Swift.UInt8>)
+  public func worker(blockSize: Swift.Int, cipherOperation: @escaping FaceCaptcha.CipherOperationOnBlock, encryptionOperation: @escaping FaceCaptcha.CipherOperationOnBlock) throws -> FaceCaptcha.CipherModeWorker
+}
+public struct CTR {
+  public enum Error : Swift.Error {
+    case invalidInitializationVector
+    public static func == (a: FaceCaptcha.CTR.Error, b: FaceCaptcha.CTR.Error) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+  public let options: FaceCaptcha.BlockModeOption
+  public let customBlockSize: Swift.Int?
+  public init(iv: Swift.Array<Swift.UInt8>, counter: Swift.Int = 0)
+  public func worker(blockSize: Swift.Int, cipherOperation: @escaping FaceCaptcha.CipherOperationOnBlock, encryptionOperation: @escaping FaceCaptcha.CipherOperationOnBlock) throws -> FaceCaptcha.CipherModeWorker
+}
+@usableFromInline
+final internal class StreamEncryptor : FaceCaptcha.Cryptor, FaceCaptcha.Updatable {
+  @usableFromInline
+  final internal let blockSize: Swift.Int
+  @usableFromInline
+  final internal var worker: FaceCaptcha.CipherModeWorker
+  @usableFromInline
+  final internal let padding: FaceCaptcha.Padding
+  @usableFromInline
+  final internal var lastBlockRemainder: Swift.Int
+  @usableFromInline
+  internal init(blockSize: Swift.Int, padding: FaceCaptcha.Padding, _ worker: FaceCaptcha.CipherModeWorker) throws
+  @inlinable final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool) throws -> Swift.Array<Swift.UInt8> {
+    var accumulated = Array(bytes)
+    if isLast {
+      // CTR doesn't need padding. Really. Add padding to the last block if really want. but... don't.
+      accumulated = self.padding.add(to: accumulated, blockSize: self.blockSize - self.lastBlockRemainder)
+    }
+
+    var encrypted = Array<UInt8>(reserveCapacity: bytes.count)
+    for chunk in accumulated.batched(by: self.blockSize) {
+      encrypted += self.worker.encrypt(block: chunk)
+    }
+
+    // omit unecessary calculation if not needed
+    if self.padding != .noPadding {
+      self.lastBlockRemainder = encrypted.count.quotientAndRemainder(dividingBy: self.blockSize).remainder
+    }
+
+    if var finalizingWorker = worker as? FinalizingEncryptModeWorker, isLast == true {
+      encrypted = Array(try finalizingWorker.finalize(encrypt: encrypted.slice))
+    }
+
+    return encrypted
+  }
+  @usableFromInline
+  final internal func seek(to: Swift.Int) throws
+  @objc @usableFromInline
+  deinit
+}
+public class BlockDecryptor : FaceCaptcha.Cryptor, FaceCaptcha.Updatable {
+  @usableFromInline
+  final internal let blockSize: Swift.Int
+  @usableFromInline
+  final internal let padding: FaceCaptcha.Padding
+  @usableFromInline
+  internal var worker: FaceCaptcha.CipherModeWorker
+  @usableFromInline
+  internal var accumulated: [Swift.UInt8]
+  @usableFromInline
+  internal init(blockSize: Swift.Int, padding: FaceCaptcha.Padding, _ worker: FaceCaptcha.CipherModeWorker) throws
+  @inlinable public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8> {
+    self.accumulated += bytes
+
+    // If a worker (eg GCM) can combine ciphertext + tag
+    // we need to remove tag from the ciphertext.
+    if !isLast && self.accumulated.count < self.blockSize + self.worker.additionalBufferSize {
+      return []
+    }
+
+    let accumulatedWithoutSuffix: Array<UInt8>
+    if self.worker.additionalBufferSize > 0 {
+      // FIXME: how slow is that?
+      accumulatedWithoutSuffix = Array(self.accumulated.prefix(self.accumulated.count - self.worker.additionalBufferSize))
+    } else {
+      accumulatedWithoutSuffix = self.accumulated
+    }
+
+    var processedBytesCount = 0
+    var plaintext = Array<UInt8>(reserveCapacity: accumulatedWithoutSuffix.count)
+    // Processing in a block-size manner. It's good for block modes, but bad for stream modes.
+    for var chunk in accumulatedWithoutSuffix.batched(by: self.blockSize) {
+      if isLast || (accumulatedWithoutSuffix.count - processedBytesCount) >= blockSize {
+        let isLastChunk = processedBytesCount + chunk.count == accumulatedWithoutSuffix.count
+
+        if isLast, isLastChunk, var finalizingWorker = worker as? FinalizingDecryptModeWorker {
+          chunk = try finalizingWorker.willDecryptLast(bytes: chunk + accumulated.suffix(worker.additionalBufferSize)) // tag size
+        }
+
+        if !chunk.isEmpty {
+          plaintext += worker.decrypt(block: chunk)
+        }
+
+        if isLast, isLastChunk, var finalizingWorker = worker as? FinalizingDecryptModeWorker {
+          plaintext = Array(try finalizingWorker.didDecryptLast(bytes: plaintext.slice))
+        }
+
+        processedBytesCount += chunk.count
+      }
+    }
+    accumulated.removeFirst(processedBytesCount) // super-slow
+
+    if isLast {
+      if accumulatedWithoutSuffix.isEmpty, var finalizingWorker = worker as? FinalizingDecryptModeWorker {
+        try finalizingWorker.willDecryptLast(bytes: self.accumulated.suffix(self.worker.additionalBufferSize))
+        plaintext = Array(try finalizingWorker.didDecryptLast(bytes: plaintext.slice))
+      }
+      plaintext = self.padding.remove(from: plaintext, blockSize: self.blockSize)
+    }
+
+    return plaintext
+  }
+  public func seek(to position: Swift.Int) throws
+  @objc deinit
+}
+extension UIKit.UIView {
+  @_Concurrency.MainActor(unsafe) public func createImageFromView() -> UIKit.UIImage
+}
+extension FaceCaptcha.DocumentscopyFocusIndicator : Swift.Equatable {}
+extension FaceCaptcha.DocumentscopyFocusIndicator : Swift.Hashable {}
+extension FaceCaptcha.SHA2.Variant : Swift.Equatable {}
+extension FaceCaptcha.SHA2.Variant : Swift.Hashable {}
+extension FaceCaptcha.Blowfish.Error : Swift.Equatable {}
+extension FaceCaptcha.Blowfish.Error : Swift.Hashable {}
+extension FaceCaptcha.CMAC.Error : Swift.Equatable {}
+extension FaceCaptcha.CMAC.Error : Swift.Hashable {}
+extension FaceCaptcha.HMAC.Error : Swift.Equatable {}
+extension FaceCaptcha.HMAC.Error : Swift.Hashable {}
+extension FaceCaptcha.HMAC.Variant : Swift.Equatable {}
+extension FaceCaptcha.HMAC.Variant : Swift.Hashable {}
+extension FaceCaptcha.GCM.Mode : Swift.Equatable {}
+extension FaceCaptcha.GCM.Mode : Swift.Hashable {}
+extension FaceCaptcha.GCM.Error : Swift.Equatable {}
+extension FaceCaptcha.GCM.Error : Swift.Hashable {}
+extension FaceCaptcha.AES.Error : Swift.Equatable {}
+extension FaceCaptcha.AES.Error : Swift.Hashable {}
+extension FaceCaptcha.AES.Variant : Swift.Equatable {}
+extension FaceCaptcha.AES.Variant : Swift.Hashable {}
+extension FaceCaptcha.AES.Variant : Swift.RawRepresentable {}
+extension FaceCaptcha.SHA3.Variant : Swift.Equatable {}
+extension FaceCaptcha.SHA3.Variant : Swift.Hashable {}
+extension FaceCaptcha.PKCS5.PBKDF1.Error : Swift.Equatable {}
+extension FaceCaptcha.PKCS5.PBKDF1.Error : Swift.Hashable {}
+extension FaceCaptcha.PKCS5.PBKDF1.Variant : Swift.Equatable {}
+extension FaceCaptcha.PKCS5.PBKDF1.Variant : Swift.Hashable {}
+extension FaceCaptcha.Rabbit.Error : Swift.Equatable {}
+extension FaceCaptcha.Rabbit.Error : Swift.Hashable {}
+extension FaceCaptcha.DocumentscopyError : Swift.Equatable {}
+extension FaceCaptcha.DocumentscopyError : Swift.Hashable {}
+extension FaceCaptcha.CBC.Error : Swift.Equatable {}
+extension FaceCaptcha.CBC.Error : Swift.Hashable {}
+extension FaceCaptcha.Padding : Swift.Equatable {}
+extension FaceCaptcha.Padding : Swift.Hashable {}
+extension FaceCaptcha.Liveness3DErrorCode : Swift.Equatable {}
+extension FaceCaptcha.Liveness3DErrorCode : Swift.Hashable {}
+extension FaceCaptcha.Liveness3DErrorCode : Swift.RawRepresentable {}
+extension FaceCaptcha.CCM : FaceCaptcha.BlockMode {}
+extension FaceCaptcha.CCM.Error : Swift.Equatable {}
+extension FaceCaptcha.CCM.Error : Swift.Hashable {}
+extension FaceCaptcha.ChaCha20.Error : Swift.Equatable {}
+extension FaceCaptcha.ChaCha20.Error : Swift.Hashable {}
+extension FaceCaptcha.Visibility : Swift.Equatable {}
+extension FaceCaptcha.Visibility : Swift.Hashable {}
+extension FaceCaptcha.CipherError : Swift.Equatable {}
+extension FaceCaptcha.CipherError : Swift.Hashable {}
+extension FaceCaptcha.Poly1305.Error : Swift.Equatable {}
+extension FaceCaptcha.Poly1305.Error : Swift.Hashable {}
+extension FaceCaptcha.OFB.Error : Swift.Equatable {}
+extension FaceCaptcha.OFB.Error : Swift.Hashable {}
+extension FaceCaptcha.Bit : Swift.Equatable {}
+extension FaceCaptcha.Bit : Swift.Hashable {}
+extension FaceCaptcha.Bit : Swift.RawRepresentable {}
+extension FaceCaptcha.OCB.Mode : Swift.Equatable {}
+extension FaceCaptcha.OCB.Mode : Swift.Hashable {}
+extension FaceCaptcha.OCB.Error : Swift.Equatable {}
+extension FaceCaptcha.OCB.Error : Swift.Hashable {}
+extension FaceCaptcha.HKDF.Error : Swift.Equatable {}
+extension FaceCaptcha.HKDF.Error : Swift.Hashable {}
+extension FaceCaptcha.CFB.Error : Swift.Equatable {}
+extension FaceCaptcha.CFB.Error : Swift.Hashable {}
+extension FaceCaptcha.CFB.SegmentSize : Swift.Equatable {}
+extension FaceCaptcha.CFB.SegmentSize : Swift.Hashable {}
+extension FaceCaptcha.CFB.SegmentSize : Swift.RawRepresentable {}
+extension FaceCaptcha.PKCS5.PBKDF2.Error : Swift.Equatable {}
+extension FaceCaptcha.PKCS5.PBKDF2.Error : Swift.Hashable {}
+extension FaceCaptcha.FaceCaptchaError : Swift.Equatable {}
+extension FaceCaptcha.FaceCaptchaError : Swift.Hashable {}
+extension FaceCaptcha.Environment3D : Swift.Equatable {}
+extension FaceCaptcha.Environment3D : Swift.Hashable {}
+extension FaceCaptcha.Liveness3DThemeType : Swift.Equatable {}
+extension FaceCaptcha.Liveness3DThemeType : Swift.Hashable {}
+extension FaceCaptcha.Liveness3DThemeType : Swift.RawRepresentable {}
+extension FaceCaptcha.Liveness3DTheme.CancelButtonLocation : Swift.Equatable {}
+extension FaceCaptcha.Liveness3DTheme.CancelButtonLocation : Swift.Hashable {}
+extension FaceCaptcha.Liveness3DTheme.CancelButtonLocation : Swift.RawRepresentable {}
+extension FaceCaptcha.PCBC.Error : Swift.Equatable {}
+extension FaceCaptcha.PCBC.Error : Swift.Hashable {}
+extension FaceCaptcha.CTR : FaceCaptcha.BlockMode {}
+extension FaceCaptcha.CTR.Error : Swift.Equatable {}
+extension FaceCaptcha.CTR.Error : Swift.Hashable {}