kaafil-js 0.3.1 → 0.4.0

package/dist/{vocabulary-DFjpj3M4.d.ts → vocabulary--cKHiCky.d.ts}

@@ -708,6 +708,7 @@ interface components {
             proof: string | null;
             why?: string;
             lastObservedAt: string | null;
+            lastCheckedAt: string | null;
         };
         ChangeMyConsolePasswordRequest: {
             currentPassword: string;
@@ -2021,6 +2022,9 @@ interface components {
             periodStart?: string;
             /** Format: date-time */
             periodEnd?: string;
+            overrides?: {
+                includedStorageBytes?: number | null;
+            };
             adminEmail: string;
             adminName?: string;
             /** @enum {string} */
@@ -6767,6 +6771,15 @@ interface components {
             updatedAt: string;
             key: string;
         };
+        RevealedShareTokenViewResponse: {
+            /** @description The link's plaintext, or null when this link predates recoverable storage and can never be shown again. Null is a normal answer — offer the operator `regenerate`, not a retry. */
+            token: string | null;
+            /**
+             * @description Why `token` is what it is. `revealed` — the address is in this response. `not_recoverable` — the link was minted before Kaafil stored a recoverable copy, so only a digest exists and the address is gone for good.
+             * @enum {string}
+             */
+            reason: "revealed" | "not_recoverable";
+        };
         RevealedWebhookEndpointResponse: {
             /**
              * @description Kaafil's own id for this webhook endpoint. Use it in every later call that names this endpoint.
@@ -7973,6 +7986,8 @@ interface components {
                  * @enum {string}
                  */
                 phase: "PRE_DEPARTURE" | "ON_TRIP" | "POST_TRIP";
+                /** @description Whether this trip has been cancelled. Deliberately a separate field rather than a fourth `phase` member, because `phase` is date-derived and is a total enum existing clients switch on exhaustively. A cancelled trip still reports whichever `phase` its dates imply, so a client MUST check this field before rendering any date-derived status — otherwise a cancelled trip reads as 'Upcoming' with a countdown to a departure that is not happening. Always present. */
+                cancelled: boolean;
             };
             /** @description This trip's day-by-day itinerary. Present only when the link exposes this section and there's data for it; otherwise the key is absent entirely, never null. */
             itinerary?: {
@@ -10533,21 +10548,6 @@ interface operations {
                     };
                 };
             };
-            /** @description `UNAUTHENTICATED` — Missing/expired credential — the SDK attempts one token refresh first */
-            401: {
-                headers: {
-                    "X-Request-Id"?: string;
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ErrorEnvelope"] & {
-                        error?: {
-                            /** @enum {string} */
-                            code?: "UNAUTHENTICATED";
-                        };
-                    };
-                };
-            };
             /** @description `VALIDATION_ERROR` — Body/params fail schema validation */
             422: {
                 headers: {
@@ -10774,20 +10774,16 @@ interface operations {
             };
         };
     };
-    inspectConsoleInvite: {
+    refreshConsoleSession: {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["InspectConsoleInviteRequest"];
-            };
-        };
+        requestBody?: never;
         responses: {
-            /** @description Preview a console invite before accepting it */
+            /** @description Rotate the console session forward */
             200: {
                 headers: {
                     "X-Request-Id"?: string;
@@ -10795,7 +10791,7 @@ interface operations {
                 };
                 content: {
                     "application/json": components["schemas"]["SuccessEnvelope"] & {
-                        data: components["schemas"]["ConsoleInviteInspectResponse"];
+                        data: components["schemas"]["ConsoleSessionResponse"];
                     };
                 };
             };
@@ -10814,6 +10810,71 @@ interface operations {
                     };
                 };
             };
+            /** @description `RATE_LIMITED` — Per-key/per-token rate limit */
+            429: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    /** @description Seconds until the limiter refills enough to accept another request. Integer, never below 1 on a 429 — `decision()` in `rate-limit.ts` floors it at 1 so `Retry-After: 0` ("retry instantly") never ships on an actual refusal. */
+                    "Retry-After"?: number;
+                    /** @description The ceiling, in requests per window, of the specific limiter tier (IP / API key / share token / bulk-ingest / session-rotation) that refused this request. */
+                    "X-RateLimit-Limit"?: number;
+                    /** @description Requests remaining in the current window for that tier — always 0 on a 429. */
+                    "X-RateLimit-Remaining"?: number;
+                    /** @description Seconds until the window resets — relative, not an absolute epoch, so an offline-first client whose clock is wrong cannot misread it. Same value as `Retry-After` on a 429. */
+                    "X-RateLimit-Reset"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"] & {
+                        error?: {
+                            /** @enum {string} */
+                            code?: "RATE_LIMITED";
+                        };
+                    };
+                };
+            };
+            /** @description `INTERNAL_ERROR` — Engine fault; safe to retry with backoff (all writes are idempotent); `TENANT_SCOPE_MISSING` — Engine invariant tripped — a query reached the database without tenant scope; always a bug, never client-fixable */
+            500: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"] & {
+                        error?: {
+                            /** @enum {string} */
+                            code?: "INTERNAL_ERROR" | "TENANT_SCOPE_MISSING";
+                        };
+                    };
+                };
+            };
+        };
+    };
+    inspectConsoleInvite: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["InspectConsoleInviteRequest"];
+            };
+        };
+        responses: {
+            /** @description Preview a console invite before accepting it */
+            200: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["ConsoleInviteInspectResponse"];
+                    };
+                };
+            };
             /** @description `VALIDATION_ERROR` — Body/params fail schema validation */
             422: {
                 headers: {
@@ -10896,21 +10957,6 @@ interface operations {
                     };
                 };
             };
