@slytrunk/sly-tifo-client 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1126 @@
+interface operations {
+    awardEvent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The action definition key, e.g. `purchase`. */
+                    action: string;
+                    /** @description Your id for the end user. Required with a secret key; a token already names one. */
+                    external_id?: string;
+                    /** @description Optional, and may only name the program the credential is already scoped to. */
+                    program_id?: string;
+                    /** @description Used only when enrolling a new end user. */
+                    display_name?: string;
+                    /** @description Not accepted on this route today; a browser token sending it is refused outright. */
+                    avatar_url?: string;
+                    /** @description Not accepted on this route today; a browser token sending it is refused outright. */
+                    background_url?: string;
+                    /** @description When it happened, as an ISO 8601 timestamp — anything Date.parse accepts, UTC offsets included. Defaults to now. */
+                    occurred_at?: string;
+                    /** @description A support annotation. Never accepted from a browser token. */
+                    reason?: string;
+                    /** @description What the action was about, for definitions that require one. */
+                    subject?: string;
+                    /** @description Scored against the action definition payload schema and formula. */
+                    payload?: unknown;
+                };
+            };
+        };
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {boolean} */
+                        accepted: true;
+                        /** @description True when an Idempotency-Key replayed an earlier award. */
+                        replayed: boolean;
+                        event_id: string;
+                        /** @description Points this event awarded. */
+                        points: number;
+                        /** @description The end user score in the current season after it. */
+                        score: number;
+                        lifetime_points: number;
+                        tier_key: string | null;
+                        /** @description `{ "fromRank": number|null, "toRank": number|null }` when the tier moved, else null. */
+                        transition: unknown;
+                        /**
+                         * @description Present only when the action is a collectible. `earned` on the accepted branch; the rest on refusals.
+                         * @enum {string}
+                         */
+                        outcome?: "earned" | "already-owned" | "not-yet-open" | "closed" | "tier-locked";
+                    } | {
+                        /** @enum {boolean} */
+                        accepted: false;
+                        reason: string;
+                        /**
+                         * @description Present only when the action is a collectible. `earned` on the accepted branch; the rest on refusals.
+                         * @enum {string}
+                         */
+                        outcome?: "earned" | "already-owned" | "not-yet-open" | "closed" | "tier-locked";
+                    };
+                };
+            };
+            /** @description Default Response */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Rate limited. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+    getEndUserStanding: {
+        parameters: {
+            query?: {
+                program_id?: string;
+            };
+            header?: never;
+            path: {
+                externalId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        end_user: {
+                            id: string;
+                            external_id: string;
+                            display_name: string;
+                            attributes: {
+                                [key: string]: string | number | boolean;
+                            };
+                        };
+                        program: {
+                            id: string;
+                            name: string;
+                        };
+                        season: {
+                            slug: string;
+                            name: string;
+                            ends_at: string | null;
+                        };
+                        score: number;
+                        lifetime_points: number;
+                        tier: {
+                            key: string;
+                            label: string;
+                            rank: number;
+                            threshold: number;
+                        } | null;
+                        next_tier: {
+                            key: string;
+                            threshold: number;
+                            points_needed: number;
+                        } | null;
+                        peak: {
+                            rank: number;
+                            season: {
+                                slug: string;
+                            };
+                        } | null;
+                        card_url: string | null;
+                        card_version: string | null;
+                        cards: {
+                            slug: string;
+                            name: string;
+                            url: string;
+                            version: string;
+                        }[];
+                        collectibles: {
+                            id: string;
+                            key: string;
+                            name: string;
+                            description: string | null;
+                            /** @description Collection keys; see `collections`. */
+                            collections: string[];
+                            rarity: number;
+                            owned: boolean;
+                            earned_at: string | null;
+                            /**
+                             * @description Where this collectible stands for EARNING, not for display. `upcoming` — its window has not opened. `open` — earnable now. `closed` — its window has ended. `archived` — retired by the program and no longer earnable whatever its dates say, which is why archived wins over the window. Recomputed from the program’s settings and the CURRENT time on every request, and blind to who is reading: earning a collectible does not change its `state`, so one earned while `open` reports `closed` once its window ends and `archived` once it is retired. Do not cache this as a fact about the earn; read `owned` for whether this end user has it.
+                             * @enum {string}
+                             */
+                            state: "upcoming" | "open" | "closed" | "archived";
+                            /** @description True when this end user is below the collectible minimum tier rank. Always false once owned. */
+                            tier_locked: boolean;
+                            /** @description Whether a browser holding an end-user token may claim this collectible by POSTing its `key` as an action. False means the secret-key door only. */
+                            client_fireable: boolean;
+                            /**
+                             * @description The picture this end user may see for this collectible right now — public, content-addressed, never expires. For an unearned collectible this is not necessarily the real art: it may be the program's own teased or uncollected treatment instead, when the program has configured one. Most commonly null for an unowned teased collectible still `upcoming` with no teased art configured, on the collectible or as a program default — but null is also possible on any collectible, owned or not, whose own art has no usable image at all (deleted or a non-image asset).
+                             *
+                             *     Which picture this is follows one rule, ownership first and then `state`: an OWNED collectible always sends its own art; an unowned `teased` one whose `state` is `upcoming` sends the teased picture (its own, else the program default, else null) and never falls through to the uncollected treatment; every other unowned collectible sends the uncollected picture (its own, else the program default, else the real art). An unowned `hidden` collectible is likewise absent from this array entirely only while its `state` is `upcoming`, and reappears as soon as it is not — because the window opened, or because archiving the collectible made its `state` `archived` whatever its dates say — whether or not it has been earned.
+                             *
+                             *     A CARD MAY DISAGREE, deliberately. A card has no clock, so it keys teased and hidden off ownership alone: a teased collectible goes on showing its teased picture on a card until it is earned, while this field stops teasing the moment the collectible stops being `upcoming`.
+                             *
+                             *     AUTHORITATIVE, unlike the same collectible’s `art_url` on GET /v1/collectibles: that route cannot know who owns what, so it sends the unearned treatment to everyone. If you read both bodies, prefer this value wherever a collectible appears in both.
+                             *
+                             *     May be an `image/svg+xml` document rather than a raster image; a native `<Image>` (e.g. React Native) will not render an SVG.
+                             */
+                            art_url: string | null;
+                            /** @description Public, content-addressed, at most 256px on the longest edge; the full-size `art_url` when no thumbnail exists yet. It follows `art_url` exactly: AUTHORITATIVE, so prefer it over the same collectible’s `art_thumb_url` on GET /v1/collectibles, which is the unearned baseline. For an `image/svg+xml` `art_url`, this is always that same unresized original with no size bound, by design — there is never a thumbnail for vector art. */
+                            art_thumb_url: string | null;
+                        }[];
+                        collections: {
+                            key: string;
+                            name: string;
+                            description: string | null;
+                            sort: number;
+                        }[];
+                    } | {
+                        /** @enum {boolean} */
+                        accepted: false;
+                        reason: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Rate limited. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+    patchEndUser: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                externalId: string;
+            };
+            cookie?: never;
+        };
+        /** @description Secret key only — a supporter must not be able to rename themselves or choose their own picture. Attribute keys are validated against the program's declared attribute_schema at request time, so a key legal for one program may be refused for another. An attribute value of null clears that key rather than setting it to null. */
+        requestBody: {
+            content: {
+                "application/json": {
+                    display_name?: string | null;
+                    attributes?: {
+                        [key: string]: (string | number | boolean) | null;
+                    };
+                };
+            };
+        };
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        external_id: string;
+                        display_name: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Rate limited. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+    listEndUserEvents: {
+        parameters: {
+            query?: {
+                program_id?: string;
+                limit?: number;
+                before?: string;
+            };
+            header?: never;
+            path: {
+                externalId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        events: {
+                            id: string;
+                            action: string;
+                            points: number;
+                            occurred_at: string;
+                            subject: string | null;
+                            reason: string | null;
+                            payload: unknown;
+                        }[];
+                        next_cursor: string | null;
+                    } | {
+                        /** @enum {boolean} */
+                        accepted: false;
+                        reason: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Rate limited. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+    mintEndUserToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    external_id: string;
+                    display_name?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        token: string;
+                        expires_at: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Rate limited. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+    getMyStanding: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        end_user: {
+                            id: string;
+                            external_id: string;
+                            display_name: string;
+                            attributes: {
+                                [key: string]: string | number | boolean;
+                            };
+                        };
+                        program: {
+                            id: string;
+                            name: string;
+                        };
+                        season: {
+                            slug: string;
+                            name: string;
+                            ends_at: string | null;
+                        };
+                        score: number;
+                        lifetime_points: number;
+                        tier: {
+                            key: string;
+                            label: string;
+                            rank: number;
+                            threshold: number;
+                        } | null;
+                        next_tier: {
+                            key: string;
+                            threshold: number;
+                            points_needed: number;
+                        } | null;
+                        peak: {
+                            rank: number;
+                            season: {
+                                slug: string;
+                            };
+                        } | null;
+                        card_url: string | null;
+                        card_version: string | null;
+                        cards: {
+                            slug: string;
+                            name: string;
+                            url: string;
+                            version: string;
+                        }[];
+                        collectibles: {
+                            id: string;
+                            key: string;
+                            name: string;
+                            description: string | null;
+                            /** @description Collection keys; see `collections`. */
+                            collections: string[];
+                            rarity: number;
+                            owned: boolean;
+                            earned_at: string | null;
+                            /**
+                             * @description Where this collectible stands for EARNING, not for display. `upcoming` — its window has not opened. `open` — earnable now. `closed` — its window has ended. `archived` — retired by the program and no longer earnable whatever its dates say, which is why archived wins over the window. Recomputed from the program’s settings and the CURRENT time on every request, and blind to who is reading: earning a collectible does not change its `state`, so one earned while `open` reports `closed` once its window ends and `archived` once it is retired. Do not cache this as a fact about the earn; read `owned` for whether this end user has it.
+                             * @enum {string}
+                             */
+                            state: "upcoming" | "open" | "closed" | "archived";
+                            /** @description True when this end user is below the collectible minimum tier rank. Always false once owned. */
+                            tier_locked: boolean;
+                            /** @description Whether a browser holding an end-user token may claim this collectible by POSTing its `key` as an action. False means the secret-key door only. */
+                            client_fireable: boolean;
+                            /**
+                             * @description The picture this end user may see for this collectible right now — public, content-addressed, never expires. For an unearned collectible this is not necessarily the real art: it may be the program's own teased or uncollected treatment instead, when the program has configured one. Most commonly null for an unowned teased collectible still `upcoming` with no teased art configured, on the collectible or as a program default — but null is also possible on any collectible, owned or not, whose own art has no usable image at all (deleted or a non-image asset).
+                             *
+                             *     Which picture this is follows one rule, ownership first and then `state`: an OWNED collectible always sends its own art; an unowned `teased` one whose `state` is `upcoming` sends the teased picture (its own, else the program default, else null) and never falls through to the uncollected treatment; every other unowned collectible sends the uncollected picture (its own, else the program default, else the real art). An unowned `hidden` collectible is likewise absent from this array entirely only while its `state` is `upcoming`, and reappears as soon as it is not — because the window opened, or because archiving the collectible made its `state` `archived` whatever its dates say — whether or not it has been earned.
+                             *
+                             *     A CARD MAY DISAGREE, deliberately. A card has no clock, so it keys teased and hidden off ownership alone: a teased collectible goes on showing its teased picture on a card until it is earned, while this field stops teasing the moment the collectible stops being `upcoming`.
+                             *
+                             *     AUTHORITATIVE, unlike the same collectible’s `art_url` on GET /v1/collectibles: that route cannot know who owns what, so it sends the unearned treatment to everyone. If you read both bodies, prefer this value wherever a collectible appears in both.
+                             *
+                             *     May be an `image/svg+xml` document rather than a raster image; a native `<Image>` (e.g. React Native) will not render an SVG.
+                             */
+                            art_url: string | null;
+                            /** @description Public, content-addressed, at most 256px on the longest edge; the full-size `art_url` when no thumbnail exists yet. It follows `art_url` exactly: AUTHORITATIVE, so prefer it over the same collectible’s `art_thumb_url` on GET /v1/collectibles, which is the unearned baseline. For an `image/svg+xml` `art_url`, this is always that same unresized original with no size bound, by design — there is never a thumbnail for vector art. */
+                            art_thumb_url: string | null;
+                        }[];
+                        collections: {
+                            key: string;
+                            name: string;
+                            description: string | null;
+                            sort: number;
+                        }[];
+                    } | {
+                        /** @enum {boolean} */
+                        accepted: false;
+                        reason: string;
+                    };
+                };
+            };
+            /** @description Rate limited. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+    listCollections: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        collections: {
+                            key: string;
+                            name: string;
+                            description: string | null;
+                            sort: number;
+                        }[];
+                    };
+                };
+            };
+            /** @description Rate limited. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+    listCollectibles: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        collectibles: {
+                            id: string;
+                            /** @description The identifier you POST to /v1/events to claim this. */
+                            key: string;
+                            name: string;
+                            description: string | null;
+                            /** @description Collection keys; see GET /v1/collections. */
+                            collections: string[];
+                            /** @description Set by the club, not measured. See GET /v1/collectibles/{key}. */
+                            rarity: number;
+                            /** @enum {string} */
+                            state: "upcoming" | "open" | "closed" | "archived";
+                            starts_at: string | null;
+                            ends_at: string | null;
+                            /** @description Whether a browser holding an end-user token may claim this. False means the secret-key door only. */
+                            client_fireable: boolean;
+                            /**
+                             * @description The picture a supporter who has NOT earned this collectible should see — public, content-addressed, never expires. This route is the unearned baseline: it cannot know who owns what, so it sends the program’s "uncollected" treatment when one is configured (on the collectible, else the program default), and the real art only when neither is.
+                             *
+                             *     PREFER `GET /v1/me`’s `art_url` for any collectible that appears in both bodies. That one knows what the calling supporter owns and sends the REAL art for an earned collectible; this one would render it as unearned. Fall back to this field only for a collectible `/v1/me` did not carry.
+                             *
+                             *     A `teased` collectible before its window opens is the exception to the baseline: teasing is keyed to the window, which is the same for every caller, so this is its teased art, or the program’s teased default, or null if neither is configured. Null is also possible, in any state, for a collectible whose own art has no usable image at all.
+                             *
+                             *     May be an `image/svg+xml` document rather than a raster image; a native `<Image>` (e.g. React Native) will not render an SVG.
+                             */
+                            art_url: string | null;
+                            /** @description At most 256px on the longest edge; the full-size art when none exists yet. It follows `art_url` exactly: the unearned baseline, so prefer `GET /v1/me`’s `art_thumb_url` for any collectible that appears in both bodies. For an `image/svg+xml` `art_url`, this is always that same unresized original with no size bound, by design — there is never a thumbnail for vector art. */
+                            art_thumb_url: string | null;
+                        }[];
+                    };
+                };
+            };
+            /** @description Rate limited. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+    getCollectible: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        id: string;
+                        /** @description The identifier you POST to /v1/events to claim this. */
+                        key: string;
+                        name: string;
+                        description: string | null;
+                        /** @description Collection keys; see GET /v1/collections. */
+                        collections: string[];
+                        /** @description Set by the club, not measured. See GET /v1/collectibles/{key}. */
+                        rarity: number;
+                        /** @enum {string} */
+                        state: "upcoming" | "open" | "closed" | "archived";
+                        starts_at: string | null;
+                        ends_at: string | null;
+                        /** @description Whether a browser holding an end-user token may claim this. False means the secret-key door only. */
+                        client_fireable: boolean;
+                        /**
+                         * @description The picture a supporter who has NOT earned this collectible should see — public, content-addressed, never expires. This route is the unearned baseline: it cannot know who owns what, so it sends the program’s "uncollected" treatment when one is configured (on the collectible, else the program default), and the real art only when neither is.
+                         *
+                         *     PREFER `GET /v1/me`’s `art_url` for any collectible that appears in both bodies. That one knows what the calling supporter owns and sends the REAL art for an earned collectible; this one would render it as unearned. Fall back to this field only for a collectible `/v1/me` did not carry.
+                         *
+                         *     A `teased` collectible before its window opens is the exception to the baseline: teasing is keyed to the window, which is the same for every caller, so this is its teased art, or the program’s teased default, or null if neither is configured. Null is also possible, in any state, for a collectible whose own art has no usable image at all.
+                         *
+                         *     May be an `image/svg+xml` document rather than a raster image; a native `<Image>` (e.g. React Native) will not render an SVG.
+                         */
+                        art_url: string | null;
+                        /** @description At most 256px on the longest edge; the full-size art when none exists yet. It follows `art_url` exactly: the unearned baseline, so prefer `GET /v1/me`’s `art_thumb_url` for any collectible that appears in both bodies. For an `image/svg+xml` `art_url`, this is always that same unresized original with no size bound, by design — there is never a thumbnail for vector art. */
+                        art_thumb_url: string | null;
+                        /** @description End users who have earned this collectible. */
+                        owner_count: number;
+                        /** @description Every end user in the program. The denominator for `owner_count`. */
+                        program_end_user_count: number;
+                    };
+                };
+            };
+            /** @description Default Response */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Rate limited. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+    listActions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        actions: {
+                            /** @description What you send as `action` to POST /v1/events. */
+                            key: string;
+                            name: string;
+                            description: string | null;
+                            /**
+                             * @description A `collectible` also appears in GET /v1/collectibles, with its art — unless it is an unannounced one (`reveal: hidden`, before its window), which this route omits too.
+                             * @enum {string}
+                             */
+                            kind: "standard" | "collectible";
+                            /** @enum {string} */
+                            state: "upcoming" | "open" | "closed" | "archived";
+                            starts_at: string | null;
+                            ends_at: string | null;
+                            /** @description False means a browser token cannot fire this — secret key only. */
+                            client_fireable: boolean;
+                            subject_required: boolean;
+                            once_per_subject: boolean;
+                            /** @description What POST /v1/events validates your payload against. */
+                            payload_schema: unknown;
+                            cap_max: number | null;
+                            /** @enum {string|null} */
+                            cap_window: "day" | "week" | "month" | "season" | "ever" | null;
+                        }[];
+                    };
+                };
+            };
+            /** @description Rate limited. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+    inviteMember: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /**
+                     * Format: uuid
+                     * @description The org to add the person to. Resolves the caller's own standing against it.
+                     */
+                    org_id: string;
+                    /** @description The address to invite or grant a membership to. */
+                    email: string;
+                    /** @description One of owner, admin, editor or viewer. */
+                    role: string;
+                    /** @description Shown on the invited account once it exists. Omitted or blank means no name is stored. */
+                    full_name?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {boolean} */
+                        invited: true;
+                        /** @description The invited or matched account id. */
+                        user_id: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Rate limited. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+    patchMember: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The account whose name is being changed. */
+                userId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /**
+                     * Format: uuid
+                     * @description The org to resolve both the caller's and the target's standing in.
+                     */
+                    org_id: string;
+                    /** @description The new name, or null to clear it. A blank string also clears it. */
+                    full_name: string | null;
+                };
+            };
+        };
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {boolean} */
+                        updated: true;
+                    };
+                };
+            };
+            /** @description Default Response */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Rate limited. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+            /** @description Default Response */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+}
+
+/**
+ * A refusal that arrived as HTTP 200.
+ *
+ * `{ accepted: false, reason: "cap-exhausted: …" }` is a 200 because a daily
+ * cap, a closed season or a half-built ladder is ordinary program state rather
+ * than a fault in the request. A generated client reports SUCCESS for this
+ * unless the caller reads `accepted` — which is the single most common way to
+ * misuse this API, and the reason this package makes it a typed value rather
+ * than a documented footnote.
+ *
+ * The reason is split so a caller can branch on a stable code without string
+ * matching at every call site. `apps/api` writes it as `code: detail`; an
+ * unprefixed reason is all code and no detail.
+ */
+type Refused = {
+    accepted: false;
+    reason: string;
+    code: string;
+    detail: string;
+};
+declare function splitRefusal(reason: string): {
+    code: string;
+    detail: string;
+};
+/** Narrow a 200 body that may be either an answer or a refusal. */
+declare function isRefused(body: unknown): body is {
+    accepted: false;
+    reason: string;
+};
+
+type MintedToken = {
+    token: string;
+    expiresAt: string;
+};
+type GetToken = () => Promise<MintedToken>;
+
+/**
+ * One request, one place.
+ *
+ * The rules here are lifted from the admin app's API client, which
+ * solved the same problem for the admin's session credential: read the body
+ * BEFORE branching on `ok`, because this API writes its message on the failure
+ * paths; throw the server's sentence rather than a status, because the sentence
+ * is written for a person to act on; and replace `TypeError: fetch failed` with
+ * something that names the service, because a JavaScript builtin's name is not
+ * a next step.
+ *
+ * What is NOT here, deliberately: retries. The token-aware layer in
+ * `client.ts` retries exactly once on a 401 after refreshing, and that is the
+ * only retry this package performs.
+ */
+type Fetch = typeof globalThis.fetch;
+declare class ApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(message: string, status: number, code: string, options?: ErrorOptions);
+}
+
+/** The 200 JSON body of one operation. */
+type Json200<Op> = Op extends {
+    responses: {
+        200: {
+            content: {
+                'application/json': infer T;
+            };
+        };
+    };
+} ? T : never;
+type Standing = Exclude<Json200<operations['getMyStanding']>, {
+    accepted: false;
+}>;
+type AwardAccepted = Extract<Json200<operations['awardEvent']>, {
+    accepted: true;
+}>;
+type CatalogCollectible = Json200<operations['listCollectibles']>['collectibles'][number];
+type Collection = Json200<operations['listCollections']>['collections'][number];
+type CatalogAction = Json200<operations['listActions']>['actions'][number];
+type AwardInput = {
+    action: string;
+    payload?: unknown;
+    subject?: string;
+    /** Sent as the `Idempotency-Key` HEADER. The API has never read a body field of that name. */
+    idempotencyKey?: string;
+};
+type ClientOptions = {
+    apiBase: string;
+    /**
+     * Where a token comes from. The client NEVER sees a secret key — this is the
+     * property that makes the package publishable, and a caller wiring a secret
+     * key in here has defeated the whole design.
+     */
+    getToken: GetToken;
+    fetch?: Fetch;
+    now?: () => Date;
+};
+type SlyClient = {
+    me(): Promise<Standing | Refused>;
+    award(input: AwardInput): Promise<AwardAccepted | Refused>;
+    collectibles(): Promise<CatalogCollectible[]>;
+    collections(): Promise<Collection[]>;
+    actions(): Promise<CatalogAction[]>;
+};
+declare function createClient(opts: ClientOptions): SlyClient;
+
+/**
+ * The two hosted API origins, so nobody hand-types a hostname.
+ *
+ * Deliberately NOT an `environment: 'stage'` option on `createClient`: a
+ * customer behind their own proxy needs the raw base anyway, and an option
+ * would hide which host is being called. And the environment is decided by
+ * the KEY, not by this: a token minted with a production key and sent to stage
+ * answers 401, retried once, then thrown as `ApiError(401)`.
+ */
+declare const API_BASES: {
+    readonly production: "https://api.slytifo.com";
+    readonly stage: "https://api.stage-slytifo.com";
+};
+
+export { API_BASES, ApiError, type AwardAccepted, type AwardInput, type CatalogAction, type CatalogCollectible, type ClientOptions, type Collection, type GetToken, type MintedToken, type Refused, type SlyClient, type Standing, createClient, isRefused, splitRefusal };