@everfur/sdk 0.1.0 → 0.3.0

package/dist/attachments-D8T5re7e.d.cts

@@ -0,0 +1,256 @@
+import { E as EverfurError, c as EverfurResult } from './EverfurResult-DN9pL2Ab.cjs';
+import { C as ConversationId, P as PetRef, b as ResponseId } from './ids-B2GAAifq.cjs';
+import { f as ChatFeedbackType, j as ChatStatus, i as ChatMessage, c as ChatConversationListOptions, d as ChatConversationPage, g as ChatHistoryOptions, h as ChatMessagePage, a as ChatCheckinTarget, e as ChatFeedbackReceipt } from './ports-DEBzEhbp.cjs';
+import { C as CheckinAnswer, a as CheckinOutcome, b as WidgetPet } from './casesRepository-DHwtGRYY.cjs';
+import { i as UrgencyLevel } from './config-CzTZGlfF.cjs';
+import { U as UploadTransport, F as FileHandle } from './ports-BN6RHF9W.cjs';
+import { c as AttachmentQueue, d as AttachmentState, A as AttachmentError, b as AttachmentOutcome } from './attachments-CQgFrEQ7.cjs';
+
+/** The three thumbs. `'neutral'` is the app's rotated thumbs-down glyph. */
+type ChatSentiment = 'up' | 'neutral' | 'down';
+/** The reason keys of the not-helpful sheet, in the app's order. */
+type ChatFeedbackReason = 'inaccurate' | 'outdated' | 'unsafe' | 'unclear' | 'other';
+interface ChatFeedbackReasonOption {
+    readonly key: ChatFeedbackReason;
+    /** The chip label, verbatim from the app. */
+    readonly label: string;
+    /** The `feedback_type` the chip records. */
+    readonly feedbackType: ChatFeedbackType;
+}
+
+/**
+ * Headless chat state. `isBootstrapping` is a deliberate superset of the SPEC-10 §7.4 minimum: the
+ * controller snapshot carries it (§7.1) and the prebuilt component maps it to the Loading state.
+ */
+interface UseEverfurChatState {
+    readonly status: ChatStatus;
+    readonly messages: ReadonlyArray<ChatMessage>;
+    readonly conversationId: ConversationId | null;
+    /** The pet this surface is scoped to (the option, else the provider's active pet); null when unscoped. */
+    readonly petRef: PetRef | null;
+    readonly error: EverfurError | null;
+    readonly isStreaming: boolean;
+    readonly isBootstrapping: boolean;
+    readonly historyCursor: string | null;
+    readonly isLoadingHistory: boolean;
+    /**
+     * The last turn was stopped before its first token: the question is on screen with no answer under it. The
+     * prebuilt surface renders the app's `Response stopped` notice with a retry; a fresh send, a retry or a
+     * thread change clears it.
+     *
+     * OPTIONAL on the type, always present from the hook. It was added to a shipped interface that partners and
+     * suites already build doubles of, and a required field would have made every one of those a type error for
+     * a flag they have no opinion about; absent reads the same as `false` everywhere it is consumed.
+     */
+    readonly stopped?: boolean;
+    listConversations(opts?: ChatConversationListOptions): Promise<EverfurResult<ChatConversationPage>>;
+    getMessages(id: ConversationId, opts?: ChatHistoryOptions): Promise<EverfurResult<ChatMessagePage>>;
+    resumeConversation(id: ConversationId): Promise<EverfurResult<void>>;
+    loadOlderMessages(): Promise<EverfurResult<void>>;
+    /**
+     * Backend-owned suggested-prompt strings (flattened + de-duplicated) from the chat bootstrap. Empty until the
+     * bootstrap resolves and empty when the backend returns none; the prebuilt component renders them as the
+     * tappable "Follow up questions" list, each string a ready-to-send message.
+     */
+    readonly suggestedPrompts: ReadonlyArray<string>;
+    /** Unread assistant messages in the active thread (see `ChatSnapshot.unreadCount`); null while unknown. */
+    readonly unreadCount: number | null;
+    /**
+     * Does any thread the SDK has listed still carry unread assistant content? The header dot, answerable from
+     * the chat bootstrap's own head read, so it never waits on the history drawer being opened.
+     *
+     * OPTIONAL on the type, always present from the hook, for the same reason `stopped` is: it was added to a
+     * shipped interface that partners and suites already build doubles of, and absent reads as `false`.
+     */
+    readonly hasUnreadThreads?: boolean;
+    /**
+     * Open the thread a follow-up check-in landed in: the conversation an Everfur push named, or, with only a
+     * pet, the head of that pet's list (the read that also materializes a check-in the member is owed).
+     * Settles to the conversation opened, `ok(null)` when there is no thread yet; never throws.
+     *
+     * OPTIONAL on the type, always present from the hook, for the same reason `stopped` is: it was added to a
+     * shipped interface that partners and suites already build doubles of, and a required member would have
+     * made every one of those a type error. A double that omits it simply opens nothing.
+     */
+    openCheckin?(target?: ChatCheckinTarget): Promise<EverfurResult<ConversationId | null>>;
+    /** Mark the active thread read and zero `unreadCount`. Settles; a no-op without an active thread. */
+    markRead(): Promise<EverfurResult<void>>;
+    /**
+     * CRN-16. The turn in flight is being re-attempted by the SDK with nothing asked of the reader. The
+     * prebuilt surfaces render the app's `Reconnecting` caption for it.
+     *
+     * OPTIONAL on the type, always present from the hook, for the same reason `stopped` is.
+     */
+    readonly reconnecting?: boolean;
+    /**
+     * CRN-16. Re-read the active thread's newest window and the limit-1 list, merging in anything the platform
+     * wrote while the host was away. Settles; a no-op without a thread and while a turn is in flight.
+     *
+     * OPTIONAL on the type, always present from the hook, for the same reason `stopped` is.
+     */
+    refreshActiveThread?(): Promise<EverfurResult<void>>;
+    /**
+     * Record the owner's answer to a follow-up check-in against the scoped pet and reflect it on the message
+     * (`message.checkin`). Settles; without a pet in scope it is `validationFailed` before any I/O.
+     */
+    answerCheckin(caseId: string, answer: CheckinAnswer): Promise<EverfurResult<CheckinOutcome>>;
+    /**
+     * Leave the active thread for a fresh, empty one (the history drawer's "New conversation"): the transcript
+     * clears and the next `send` creates the conversation. Nothing is fetched or deleted.
+     */
+    newConversation(): void;
+    /**
+     * The reader's rating per assistant message (keyed by the message id), for the thumbs: what was last recorded
+     * this session. A message with no entry is unrated. Local state; the server keeps its own copy.
+     */
+    readonly sentimentByMessage: Readonly<Record<string, ChatSentiment>>;
+    /**
+     * Rate an assistant reply (`POST /widget/v1/messages/{message_id}/feedback`). Only a message with a server
+     * `responseId` is eligible (a local or pending id settles to `validationFailed` before any I/O). A tap on the
+     * sentiment already recorded CLEARS it locally and sends nothing (the consumer app's behaviour); a different
+     * one replaces it. `reason` upgrades a thumbs-down to the specific `feedback_type` the not-helpful sheet
+     * picks, `notes` (<= 4000 characters) rides with it. Settles `ok({ feedbackId })` (an empty id on a local
+     * clear); never throws.
+     */
+    feedback(responseId: ResponseId, sentiment: ChatSentiment, reason?: ChatFeedbackReason | null, notes?: string | null): Promise<EverfurResult<ChatFeedbackReceipt>>;
+    /**
+     * Optimistic; the blank user bubble is removed on a pre-first-delta failure (controller-owned). Drives the
+     * controller stream to completion and settles: `ok(responseId)` on a completed turn (the id is null when
+     * the terminal `done` frame carried no message id), or `err` with the terminal EverfurError. `imageS3Keys`
+     * are the keys of images staged through the attachments queue (at most 5).
+     */
+    send(text: string, opts?: {
+        readonly imageS3Keys?: readonly string[];
+    }): Promise<EverfurResult<ResponseId | null>>;
+    /**
+     * CRN-06. Ask a grounded question in a FRESH conversation: the thread on screen is left and `prompt` is
+     * the first turn of a new one (the consumer's "Ask Everfur" handoff from a records card). Settles like
+     * `send`.
+     *
+     * OPTIONAL on the type, always present from the hook, for the same reason `stopped` is.
+     */
+    askEverfur?(prompt: string): Promise<EverfurResult<ResponseId | null>>;
+    /** Re-sends the last turn with the SAME idempotency key; no duplicate user bubble (§7.4). */
+    retryLast(): Promise<EverfurResult<ResponseId | null>>;
+    /** Aborts the in-flight stream; not an error. */
+    stop(): void;
+}
+/**
+ * @throws {EverfurConfigError} kind 'not-initialized' if called outside an EverfurProvider.
+ * Auto-disposes its controller reference on unmount.
+ */
+declare function useEverfurChat(opts?: {
+    readonly petRef?: PetRef;
+    readonly conversationId?: ConversationId;
+}): UseEverfurChatState;
+
+/**
+ * The host's lifecycle and connectivity signals. Each subscribe returns its own unsubscribe, which the SDK
+ * calls on unmount; a listener that throws is contained by the caller, never by the host.
+ */
+interface LifecyclePort {
+    /**
+     * The host came back to the foreground. Only the real blur-to-focus edge, please: a platform that flips
+     * through an inactive state constantly (iOS control centre, a call banner) would otherwise turn a
+     * notification-shade pull into a request.
+     */
+    onForeground(listener: () => void): () => void;
+    /** Connectivity returned. Omit it and a deferred refresh waits for the next foreground instead. */
+    onOnline?(listener: () => void): () => void;
+    /**
+     * Something told the host THIS member's thread changed: the push that carried the message. Announced
+     * triggers are never coalesced, because that is the one case where the reader is waiting on new content.
+     */
+    onAnnounced?(listener: () => void): () => void;
+    /** Is the host unambiguously offline? Absent reads as online, which is exactly today's behaviour. */
+    isOffline?(): boolean;
+}
+
+/**
+ * CRN-16. The host's own storage for an unsent draft. The SDK ships NO persistence of its own: a draft is
+ * memory-only unless a host passes this, because a question half-typed on a health surface is the reader's
+ * own text and where it may be written down is the host's decision, not the SDK's. `conversationId` is null
+ * for the not-yet-created thread, so a host that keys on it can scope per thread.
+ */
+interface EverfurChatDraftStore {
+    /** The draft you last stored for this thread, or null. May be async. */
+    read(conversationId: string | null): string | null | Promise<string | null>;
+    /** Store the unsent draft for this thread; an empty string means the reader cleared it. May be async. */
+    write(conversationId: string | null, text: string): void | Promise<void>;
+}
+
+/** The three server tiers plus the app's calm `general` tier for an informational turn. */
+type UrgencyDisplayLevel = UrgencyLevel | 'general';
+
+/** The pet list state a header or switcher renders from. */
+interface UseEverfurPetsState {
+    /** The registered pets, newest first as the server lists them; empty until the first fetch settles. */
+    readonly pets: readonly WidgetPet[];
+    /** The provider's active pet (`activePet` prop or `handle.setActivePet`), resolved against the list; null when unscoped or not listed. */
+    readonly activePet: WidgetPet | null;
+    /** True while a fetch is in flight (the first one too, so a header can hold its disc until the name is known). */
+    readonly loading: boolean;
+    /** The last fetch's settled error (`error.displayMessage` is safe to show), or null. */
+    readonly error: EverfurError | null;
+    /** Fetch the list again (after `registerPet`, or a retry). Settles; never throws. */
+    refresh(): Promise<void>;
+}
+/**
+ * @throws {EverfurConfigError} kind 'not-initialized' if called outside an EverfurProvider.
+ */
+declare function useEverfurPets(): UseEverfurPetsState;
+
+/** What a composer renders and calls. */
+interface UseChatAttachmentsState {
+    /** True when the host wired an upload transport; the attach control is hidden otherwise. */
+    readonly available: boolean;
+    /** The rows, in the order they were added. */
+    readonly attachments: readonly AttachmentState[];
+    /** The composer's slots. */
+    readonly maxPerMessage: number;
+    /** True while any row is still uploading: the send is blocked meanwhile. */
+    readonly uploading: boolean;
+    /**
+     * True while any row FAILED to upload. The send is blocked on this too, because the alternative is the
+     * silent drop: `s3Keys` names only the rows that landed and the strip is cleared on dispatch, so a send here
+     * would post the message without the photo the owner picked and leave nothing behind to say so. The consumer
+     * app blocks the same way (everfur-mobile `useAuthenticatedReportChat.ts`, the `blockingAttachment` guard).
+     */
+    readonly failed: boolean;
+    /**
+     * True while the composer must refuse the send: a row is uploading or a row failed. `failed` says which of
+     * the two needs a sentence (the spinner already speaks for the other).
+     */
+    readonly blocked: boolean;
+    /** The S3 keys of every uploaded row, for `send(text, { imageS3Keys })`. */
+    readonly s3Keys: readonly string[];
+    /** The last failure that kept a pick out of the queue (`too_large`, `unsupported_type`, `too_many`), or null. */
+    readonly rejected: AttachmentError | null;
+    /** Validate and enqueue one or more picked files; returns each outcome. Never throws. */
+    add(files: FileHandle | readonly FileHandle[]): readonly AttachmentOutcome<AttachmentState>[];
+    retry(id: string): void;
+    remove(id: string): void;
+    /** Drop every row (after a successful send). */
+    clear(): void;
+    /** Forget the last rejection (the composer showed it). */
+    dismissRejected(): void;
+}
+interface UseChatAttachmentsOptions {
+    /** The composer's slots; default `MAX_ATTACHMENTS_PER_MESSAGE` (5). */
+    readonly maxPerMessage?: number;
+    /** Test seam: a queue to bind instead of building one from the provider. */
+    readonly queue?: AttachmentQueue;
+    /**
+     * The upload transport to bind instead of the provider's `uploadTransport`: the web surface passes its own
+     * fetch-based one, since a browser needs no host adapter to post a multipart form. Absent, the host's.
+     */
+    readonly transport?: UploadTransport;
+}
+/**
+ * The attachment rows of the composer. The queue lives for the scope (user, session epoch) and is disposed on
+ * unmount or re-scope, so a previous user's thumbnails never survive a switch.
+ * @throws {EverfurConfigError} kind 'not-initialized' if called outside an EverfurProvider.
+ */
+declare function useChatAttachments(options?: UseChatAttachmentsOptions): UseChatAttachmentsState;
+
+export { type ChatFeedbackReason as C, type EverfurChatDraftStore as E, type LifecyclePort as L, type UrgencyDisplayLevel as U, type ChatFeedbackReasonOption as a, type ChatSentiment as b, type UseChatAttachmentsOptions as c, type UseChatAttachmentsState as d, type UseEverfurChatState as e, type UseEverfurPetsState as f, useEverfurChat as g, useEverfurPets as h, useChatAttachments as u };

