biometric_auth_lock library

Biometric authentication and PIN lock service for Flutter

Classes

Applicative<F>
ApplicativeOps<F, A>
ApplicativePlus<F>
ApplicativePlusOps<F, A>
Attempt<A>
AVLTree<A>
AVLTreeMonoid<A>
Bind<F, A, B>
BiometricAuthData
BiometricAuthResult
Result of a successful biometric authentication
BiometricLockService
App-level facade over biometric_auth_lock that centralizes FaceID / fingerprint lock management and gating of critical operations (payments, transfers, PIN change, etc.).
BooleanConjunctionMonoid
BooleanDisjunctionMonoid
CloseFile
ComparableOrder<A extends Comparable>
ComposedFunctor<F, G>
Cons<A>
Delay<A>
DualMonoid<A>
DualSemigroup<A>
Either<L, R>
EitherLens<A, B, E>
EitherMonad<L>
Eq<A>
EqOps<A>
Evaluation<E, R, W, S, A>
EvaluationMonad<E, R, W, S>
Execute
ExecutionResult
Fail<A>
FileRef
Foldable<F>
FoldableOps<F, A>
FoldableOpsFoldable<F extends FoldableOps>
Free<F, A>
Free2<First, Second>
Free3<First, Second, Third>
FreeComposer<F, C>
FreeMonad<F>
FreeOps<F, O>
Function0TraversableMonad
Functor<F>
FunctorOps<F, A>
FutureMonad
Gather<A>
IBiometricAuthService
IBiometricIdentityService
Repository interface for biometric authentication operations
IdFreeComposer<F>
IdMonad
IdTraversable
IHashMap<K, V>
IList<A>
IListMonoid<A>
IListTMonad<M>
ILocalAuthService
IMap<K, V>
IMapMonoid<K, V>
IntSumMonoid
IOMonad
IOOp<A>
IOOps<F>
ISet<A>
ISetMonoid<A>
IteratorEq<A>
IVector<A>
IVectorMonoid<A>
Left<L, R>
LeftFreeComposer<LL, L, R>
Lens<AIn, AOut, BIn, BOut>
ListMonoid<A>
ListTMonad<M>
ListTraversableMonadPlus
LocalAuthBiometricIdentityService
LocalAuthService
LocalStorageBiometricAuthService
MaxSemigroup<A>
MinSemigroup<A>
Monad<F>
MonadCatch<F>
MonadCatchOps<F, A>
MonadOps<F, A>
MonadOpsMonad<F extends MonadOps>
MonadPlus<F>
MonadPlusOps<F, A>
MonadPlusOpsMonadPlus<F extends MonadPlusOps>
Monoid<A>
Nil<A>
None<A>
NumMaxSemigroup
NumMinSemigroup
NumProductMonoid
NumSumMonoid
OpenFile
Option<A>
OptionLens<A, B>
OptionMonadPlus
OptionMonoid<A>
OptionTraversable
Order<A>
Plus<F>
PlusEmpty<F>
PlusEmptyOps<F, A>
PlusOps<F, A>
Println
Pure<F, A>
ReadBytes
Readln
RightFreeComposer<RR, L, R>
Semigroup<A>
SimpleLens<A, B>
Some<A>
State<S, A>
StateMonad<S>
StateT<F, S, A>
StateTMonad<F, S>
StringMonoid
Suspend<F, A>
Task<A>
TaskMonadCatch
ToStringOrder<A extends Object>
Trampoline<A>
Traversable<F>
TraversableMonad<F>
TraversableMonadOps<F, A>
TraversableMonadPlus<F>
TraversableMonadPlusOps<F, A>
TraversableOps<F, A>
TraversableOpsTraversable<F extends TraversableOps>
Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
Tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
Tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
Tuple2<T1, T2>
Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
Tuple2Monoid<T1, T2>
Tuple2Semigroup<T1, T2>
Tuple3<T1, T2, T3>
Tuple3Monoid<T1, T2, T3>
Tuple3Semigroup<T1, T2, T3>
Tuple4<T1, T2, T3, T4>
Tuple4Monoid<T1, T2, T3, T4>
Tuple4Semigroup<T1, T2, T3, T4>
Tuple5<T1, T2, T3, T4, T5>
Tuple6<T1, T2, T3, T4, T5, T6>
Tuple7<T1, T2, T3, T4, T5, T6, T7>
Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>
Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
Unit
UnitMonoid
WriteBytes