-            /** @description `UNAUTHENTICATED` — Missing/expired credential — the SDK attempts one token refresh first */
-            401: {
-                headers: {
-                    "X-Request-Id"?: string;
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ErrorEnvelope"] & {
-                        error?: {
-                            /** @enum {string} */
-                            code?: "UNAUTHENTICATED";
-                        };
-                    };
-                };
-            };
             /** @description `SECRET_NOT_REPLAYABLE` — Replay of an operation whose response carried a one-time secret. The operation completed exactly once; the secret was never stored and cannot be re-shown */
             409: {
                 headers: {
@@ -12197,6 +12243,82 @@ interface operations {
             };
         };
     };
+    recheckConsoleCertification: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Re-run the certification evaluator for this tenant */
+            200: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["CertificationItemResponse"][];
+                    };
+                };
+            };
+            /** @description `UNAUTHENTICATED` — Missing/expired credential — the SDK attempts one token refresh first */
+            401: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"] & {
+                        error?: {
+                            /** @enum {string} */
+                            code?: "UNAUTHENTICATED";
+                        };
+                    };
+                };
+            };
+            /** @description `RATE_LIMITED` — Per-key/per-token rate limit */
+            429: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    /** @description Seconds until the limiter refills enough to accept another request. Integer, never below 1 on a 429 — `decision()` in `rate-limit.ts` floors it at 1 so `Retry-After: 0` ("retry instantly") never ships on an actual refusal. */
+                    "Retry-After"?: number;
+                    /** @description The ceiling, in requests per window, of the specific limiter tier (IP / API key / share token / bulk-ingest / session-rotation) that refused this request. */
+                    "X-RateLimit-Limit"?: number;
+                    /** @description Requests remaining in the current window for that tier — always 0 on a 429. */
+                    "X-RateLimit-Remaining"?: number;
+                    /** @description Seconds until the window resets — relative, not an absolute epoch, so an offline-first client whose clock is wrong cannot misread it. Same value as `Retry-After` on a 429. */
+                    "X-RateLimit-Reset"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"] & {
+                        error?: {
+                            /** @enum {string} */
+                            code?: "RATE_LIMITED";
+                        };
+                    };
+                };
+            };
+            /** @description `INTERNAL_ERROR` — Engine fault; safe to retry with backoff (all writes are idempotent); `TENANT_SCOPE_MISSING` — Engine invariant tripped — a query reached the database without tenant scope; always a bug, never client-fixable */
+            500: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"] & {
+                        error?: {
+                            /** @enum {string} */
+                            code?: "INTERNAL_ERROR" | "TENANT_SCOPE_MISSING";
+                        };
+                    };
+                };
+            };
+        };
+    };
     listApiKeys: {
         parameters: {
             query?: {
@@ -13462,6 +13584,114 @@ interface operations {
             };
         };
     };
+    revealShareToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Show an existing link's address again */
+            200: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["RevealedShareTokenViewResponse"];
+                    };
+                };
+            };
+            /** @description `UNAUTHENTICATED` — Missing/expired credential — the SDK attempts one token refresh first */
+            401: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"] & {
+                        error?: {
+                            /** @enum {string} */
+                            code?: "UNAUTHENTICATED";
+                        };
+                    };
+                };
+            };
+            /** @description `RESOURCE_NOT_FOUND` — Missing or out-of-scope — the same 404 either way; treat as loss-of-access (purge + surface) */
+            404: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"] & {
+                        error?: {
+                            /** @enum {string} */
+                            code?: "RESOURCE_NOT_FOUND";
+                        };
+                    };
+                };
+            };
+            /** @description `VALIDATION_ERROR` — Body/params fail schema validation */
+            422: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"] & {
+                        error?: {
+                            /** @enum {string} */
+                            code?: "VALIDATION_ERROR";
+                        };
+                    };
+                };
+            };
+            /** @description `RATE_LIMITED` — Per-key/per-token rate limit */
+            429: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    /** @description Seconds until the limiter refills enough to accept another request. Integer, never below 1 on a 429 — `decision()` in `rate-limit.ts` floors it at 1 so `Retry-After: 0` ("retry instantly") never ships on an actual refusal. */
+                    "Retry-After"?: number;
+                    /** @description The ceiling, in requests per window, of the specific limiter tier (IP / API key / share token / bulk-ingest / session-rotation) that refused this request. */
+                    "X-RateLimit-Limit"?: number;
+                    /** @description Requests remaining in the current window for that tier — always 0 on a 429. */
+                    "X-RateLimit-Remaining"?: number;
+                    /** @description Seconds until the window resets — relative, not an absolute epoch, so an offline-first client whose clock is wrong cannot misread it. Same value as `Retry-After` on a 429. */
+                    "X-RateLimit-Reset"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"] & {
+                        error?: {
+                            /** @enum {string} */
+                            code?: "RATE_LIMITED";
+                        };
+                    };
+                };
+            };
+            /** @description `INTERNAL_ERROR` — Engine fault; safe to retry with backoff (all writes are idempotent); `TENANT_SCOPE_MISSING` — Engine invariant tripped — a query reached the database without tenant scope; always a bug, never client-fixable */
+            500: {
+                headers: {
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"] & {
+                        error?: {
+                            /** @enum {string} */
+                            code?: "INTERNAL_ERROR" | "TENANT_SCOPE_MISSING";
+                        };
+                    };
+                };
+            };
+        };
+    };
     upsertTrip: {
         parameters: {
             query?: never;
@@ -48307,6 +48537,7 @@ declare const OperationId: {
     readonly ReadWebhookEventCatalog: "readWebhookEventCatalog";
     readonly ReassignPickupStopTravellers: "reassignPickupStopTravellers";
     readonly RebuildJourney: "rebuildJourney";
+    readonly RecheckConsoleCertification: "recheckConsoleCertification";
     readonly ReconcileTrekWalkIn: "reconcileTrekWalkIn";
     readonly RecordCollection: "recordCollection";
     readonly RedeliverEndpointDelivery: "redeliverEndpointDelivery";
@@ -48314,6 +48545,7 @@ declare const OperationId: {
     readonly RedeliverWebhookDeliveryConsole: "redeliverWebhookDeliveryConsole";
     readonly RedriveSupportWebhookDelivery: "redriveSupportWebhookDelivery";
     readonly RefreshAgencyAdminTokens: "refreshAgencyAdminTokens";
+    readonly RefreshConsoleSession: "refreshConsoleSession";
     readonly RefreshManagerTokens: "refreshManagerTokens";
     readonly RegenerateShareToken: "regenerateShareToken";
     readonly RegisterWebhookEndpoint: "registerWebhookEndpoint";
@@ -48337,6 +48569,7 @@ declare const OperationId: {
     readonly ResetTestClockConsole: "resetTestClockConsole";
     readonly ResolvePlatformCredential: "resolvePlatformCredential";
     readonly ReturnFloat: "returnFloat";
+    readonly RevealShareToken: "revealShareToken";
     readonly RevokeApiKey: "revokeApiKey";
     readonly RevokeMyConsoleSession: "revokeMyConsoleSession";
     readonly RevokePlatformPartnerApiKey: "revokePlatformPartnerApiKey";
@@ -52738,6 +52971,7 @@ type MintedShareTokenViewResponse = components['schemas']['MintedShareTokenViewR
 type ShareTokenViewResponse = components['schemas']['ShareTokenViewResponse'];
 type PatchShareTokenRequest = components['schemas']['PatchShareTokenRequest'];
 type RegenerateShareTokenRequest = components['schemas']['RegenerateShareTokenRequest'];
+type RevealedShareTokenViewResponse = components['schemas']['RevealedShareTokenViewResponse'];
 interface CreateShareTokenOptions extends Omit<MintShareTokenRequest, 'expiresAt'> {
     /** Optional on the wire (`ttlDays` is the other way to set expiry) — see
      * `../datetime` for the coercion contract; a full ISO string with an
@@ -52816,6 +53050,17 @@ interface ShareTokensResource {
      * the same subject, superseding the old one. By default the old token is
      * revoked in the same transaction; pass `keepOld: true` to retain it. */
     regenerate(options: RegenerateShareTokenOptions): Promise<KaafilResponse<MintedShareTokenViewResponse>>;
+    /**
+     * `GET /api/v1/share-tokens/{id}/reveal` — show an EXISTING link's address
+     * again, so a desk can re-send it instead of calling `regenerate`, which
+     * revokes the copy the family is already using.
+     *
+     * `token` is `null` with `reason: 'not_recoverable'` for a link minted
+     * before Kaafil kept a recoverable copy: those rows hold only a digest, so
+     * the address is gone for good and the caller should offer `regenerate`
+     * rather than a retry. That is a 200, not an error.
+     */
+    reveal(options: ReadShareTokenOptions): Promise<KaafilResponse<RevealedShareTokenViewResponse>>;
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaafil-js",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Headless, typed TypeScript client for the Kaafil on-ground and post-trip engine.",
   "keywords": [
     "kaafil",