@everfur/sdk 0.1.1 → 0.4.0

package/dist/server/events/index.d.cts

@@ -0,0 +1,550 @@
+import { b as PartnerPetProfile } from '../../pets-JVCXgRgR.cjs';
+import { c as EverfurResult } from '../../EverfurResult-DN9pL2Ab.cjs';
+import { j as FetchLike } from '../../config--Wu1Umhd.cjs';
+export { b as PetActivityLevel, c as PetAllergy, d as PetAllergySeverity, e as PetBirthDatePrecision, f as PetCondition, P as PetHealthProfileInput, g as PetIndoorOutdoor, h as PetMedication, i as PetSex } from '../../profile-CSs1wlXT.cjs';
+
+/** Every outbound event type in the catalog. Order matches EFBackend `OUTBOUND_EVENT_TYPES`. */
+declare const EVERFUR_WEBHOOK_EVENT_TYPES: readonly ["member.linked", "member.unlinked", "visit.booked", "visit.cancelled", "visit.completed", "visit.no_show", "record_request.updated", "record.ready", "webhook_endpoint.test", "chat.follow_up_due", "chat.urgency.flagged", "pet.vaccination.due", "visit.rescheduled", "visit.reminder", "visit.followup_sent", "chat.reminder_due", "record.activation", "visit.message_received", "visit.ended"];
+/** One outbound event type name. */
+type EverfurWebhookEventType = (typeof EVERFUR_WEBHOOK_EVENT_TYPES)[number];
+/**
+ * The types that reach your WEBHOOK ONLY and can never reach a member's device, whatever the member's
+ * notification settings say (EFBackend `partner_notifications/channels.py` NO_COPY_TYPES, which is also why
+ * `partner_target.py` builds no push target for them):
+ *
+ * - `member.linked` / `member.unlinked` are your bookkeeping, not news for the member;
+ * - `chat.urgency.flagged` is an in-app affordance, not a push;
+ * - `webhook_endpoint.test` is the console's own test button.
+ *
+ * Every OTHER catalog type does build a push target, so it can announce itself on a device and
+ * `parseEverfurNotification` can read it (three of them, `visit.completed`, `visit.rescheduled` and
+ * `visit.ended`, have a target but no consumer copy, so in practice no push is sent for them either).
+ * Read this list when you decide which events your own backend must act on rather than leave to the device.
+ */
+declare const EVERFUR_WEBHOOK_ONLY_EVENT_TYPES: readonly ["member.linked", "member.unlinked", "chat.urgency.flagged", "webhook_endpoint.test"];
+/** One type that never reaches a device. */
+type EverfurWebhookOnlyEventType = (typeof EVERFUR_WEBHOOK_ONLY_EVENT_TYPES)[number];
+/** Fields any payload may carry beyond the ones typed here (forward compatible). */
+interface OpenEventPayload {
+    readonly [field: string]: unknown;
+}
+/** `member.linked` / `member.unlinked`: a partner member's link to an Everfur account changed. */
+interface MemberLinkPayload extends OpenEventPayload {
+    readonly object: 'member';
+    /** Your own opaque id for the member, as you passed it when minting the session. */
+    readonly user_ref: string;
+}
+/**
+ * What the partner may know a visit to be. A visit in progress or awaiting its note is still `booked`; every
+ * terminal consult status maps to one of the other three (`VISIT_STATUS_BY_CONSULT_STATUS`), and a visit
+ * nobody attended and nobody cancelled is a `no_show` that blames no one.
+ */
+type EverfurVisitStatus = 'booked' | 'cancelled' | 'completed' | 'no_show';
+/**
+ * The fields every `visit.*` event carries (`VISIT_EVENT_DATA_KEYS`). Sent only for a visit that started from
+ * your integration, and only when the member opted in to share visit status with you.
+ */
+interface VisitPayload extends OpenEventPayload {
+    readonly object: 'visit';
+    /**
+     * The visit's opaque partner reference (the platform's `partner_visit_ref`, minted when a visit starts from
+     * your integration). Never an internal consult id, and the same on every event for that visit; a follow-up
+     * visit gets its own.
+     */
+    readonly visit_ref: string;
+    readonly user_ref: string;
+    /** Your pet id, or `null` when you never named a pet for this link (or the owner has not confirmed one). */
+    readonly pet_ref: string | null;
+    /** The partner-visible status of the visit at the moment of the event. */
+    readonly status: EverfurVisitStatus;
+    /** ISO 8601. The visit's scheduled time; on `visit.rescheduled` it is already the NEW time. */
+    readonly scheduled_at: string;
+    /** ISO 8601. When the change happened (the status transition, the reschedule, the reminder or the send). */
+    readonly occurred_at: string;
+}
+/** `visit.rescheduled`: the owner moved the visit. `status` is `booked`. */
+interface VisitRescheduledPayload extends VisitPayload {
+    readonly status: 'booked';
+    /** ISO 8601. The time the visit was scheduled for before this move. */
+    readonly previous_scheduled_at: string;
+}
+/** The two consumer reminder rows, by lead time (`VISIT_REMINDER_STAGE_BY_OUTBOX_EVENT`). */
+type EverfurVisitReminderStage = '24h' | '30m';
+/** `visit.reminder`: the member's reminder for a visit still to happen was released. `status` is `booked`. */
+interface VisitReminderPayload extends VisitPayload {
+    readonly status: 'booked';
+    readonly stage: EverfurVisitReminderStage;
+}
+/**
+ * `visit.followup_sent`: the post-visit check-in message was delivered to the member. `status` is what the
+ * partner may know the visit to be at that moment: `completed`, or `booked` while the note is still pending.
+ */
+interface VisitFollowupSentPayload extends VisitPayload {
+    readonly status: 'booked' | 'completed';
+    /** ISO 8601. When the check-in was sent. Never the message. */
+    readonly sent_at: string;
+}
+/**
+ * `visit.message_received` (owner decision 4): the vet wrote in the visit thread. One per message. Ids and one
+ * timestamp: never the message, a preview or the vet's name.
+ */
+interface VisitMessageReceivedPayload extends VisitPayload {
+    /** ISO 8601. When the vet's message was written. */
+    readonly message_at: string;
+}
+/**
+ * `visit.ended` (owner decision 4): the call ended, before the note is signed, so your list can stop reading
+ * "booked" for a visit that has happened. One per visit. The status is still `booked` until the note is signed and
+ * `visit.completed` arrives.
+ */
+interface VisitEndedPayload extends VisitPayload {
+    /** ISO 8601. When the call ended. */
+    readonly ended_at: string;
+}
+/** The seven simple statuses of the one records status model (`records_simple_status.SimpleStatus`). */
+type RecordRequestSimpleStatus = 'requested' | 'awaiting_clinic' | 'received' | 'parsing' | 'published' | 'failed' | 'revoked';
+/**
+ * `record_request.updated`: a records request reached a new simple state, or a reviewer amended the record after
+ * it was published (one more `published` event per amendment). Field set pinned by EFBackend
+ * `tests/records/test_records_partner_events.py`.
+ */
+interface RecordRequestUpdatedPayload extends OpenEventPayload {
+    readonly object: 'record_request';
+    readonly request_id: string;
+    readonly user_ref: string;
+    readonly pet_ref: string;
+    /** The request's state in the seven-value simple status model. Never the raw status. */
+    readonly simple_status: RecordRequestSimpleStatus;
+    /**
+     * The partner-safe detail code, or `null` when the status says it all. The closed allowlist today is
+     * `awaiting_owner_upload`, `received_without_document`, `in_review`, `clinic_declined`, `no_response`,
+     * `hard_bounce` and `clinic_replied_without_records`; it can grow, so handle a value you do not know.
+     */
+    readonly simple_status_detail: string | null;
+    /** The consumer app's action-first sentence for an action-needed state, or `null`. Render verbatim. */
+    readonly action_needed_label: string | null;
+    /** The request's own recovery policy: what the member could do next, as the consumer app shows it. */
+    readonly can_retry_send: boolean;
+    readonly can_update_clinic_email: boolean;
+    readonly can_revoke: boolean;
+    readonly can_convert_to_upload: boolean;
+    /** ISO 8601. When the PUBLISHED record last changed (the latest amendment, else the publish); `null` before. */
+    readonly record_updated_at: string | null;
+}
+/** `record.ready`: a requested record is readable through the records API. Carries no record content. */
+interface RecordReadyPayload extends OpenEventPayload {
+    readonly object: 'record';
+    readonly request_id: string;
+    readonly user_ref: string;
+    readonly pet_ref: string;
+}
+/** The catalog vaccines a due-date reminder names (never a product label). */
+type EverfurVaccine = 'rabies' | 'dhpp';
+/** The consumer reminder stages a due date reaches: 14 days out, 3 days out, then overdue. */
+type EverfurVaccinationDueStage = 'due_in_14d' | 'due_in_3d' | 'overdue';
+/**
+ * `pet.vaccination.due`: a widget pet's rabies or DHPP due date reached a reminder stage. One event per (pet,
+ * vaccine, due date, stage), from the same snapshot the consumer app reminds from. Ids and closed codes only.
+ */
+interface PetVaccinationDuePayload extends OpenEventPayload {
+    readonly object: 'pet_vaccination';
+    readonly user_ref: string;
+    readonly pet_ref: string;
+    readonly vaccine: EverfurVaccine;
+    /** `YYYY-MM-DD`. */
+    readonly due_at: string;
+    readonly stage: EverfurVaccinationDueStage;
+}
+/**
+ * `chat.follow_up_due`: a follow-up check-in for a watched case is due. The partner's webhook replaces the
+ * consumer push; the in-thread check-in itself arrives through the conversation list. Ids and one timestamp,
+ * never the check-in sentence.
+ */
+interface ChatFollowUpDuePayload extends OpenEventPayload {
+    readonly object: 'chat_follow_up';
+    readonly user_ref: string;
+    readonly pet_ref: string;
+    /** The opaque case id (`WatchCase.caseId`). */
+    readonly case_ref: string;
+    /** The thread the check-in lands in when one exists, else `null`. */
+    readonly conversation_id: string | null;
+    /** ISO 8601. */
+    readonly due_at: string;
+}
+/**
+ * `chat.urgency.flagged`: an assistant reply carried an emergency urgency verdict. One per flagged message.
+ * Ids plus the closed level; no reason, no text. The backend writes no `pet_ref` on this event: the thread
+ * is named by `conversation_id`.
+ */
+interface ChatUrgencyFlaggedPayload extends OpenEventPayload {
+    readonly object: 'chat_urgency';
+    readonly user_ref: string;
+    readonly conversation_id: string;
+    /** The assistant message that carries the verdict. */
+    readonly message_id: string;
+    /** `emergency` today (`FLAGGED_URGENCY_LEVELS`); the level set can grow. */
+    readonly urgency_level: string;
+}
+/** Which of the two memory nudges is waiting in the pet's chat (`REMINDER_KIND_BY_TRIGGER`). A closed code. */
+type EverfurChatReminderKind = 'medication_due' | 'open_concern';
+/**
+ * `chat.reminder_due` (CRN-18): the consumer app's medication reminder, or its one gentle check-in on an unresolved
+ * concern, is waiting in the pet's chat. One per (pet, kind, due day), under the same claim, pause and opt-out fences
+ * the consumer push has. Ids and a closed kind: never the medicine, the symptom or the nudge sentence.
+ */
+interface ChatReminderDuePayload extends OpenEventPayload {
+    readonly object: 'chat_reminder';
+    readonly user_ref: string;
+    readonly pet_ref: string;
+    /** The thread the reminder lands in when one exists, else `null`. */
+    readonly conversation_id: string | null;
+    readonly kind: EverfurChatReminderKind;
+    /** ISO 8601. When the nudge became due. */
+    readonly due_at: string;
+}
+/**
+ * The closed classes of thing a parsed record can hold (`copy/records_activation.py` RECORD_CLASSES), in the
+ * order the platform counts them. A `record.activation` event names exactly one of these.
+ */
+type EverfurRecordClass = 'weight_history' | 'vaccinations' | 'medications' | 'bloodwork' | 'diagnoses';
+/**
+ * `record.activation` (CRN-19): a requested record was read and something was found in it, so a member is told
+ * WHAT was found rather than only that records are ready.
+ *
+ * ONE EVENT PER NON-EMPTY CLASS, the way the consumer app sends one paced push per class: `record_class` names
+ * the class this event is about and `count` is how many rows of it the parse found. `counts` carries all five
+ * for the same request, so a single event is enough to render a summary. Counts and a closed class name only:
+ * never a weight, a drug, a result or a diagnosis.
+ *
+ * SEVERAL OF THESE FOR ONE REQUEST IS NORMAL, not a duplicate: one per non-empty class, deduped by the
+ * platform on `request:class`. An empty class produces no event at all, so never wait for a zero-count ping,
+ * and never dedupe your own handling on `request_id` alone or you will swallow every class but the first.
+ */
+interface RecordActivationPayload extends OpenEventPayload {
+    readonly object: 'record_activation';
+    readonly request_id: string;
+    readonly user_ref: string;
+    readonly pet_ref: string;
+    /** Which class this event is about. One event per non-empty class of one request. */
+    readonly record_class: EverfurRecordClass;
+    /** How many rows of `record_class` the parse found. Always at least 1: an empty class sends nothing. */
+    readonly count: number;
+    /** All five counts for the same request, so one event can render the whole summary. */
+    readonly counts: Readonly<Record<EverfurRecordClass, number>>;
+}
+/** `webhook_endpoint.test`: sent when you press Send test on an endpoint. Names the endpoint it was sent to. */
+interface WebhookEndpointTestPayload extends OpenEventPayload {
+    readonly object: 'webhook_endpoint';
+    readonly endpoint_id: string;
+}
+/** Payload type for each outbound event type. */
+interface EverfurWebhookPayloadMap {
+    readonly 'member.linked': MemberLinkPayload;
+    readonly 'member.unlinked': MemberLinkPayload;
+    readonly 'visit.booked': VisitPayload;
+    readonly 'visit.cancelled': VisitPayload;
+    readonly 'visit.completed': VisitPayload;
+    readonly 'visit.no_show': VisitPayload;
+    readonly 'record_request.updated': RecordRequestUpdatedPayload;
+    readonly 'record.ready': RecordReadyPayload;
+    readonly 'webhook_endpoint.test': WebhookEndpointTestPayload;
+    readonly 'chat.follow_up_due': ChatFollowUpDuePayload;
+    readonly 'chat.urgency.flagged': ChatUrgencyFlaggedPayload;
+    readonly 'pet.vaccination.due': PetVaccinationDuePayload;
+    readonly 'visit.rescheduled': VisitRescheduledPayload;
+    readonly 'visit.reminder': VisitReminderPayload;
+    readonly 'visit.followup_sent': VisitFollowupSentPayload;
+    readonly 'chat.reminder_due': ChatReminderDuePayload;
+    readonly 'record.activation': RecordActivationPayload;
+    readonly 'visit.message_received': VisitMessageReceivedPayload;
+    readonly 'visit.ended': VisitEndedPayload;
+}
+/** The signed envelope of one outbound event of type `T`. */
+interface EverfurWebhookEventOf<T extends EverfurWebhookEventType> {
+    /** `evt_...`. Unique per event; a manual resend reuses it on purpose, so dedupe on it. */
+    readonly id: string;
+    readonly object: 'event';
+    readonly type: T;
+    /** The payload version, for example `2026-09-15`. */
+    readonly api_version: string;
+    /** Unix seconds when the event was created (not when it was delivered). */
+    readonly created: number;
+    /** `false` for a sandbox (test) tenant. */
+    readonly livemode: boolean;
+    readonly data: {
+        readonly object: EverfurWebhookPayloadMap[T];
+    };
+}
+/**
+ * A verified outbound event whose type is in the catalog. After `isEverfurWebhookEvent(event)`, narrow on
+ * `type`: `if (event.type === 'record.ready') event.data.object.request_id`.
+ */
+type EverfurWebhookEvent = {
+    [T in EverfurWebhookEventType]: EverfurWebhookEventOf<T>;
+}[EverfurWebhookEventType];
+/**
+ * A verified outbound event whose type this SDK version does not know (a type added after it shipped).
+ * `constructEvent` returns it rather than throwing, because the signature is valid and the right answer to an
+ * event you do not handle is still a 2xx. Separate it with `isEverfurWebhookEvent` before narrowing on `type`.
+ */
+interface UnrecognizedEverfurWebhookEvent {
+    readonly id: string;
+    readonly object: 'event';
+    readonly type: string;
+    readonly api_version: string;
+    readonly created: number;
+    readonly livemode: boolean;
+    readonly data: {
+        readonly object: OpenEventPayload;
+    };
+}
+/** True when `type` is in this SDK version's outbound catalog. */
+declare function isEverfurWebhookEventType(type: unknown): type is EverfurWebhookEventType;
+/**
+ * Separates a catalog event from one this SDK version does not know, so a `switch (event.type)` narrows the
+ * payload. Answer 2xx to the other branch: Everfur retries anything else.
+ */
+declare function isEverfurWebhookEvent(event: EverfurWebhookEvent | UnrecognizedEverfurWebhookEvent): event is EverfurWebhookEvent;
+/** Every inbound event type in the v1 registry. Order matches EFBackend `INBOUND_EVENT_TYPES`. */
+declare const PARTNER_INBOUND_EVENT_TYPES: readonly ["pet.profile.updated", "pet.incident.reported", "pet.behavior_note.added", "pet.service_score.recorded", "pet.deleted", "member.status_changed", "member.deleted"];
+/** One inbound event type name. A `pet.*` type is about a pet (`petRef` required); a `member.*` type is not. */
+type PartnerInboundEventType = (typeof PARTNER_INBOUND_EVENT_TYPES)[number];
+/**
+ * `pet.profile.updated` schema_version 1: profile fields you are the system of record for. AUTHORITATIVE: it updates
+ * the pet profile itself, in the event's own transaction (PF-11), so an applied receipt never names a write that did
+ * not happen. Every field is optional and an absent field (or `null`) is unchanged: the event API has no clear, use
+ * `updatePartnerPet` for that. Strings are trimmed by Everfur before their length is checked. `date_of_birth` is
+ * recorded as the birth date at day precision and `neutered` as the spay status; for a pet that is not a dog or a
+ * cat those three are accepted and not applied (v1 is best effort there), while the identity fields still land.
+ */
+interface PetProfileUpdatedData {
+    /** 1 to 64 characters. */
+    readonly name?: string | null;
+    /** 1 to 64 characters. */
+    readonly species?: string | null;
+    /** 1 to 128 characters. */
+    readonly breed?: string | null;
+    readonly sex?: 'male' | 'female' | 'unknown' | null;
+    /** `YYYY-MM-DD`. */
+    readonly date_of_birth?: string | null;
+    /** Greater than 0 and less than 500. */
+    readonly weight_kg?: number | null;
+    readonly neutered?: boolean | null;
+}
+/**
+ * `pet.incident.reported`. `incident_id` is the natural id: a later event with the same id replaces this one when
+ * its `occurredAt` is later.
+ */
+interface PetIncidentReportedData {
+    /** Your id for the incident, 1 to 128 characters. */
+    readonly incident_id: string;
+    readonly category: 'injury' | 'illness' | 'behavior' | 'escape' | 'other';
+    readonly severity: 'low' | 'medium' | 'high';
+    readonly location_type: 'daycare' | 'boarding' | 'grooming' | 'walk' | 'training' | 'home' | 'other';
+    /** 1 to 2000 characters. */
+    readonly description: string;
+    /** Defaults to `false`. */
+    readonly resolved?: boolean;
+}
+/** `pet.behavior_note.added`. `note_id` is the natural id. */
+interface PetBehaviorNoteAddedData {
+    /** Your id for the note, 1 to 128 characters. */
+    readonly note_id: string;
+    readonly context: 'daycare' | 'boarding' | 'grooming' | 'walk' | 'training' | 'other';
+    /** 1 to 2000 characters. */
+    readonly note: string;
+    readonly sentiment?: 'positive' | 'neutral' | 'concern' | null;
+}
+/** `pet.service_score.recorded`. `score_id` is the natural id. */
+interface PetServiceScoreRecordedData {
+    /** Your id for the score, 1 to 128 characters. */
+    readonly score_id: string;
+    readonly service: 'daycare' | 'boarding' | 'grooming' | 'walk' | 'training';
+    /** An integer from 1 to 5. */
+    readonly score: number;
+    /** At most 2000 characters. */
+    readonly comment?: string | null;
+}
+/** `pet.deleted`: erases what you sent about this pet. */
+interface PetDeletedData {
+    readonly reason?: 'owner_request' | 'deceased' | 'rehomed' | 'other' | null;
+}
+/** `member.status_changed`: the member's status in your service. */
+interface MemberStatusChangedData {
+    readonly status: 'active' | 'paused' | 'cancelled' | 'lapsed';
+    /** At most 64 characters. */
+    readonly plan?: string | null;
+    /** `YYYY-MM-DD`. */
+    readonly effective_on?: string | null;
+}
+/** `member.deleted`: erases what you sent about this member. */
+interface MemberDeletedData {
+    readonly reason?: 'owner_request' | 'account_closed' | 'other' | null;
+}
+/** The `data` schema of each inbound event type (schema version 1). */
+interface PartnerInboundEventDataMap {
+    readonly 'pet.profile.updated': PetProfileUpdatedData;
+    readonly 'pet.incident.reported': PetIncidentReportedData;
+    readonly 'pet.behavior_note.added': PetBehaviorNoteAddedData;
+    readonly 'pet.service_score.recorded': PetServiceScoreRecordedData;
+    readonly 'pet.deleted': PetDeletedData;
+    readonly 'member.status_changed': MemberStatusChangedData;
+    readonly 'member.deleted': MemberDeletedData;
+}
+/** One event of type `T` your backend sends to Everfur. */
+interface PartnerInboundEventOf<T extends PartnerInboundEventType> {
+    readonly type: T;
+    /**
+     * The schema version of `data`. Every type is at version 1; omit it or pass 1. `pet.profile.updated` also has
+     * version 2, the whole partner pet body (`PetProfileUpdatedV2Event`).
+     */
+    readonly schemaVersion?: 1;
+    /** Your opaque member id (the same one you mint sessions with). 1 to 128 printable characters, no `@`. */
+    readonly userRef: string;
+    /**
+     * Your opaque pet id, under the same rule as `userRef`. Required on a `pet.*` event and refused on a
+     * `member.*` event (`sendPartnerEvent` throws before sending either mistake).
+     */
+    readonly petRef?: string;
+    /**
+     * When it happened: a `Date`, or an ISO 8601 date-time string with an explicit offset (`Z` or `+05:30`). Everfur
+     * refuses a time older than 30 days or more than 5 minutes ahead of its clock.
+     */
+    readonly occurredAt: Date | string;
+    /** The type's fields. Closed: a field not in the type's schema is refused. */
+    readonly data: PartnerInboundEventDataMap[T];
+}
+/**
+ * `pet.profile.updated` schema_version 2 (PF-11): the whole partner pet body, health profile included, exactly what
+ * `upsertPartnerPet` takes. Everfur applies it through the same write path the pet routes use, onto the same tables,
+ * so what Everfur chat and an Everfur vet see is the same whichever door you use.
+ *
+ * - Absent is unchanged and there is NO CLEAR over the event API (nulls are dropped): use `updatePartnerPet` to clear.
+ *   A health LIST you send is still the complete set you hold (set-replace, `[]` clears it).
+ * - A health field needs `pets.health.update` as well as `partner_events.inbound.create`, and a dog or a cat: any
+ *   other species is the 422 `pet_health_species_unsupported` with nothing applied.
+ * - Version 2 rides the server pet API's own switch: while Everfur has it off, version 2 is refused exactly as a
+ *   version that does not exist (400 `event_payload_invalid`).
+ * - A member you have not brought to Everfur is accepted and updates nothing; it never creates an account.
+ */
+interface PetProfileUpdatedV2Event {
+    readonly type: 'pet.profile.updated';
+    readonly schemaVersion: 2;
+    /** Your opaque member id (the same one you mint sessions with). 1 to 128 printable characters, no `@`. */
+    readonly userRef: string;
+    /** Your opaque pet id, under the same rule as `userRef`. */
+    readonly petRef: string;
+    /** When it happened: a `Date`, or an ISO 8601 date-time string with an explicit offset. */
+    readonly occurredAt: Date | string;
+    /** The partner pet body, as `upsertPartnerPet` takes it. Only the fields it names are sent. */
+    readonly data: PartnerPetProfile;
+}
+/** One event your backend sends to Everfur. Narrow on `type` (and `schemaVersion`) to get that type's `data`. */
+type PartnerInboundEvent = {
+    [T in PartnerInboundEventType]: PartnerInboundEventOf<T>;
+}[PartnerInboundEventType] | PetProfileUpdatedV2Event;
+
+/** The request header carrying the signature. Header lookups are case-insensitive in Node. */
+declare const EVERFUR_SIGNATURE_HEADER = "Everfur-Signature";
+/** Default replay window, in seconds, matching the platform. */
+declare const DEFAULT_WEBHOOK_TOLERANCE_SECONDS = 300;
+/** Why a delivery was refused. Programmer errors (no secret, a parsed body) throw `EverfurConfigError`. */
+type WebhookVerificationFailure = 
+/** The header is missing, too long, or not `t=...,v1=...`. */
+'malformed_header'
+/** The signed timestamp is outside the tolerance (a replay, or a clock that is far off). */
+ | 'timestamp_outside_tolerance'
+/** No `v1` matches any of the secrets. Wrong secret, or the body was changed after signing. */
+ | 'no_matching_signature'
+/** The signature is valid but the body is not an Everfur event envelope. */
+ | 'malformed_payload';
+/** Thrown by `constructEvent` when a delivery must be refused. Answer it with a 400. */
+declare class EverfurWebhookVerificationError extends Error {
+    readonly code: WebhookVerificationFailure;
+    constructor(code: WebhookVerificationFailure);
+}
+/** Options for `constructEvent`. */
+interface ConstructEventOptions {
+    /** Replay window in seconds, applied both ways. Defaults to 300. */
+    readonly toleranceSeconds?: number;
+    /** The current time in unix seconds. For tests; defaults to the system clock. */
+    readonly nowSeconds?: number;
+}
+/** A raw request body: the exact bytes received, or those bytes decoded as UTF-8. Never parsed JSON. */
+type WebhookPayload = string | Uint8Array;
+/**
+ * Verify an Everfur webhook delivery and return the event it carries.
+ *
+ * Pass the RAW body (a `Buffer` from `express.raw()`, or `await request.text()`), the `Everfur-Signature`
+ * header, and your endpoint's signing secret. During a rotation pass both secrets. Throws
+ * `EverfurWebhookVerificationError` when the delivery must be refused (answer 400), and `EverfurConfigError`
+ * for a call that can never succeed (no secret, a parsed object for a body, a bad tolerance).
+ *
+ * The result may be an event type this SDK version does not know yet; `isEverfurWebhookEvent` separates the
+ * two before you switch on `type`. Deduplicate on `event.id`: a resend carries the same id on purpose.
+ */
+declare function constructEvent(payload: WebhookPayload, signatureHeader: string | null | undefined, secrets: string | readonly string[], options?: ConstructEventOptions): EverfurWebhookEvent | UnrecognizedEverfurWebhookEvent;
+/** Options for `generateTestSignatureHeader`. */
+interface TestSignatureHeaderParams {
+    readonly payload: WebhookPayload;
+    /** Current secret first, then any grace secrets, the order Everfur sends them in. */
+    readonly secrets: string | readonly string[];
+    /** Unix seconds. Defaults to now. */
+    readonly timestamp?: number;
+}
+/**
+ * Build an `Everfur-Signature` header exactly as Everfur would, for testing your webhook handler with a
+ * test secret. Never needed in production.
+ */
+declare function generateTestSignatureHeader(params: TestSignatureHeaderParams): string;
+
+/** How your backend reaches Everfur. Build it once and reuse it for every event. */
+interface PartnerEventsClient {
+    /** The Everfur API base URL, for example `https://api.everfur.com/api/v1`. https only (loopback excepted). */
+    readonly apiBaseUrl: string;
+    /**
+     * `sk_partner_...`, or an `rk_partner_...` restricted key carrying `partner_events.inbound.create`. Never shipped
+     * to a device.
+     */
+    readonly partnerSecretKey: string;
+    readonly contractVersion?: string;
+    readonly fetchImpl?: FetchLike;
+}
+/** What Everfur recorded for one inbound event: the 201 receipt. A replay of the same request answers the same one. */
+interface PartnerEventReceipt {
+    /** `ievt_...`. */
+    readonly id: string;
+    readonly type: PartnerInboundEventType;
+    readonly schemaVersion: number;
+    readonly userRef: string;
+    /** The pet the event is about, or `null` for a member event. */
+    readonly petRef: string | null;
+    /** ISO 8601, in UTC, as Everfur stored it. */
+    readonly occurredAt: string;
+    /** ISO 8601, in UTC. */
+    readonly receivedAt: string;
+    /**
+     * `applied`, or `superseded` when an event for the same fact with a later `occurredAt` already landed. A later
+     * read of the event can also show `erased`, after a `pet.deleted` or `member.deleted`.
+     */
+    readonly status: string;
+    /** `false` for a sandbox (test) tenant. */
+    readonly livemode: boolean;
+    /** The key the request was sent with (the one you passed, or the one generated). */
+    readonly idempotencyKey: string;
+}
+/**
+ * Send one event about a member or a pet to Everfur.
+ *
+ * `idempotencyKey` makes a retry safe: send the same key with the same event and Everfur records it once (the
+ * SDK serialises one event to the same bytes every time). Omit it and a random key is generated, but it is only
+ * returned on a successful receipt: after a timeout or a network failure it is lost, and a resend gets a new key
+ * and can record the event twice. Pass your own key (an id from your system) whenever you might retry.
+ *
+ * Settles to an `EverfurResult` for HTTP and network failures. Throws `EverfurConfigError` for a request that can
+ * never be accepted: a malformed key or event, a pet event without `petRef` (or a member event with one), an
+ * `occurredAt` without an offset, or a body over 32 KB.
+ */
+declare function sendPartnerEvent(client: PartnerEventsClient, event: PartnerInboundEvent, idempotencyKey?: string): Promise<EverfurResult<PartnerEventReceipt>>;
+
+export { type ChatFollowUpDuePayload, type ChatReminderDuePayload, type ChatUrgencyFlaggedPayload, type ConstructEventOptions, DEFAULT_WEBHOOK_TOLERANCE_SECONDS, EVERFUR_SIGNATURE_HEADER, EVERFUR_WEBHOOK_EVENT_TYPES, EVERFUR_WEBHOOK_ONLY_EVENT_TYPES, type EverfurChatReminderKind, type EverfurRecordClass, type EverfurVaccinationDueStage, type EverfurVaccine, type EverfurVisitReminderStage, type EverfurVisitStatus, type EverfurWebhookEvent, type EverfurWebhookEventOf, type EverfurWebhookEventType, type EverfurWebhookOnlyEventType, type EverfurWebhookPayloadMap, EverfurWebhookVerificationError, type MemberDeletedData, type MemberLinkPayload, type MemberStatusChangedData, type OpenEventPayload, PARTNER_INBOUND_EVENT_TYPES, type PartnerEventReceipt, type PartnerEventsClient, type PartnerInboundEvent, type PartnerInboundEventDataMap, type PartnerInboundEventOf, type PartnerInboundEventType, PartnerPetProfile, type PetBehaviorNoteAddedData, type PetDeletedData, type PetIncidentReportedData, type PetProfileUpdatedData, type PetProfileUpdatedV2Event, type PetServiceScoreRecordedData, type PetVaccinationDuePayload, type RecordActivationPayload, type RecordReadyPayload, type RecordRequestSimpleStatus, type RecordRequestUpdatedPayload, type TestSignatureHeaderParams, type UnrecognizedEverfurWebhookEvent, type VisitEndedPayload, type VisitFollowupSentPayload, type VisitMessageReceivedPayload, type VisitPayload, type VisitReminderPayload, type VisitRescheduledPayload, type WebhookEndpointTestPayload, type WebhookPayload, type WebhookVerificationFailure, constructEvent, generateTestSignatureHeader, isEverfurWebhookEvent, isEverfurWebhookEventType, sendPartnerEvent };