Enums

BiometricUnlockResult
Result of an unlock attempt for a critical operation.
IBiometricIdentityType
Enum representing different types of biometric authentication supported.
Ordering

Constants

unit → const Unit

Properties

AVLTreeFo → Foldable<AVLTree>
final
BoolAndMi → Monoid<bool>
final
BoolOrMi → Monoid<bool>
final
DoubleOrder → Order<double>
final
DualEndoMi → Monoid<Endo>
final
EitherM → EitherMonad
final
EitherTr → Traversable<Either>
final
EndoMi → Monoid<Endo>
final
FirstSemigroup → Semigroup
final
FreeM → FreeMonad
final
Function0TrM → Function0TraversableMonad
final
FutureM → FutureMonad
final
IdM → IdMonad
final
IdTr → IdTraversable
final
IHashMapTr → Traversable<IHashMap>
final
IListMi → Monoid<IList>
final
IListMP → MonadPlus<IList>
final
IListTr → Traversable<IList>
final
IMapMi → Monoid<IMap>
final
IMapTr → Traversable<IMap>
final
IntOrder → Order<int>
final
IntSumMi → Monoid<int>
final
io → IOOps<IOOp>
final
IOM → IOMonad
final
IOMC → MonadCatch<Free<IOOp, dynamic>>
final
ISetFo → Foldable<ISet>
final
IVectorMi → Monoid<IVector>
final
IVectorMP → MonadPlus<IVector>
final
IVectorTr → Traversable<IVector>
final
ListMi → Monoid<List>
final
ListMP → ListTraversableMonadPlus
final
ListTr → Traversable<List>
final
NumMaxSi → Semigroup<num>
final
NumMinSi → Semigroup<num>
final
NumOrder → Order<num>
final
NumProductMi → Monoid<num>
final
NumSumMi → Monoid<num>
final
ObjectEq → Eq<Object>
final
ObjectIteratorEq → Eq<Iterator>
final
SecondSemigroup → Semigroup
final
StateM → StateMonad
final
StringMi → Monoid<String>
final
StringOrder → Order<String>
final
TaskMC → MonadCatch<Task>
final
toStringOrder → Order
final
TrampolineM → Monad<Trampoline>
final
TStateM → StateTMonad<Trampoline, dynamic>
final
tunit → Trampoline<Unit>
final
UnitMi → Monoid<Unit>
final

Functions

