1// Package.swift
2dependencies: [
3    .package(url: "https://github.com/EntrustCorporation/biometric-passkey-ios", from: "<version>")
4]
5
6// In your target:
7.target(
8    name: "YourApp",
9    dependencies: [
10        .product(name: "BiometricPasskeySDK", package: "biometric-passkey-ios")
11    ]
12)

1// 1. Build configuration
2let configuration = try BiometricPasskeyConfiguration(
3    rpDomain: "auth.example.com",
4    serverBaseUrl: URL(string: "https://api.example.com")!,
5    keychainAccessGroup: "TEAMID.com.example.passkeys"
6)
7
8// 2. Create the SDK instance
9let biometricPasskey: BiometricPasskeyClientProtocol = BiometricPasskeyClient(configuration: configuration)
10
11// 3. Enroll
12let start = try await backend.startRegistration(userId: currentUserId)
13let output = try await biometricPasskey.enroll(
14    EnrollmentInput(
15        challenge: start.challenge,
16        userId: start.userId,
17        workflowRunId: start.workflowRunId,
18        idvToken: start.idvToken,
19        expiresAt: start.expiresAt
20    )
21)
22try await backend.completeRegistration(
23    registrationAttemptId: start.registrationAttemptId,
24    credentialId: output.credentialId,
25    attestationObject: output.attestationObject,
26    clientDataJson: output.clientDataJson
27)

1let start = try await backend.startAuthentication(userId: currentUserId)
2let output = try await biometricPasskey.authenticate(
3    AuthenticationInput(
4        challenge: start.challenge,
5        allowCredentials: start.allowCredentials,
6        biometricPasskeySessionId: start.biometricPasskeySessionId
7    )
8)
9try await backend.completeAuthentication(
10    biometricPasskeySessionId: output.biometricPasskeySessionId,
11    credentialId: output.credentialId,
12    authenticatorData: output.authenticatorData,
13    clientDataJson: output.clientDataJson,
14    signature: output.signature
15)

1import BiometricPasskeySDK
2
3let configuration = try BiometricPasskeyConfiguration(
4    rpDomain: "auth.example.com",
5    serverBaseUrl: URL(string: "https://api.example.com")!,
6    keychainAccessGroup: "TEAMID.com.example.passkeys"
7)

1import BiometricPasskeySDK
2import SwiftUI
3
4@main
5struct ExampleApp: App {
6    let biometricPasskey: BiometricPasskeyClientProtocol
7
8    init() {
9        let configuration: BiometricPasskeyConfiguration
10        do {
11            configuration = try BiometricPasskeyConfiguration(
12                rpDomain: "auth.example.com",
13                serverBaseUrl: URL(string: "https://api.example.com")!,
14                keychainAccessGroup: "TEAMID.com.example.passkeys"
15            )
16        } catch {
17            fatalError("Invalid SDK configuration: \(error)")
18        }
19        biometricPasskey = BiometricPasskeyClient(configuration: configuration)
20    }
21
22    var body: some Scene {
23        WindowGroup {
24            RootView()
25        }
26    }
27}

1import BiometricPasskeySDK
2
3func enrollPasskey(_ start: RegistrationStartBundle) async throws {
4    let output = try await biometricPasskey.enroll(
5        EnrollmentInput(
6            challenge: start.challenge,
7            workflowRunId: start.workflowRunId,
8            idvToken: start.idvToken,
9            expiresAt: start.expiresAt,
10            userId: start.userId,
11            userHandle: start.userHandle
12        )
13    )
14
15    try await backend.completeRegistration(
16        registrationAttemptId: start.registrationAttemptId,
17        credentialId: output.credentialId,
18        attestationObject: output.attestationObject,
19        clientDataJson: output.clientDataJson
20    )
21}

1import BiometricPasskeySDK
2
3func approveHighRiskAction(_ start: AuthenticationStartBundle) async throws {
4    let output = try await biometricPasskey.authenticate(
5        AuthenticationInput(
6            challenge: start.challenge,
7            allowCredentials: start.allowCredentials,
8            biometricPasskeySessionId: start.biometricPasskeySessionId,
9            crossPlatformSessionId: start.crossPlatformSessionId
10        )
11    )
12
13    try await backend.completeAuthentication(
14        biometricPasskeySessionId: output.biometricPasskeySessionId,
15        credentialId: output.credentialId,
16        authenticatorData: output.authenticatorData,
17        clientDataJson: output.clientDataJson,
18        signature: output.signature,
19        userHandle: output.userHandle
20    )
21}

1func handleCrossPlatformHandoff(_ handoffToken: String) async throws {
2    let resumed = try await backend.resumeCrossPlatformSession(handoffToken)
3    let start = try await backend.startCrossPlatformAuthentication(
4        crossPlatformSessionId: resumed.crossPlatformSessionId
5    )
6
7    let output = try await biometricPasskey.authenticate(
8        AuthenticationInput(
9            challenge: start.challenge,
10            allowCredentials: start.allowCredentials,
11            biometricPasskeySessionId: start.biometricPasskeySessionId,
12            crossPlatformSessionId: resumed.crossPlatformSessionId
13        )
14    )
15
16    try await backend.completeAuthentication(
17        biometricPasskeySessionId: output.biometricPasskeySessionId,
18        credentialId: output.credentialId,
19        authenticatorData: output.authenticatorData,
20        clientDataJson: output.clientDataJson,
21        signature: output.signature,
22        userHandle: output.userHandle
23    )
24}

