// swift-interface-format-version: 1.0
// swift-compiler-version: Apple Swift version 6.2.4 effective-5.10 (swiftlang-6.2.4.1.4 clang-1700.6.4.2)
// swift-module-flags: -target arm64-apple-ios16.0 -enable-objc-interop -enable-library-evolution -swift-version 5 -enforce-exclusivity=checked -O -enable-upcoming-feature ExistentialAny -enable-experimental-feature DebugDescriptionMacro -module-name BlinkIDUX -package-name blinkid_ios
// swift-module-flags-ignorable:  -formal-cxx-interoperability-mode=off -interface-compiler-version 6.2.4
import AVFoundation
import BlinkID
import Combine
import CoreImage
import CoreVideo
import DeveloperToolsSupport
import Foundation
import Foundation/*.Bundle*/
import Foundation/*.ProcessInfo*/
import Foundation/*.URL*/
import Network
import Swift
import SwiftUI
import UIKit
import _Concurrency
import _StringProcessing
import _SwiftConcurrencyShims
import os.log
import os
public actor BlinkIDEventStream : BlinkIDUX.EventStream {
  public init()
  @objc deinit
  public func send(_ events: [BlinkIDUX.UIEvent])
  public var stream: _Concurrency.AsyncStream<[BlinkIDUX.UIEvent]> {
    get
  }
  public typealias Event = BlinkIDUX.UIEvent
  @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
  @_semantics("defaultActor") nonisolated final public var unownedExecutor: _Concurrency.UnownedSerialExecutor {
    get
  }
}
public protocol BlinkIDClassFilter {
  func classAllowed(classInfo: BlinkID.BlinkIDSDK.DocumentClassInfo) -> Swift.Bool
}
public enum BlinkIDExtractionMode : Swift.Sendable {
  case barcodeOnly, documentWithBarcode, fullDocument
  public static func == (a: BlinkIDUX.BlinkIDExtractionMode, b: BlinkIDUX.BlinkIDExtractionMode) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
public actor BlinkIDAnalyzer : BlinkIDUX.CameraFrameAnalyzer {
  public typealias Event = BlinkIDUX.UIEvent
  public typealias Result = BlinkIDUX.ScanningResult<BlinkID.BlinkIDScanningResult, BlinkIDUX.BlinkIDScanningAlertType>
  public typealias Frame = BlinkID.CameraFrame
  public var stepTimeoutDuration: Foundation.TimeInterval {
    get
  }
  public var inactivityTimeoutDuration: Foundation.TimeInterval {
    get
  }
  #if compiler(>=5.3) && $NonescapableTypes
  public init(sdk: BlinkID.BlinkIDSdk, blinkIdSessionSettings: BlinkID.BlinkIDSessionSettings = BlinkIDSessionSettings(inputImageSource: .video), eventStream: BlinkIDUX.BlinkIDEventStream = BlinkIDEventStream(), classFilter: (any BlinkIDUX.BlinkIDClassFilter)? = nil, redactionSettingsResolver: (any BlinkID.RedactionSettingsResolver)? = nil) async throws
  #endif
  nonisolated public var sessionNumber: Swift.Int {
    get
  }
  nonisolated public var extractionMode: BlinkIDUX.BlinkIDExtractionMode {
    get
  }
  public func analyze(image: BlinkIDUX.BlinkIDAnalyzer.Frame) async
  public func cancel()
  public func result() async -> BlinkIDUX.ScanningResult<BlinkID.BlinkIDScanningResult, BlinkIDUX.BlinkIDScanningAlertType>
  public func pause()
  public func resume()
  public func restart() throws
  public func resetStepTimer()
  public func end()
  nonisolated public var events: any BlinkIDUX.EventStream<BlinkIDUX.UIEvent> {
    get
  }
  @objc deinit
  @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
  @_semantics("defaultActor") nonisolated final public var unownedExecutor: _Concurrency.UnownedSerialExecutor {
    get
  }
}
public struct FrameProcessResultHandle : Swift.Sendable {
  public let processResult: BlinkID.BlinkIDSDK.ProcessResult?
  public let advanceToNextStep: @Sendable () async -> Swift.Void
  public let getLastFrame: @Sendable () -> BlinkIDUX.LastFrameResult?
  public let triggerStepTimeout: @Sendable () -> Swift.Void
}
public struct LastFrameResult : Swift.Sendable {
  public let image: UIKit.UIImage?
  public let orientation: BlinkID.CameraFrameVideoOrientation
}
public struct BlinkIDResultState {
  public let scanningResult: BlinkID.BlinkIDScanningResult?
}
public enum BlinkIDScanningAlertType : Swift.Int, Swift.Sendable, BlinkIDUX.AlertTypeProtocol {
  public var id: Swift.Int {
    get
  }
  case timeout
  case disallowedClass
  case unsupportedDocument
  public var title: Swift.String {
    get
  }
  public var description: Swift.String {
    get
  }
  public var buttonTitle: Swift.String {
    get
  }
  public var pingletAlertType: BlinkID.UxEventPinglet.AlertType {
    get
  }
  #if compiler(>=5.3) && $NonescapableTypes
  public init?(rawValue: Swift.Int)
  #endif
  public typealias ID = Swift.Int
  public typealias RawValue = Swift.Int
  public var rawValue: Swift.Int {
    get
  }
}
@_Concurrency.MainActor final public class BlinkIDUXModel : BlinkIDUX.ScanningViewModel<BlinkID.BlinkIDScanningResult, BlinkIDUX.UIEvent, BlinkIDUX.ReticleStateMachine, BlinkIDUX.BlinkIDScanningAlertType> {
  #if compiler(>=5.3) && $NonescapableTypes
  @_Concurrency.MainActor public init(analyzer: any BlinkIDUX.CameraFrameAnalyzer<BlinkID.CameraFrame, BlinkIDUX.UIEvent>, uxSettings: BlinkIDUX.ScanningUXSettings = ScanningUXSettings(), onScanCompleted: @escaping (BlinkIDUX.BlinkIDResultState) -> Swift.Void, onFrameProcessResult: (@Sendable (BlinkIDUX.FrameProcessResultHandle) async -> Swift.Void)? = nil)
  #endif
  @_Concurrency.MainActor override final public func processAnalyzerResult() async
  @_Concurrency.MainActor override final public func timeoutAlertDismised()
  @objc deinit
}
extension BlinkID.DocumentRotation {
  public var passportOrientation: BlinkIDUX.PassportOrientation {
    get
  }
}
@_Concurrency.MainActor @preconcurrency public struct BlinkIDUXView : SwiftUICore.View {
  @_Concurrency.MainActor @preconcurrency public init(analyzer: any BlinkIDUX.CameraFrameAnalyzer<BlinkID.CameraFrame, BlinkIDUX.UIEvent>, onScanCompleted: @escaping (BlinkIDUX.BlinkIDResultState) -> Swift.Void)
  @_Concurrency.MainActor @preconcurrency public init(viewModel: BlinkIDUX.BlinkIDUXModel)
  @_Concurrency.MainActor @preconcurrency public var body: some SwiftUICore.View {
    get
  }
  public typealias Body = @_opaqueReturnTypeOf("$s9BlinkIDUX0A8IDUXViewV4bodyQrvp", 0) __
}
extension SwiftUICore.View {
  @_Concurrency.MainActor @preconcurrency public func uxSettings(_ settings: BlinkIDUX.ScanningUXSettings) -> some SwiftUICore.View
  
