Events

client.on subscribes to one event type at a time and delivers its payload. enrollment.on('change') reports an Enrollment’s state on the device still waiting to be enrolled.

Subscribing

TypeScript

const unsubscribe = client.on('session', ({ state }) => render(state));

Swift

for await event in client.on(.session) {
  render(event.state)
}

Kotlin

client.on<ClientEvent.Session>().collect { event -> render(event.state) }

ClientEvent

TypeScript

type ClientEvent =
  | { type: 'session'; state: SessionState }
  | { type: 'locked' }
  | { type: 'revoked' }
  | { type: 'reachable'; reachable: boolean }
  | { type: 'lease'; lease?: LeaseState }
  | { type: 'worklist' }
  | { type: 'enrollment-request'; requestId: string }
  | { type: 'device-revoked'; recipientId: RecipientId; reason: RevocationReason }
  | { type: 'backfill'; waiting: BackfillWaiting[] }
  | { type: 'roles'; roles: Role[] }
  | { type: 'ceremony'; ceremonyId: string }
  | { type: 'drafts'; count: number };

Swift

enum ClientEvent {
  struct Kind<Payload> {
    static var session: Kind<Session> { .init() }
    static var locked: Kind<Locked> { .init() }
    static var revoked: Kind<Revoked> { .init() }
    static var reachable: Kind<Reachable> { .init() }
    static var lease: Kind<Lease> { .init() }
    static var worklist: Kind<Worklist> { .init() }
    static var enrollmentRequest: Kind<EnrollmentRequest> { .init() }
    static var deviceRevoked: Kind<DeviceRevoked> { .init() }
    static var backfill: Kind<Backfill> { .init() }
    static var roles: Kind<Roles> { .init() }
    static var ceremony: Kind<Ceremony> { .init() }
    static var drafts: Kind<Drafts> { .init() }
  }

  struct Session { let state: SessionState }
  struct Locked {}
  struct Revoked {}
  struct Reachable { let reachable: Bool }
  struct Lease { let lease: LeaseState? }
  struct Worklist {}
  struct EnrollmentRequest { let requestId: String }
  struct DeviceRevoked { let recipientId: RecipientId; let reason: RevocationReason }
  struct Backfill { let waiting: [BackfillWaiting] }
  struct Roles { let roles: [Role] }
  struct Ceremony { let ceremonyId: String }
  struct Drafts { let count: Int }
}

Kotlin

sealed interface ClientEvent {
  data class Session(val state: SessionState) : ClientEvent
  object Locked : ClientEvent
  object Revoked : ClientEvent
  data class Reachable(val reachable: Boolean) : ClientEvent
  data class Lease(val lease: LeaseState?) : ClientEvent
  object Worklist : ClientEvent
  data class EnrollmentRequest(val requestId: String) : ClientEvent
  data class DeviceRevoked(val recipientId: RecipientId, val reason: RevocationReason) : ClientEvent
  data class Backfill(val waiting: List<BackfillWaiting>) : ClientEvent
  data class Roles(val roles: List<Role>) : ClientEvent
  data class Ceremony(val ceremonyId: String) : ClientEvent
  data class Drafts(val count: Int) : ClientEvent
}

Type	Payload	When
session	state	The session’s state changed: "none", "open", "inactive", "offline" or "ended".
locked	none	The device key was locked by client.lock().
revoked	none	The device certificate (card) of this device is no longer active. The SDK discards its offline lease and locks the Client.
reachable	reachable	The Seald Healthcare Cloud became reachable or unreachable.
lease	lease	The offline lease changed: granted, renewed or gone.
worklist	none	The worklist changed. Call worklist.get() again.
enrollment-request	requestId	Another device of this person asked to enroll, or was revoked. The person sees every such request, so one they did not make is noticed.
device-revoked	recipientId, reason	A device in the tenant was revoked.
backfill	waiting	This device gained access it was waiting for. More of waiting now opens.
roles	roles	This person’s roles changed.
ceremony	ceremonyId	A break-glass ceremony this device may take part in opened or changed.
drafts	count	The Seald Healthcare Cloud is back and this many drafts wait to be saved.

Enrollment’s change event

The change event fires on the device that waits to be enrolled. It fires each time the Enrollment’s state changes: pending, opened, revealed, approved, enrolled, rejected or lapsed.

TypeScript

enrollment.on('change', (state: EnrollmentState) => {
  if (state === 'revealed') showCode(enrollment.code);
});

Swift

for await state in enrollment.on(.change) {
  if state == .revealed { showCode(enrollment.code) }
}

Kotlin

enrollment.on(EnrollmentEvent.CHANGE).collect { state ->
  if (state == EnrollmentState.REVEALED) showCode(enrollment.code)
}