cast<A>(dynamic a) → A
catchAsync<A>(Function0<FutureOr<A>> f) → Future<Either<dynamic, A>>
catching<A>(Function0<A> thunk) → Either<dynamic, A>
comparableOrder<A extends Comparable>() → Order<A>
composeF<A, B, C>(Function1<B, C> f, Function1<A, B> g) → Function1<A, C>
composeInterpreters<L, R, O>(O lInterpreter(L l), O rInterpreter(R r)) → Function1<Either<L, R>, O>
cons<A>(A head, IList<A> tail) → IList<A>
constF<A, B>(B b) → Function1<A, B>
curry2<A, B, C>(Function2<A, B, C> fun) → Function1<A, Function1<B, C>>
curry3<A, B, C, D>(Function3<A, B, C, D> fun) → Function1<A, Function1<B, Function1<C, D>>>
curry4<A, B, C, D, E>(Function4<A, B, C, D, E> fun) → Function1<A, Function1<B, Function1<C, Function1<D, E>>>>
curry5<A, B, C, D, E, F>(Function5<A, B, C, D, E, F> fun) → Function1<A, Function1<B, Function1<C, Function1<D, Function1<E, F>>>>>
curry6<A, B, C, D, E, F, G>(Function6<A, B, C, D, E, F, G> fun) → Function1<A, Function1<B, Function1<C, Function1<D, Function1<E, Function1<F, G>>>>>>
dualEndoMi<A>() → Monoid<Endo<A>>
dualMonoid<A>(Monoid<A> mi) → Monoid<A>
dualSemigroup<A>(Semigroup<A> si) → Semigroup<A>
eitherM<L>() → EitherMonad<L>
eitherTr<L, R>() → Traversable<Either<L, R>>
emptyAVLNode<A>() → _AVLNode<A>
emptyMap<K extends Comparable, V>() → IMap<K, V>
emptySet<A extends Comparable>() → ISet<A>
emptySetWithOrder<A>(Order<A> order) → ISet<A>
emptyVector<A>() → IVector<A>
endoMi<A>() → Monoid<Endo<A>>
eq<A>(EqF<A> f) → Eq<A>
firstSemigroup<A>() → Semigroup<A>
flip<A, B, C>(Function2<A, B, C> f) → Function2<B, A, C>
freeM<F>() → FreeMonad<F>
function0TrM<A>() → TraversableMonad<Function0<A>>
futureM<A>() → Monad<Future<A>>
id<A>(A a) → A
idF<A>() → Endo<A>
ihashmap<K, V>(Map<K, V> m) → IHashMap<K, V>
ilist<A>(Iterable<A> iterable) → IList<A>
ilistMi<A>() → Monoid<IList<A>>
ilistMP<A>() → MonadPlus<IList<A>>
ilistTMonad(Monad mmonad) → Monad
imap<K extends Comparable, V>(Map<K, V> m) → IMap<K, V>
imapLensE<K, V, E>(K k, E eF()) → EitherLens<IMap<K, V>, V, E>
imapLensO<K, V>(K k) → OptionLens<IMap<K, V>, V>
imapMi<K extends Comparable, V>() → Monoid<IMap<K, V>>
imapMonoid<K extends Comparable, V>(Semigroup<V> si) → Monoid<IMap<K, V>>
imapMonoidWithOrder<K, V>(Semigroup<V> si, Order<K> order) → Monoid<IMap<K, V>>
imapWithOrder<K, K2 extends K, V>(Order<K> o, Map<K2, V> m) → IMap<K, V>
iomc<A>() → MonadCatch<Free<IOOp, A>>
iota(int n) → IList<int>
iset<A extends Comparable>(Iterable<A> i) → ISet<A>
isetMi<A>(Order<A> o) → Monoid<ISet<A>>
isetWithOrder<A, A2 extends A>(Order<A> order, Iterable<A2> i) → ISet<A>
iteratorEq<A>(Eq<A> aEq) → Eq<Iterator<A>>
ivector<A>(Iterable<A> iterable) → IVector<A>
ivectorLensE<A, E>(int i, E eF()) → EitherLens<IVector<A>, A, E>
ivectorLensO<A>(int i) → OptionLens<IVector<A>, A>
ivectorMi<A>() → Monoid<IVector<A>>
ivectorMP<A>() → MonadPlus<IVector<A>>
left<L, R>(L l) → Either<L, R>
lens<AIn, AOut, BIn, BOut>(Function1<AIn, BOut> getter, Function2<AIn, BIn, AOut> setter) → Lens<AIn, AOut, BIn, BOut>
lensE<A, B, E>(Function1<A, Either<E, B>> getter, Function2<A, B, Either<E, A>> setter) → EitherLens<A, B, E>
lensEtoO<A, B>(EitherLens<A, B, dynamic> aLens) → OptionLens<A, B>
lensO<A, B>(Function1<A, Option<B>> getter, Function2<A, B, Option<A>> setter) → OptionLens<A, B>
lensOToE<A, B, E>(OptionLens<A, B> aLens, E eF()) → EitherLens<A, B, E>
lensS<A, B>(Function1<A, B> getter, Function2<A, B, A> setter) → SimpleLens<A, B>
liftF<F, A>(F fa) → Free<F, A>
listMi<A>() → Monoid<List<A>>
listMP<A>() → MonadPlus<List<A>>
listTMonad<M>(Monad<M> mmonad) → Monad<M>
monoid<A>(A zero(), A append(A t1, A t2)) → Monoid<A>
nil<A>() → IList<A>
none<A>() → Option<A>
objectEq<A>() → Eq<A>
option<A>(bool test, A value) → Option<A>
optionMi<A>(Semigroup<A> si) → Monoid<Option<A>>
optionOf<A>(A? value) → Option<A>
order<A>(OrderF<A> f) → Order<A>
orderBy<A, B>(Order<B> o, B by(A a)) → Order<A>
secondSemigroup<A>() → Semigroup<A>
semigroup<A>(A append(A a1, A a2)) → Semigroup<A>
singletonMap<K extends Comparable, V>(K k, V v) → IMap<K, V>
some<A>(A a) → Option<A>
stateM<S>() → StateMonad<S>
taskMC<A>() → MonadCatch<Task<A>>
tcall<T>(Function0<Trampoline<T>> thunk) → Trampoline<T>
treturn<T>(T t) → Trampoline<T>
tstateM<F, S>() → StateTMonad<Trampoline<F>, S>
tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) → Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11) → Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12) → Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13) → Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) → Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) → Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) → Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17) → Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18) → Tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) → Tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
tuple2<T1, T2>(T1 v1, T2 v2) → Tuple2<T1, T2>
tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) → Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
tuple2Monoid<T1, T2>(Monoid<T1> value1Monoid, Monoid<T2> value2Monoid) → Monoid<Tuple2<T1, T2>>
tuple2Semigroup<T1, T2>(Semigroup<T1> value1Semigroup, Semigroup<T2> value2Semigroup) → Semigroup<Tuple2<T1, T2>>
tuple3<T1, T2, T3>(T1 v1, T2 v2, T3 v3) → Tuple3<T1, T2, T3>
tuple3Monoid<T1, T2, T3>(Monoid<T1> value1Monoid, Monoid<T2> value2Monoid, Monoid<T3> value3Monoid) → Monoid<Tuple3<T1, T2, T3>>
tuple3Semigroup<T1, T2, T3>(Semigroup<T1> value1Semigroup, Semigroup<T2> value2Semigroup, Semigroup<T3> value3Semigroup) → Semigroup<Tuple3<T1, T2, T3>>
tuple4<T1, T2, T3, T4>(T1 v1, T2 v2, T3 v3, T4 v4) → Tuple4<T1, T2, T3, T4>
tuple4Monoid<T1, T2, T3, T4>(Monoid<T1> value1Monoid, Monoid<T2> value2Monoid, Monoid<T3> value3Monoid, Monoid<T4> value4Monoid) → Monoid<Tuple4<T1, T2, T3, T4>>
tuple4Semigroup<T1, T2, T3, T4>(Semigroup<T1> value1Semigroup, Semigroup<T2> value2Semigroup, Semigroup<T3> value3Semigroup, Semigroup<T4> value4Semigroup) → Semigroup<Tuple4<T1, T2, T3, T4>>
tuple5<T1, T2, T3, T4, T5>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) → Tuple5<T1, T2, T3, T4, T5>
tuple6<T1, T2, T3, T4, T5, T6>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) → Tuple6<T1, T2, T3, T4, T5, T6>
tuple7<T1, T2, T3, T4, T5, T6, T7>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) → Tuple7<T1, T2, T3, T4, T5, T6, T7>
tuple8<T1, T2, T3, T4, T5, T6, T7, T8>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) → Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>
tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) → Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
tuplize2<A, B, C>(Function2<A, B, C> fun) → Function1<Tuple2<A, B>, C>
tuplize3<A, B, C, D>(Function3<A, B, C, D> fun) → Function1<Tuple3<A, B, C>, D>
tuplize4<A, B, C, D, E>(Function4<A, B, C, D, E> fun) → Function1<Tuple4<A, B, C, D>, E>
uncurry2<A, B, C>(Function1<A, Function1<B, C>> fun) → Function2<A, B, C>
uncurry3<A, B, C, D>(Function1<A, Function1<B, Function1<C, D>>> fun) → Function3<A, B, C, D>
uncurry4<A, B, C, D, E>(Function1<A, Function1<B, Function1<C, Function1<D, E>>>> fun) → Function4<A, B, C, D, E>
uncurry5<A, B, C, D, E, F>(Function1<A, Function1<B, Function1<C, Function1<D, Function1<E, F>>>>> fun) → Function5<A, B, C, D, E, F>
uncurry6<A, B, C, D, E, F, G>(Function1<A, Function1<B, Function1<C, Function1<D, Function1<E, Function1<F, G>>>>>> fun) → Function6<A, B, C, D, E, F, G>

