HAAPI Flow#

haapiManager.start { [weak self] haapiResult in
    self?.handleHaapiResult(haapiResult)
}

GlobalScope.launch(Dispatchers.IO + coroutineExceptionHandler) {
    val response = haapiManager.start(coroutineContext)
    handleHaapiResponse(response)
}

const response = await accessor.haapiManager.start()
handleHaapiResponse(response)

Transport-level failures, attestation failures, and bridge invariants reject the Promise with a typed HaapiError. Wrap in try/catch + isHaapiError(e) when you need to recover. See Error Handling .

private func handleHaapiResult(_ haapiResult: HaapiResult) {
    switch haapiResult {
    case .representation(let haapiRepresentation):
        handleHaapiRepresentation(haapiRepresentation)
    case .problem(let problemRepresentation):
        handleProblemRepresentation(problemRepresentation)
    case .error(let anError):
        handleError(anError)
    }
}

private func handleHaapiRepresentation(_ haapiRepresentation: HaapiRepresentation) {
    switch haapiRepresentation {
    case let authenticatorSelectorStep as AuthenticatorSelectorStep:
        // render authenticator selector
        break
    case let interactiveFormStep as InteractiveFormStep:
        // render form
        break
    case let pollingStep as PollingStep:
        // start polling
        break
    case let authResponseStep as OAuthAuthorizationResponseStep:
        // flow complete — exchange code for tokens
        break
    default:
        // handle other step types
        break
    }
}

All 14 step types and their carried fields are catalogued in iOS Representations .

private fun handleHaapiResponse(haapiResponse: HaapiResponse) {
    when (haapiResponse) {
        is HaapiRepresentation -> handleHaapiRepresentation(haapiResponse)
        is ClientOperationStep -> handleClientOperationStep(haapiResponse)
        is ProblemRepresentation -> handleProblemRepresentation(haapiResponse)
    }
}

private fun handleHaapiRepresentation(haapiRepresentation: HaapiRepresentation) {
    when (haapiRepresentation) {
        is AuthenticatorSelectorStep -> { /* render authenticator selector */ }
        is InteractiveFormStep -> { /* render form */ }
        is PollingStep -> { /* start polling */ }
        is OAuthAuthorizationResponseStep -> { /* flow complete — exchange code for tokens */ }
        else -> {
            // handle other step types
        }
    }
}

All 14 step types and their carried fields are catalogued in Android Representations .

HaapiResponse is a discriminated union on responseCategory; the representation it carries is a discriminated union on stepType. Branch on both, narrowing TypeScript at each step:

import { StepType } from 'identityserver.haapi.reactnative.sdk'
import type { HaapiResponse } from 'identityserver.haapi.reactnative.sdk'

function handleHaapiResponse(response: HaapiResponse) {
    if (response.responseCategory === 'problem') {
        // RFC 7807 problem — see "Problems" in React Native Representations
        handleProblem(response.problem)
        return
    }

    switch (response.representation.stepType) {
        case StepType.AuthenticatorSelector:
            // narrows to AuthenticatorSelectorStep
            break
        case StepType.InteractiveForm:
            // narrows to InteractiveFormStep
            break
        case StepType.Polling:
            // narrows to PollingStep
            break
        case StepType.OAuthAuthorizationResponse:
            // narrows to OAuthAuthorizationResponseStep — exchange code for tokens
            break
        case StepType.ExternalBrowserClientOperation:
        case StepType.BankIdClientOperation:
        case StepType.WebAuthnRegistrationClientOperation:
            // Client-operation steps — delegate to the host platform
            break
        default:
            // GenericRepresentationStep, ContinueSameStep, UserConsentStep, RedirectionStep, etc.
            break
    }
}

All 14 step types and their carried fields are catalogued in React Native Representations . Unlike iOS / Android, React Native does not surface client-operation steps as a separate sibling category — they live alongside other representations under the same representation field, discriminated by stepType.

private func submit(formActionModel: FormActionModel, parameters: [String: Any]) {
    haapiManager.submitForm(formActionModel, parameters: parameters) { [weak self] haapiResult in
        self?.handleHaapiResult(haapiResult)
    }
}

private func followLink(_ link: Link) {
    haapiManager.followLink(link) { [weak self] haapiResult in
        self?.handleHaapiResult(haapiResult)
    }
}

private fun submit(form: FormActionModel, parameters: Map<String, Any>) {
    GlobalScope.launch(Dispatchers.IO + coroutineExceptionHandler) {
        val response = haapiManager.submitForm(
            form = form,
            parameters = parameters,
            onCoroutineContext = this.coroutineContext
        )
        handleHaapiResponse(response)
    }
}

private fun followLink(link: Link) {
    GlobalScope.launch(Dispatchers.IO + coroutineExceptionHandler) {
        val response = haapiManager.followLink(
            link = link,
            onCoroutineContext = this.coroutineContext
        )
        handleHaapiResponse(response)
    }
}

Pass the entire FormAction (or Link) from the current step — not a copy or reconstructed object. The SDK identifies the target action by reference; cached actions from a previous accessor lifecycle yield HaapiErrorCode.FlowCacheMiss.

import type { FormAction, Link } from 'identityserver.haapi.reactnative.sdk'

async function submit(action: FormAction, parameters: Record<string, unknown>) {
    const response = await accessor.haapiManager.submitForm(action, parameters)
    handleHaapiResponse(response)
}

async function follow(link: Link) {
    const response = await accessor.haapiManager.followLink(link)
    handleHaapiResponse(response)
}