  @_Concurrency.MainActor @preconcurrency public func onFrameProcessResult(_ callback: @escaping @Sendable (BlinkIDUX.FrameProcessResultHandle) async -> Swift.Void) -> some SwiftUICore.View
  
}
public enum DocumentSide : Swift.Sendable, Swift.Equatable {
  case front
  case back
  case barcode
  case passport(BlinkIDUX.PassportOrientation)
  case passportBarcode
  public static func == (a: BlinkIDUX.DocumentSide, b: BlinkIDUX.DocumentSide) -> Swift.Bool
}
public enum PassportOrientation : Swift.Sendable, Swift.Equatable {
  case none
  case left90
  case right90
  public static func == (a: BlinkIDUX.PassportOrientation, b: BlinkIDUX.PassportOrientation) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
public enum ReticleState : BlinkIDUX.ReticleStateProtocol {
  case front
  case back
  case barcode
  case barcodeSide
  case detecting
  case flip
  case error(Swift.String)
  case inactive
  case passport(Swift.String)
  case inactiveWithMessage(Swift.String)
  public static var inactiveState: BlinkIDUX.ReticleState {
    get
  }
  #if compiler(>=5.3) && $NonescapableTypes
  public var text: Swift.String? {
    get
  }
  #endif
  public var duration: Swift.Double {
    get
  }
  public var shouldExpire: Swift.Bool {
    get
  }
  public var canBeFallback: Swift.Bool {
    get
  }
  public var isErrorState: Swift.Bool {
    get
  }
  public var reticleStateAppearance: BlinkIDUX.ReticleStateAppearance {
    get
  }
  public static func == (a: BlinkIDUX.ReticleState, b: BlinkIDUX.ReticleState) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
public class ReticleStateMachine : BlinkIDUX.ReticleStateMachineProtocol {
  public typealias ReticleStateType = BlinkIDUX.ReticleState
  @Combine.Published @_projectedValueProperty($reticleState) public var reticleState: BlinkIDUX.ReticleState {
    get
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    set
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    _modify
  }
  public var $reticleState: Combine.Published<BlinkIDUX.ReticleState>.Publisher {
    get
    @available(iOS 14.0, tvOS 14.0, watchOS 7.0, macOS 11.0, *)
    set
  }
  public var fallbackState: BlinkIDUX.ReticleState
  public var lastReticleStateChange: Foundation.TimeInterval
  public var eventCounter: [BlinkIDUX.ReticleState : Swift.Int]
  public var reticleStateIsInterruptible: Swift.Bool
  #if compiler(>=5.3) && $NonescapableTypes
  public init(extractionMode: BlinkIDUX.BlinkIDExtractionMode?)
  #endif
  public func calculateState(using mostFrequentState: BlinkIDUX.ReticleState) -> BlinkIDUX.ReticleState
  public func forcedState(state: BlinkIDUX.ReticleState)
  public func setInitialState()
  public typealias ObjectWillChangePublisher = Combine.ObservableObjectPublisher
  @objc deinit
}
public enum UIEvent : Swift.Equatable, Swift.Sendable {
  case requestDocumentSide(side: BlinkIDUX.DocumentSide)
  case wrongSide
  case wrongSidePassport(passportOrientation: BlinkIDUX.PassportOrientation)
  case blur
  case glare
  case occlusion
  case tilt
  case tooClose
  case tooFar
  case tooCloseToEdge
  case notFullyVisible
  case tooDark
  case tooBright
  case facePhotoNotFullyVisible
  case wrongSidePassportWithBarcode
  case unsupportedDocument
  case unparsableBarcode
  case undetectedBarcode
  public static func == (a: BlinkIDUX.UIEvent, b: BlinkIDUX.UIEvent) -> Swift.Bool
}
@_hasMissingDesignatedInitializers final public class BlinkIDTheme : BlinkIDUX.UXThemeProtocol {
  public static let shared: BlinkIDUX.BlinkIDTheme
  final public var alertTitleColor: SwiftUICore.Color
  final public var alertTitleFont: SwiftUICore.Font
  final public var alertDescriptionColor: SwiftUICore.Color
  final public var alertDescriptionFont: SwiftUICore.Font
  final public var alertButtonColor: SwiftUICore.Color
  final public var alertButtonFont: SwiftUICore.Font
  final public var alertBackgroundColor: SwiftUICore.Color
  final public var onboardingSheetTitleColor: SwiftUICore.Color
  final public var onboardingSheetTitleFont: SwiftUICore.Font
  final public var onboardingSheetDescriptionColor: SwiftUICore.Color
  final public var onboardingSheetDescriptionFont: SwiftUICore.Font
  final public var onboardingSheetButtonColor: SwiftUICore.Color
  final public var onboardingSheetButtonFont: SwiftUICore.Font
  final public var onboardingSheetPageIndicatorColor: SwiftUICore.Color
  final public var onboardingSheetBackgroundColor: SwiftUICore.Color
  final public var reticleTooltipFont: SwiftUICore.Font
  final public var helpButtonForegroundColor: SwiftUICore.Color
  final public var helpButtonBackgroundColor: SwiftUICore.Color
  final public var helpButtonTooltipForegroundColor: SwiftUICore.Color
  final public var helpButtonTooltipBackgroundColor: SwiftUICore.Color
  final public var toastBackgroundColor: SwiftUICore.Color
  @objc deinit
}
public protocol ScanningResultProtocol : Swift.Sendable {
  associatedtype Result : Swift.Sendable
  #if compiler(>=5.3) && $NonescapableTypes
  nonisolated var scanResult: Self.Result? { get }
  #endif
}
public enum ScanningResult<T, U> : BlinkIDUX.ScanningResultProtocol where T : Swift.Sendable, U : Swift.Sendable {
  public typealias Result = T
  case completed(T)
  case interrupted(U)
  case cancelled
  case ended
  #if compiler(>=5.3) && $NonescapableTypes
  nonisolated public var scanResult: T? {
    get
  }
  #endif
}
public protocol EventStream<Event> : Swift.Sendable {
  associatedtype Event : Swift.Sendable
  var stream: _Concurrency.AsyncStream<[Self.Event]> { get async }
}
public protocol CameraFrameAnalyzer<Frame, Event> : Swift.Sendable {
  associatedtype Result : BlinkIDUX.ScanningResultProtocol
  associatedtype Frame : Swift.Sendable
  associatedtype Event : Swift.Sendable
  func analyze(image: Self.Frame) async
  func cancel() async
  func pause() async
  func resume() async
  func restart() async throws
  func resetStepTimer() async
  func end() async
  func result() async -> Self.Result
  var events: any BlinkIDUX.EventStream<Self.Event> { get }
  var stepTimeoutDuration: Foundation.TimeInterval { get async }
  var inactivityTimeoutDuration: Foundation.TimeInterval { get async }
  var sessionNumber: Swift.Int { get }
}
extension BlinkIDUX.CameraFrameAnalyzer {
  public func resetStepTimer() async
}
@_Concurrency.MainActor final public class Camera : BlinkIDUX.CameraModel {
  public enum CameraPosition : Swift.Equatable {
    case back
    case front
    public static func == (a: BlinkIDUX.Camera.CameraPosition, b: BlinkIDUX.Camera.CameraPosition) -> Swift.Bool
    public func hash(into hasher: inout Swift.Hasher)
    public var hashValue: Swift.Int {
      get
    }
  }
  @_Concurrency.MainActor final public var preferredCamera: BlinkIDUX.Camera.CameraPosition {
    get
    set
  }
  @Combine.Published @_projectedValueProperty($status) @_Concurrency.MainActor final public var status: BlinkIDUX.CameraStatus {
    get
  }
  @_Concurrency.MainActor final public var $status: Combine.Published<BlinkIDUX.CameraStatus>.Publisher {
    get
  }
  @_Concurrency.MainActor final public var error: (any Swift.Error)? {
    get
  }
  @_Concurrency.MainActor final public var isSwitchingModes: Swift.Bool {
    get
  }
  @_Concurrency.MainActor final public var orientation: AVFoundation.AVCaptureVideoOrientation {
    get
  }
  @_Concurrency.MainActor final public let captureService: BlinkIDUX.CaptureService
  @_Concurrency.MainActor final public var previewSource: any BlinkIDUX.PreviewSource {
    get
  }
  @_Concurrency.MainActor final public var isTorchSupported: Swift.Bool {
    get
  }
  @_Concurrency.MainActor public init()
  @objc deinit
  @_Concurrency.MainActor final public func start() async
  @_Concurrency.MainActor final public func checkAuthorization(sessionNumber: Swift.Int) async
  @_Concurrency.MainActor final public func stop() async
  @_Concurrency.MainActor final public func focusAndExpose(at point: CoreFoundation.CGPoint) async
  @_Concurrency.MainActor final public var sampleBuffer: _Concurrency.AsyncStream<BlinkIDUX.SampleBuffer> {
    get async
  }
  @_Concurrency.MainActor final public var isTorchEnabled: Swift.Bool {
    get
    set
  }
  @_Concurrency.MainActor final public func stopRotationCoordinator()
}
@_hasMissingDesignatedInitializers final public class SampleBuffer : @unchecked Swift.Sendable {
  final public let buffer: CoreMedia.CMSampleBuffer
  @objc deinit
}
@_hasMissingDesignatedInitializers public actor CaptureService {
  @objc deinit
  @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
  @_semantics("defaultActor") nonisolated final public var unownedExecutor: _Concurrency.UnownedSerialExecutor {
    get
  }
}
@_Concurrency.MainActor public protocol CameraModel : AnyObject {
  @_Concurrency.MainActor var status: BlinkIDUX.CameraStatus { get }
  @_Concurrency.MainActor var previewSource: any BlinkIDUX.PreviewSource { get }
  @_Concurrency.MainActor var isSwitchingModes: Swift.Bool { get }
  @_Concurrency.MainActor func start() async
  @_Concurrency.MainActor func stop() async
  @_Concurrency.MainActor func focusAndExpose(at point: CoreFoundation.CGPoint) async
  #if compiler(>=5.3) && $NonescapableTypes
  @_Concurrency.MainActor var error: (any Swift.Error)? { get }
  #endif
  @_Concurrency.MainActor var isTorchSupported: Swift.Bool { get }
  @_Concurrency.MainActor var isTorchEnabled: Swift.Bool { get set }
  @_Concurrency.MainActor var orientation: AVFoundation.AVCaptureVideoOrientation { get }
  @_Concurrency.MainActor var sampleBuffer: _Concurrency.AsyncStream<BlinkIDUX.SampleBuffer> { get async }
}
public enum CameraStatus {
  case unknown
  case unauthorized
  case failed
  case running
  case interrupted
  case stopped
  public static func == (a: BlinkIDUX.CameraStatus, b: BlinkIDUX.CameraStatus) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
public enum CaptureMode : Swift.String, Swift.Identifiable, Swift.CaseIterable {
  public var id: BlinkIDUX.CaptureMode {
    get
  }
  case video
  #if compiler(>=5.3) && $NonescapableTypes
  public init?(rawValue: Swift.String)
  #endif
  public typealias AllCases = [BlinkIDUX.CaptureMode]
  public typealias ID = BlinkIDUX.CaptureMode
  public typealias RawValue = Swift.String
  nonisolated public static var allCases: [BlinkIDUX.CaptureMode] {
    get
  }
  public var rawValue: Swift.String {
    get
  }
}
public enum CaptureActivity {
  case idle
  public static func == (a: BlinkIDUX.CaptureActivity, b: BlinkIDUX.CaptureActivity) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}

@_Concurrency.MainActor @preconcurrency public struct CameraPreview : SwiftUI.UIViewRepresentable {
  @_Concurrency.MainActor @preconcurrency public init(source: any BlinkIDUX.PreviewSource, videoGravity: AVFoundation.AVLayerVideoGravity = .resizeAspectFill)
  @_Concurrency.MainActor @preconcurrency public func makeUIView(context: BlinkIDUX.CameraPreview.Context) -> BlinkIDUX.CameraPreview.PreviewView
  @_Concurrency.MainActor @preconcurrency public func updateUIView(_ previewView: BlinkIDUX.CameraPreview.PreviewView, context: BlinkIDUX.CameraPreview.Context)
  @objc @_hasMissingDesignatedInitializers @_Concurrency.MainActor @preconcurrency public class PreviewView : UIKit.UIView, BlinkIDUX.PreviewTarget {
    @_Concurrency.MainActor @preconcurrency @objc override dynamic public class var layerClass: Swift.AnyClass {
      @objc get
    }
    @_Concurrency.MainActor @preconcurrency public var videoGravity: AVFoundation.AVLayerVideoGravity {
      get
      set
    }
    nonisolated public func setSession(_ session: AVFoundation.AVCaptureSession)
    @objc deinit
  }
  public typealias Body = Swift.Never
  public typealias Coordinator = Swift.Void
  public typealias UIViewType = BlinkIDUX.CameraPreview.PreviewView
}
public protocol PreviewSource : Swift.Sendable {
  func connect(to target: any BlinkIDUX.PreviewTarget)
}
public protocol PreviewTarget {
  func setSession(_ session: AVFoundation.AVCaptureSession)
}
@_Concurrency.MainActor public struct CameraView<Camera> where Camera : BlinkIDUX.CameraModel {
  @_Concurrency.MainActor public init(camera: Camera)
  @_Concurrency.MainActor @preconcurrency public var body: some SwiftUICore.View {
    get
  }
  public typealias Body = @_opaqueReturnTypeOf("$s9BlinkIDUX10CameraViewV4bodyQrvp", 0) __<Camera>
}
@_Concurrency.MainActor public class NetworkMonitor : Combine.ObservableObject {
  @Combine.Published @_projectedValueProperty($isConnected) @_Concurrency.MainActor public var isConnected: Swift.Bool {
    get
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    set
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    _modify
  }
  @_Concurrency.MainActor public var $isConnected: Combine.Published<Swift.Bool>.Publisher {
    get
    @available(iOS 14.0, tvOS 14.0, watchOS 7.0, macOS 11.0, *)
    set
  }
  @_Concurrency.MainActor public var isOffline: Swift.Bool {
    get
  }
  @_Concurrency.MainActor public init()
  @objc deinit
  public typealias ObjectWillChangePublisher = Combine.ObservableObjectPublisher
}
@_Concurrency.MainActor @preconcurrency public struct NoInternetView : SwiftUICore.View {
  @_Concurrency.MainActor @preconcurrency public init(retryAction: @escaping () -> Swift.Void)
  @_Concurrency.MainActor @preconcurrency public var body: some SwiftUICore.View {
    get
  }
  public typealias Body = @_opaqueReturnTypeOf("$s9BlinkIDUX14NoInternetViewV4bodyQrvp", 0) __
}
public protocol AlertTypeProtocol : Swift.Identifiable {
  var title: Swift.String { get }
  var description: Swift.String { get }
  var buttonTitle: Swift.String { get }
  var pingletAlertType: BlinkID.UxEventPinglet.AlertType { get }
}
public struct ScanningUXSettings {
  public init(showIntroductionAlert: Swift.Bool = true, showHelpButton: Swift.Bool = true, preferredCameraPosition: BlinkIDUX.Camera.CameraPosition = .back, allowHapticFeedback: Swift.Bool = true)
}
@_Concurrency.MainActor public class ScanningViewModel<T, U, V, A> : Foundation.ObservableObject where V : BlinkIDUX.ReticleStateMachineProtocol, A : BlinkIDUX.AlertTypeProtocol {
  #if compiler(>=5.3) && $NonescapableTypes
  @Combine.Published @_projectedValueProperty($scanningResult) @_Concurrency.MainActor public var scanningResult: T? {
    get
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    set
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    _modify
  }
  #endif
  #if compiler(>=5.3) && $NonescapableTypes
  @_Concurrency.MainActor public var $scanningResult: Combine.Published<T?>.Publisher {
    get
    @available(iOS 14.0, tvOS 14.0, watchOS 7.0, macOS 11.0, *)
    set
  }
  #endif
  @Combine.Published @_projectedValueProperty($roi) @_Concurrency.MainActor public var roi: BlinkID.RegionOfInterest {
    get
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    set
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    _modify
  }
  @_Concurrency.MainActor public var $roi: Combine.Published<BlinkID.RegionOfInterest>.Publisher {
    get
    @available(iOS 14.0, tvOS 14.0, watchOS 7.0, macOS 11.0, *)
    set
  }
  @_Concurrency.MainActor final public let reticleStateMachine: V
  @Combine.Published @_projectedValueProperty($isTorchOn) @_Concurrency.MainActor public var isTorchOn: Swift.Bool {
    get
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    set
  }
  @_Concurrency.MainActor public var $isTorchOn: Combine.Published<Swift.Bool>.Publisher {
    get
    @available(iOS 14.0, tvOS 14.0, watchOS 7.0, macOS 11.0, *)
    set
  }
  @Combine.Published @_projectedValueProperty($isToastVisible) @_Concurrency.MainActor public var isToastVisible: Swift.Bool {
    get
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    set
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    _modify
  }
  @_Concurrency.MainActor public var $isToastVisible: Combine.Published<Swift.Bool>.Publisher {
    get
    @available(iOS 14.0, tvOS 14.0, watchOS 7.0, macOS 11.0, *)
    set
  }
  @Combine.Published @_projectedValueProperty($showIntroductionAlert) @_Concurrency.MainActor public var showIntroductionAlert: Swift.Bool {
    get
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    set
  }
  @_Concurrency.MainActor public var $showIntroductionAlert: Combine.Published<Swift.Bool>.Publisher {
    get
    @available(iOS 14.0, tvOS 14.0, watchOS 7.0, macOS 11.0, *)
    set
  }
  #if compiler(>=5.3) && $NonescapableTypes
  @Combine.Published @_projectedValueProperty($alertType) @_Concurrency.MainActor public var alertType: A? {
    get
    @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
    set
  }
  #endif
  #if compiler(>=5.3) && $NonescapableTypes
  @_Concurrency.MainActor public var $alertType: Combine.Published<A?>.Publisher {
    get
    @available(iOS 14.0, tvOS 14.0, watchOS 7.0, macOS 11.0, *)
    set
  }
  #endif
  @_Concurrency.MainActor public init(analyzer: any BlinkIDUX.CameraFrameAnalyzer<BlinkID.CameraFrame, U>, uxSettings: BlinkIDUX.ScanningUXSettings = ScanningUXSettings(), reticleStateMachine: V, firstSideFinishedText: Swift.String, scanFinishedText: Swift.String)
  @objc deinit
  @_Concurrency.MainActor public func processAnalyzerResult() async
  @_Concurrency.MainActor public func licenseErrorAlertDismised()
  @_Concurrency.MainActor public func timeoutAlertDismised()
  @_Concurrency.MainActor public func presentAlert()
  @_Concurrency.MainActor public func dismissAlert()
  @_Concurrency.MainActor public func stopEventHandling()
  @_Concurrency.MainActor public func startScanning()
  @_Concurrency.MainActor public func pauseScanning()
  @_Concurrency.MainActor public func resumeScanning()
  @_Concurrency.MainActor public func restartScanning()
  @_Concurrency.MainActor public func resetStepTimer()
  @_Concurrency.MainActor public func finishScan() async
  public typealias ObjectWillChangePublisher = Combine.ObservableObjectPublisher
}
public protocol UXThemeProtocol {
  var alertTitleColor: SwiftUICore.Color { get }
  var alertTitleFont: SwiftUICore.Font { get }
  var alertDescriptionColor: SwiftUICore.Color { get }
  var alertDescriptionFont: SwiftUICore.Font { get }
  var alertButtonColor: SwiftUICore.Color { get }
  var alertButtonFont: SwiftUICore.Font { get }
  var alertBackgroundColor: SwiftUICore.Color { get }
  var onboardingSheetTitleColor: SwiftUICore.Color { get }
  var onboardingSheetTitleFont: SwiftUICore.Font { get }
  var onboardingSheetDescriptionColor: SwiftUICore.Color { get }
  var onboardingSheetDescriptionFont: SwiftUICore.Font { get }
  var onboardingSheetButtonColor: SwiftUICore.Color { get }
  var onboardingSheetButtonFont: SwiftUICore.Font { get }
  var onboardingSheetPageIndicatorColor: SwiftUICore.Color { get }
  var onboardingSheetBackgroundColor: SwiftUICore.Color { get }
  var reticleTooltipFont: SwiftUICore.Font { get }
  var helpButtonForegroundColor: SwiftUICore.Color { get }
  var helpButtonBackgroundColor: SwiftUICore.Color { get }
  var helpButtonTooltipForegroundColor: SwiftUICore.Color { get }
  var helpButtonTooltipBackgroundColor: SwiftUICore.Color { get }
  var toastBackgroundColor: SwiftUICore.Color { get }
}
extension AVFoundation.AVCaptureVideoOrientation {
  public func toCameraFrameVideoOrientation() -> BlinkID.CameraFrameVideoOrientation
  public static func fromCameraFrameVideoOrientation(_ orientation: BlinkID.CameraFrameVideoOrientation) -> AVFoundation.AVCaptureVideoOrientation
}
public enum MicroblinkColor : Swift.String {
  case secondary
  case primary
  case tooltipBackground
  case helpBackground
  case background
  case needHelpTooltipBackground
  case toastBackgroundColor
  #if compiler(>=5.3) && $NonescapableTypes
  public init?(rawValue: Swift.String)
  #endif
  public typealias RawValue = Swift.String
  public var rawValue: Swift.String {
    get
  }
}
extension SwiftUICore.Color {
  public init(_ mbColor: BlinkIDUX.MicroblinkColor)
}
public protocol OnboardingStepProtocol : Swift.CaseIterable, Swift.Hashable, Swift.Identifiable {
  var image: SwiftUICore.Image { get }
  var title: Swift.String { get }
  var description: Swift.String { get }
}
extension SwiftUICore.Animation {
  public static func easeOutExpo(duration: Foundation.TimeInterval) -> SwiftUICore.Animation
}
public enum ReticleStateAppearance {
  case empty
  case detecting
  case spinning
  case error
  public static func == (a: BlinkIDUX.ReticleStateAppearance, b: BlinkIDUX.ReticleStateAppearance) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
public protocol ReticleStateMachineProtocol : Combine.ObservableObject {
  associatedtype ReticleStateType : BlinkIDUX.ReticleStateProtocol
  var reticleState: Self.ReticleStateType { get set }
  var fallbackState: Self.ReticleStateType { get set }
  var lastReticleStateChange: Foundation.TimeInterval { get set }
  var eventCounter: [Self.ReticleStateType : Swift.Int] { get set }
  var reticleStateIsInterruptible: Swift.Bool { get set }
  func nextState(state: Self.ReticleStateType, force: Swift.Bool) -> Swift.Bool
  func calculateState(using mostFrequentState: Self.ReticleStateType) -> Self.ReticleStateType
  func forcedState(state: Self.ReticleStateType)
  func setInitialState()
  #if compiler(>=5.3) && $NonescapableTypes
  func calculateRemainingTime(stateDuration: Swift.Double?) -> Swift.Double
  #endif
}
extension BlinkIDUX.ReticleStateMachineProtocol {
  public func nextState(state: Self.ReticleStateType, force: Swift.Bool = false) -> Swift.Bool
  #if compiler(>=5.3) && $NonescapableTypes
  public func calculateRemainingTime(stateDuration: Swift.Double? = nil) -> Swift.Double
  #endif
}
public protocol ReticleStateProtocol : Swift.Hashable {
  #if compiler(>=5.3) && $NonescapableTypes
  var text: Swift.String? { get }
  #endif
  var duration: Swift.Double { get }
  var shouldExpire: Swift.Bool { get }
  var canBeFallback: Swift.Bool { get }
  var isErrorState: Swift.Bool { get }
  static var inactiveState: Self { get }
  var reticleStateAppearance: BlinkIDUX.ReticleStateAppearance { get }
}
extension BlinkIDUX.BlinkIDExtractionMode : Swift.Equatable {}
extension BlinkIDUX.BlinkIDExtractionMode : Swift.Hashable {}
extension BlinkIDUX.BlinkIDScanningAlertType : Swift.Equatable {}
extension BlinkIDUX.BlinkIDScanningAlertType : Swift.Hashable {}
extension BlinkIDUX.BlinkIDScanningAlertType : Swift.RawRepresentable {}
extension BlinkIDUX.BlinkIDUXView : Swift.Sendable {}
extension BlinkIDUX.PassportOrientation : Swift.Hashable {}
extension BlinkIDUX.Camera : Swift.Sendable {}
extension BlinkIDUX.Camera.CameraPosition : Swift.Hashable {}
extension BlinkIDUX.CameraStatus : Swift.Equatable {}
extension BlinkIDUX.CameraStatus : Swift.Hashable {}
extension BlinkIDUX.CaptureMode : Swift.Equatable {}
extension BlinkIDUX.CaptureMode : Swift.Hashable {}
extension BlinkIDUX.CaptureMode : Swift.RawRepresentable {}
extension BlinkIDUX.CaptureActivity : Swift.Equatable {}
extension BlinkIDUX.CaptureActivity : Swift.Hashable {}
extension BlinkIDUX.CameraPreview : Swift.Sendable {}
extension BlinkIDUX.CameraView : SwiftUICore.View {}
extension BlinkIDUX.CameraView : Swift.Sendable {}
extension BlinkIDUX.NetworkMonitor : Swift.Sendable {}
extension BlinkIDUX.NoInternetView : Swift.Sendable {}
extension BlinkIDUX.ScanningViewModel : Swift.Sendable {}
extension BlinkIDUX.MicroblinkColor : Swift.Equatable {}
extension BlinkIDUX.MicroblinkColor : Swift.Hashable {}
extension BlinkIDUX.MicroblinkColor : Swift.RawRepresentable {}
extension BlinkIDUX.ReticleStateAppearance : Swift.Equatable {}
extension BlinkIDUX.ReticleStateAppearance : Swift.Hashable {}