@wokuapp/react-native 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -16,7 +16,13 @@ interface HttpRequest {
     method: string;
     url: string;
     headers: Record<string, string>;
-    body?: string;
+    /**
+     * JSON string for text/rating captures, or a `FormData` for audio captures
+     * (multipart). For `FormData` the host's `fetch` sets the
+     * `multipart/form-data` Content-Type (with boundary) itself.
+     */
+    body?: string | FormData;
+    signal?: AbortSignal;
 }
 /** HTTP transport. Defaults to global `fetch`. */
 interface HttpClient {
@@ -55,8 +61,14 @@ declare const noopLogger: Logger;
  * capture payloads and hands them to injectable adapters (HTTP, storage,
  * audio). React Native apps wire those adapters at init time.
  */
-/** The two capture flows Woku supports. */
-type CaptureKind = 'woku' | 'nps';
+/** The four capture instruments supported by API v1. */
+type CaptureKind = 'woku' | 'nps' | 'csat' | 'ces';
+type CaptureLanguage = 'es' | 'en';
+/** Capture provenance, declared when the response is first created. */
+interface CaptureContext {
+    collectionKind?: 'standalone' | 'flow';
+    flowId?: string;
+}
 /** An audio attachment for a text/voice comment. */
 interface AudioAttachment {
     /** URI or local path to the recorded audio file. */
@@ -74,7 +86,7 @@ interface Respondent {
     externalId?: string;
 }
 /** Input for a Woku capture (1-tap rating 1..5 + optional comment/audio). */
-interface WokuCaptureInput {
+interface WokuCaptureInput extends CaptureContext {
     wokuId: string;
     /** Integer 1..5. */
     rating: number;
@@ -83,30 +95,36 @@ interface WokuCaptureInput {
     respondent?: Respondent;
     /** Arbitrary context tags attached to the submission. */
     metadata?: Record<string, unknown>;
+    dispatchToken?: string;
+    language?: CaptureLanguage;
 }
 /** Input for an NPS capture (score 0..10 + optional review). */
-interface NpsCaptureInput {
-    npsId: string;
+interface NpsCaptureInput extends CaptureContext {
+    npsId?: string;
     /** Integer 0..10. */
     score: number;
     comment?: string;
     audio?: AudioAttachment;
     respondent?: Respondent;
     metadata?: Record<string, unknown>;
+    dispatchToken?: string;
+    language?: CaptureLanguage;
 }
 /** Normalized submission persisted in the offline queue and sent to Woku. */
-interface CaptureSubmission {
+interface CaptureSubmission extends CaptureContext {
     /** Client-generated idempotency id. */
     id: string;
     kind: CaptureKind;
     companyId: string;
-    targetId: string;
+    targetId?: string;
     rating?: number;
     score?: number;
     comment?: string;
     audio?: AudioAttachment;
     respondent?: Respondent;
     metadata?: Record<string, unknown>;
+    dispatchToken?: string;
+    language?: CaptureLanguage;
     /** Unix epoch ms when the capture was created on the device. */
     createdAt: number;
 }
@@ -117,10 +135,67 @@ interface SubmissionResult {
     /** Server id once accepted. */
     remoteId?: string;
     error?: string;
+    retryable?: boolean;
+}
+/** Focused satisfaction/effort scores; audio is not supported by these API kinds. */
+interface CsatCaptureInput extends CaptureContext {
+    csatId: string;
+    score: number;
+    comment?: string;
+    respondent?: Respondent;
+    metadata?: Record<string, unknown>;
+    dispatchToken?: string;
+}
+interface CesCaptureInput extends CaptureContext {
+    cesId: string;
+    score: number;
+    comment?: string;
+    respondent?: Respondent;
+    metadata?: Record<string, unknown>;
+    dispatchToken?: string;
+}
+
+interface FailedCapture {
+    submission: CaptureSubmission;
+    reason: string;
+}
+interface OfflineQueueOptions {
+    storage?: Storage;
+    storageKey?: string;
+    maxAttempts?: number;
+    /** Restrict reads, delivery and clearing to this company, including legacy rows. */
+    companyId?: string;
+}
+interface FlushResult {
+    sent: number;
+    failed: number;
+    remaining: number;
+    quarantined?: boolean;
+}
+/** Persistent FIFO with scoped ownership, atomic local mutations and retained failures. */
+declare class OfflineQueue {
+    private readonly storage;
+    private readonly key;
+    private readonly maxAttempts;
+    private readonly companyId?;
+    constructor(opts?: OfflineQueueOptions);
+    private owned;
+    private load;
+    private persist;
+    private mutation;
+    enqueue(submission: CaptureSubmission): Promise<void>;
+    size(): Promise<number>;
+    pending(): Promise<CaptureSubmission[]>;
+    failures(): Promise<FailedCapture[]>;
+    acknowledge(submission: CaptureSubmission): Promise<void>;
+    reject(submission: CaptureSubmission, reason: string): Promise<void>;
+    flush(send: (submission: CaptureSubmission) => Promise<SubmissionResult>): Promise<FlushResult>;
+    private runFlush;
+    clear(): Promise<void>;
 }
 
 interface WokuClientConfig {
-    /** Base URL of the Woku API, e.g. `https://api.woku.app`. */
+    /** Base URL of the Woku API, e.g. `https://clientapi.woku.app`. */
     apiUrl: string;
     /** Public SDK key issued per company for capture ingestion. */
     publicKey: string;
@@ -129,8 +204,12 @@ interface WokuClientConfig {
     /** HTTP transport. Defaults to the global `fetch`. */
     http?: HttpClient;
     logger?: Logger;
-    /** Ingest path appended to `apiUrl`. Defaults to `/sdk/v1/captures`. */
+    /** Ingest path appended to `apiUrl`. Defaults to `/v1/captures`. */
     capturePath?: string;
+    /** Default audio language for WokuSdk builders; send() preserves payloads. */
+    language?: 'es' | 'en';
+    /** Bound a transport attempt, including injected adapters. Default 30s. */
+    timeoutMs?: number;
 }
 /**
  * Thin, typed transport to the Woku capture ingest endpoint. Stateless:
@@ -153,61 +232,10 @@ declare class WokuClient {
     private safeJson;
 }
 
-interface OfflineQueueOptions {
-    storage?: Storage;
-    /** Storage key for the persisted queue. */
-    storageKey?: string;
-    /** Drop a submission after this many failed delivery attempts. */
-    maxAttempts?: number;
-}
-interface FlushResult {
-    sent: number;
-    failed: number;
-    remaining: number;
-    /** Set when flushing stopped early due to quarantine. */
-    quarantined?: boolean;
-}
-/**
- * Durable, FIFO offline buffer for captures. Persists through an
- * injectable {@link Storage} so submissions survive app restarts, and
- * flushes them through a caller-provided `send` function. Pure and
- * deterministic: no timers, no platform APIs.
- *
- * Delivery semantics on flush:
- *  - `sent`        -> removed from the queue.
- *  - quarantine    -> flush stops (server is rate-limiting the
- *                     respondent); items are kept for the next attempt.
- *  - network error -> attempt count bumped, item kept, flush continues.
- *  - `failed`      -> attempt count bumped; dropped once maxAttempts is
- *                     reached so a permanently-bad item can't wedge it.
- */
-declare class OfflineQueue {
-    private readonly storage;
-    private readonly key;
-    private readonly maxAttempts;
-    private items;
-    constructor(opts?: OfflineQueueOptions);
-    private load;
-    private persist;
-    /** Adds a submission to the tail of the queue (dedup by id). */
-    enqueue(submission: CaptureSubmission): Promise<void>;
-    size(): Promise<number>;
-    /** Returns a copy of the pending submissions (oldest first). */
-    pending(): Promise<CaptureSubmission[]>;
-    /**
-     * Attempts to deliver every queued submission through `send`, applying
-     * the delivery semantics documented on the class. Persists once at the
-     * end and returns a summary.
-     */
-    flush(send: (submission: CaptureSubmission) => Promise<SubmissionResult>): Promise<FlushResult>;
-    /** Clears the queue (e.g. on logout). */
-    clear(): Promise<void>;
-}
-
 interface WokuSdkConfig extends WokuClientConfig {
     /** Storage adapter for the offline queue (MMKV/AsyncStorage in RN). */
     storage?: Storage;
-    /** Drop a queued submission after this many failed attempts. */
+    /** Retain a failed submission for inspection after this many flush attempts. */
     maxQueueAttempts?: number;
 }
 /**
@@ -230,16 +258,21 @@ declare class WokuSdk {
     private readonly queue;
     private readonly logger;
     private readonly companyId;
+    private readonly language;
     constructor(config: WokuSdkConfig);
     /** Captures a Woku rating (1..5) with optional text/audio comment. */
     captureWoku(input: WokuCaptureInput): Promise<SubmissionResult>;
     /** Captures an NPS score (0..10) with optional text/audio review. */
     captureNps(input: NpsCaptureInput): Promise<SubmissionResult>;
+    captureCsat(input: CsatCaptureInput): Promise<SubmissionResult>;
+    captureCes(input: CesCaptureInput): Promise<SubmissionResult>;
     /** Retries every queued submission. Safe to call on app foreground or
      *  when connectivity is regained. */
     flush(): Promise<FlushResult>;
     /** Number of submissions waiting to be delivered. */
     pendingCount(): Promise<number>;
+    /** Inspect retained captures whose automatic attempt budget was exhausted. */
+    failedCaptures(): Promise<FailedCapture[]>;
     /** Clears the offline queue (e.g. on user logout). */
     clearQueue(): Promise<void>;
     /**
@@ -276,4 +309,4 @@ declare class WokuNetworkError extends WokuError {
     constructor(message: string);
 }
 
-export { type AudioAttachment, type CaptureKind, type CaptureSubmission, type FlushResult, type HttpClient, type HttpRequest, type HttpResponse, InMemoryStorage, type Logger, type NpsCaptureInput, OfflineQueue, type OfflineQueueOptions, type Respondent, type Storage, type SubmissionResult, type WokuCaptureInput, WokuClient, type WokuClientConfig, WokuConfigError, WokuError, WokuNetworkError, WokuQuarantineError, WokuSdk, type WokuSdkConfig, WokuValidationError, fetchHttpClient, noopLogger };
+export { type AudioAttachment, type CaptureContext, type CaptureKind, type CaptureLanguage, type CaptureSubmission, type CesCaptureInput, type CsatCaptureInput, type FailedCapture, type FlushResult, type HttpClient, type HttpRequest, type HttpResponse, InMemoryStorage, type Logger, type NpsCaptureInput, OfflineQueue, type OfflineQueueOptions, type Respondent, type Storage, type SubmissionResult, type WokuCaptureInput, WokuClient, type WokuClientConfig, WokuConfigError, WokuError, WokuNetworkError, WokuQuarantineError, WokuSdk, type WokuSdkConfig, WokuValidationError, fetchHttpClient, noopLogger };