package/dist/casesRepository-ClLv6qMl.d.ts

@@ -0,0 +1,188 @@
+import { c as EverfurResult } from './EverfurResult-DN9pL2Ab.js';
+import { A as AuthContext } from './identity-BMx2SUOM.js';
+import { P as PetRef } from './ids-B2GAAifq.js';
+import { P as PetHealthProfileInput, a as PetHealthProfile } from './profile-CSs1wlXT.js';
+
+/**
+ * Server-declared bounds on `WidgetPetInput`, mirrored so a violation is refused before the wire rather
+ * than returning a refusal after the caller has already driven a registration flow. Every field is optional
+ * server-side: `POST` with an empty body registers a bare pet, which is all consent needs.
+ *
+ * WHICH STATUS THE SERVER WOULD HAVE ANSWERED, because the two are not interchangeable: a body that does not
+ * PARSE is a 400 `ValidationException` (an unknown key, the birth date pair split, a `ref` repeated in a
+ * list), rendered by the app-wide validation handler. The 422s are raised AFTER the body parses: an
+ * unsupported species and an empty PATCH body. Every rule mirrored here is refused locally, so a partner
+ * using this SDK meets neither.
+ */
+declare const PET_NAME_MAX = 100;
+declare const PET_SPECIES_MAX = 50;
+declare const PET_BREED_MAX = 100;
+declare const PET_AGE_YEARS_MAX = 50;
+declare const PET_WEIGHT_KG_MAX = 500;
+/**
+ * The optional profile fields. Omit all of them to register the pet without describing it.
+ *
+ * The five identity fields merge: an absent one leaves the stored value unchanged. The health fields
+ * (`PetHealthProfileInput`) follow the partner pet body's own rules: an explicit null clears a scalar, and a list you
+ * send REPLACES the rows your integration wrote for that list (`[]` clears them). A registration is an upsert, so
+ * sending a list on a later `registerPet` replaces the earlier one rather than adding to it. Health fields need a
+ * SIGNED session (403 `identitySignatureRequired` otherwise) and a pet that is a dog or a cat.
+ */
+interface PetProfileInput extends PetHealthProfileInput {
+    readonly name?: string;
+    readonly species?: string;
+    readonly breed?: string;
+    readonly ageYears?: number;
+    readonly weightKg?: number;
+}
+/** The registered profile, as the server echoes it back. */
+interface RegisteredPet {
+    readonly petRef: string;
+    readonly name: string | null;
+    readonly species: string | null;
+    readonly breed: string | null;
+    readonly ageYears: number | null;
+    readonly weightKg: number | null;
+}
+/**
+ * A partial profile change for `updatePet`. An omitted field is left unchanged; `null` clears it. At least one
+ * field is required. The server refuses clearing or changing `species` to an unsupported value once the pet
+ * uses Records (Records needs a dog or a cat). A health list you send replaces your rows for that list; `[]`
+ * clears them.
+ */
+interface PetProfilePatch extends PetHealthProfileInput {
+    readonly name?: string | null;
+    readonly species?: string | null;
+    readonly breed?: string | null;
+    readonly ageYears?: number | null;
+    readonly weightKg?: number | null;
+}
+/**
+ * One row of `GET /widget/v1/pets` (`WidgetPetResponse`, widget_schemas.py): the profile the partner registered,
+ * keyed by its `petRef`. The roster carries the identity fields only, never health data: the health profile is its
+ * own signed read (`getPetProfile`). `ageYears` is the registered whole-or-fractional age. Unknown wire fields are
+ * dropped at the boundary.
+ */
+interface WidgetPet {
+    /** The server's own id for the row; opaque, never a scope key (`petRef` is). */
+    readonly petId: string | null;
+    readonly petRef: PetRef;
+    readonly name: string | null;
+    readonly species: string | null;
+    readonly breed: string | null;
+    readonly ageYears: number | null;
+    readonly weightKg: number | null;
+    readonly updatedAt: string | null;
+}
+/**
+ * One pet read back WITH its health profile (`GET /widget/v1/pets/{pet_ref}/profile`, `WidgetPetProfileResponse`):
+ * the list row's fields plus `profileVersion`, the health scalars and your integration's four lists.
+ */
+interface WidgetPetProfile extends WidgetPet, PetHealthProfile {
+}
+interface PetsRepository {
+    /**
+     * `GET /widget/v1/pets` - every pet registered for the current user, as the server lists them. Settles
+     * `ok(readonly WidgetPet[])` on 200 (an empty list when none); `err(EverfurError)` otherwise. A row without a
+     * `pet_ref` is dropped rather than failing the page. Never throws.
+     */
+    list(opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<readonly WidgetPet[]>>;
+    /**
+     * `POST /widget/v1/pets/{pet_ref}` - create or update the widget pet profile. Idempotent by construction:
+     * the route is an upsert, so calling it for an already-registered pet updates rather than duplicates.
+     *
+     * Settles: `ok(RegisteredPet)` on 201, `err(EverfurError)` otherwise. Never throws.
+     */
+    registerPet(petRef: PetRef, profile?: PetProfileInput, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<RegisteredPet>>;
+    /**
+     * `PATCH /widget/v1/pets/{pet_ref}` - change part of a registered pet's profile. Settles `ok(RegisteredPet)`
+     * on 200; an unknown pet is the not-found error; an empty change is refused before the wire.
+     */
+    updatePet(petRef: PetRef, patch: PetProfilePatch, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<RegisteredPet>>;
+    /**
+     * `GET /widget/v1/pets/{pet_ref}/profile` - one pet with its health profile, so a partner app can show what
+     * Everfur holds. A SIGNED session only: any other session settles to the route's 403 `identitySignatureRequired`.
+     * An unknown pet is the not-found error. Never throws.
+     */
+    getPetProfile(petRef: PetRef, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<WidgetPetProfile>>;
+    /**
+     * `DELETE /widget/v1/pets/{pet_ref}` - delete the pet profile. The server also retires the pet's Records
+     * data. Settles `ok(undefined)` on 204; an unknown pet is the not-found error.
+     */
+    deletePet(petRef: PetRef, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<void>>;
+    /**
+     * `DELETE /widget/v1/me` - permanently erase everything Everfur holds for the current user (right to
+     * erasure). Settles `ok(undefined)` on 204. A 503 means the erasure did not finish: it is retryable and a
+     * repeat call resumes it. Sent once per call (never auto-retried, so two erasures never overlap), with a
+     * per-attempt deadline of `ERASE_USER_DATA_TIMEOUT_MS`. The next request for the same user starts a fresh,
+     * empty user.
+     */
+    eraseUserData(opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<void>>;
+}
+/**
+ * The allowlist mapper for one `GET /widget/v1/pets` row: the named fields, each type-checked; anything else on
+ * the wire is dropped. null for a row that is not an object or carries no `pet_ref` (nothing to scope by).
+ */
+declare function widgetPetFromWire(raw: unknown): WidgetPet | null;
+/** Build the repository over a device AuthContext (personalized bearer XOR anonymous pk). */
+declare function createPetsRepository(auth: AuthContext): PetsRepository;
+
+/** The owner's answer to a check-in, the wire values of the consumer `CheckinResponse` enum. */
+type CheckinAnswer = 'better' | 'same' | 'worse';
+/** The closed answer set, in the order the consumer surfaces offer it. */
+declare const CHECKIN_ANSWERS: readonly CheckinAnswer[];
+/**
+ * The member-safe view of one watch case (consumer `WatchCaseView`). Case STATE only: the concern itself
+ * never rides on this row. `status` is the server's vocabulary (`watching` while open, then `resolved`,
+ * `escalated` or `lapsed`), carried as a string so a status added later never breaks a frozen client.
+ */
+interface WatchCase {
+    readonly caseId: string;
+    readonly status: string;
+    /** The body-region copy hint (`ears`, `eyes`, ..., `general`), never a diagnosis. */
+    readonly bodyLocation: string | null;
+    readonly lastResponse: CheckinAnswer | null;
+    readonly checkInDueAt: string | null;
+    readonly openedAt: string | null;
+    readonly resolvedAt: string | null;
+    /** The server's own non-diagnostic post-answer line, stamped only on a BETTER resolve. */
+    readonly resolutionText: string | null;
+}
+/** The result of recording a check-in. `ctaDeepLink` is set only on a WORSE escalation (an `everfur://` pointer). */
+interface CheckinOutcome {
+    readonly case: WatchCase;
+    readonly ctaDeepLink: string | null;
+}
+interface CasesRepository {
+    /**
+     * `GET /widget/v1/pets/{pet_ref}/cases` - the pet's open (`watching`) cases. Settles `ok([])` when the pet
+     * has none, which the server makes indistinguishable from a non-member or the feature being off.
+     */
+    list(petRef: PetRef, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<readonly WatchCase[]>>;
+    /**
+     * `POST /widget/v1/pets/{pet_ref}/cases/{case_id}/checkin` - record the owner's answer. Settles
+     * `ok(CheckinOutcome)` on 200; a case that is stale, closed, another member's or gated off is the ordinary
+     * not-found error. A malformed case id or an answer outside the closed set is refused before the wire.
+     */
+    checkin(petRef: PetRef, caseId: string, answer: CheckinAnswer, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<CheckinOutcome>>;
+}
+/** Build the repository over a device AuthContext (personalized bearer XOR anonymous pk). */
+declare function createCasesRepository(auth: AuthContext): CasesRepository;
+
+export { type CheckinAnswer as C, type PetProfileInput as P, type RegisteredPet as R, type WatchCase as W, type CheckinOutcome as a, type WidgetPet as b, type PetProfilePatch as c, type WidgetPetProfile as d, CHECKIN_ANSWERS as e, type CasesRepository as f, PET_AGE_YEARS_MAX as g, PET_BREED_MAX as h, PET_NAME_MAX as i, PET_SPECIES_MAX as j, PET_WEIGHT_KG_MAX as k, type PetsRepository as l, createCasesRepository as m, createPetsRepository as n, widgetPetFromWire as w };

package/dist/casesRepository-DHwtGRYY.d.cts

@@ -0,0 +1,188 @@
+import { c as EverfurResult } from './EverfurResult-DN9pL2Ab.cjs';
+import { A as AuthContext } from './identity-DI4eVx9S.cjs';
+import { P as PetRef } from './ids-B2GAAifq.cjs';
+import { P as PetHealthProfileInput, a as PetHealthProfile } from './profile-CSs1wlXT.cjs';
+
+/**
+ * Server-declared bounds on `WidgetPetInput`, mirrored so a violation is refused before the wire rather
+ * than returning a refusal after the caller has already driven a registration flow. Every field is optional
+ * server-side: `POST` with an empty body registers a bare pet, which is all consent needs.
+ *
+ * WHICH STATUS THE SERVER WOULD HAVE ANSWERED, because the two are not interchangeable: a body that does not
+ * PARSE is a 400 `ValidationException` (an unknown key, the birth date pair split, a `ref` repeated in a
+ * list), rendered by the app-wide validation handler. The 422s are raised AFTER the body parses: an
+ * unsupported species and an empty PATCH body. Every rule mirrored here is refused locally, so a partner
+ * using this SDK meets neither.
+ */
+declare const PET_NAME_MAX = 100;
+declare const PET_SPECIES_MAX = 50;
+declare const PET_BREED_MAX = 100;
+declare const PET_AGE_YEARS_MAX = 50;
+declare const PET_WEIGHT_KG_MAX = 500;
+/**
+ * The optional profile fields. Omit all of them to register the pet without describing it.
+ *
+ * The five identity fields merge: an absent one leaves the stored value unchanged. The health fields
+ * (`PetHealthProfileInput`) follow the partner pet body's own rules: an explicit null clears a scalar, and a list you
+ * send REPLACES the rows your integration wrote for that list (`[]` clears them). A registration is an upsert, so
+ * sending a list on a later `registerPet` replaces the earlier one rather than adding to it. Health fields need a
+ * SIGNED session (403 `identitySignatureRequired` otherwise) and a pet that is a dog or a cat.
+ */
+interface PetProfileInput extends PetHealthProfileInput {
+    readonly name?: string;
+    readonly species?: string;
+    readonly breed?: string;
+    readonly ageYears?: number;
+    readonly weightKg?: number;
+}
+/** The registered profile, as the server echoes it back. */
+interface RegisteredPet {
+    readonly petRef: string;
+    readonly name: string | null;
+    readonly species: string | null;
+    readonly breed: string | null;
+    readonly ageYears: number | null;
+    readonly weightKg: number | null;
+}
+/**
+ * A partial profile change for `updatePet`. An omitted field is left unchanged; `null` clears it. At least one
+ * field is required. The server refuses clearing or changing `species` to an unsupported value once the pet
+ * uses Records (Records needs a dog or a cat). A health list you send replaces your rows for that list; `[]`
+ * clears them.
+ */
+interface PetProfilePatch extends PetHealthProfileInput {
+    readonly name?: string | null;
+    readonly species?: string | null;
+    readonly breed?: string | null;
+    readonly ageYears?: number | null;
+    readonly weightKg?: number | null;
+}
+/**
+ * One row of `GET /widget/v1/pets` (`WidgetPetResponse`, widget_schemas.py): the profile the partner registered,
+ * keyed by its `petRef`. The roster carries the identity fields only, never health data: the health profile is its
+ * own signed read (`getPetProfile`). `ageYears` is the registered whole-or-fractional age. Unknown wire fields are
+ * dropped at the boundary.
+ */
+interface WidgetPet {
+    /** The server's own id for the row; opaque, never a scope key (`petRef` is). */
+    readonly petId: string | null;
+    readonly petRef: PetRef;
+    readonly name: string | null;
+    readonly species: string | null;
+    readonly breed: string | null;
+    readonly ageYears: number | null;
+    readonly weightKg: number | null;
+    readonly updatedAt: string | null;
+}
+/**
+ * One pet read back WITH its health profile (`GET /widget/v1/pets/{pet_ref}/profile`, `WidgetPetProfileResponse`):
+ * the list row's fields plus `profileVersion`, the health scalars and your integration's four lists.
+ */
+interface WidgetPetProfile extends WidgetPet, PetHealthProfile {
+}
+interface PetsRepository {
+    /**
+     * `GET /widget/v1/pets` - every pet registered for the current user, as the server lists them. Settles
+     * `ok(readonly WidgetPet[])` on 200 (an empty list when none); `err(EverfurError)` otherwise. A row without a
+     * `pet_ref` is dropped rather than failing the page. Never throws.
+     */
+    list(opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<readonly WidgetPet[]>>;
+    /**
+     * `POST /widget/v1/pets/{pet_ref}` - create or update the widget pet profile. Idempotent by construction:
+     * the route is an upsert, so calling it for an already-registered pet updates rather than duplicates.
+     *
+     * Settles: `ok(RegisteredPet)` on 201, `err(EverfurError)` otherwise. Never throws.
+     */
+    registerPet(petRef: PetRef, profile?: PetProfileInput, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<RegisteredPet>>;
+    /**
+     * `PATCH /widget/v1/pets/{pet_ref}` - change part of a registered pet's profile. Settles `ok(RegisteredPet)`
+     * on 200; an unknown pet is the not-found error; an empty change is refused before the wire.
+     */
+    updatePet(petRef: PetRef, patch: PetProfilePatch, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<RegisteredPet>>;
+    /**
+     * `GET /widget/v1/pets/{pet_ref}/profile` - one pet with its health profile, so a partner app can show what
+     * Everfur holds. A SIGNED session only: any other session settles to the route's 403 `identitySignatureRequired`.
+     * An unknown pet is the not-found error. Never throws.
+     */
+    getPetProfile(petRef: PetRef, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<WidgetPetProfile>>;
+    /**
+     * `DELETE /widget/v1/pets/{pet_ref}` - delete the pet profile. The server also retires the pet's Records
+     * data. Settles `ok(undefined)` on 204; an unknown pet is the not-found error.
+     */
+    deletePet(petRef: PetRef, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<void>>;
+    /**
+     * `DELETE /widget/v1/me` - permanently erase everything Everfur holds for the current user (right to
+     * erasure). Settles `ok(undefined)` on 204. A 503 means the erasure did not finish: it is retryable and a
+     * repeat call resumes it. Sent once per call (never auto-retried, so two erasures never overlap), with a
+     * per-attempt deadline of `ERASE_USER_DATA_TIMEOUT_MS`. The next request for the same user starts a fresh,
+     * empty user.
+     */
+    eraseUserData(opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<void>>;
+}
+/**
+ * The allowlist mapper for one `GET /widget/v1/pets` row: the named fields, each type-checked; anything else on
+ * the wire is dropped. null for a row that is not an object or carries no `pet_ref` (nothing to scope by).
+ */
+declare function widgetPetFromWire(raw: unknown): WidgetPet | null;
+/** Build the repository over a device AuthContext (personalized bearer XOR anonymous pk). */
+declare function createPetsRepository(auth: AuthContext): PetsRepository;
+
+/** The owner's answer to a check-in, the wire values of the consumer `CheckinResponse` enum. */
+type CheckinAnswer = 'better' | 'same' | 'worse';
+/** The closed answer set, in the order the consumer surfaces offer it. */
+declare const CHECKIN_ANSWERS: readonly CheckinAnswer[];
+/**
+ * The member-safe view of one watch case (consumer `WatchCaseView`). Case STATE only: the concern itself
+ * never rides on this row. `status` is the server's vocabulary (`watching` while open, then `resolved`,
+ * `escalated` or `lapsed`), carried as a string so a status added later never breaks a frozen client.
+ */
+interface WatchCase {
+    readonly caseId: string;
+    readonly status: string;
+    /** The body-region copy hint (`ears`, `eyes`, ..., `general`), never a diagnosis. */
+    readonly bodyLocation: string | null;
+    readonly lastResponse: CheckinAnswer | null;
+    readonly checkInDueAt: string | null;
+    readonly openedAt: string | null;
+    readonly resolvedAt: string | null;
+    /** The server's own non-diagnostic post-answer line, stamped only on a BETTER resolve. */
+    readonly resolutionText: string | null;
+}
+/** The result of recording a check-in. `ctaDeepLink` is set only on a WORSE escalation (an `everfur://` pointer). */
+interface CheckinOutcome {
+    readonly case: WatchCase;
+    readonly ctaDeepLink: string | null;
+}
+interface CasesRepository {
+    /**
+     * `GET /widget/v1/pets/{pet_ref}/cases` - the pet's open (`watching`) cases. Settles `ok([])` when the pet
+     * has none, which the server makes indistinguishable from a non-member or the feature being off.
+     */
+    list(petRef: PetRef, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<readonly WatchCase[]>>;
+    /**
+     * `POST /widget/v1/pets/{pet_ref}/cases/{case_id}/checkin` - record the owner's answer. Settles
+     * `ok(CheckinOutcome)` on 200; a case that is stale, closed, another member's or gated off is the ordinary
+     * not-found error. A malformed case id or an answer outside the closed set is refused before the wire.
+     */
+    checkin(petRef: PetRef, caseId: string, answer: CheckinAnswer, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<CheckinOutcome>>;
+}
+/** Build the repository over a device AuthContext (personalized bearer XOR anonymous pk). */
+declare function createCasesRepository(auth: AuthContext): CasesRepository;
+
+export { type CheckinAnswer as C, type PetProfileInput as P, type RegisteredPet as R, type WatchCase as W, type CheckinOutcome as a, type WidgetPet as b, type PetProfilePatch as c, type WidgetPetProfile as d, CHECKIN_ANSWERS as e, type CasesRepository as f, PET_AGE_YEARS_MAX as g, PET_BREED_MAX as h, PET_NAME_MAX as i, PET_SPECIES_MAX as j, PET_WEIGHT_KG_MAX as k, type PetsRepository as l, createCasesRepository as m, createPetsRepository as n, widgetPetFromWire as w };