1import BiometricPasskeySDK
2
3struct AppRecoveryRegistrationProvider: RecoveryRegistrationProvider {
4    let backend: BackendClient
5
6    func fetchRegistrationData(
7        recoveryAttemptId: String,
8        recoveryToken: String
9    ) async throws -> RecoveryRegistrationData {
10        try await backend.startRecoveryRegistration(
11            recoveryAttemptId: recoveryAttemptId,
12            recoveryToken: recoveryToken
13        )
14    }
15}
16
17func recoverAccount(_ start: RecoveryStartBundle) async throws {
18    let output = try await biometricPasskey.recover(
19        RecoveryInput(
20            recoveryAttemptId: start.recoveryAttemptId,
21            recoveryToken: start.recoveryToken,
22            attemptExpiresAt: start.attemptExpiresAt
23        ),
24        registrationProvider: AppRecoveryRegistrationProvider(backend: backend)
25    )
26
27    try await backend.completeRecoveryRegistration(
28        recoveryAttemptId: start.recoveryAttemptId,
29        credentialId: output.credentialId,
30        attestationObject: output.attestationObject,
31        clientDataJson: output.clientDataJson
32    )
33}

1let credentials = try await biometricPasskey.listCredentials(
2    ListCredentialsInput(userId: currentUserId)
3)
4
5guard let first = credentials.first else { return }
6
7let credential = try await biometricPasskey.getCredential(
8    GetCredentialInput(credentialId: first.credentialId)
9)
10
11_ = try await biometricPasskey.deleteCredential(
12    DeleteCredentialInput(credentialId: credential.credentialId)
13)

1import BiometricPasskeySDK
2
3@available(iOS 17.0, *)
4final class ExampleCredentialProviderViewController: BiometricPasskeyCredentialProviderViewController {
5    override var keychainAccessGroup: String {
6        "TEAMID.com.example.passkeys"
7    }
8
9    override var rpDomain: String {
10        "auth.example.com"
11    }
12}

1// After enrollment or when the app returns to the foreground:
2await CredentialIdentityManager.syncCredentials(
3    rpDomain: configuration.rpDomain,
4    userId: currentUserId,
5    accessGroup: configuration.keychainAccessGroup
6)
7
8// Or sync all credentials for the RP domain (all users):
9await CredentialIdentityManager.syncAllCredentials(
10    rpDomain: configuration.rpDomain,
11    accessGroup: configuration.keychainAccessGroup
12)
13
14// On user sign-out — remove all registered identities from the system store:
15await CredentialIdentityManager.removeAllIdentities()

1let enabled = await CredentialProviderStatus.isEnabled()
2
3// isEnabled() returns Bool?. nil means state is unknown (e.g. on unsupported OS versions).
4// Only prompt when the provider is confirmed disabled.
5if enabled == false {
6    await CredentialProviderStatus.openSettings()
7}

1do {
2    try await approveHighRiskAction(start)
3} catch let error as BiometricPasskeyError {
4    switch error.code {
5    case .userCancelled:
6        showRetryOption()
7    case .challengeExpired:
8        restartFromBackend()
9    case .passkeyNotFound:
10        offerRecovery()
11    case .recoveryRateLimited:
12        showRateLimitMessage()
13    case .hardwareNotAvailable:
14        showDeviceNotSupportedMessage()
15    case .biometricLockout:
16        showBiometricLockedMessage()
17    default:
18        if error.isRetryable {
19            showRetryOption()
20        } else {
21            showGenericFailure(error)
22        }
23    }
24}

1// Production code — depend on the protocol
2final class PasskeyViewModel {
3    private let sdk: BiometricPasskeyClientProtocol
4    init(sdk: BiometricPasskeyClientProtocol) { self.sdk = sdk }
5}
6
7// Test code — implement a minimal fake
8final class FakeBiometricPasskeyClient: BiometricPasskeyClientProtocol {
9    var enrollResult = EnrollmentOutput(
10        credentialId: "test-credential-id",
11        attestationObject: "test-attestation",
12        clientDataJson: "test-client-data"
13    )
14
15    func enroll(_ input: EnrollmentInput) async throws -> EnrollmentOutput { enrollResult }
16    func authenticate(_ input: AuthenticationInput) async throws -> AuthenticationOutput { fatalError("not implemented") }
17    func recover(_ input: RecoveryInput, registrationProvider: any RecoveryRegistrationProvider) async throws -> RecoveredCredentialOutput { fatalError("not implemented") }
18    func listCredentials(_ input: ListCredentialsInput) async throws -> [Credential] { [] }
19    func getCredential(_ input: GetCredentialInput) async throws -> Credential { fatalError("not implemented") }
20    func deleteCredential(_ input: DeleteCredentialInput) async throws -> Credential { fatalError("not implemented") }
21}