Typedefs

BiometricIdentityTypeStatus = ({bool canAuthenticateWithBiometrics, bool isDeviceSupported})
Status information for biometric authentication capabilities
Endo<A> = A Function(A a)
EqF<A> = bool Function(A a1, A a2)
Function0<A> = A Function()
Function1<A, B> = B Function(A a)
Function10<A, B, C, D, E, F, G, H, I, J, K> = K Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j)
Function11<A, B, C, D, E, F, G, H, I, J, K, L> = L Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k)
Function12<A, B, C, D, E, F, G, H, I, J, K, L, M> = M Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l)
Function13<A, B, C, D, E, F, G, H, I, J, K, L, M, N> = N Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m)
Function14<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> = O Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n)
Function15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> = P Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o)
Function16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> = Q Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p)
Function17<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> = R Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p, Q q)
Function18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> = S Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p, Q q, R r)
Function19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> = T Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p, Q q, R r, S s)
Function2<A, B, C> = C Function(A a, B b)
Function20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> = U Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p, Q q, R r, S s, T t)
Function3<A, B, C, D> = D Function(A a, B b, C c)
Function4<A, B, C, D, E> = E Function(A a, B b, C c, D d)
Function5<A, B, C, D, E, F> = F Function(A a, B b, C c, D d, E e)
Function6<A, B, C, D, E, F, G> = G Function(A a, B b, C c, D d, E e, F f)
Function7<A, B, C, D, E, F, G, H> = H Function(A a, B b, C c, D d, E e, F f, G g)
Function8<A, B, C, D, E, F, G, H, I> = I Function(A a, B b, C c, D d, E e, F f, G g, H h)
Function9<A, B, C, D, E, F, G, H, I, J> = J Function(A a, B b, C c, D d, E e, F f, G g, H h, I i)
OrderF<A> = Ordering Function(A a1, A a2)

Exceptions / Errors

BiometricAuthException
Base sealed class for all biometric authentication exceptions
BiometricAuthFailedException
Exception thrown when biometric authentication fails
BiometricAuthLockoutException
Exception thrown when too many failed authentication attempts occur
BiometricAuthPinDataCustomException
Exception thrown when an unexpected error occurs while reading biometric auth data
BiometricAuthPinFailedException
Exception thrown when biometric authentication fails or is cancelled while retrieving the PIN fallback
BiometricAuthPinNotConfiguredException
Exception thrown when no PIN fallback has been configured on the device
BiometricNotSupportedException
Exception thrown when biometric authentication is not supported on the device
BiometricPinAuthException
Base sealed class for all biometric-gated PIN retrieval exceptions
BiometricTypeNotAvailableException
Exception thrown when the requested biometric type is not available