@recursiv/sdk 0.7.123 → 0.7.195

package/dist/resources/boosts.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { PaginatedResponse, SingleResponse } from '../types.js';
+import type { PaginatedResponse, Post, SingleResponse } from '../types.js';
 /** Campaign lifecycle axis. */
 export type BoostStatus = 'active' | 'paused' | 'completed' | 'refunded';
 /** Campaign moderation axis. A campaign delivers only when `active` AND `approved`. */
@@ -59,12 +59,30 @@ export interface BoostPlanCredit {
      */
     owed_micros?: number;
 }
+/** Paying for Boost with tokens. */
+export interface BoostTokenTopupInfo {
+    /** False until the platform sets the price of a token. */
+    available: boolean;
+    /** Micro-USD of Boost balance one token buys; null when unavailable. */
+    usd_micros_per_token: number | null;
+    /** Most whole tokens one conversion takes. */
+    max_tokens: number;
+}
+export interface BoostTokenTopupResult {
+    /** False when this request_id was already credited: nothing new was written. */
+    applied: boolean;
+    tokens: number;
+    credited_micros: number;
+    balance_micros: number;
+}
 export interface BoostBalanceResponse extends SingleResponse<BoostBalance> {
     /** `plan_credit` is null when the app's plans include no boost credit (absent from older servers). */
     meta: {
         min_cpm_micros: number;
         topup?: BoostTopupLimits;
         plan_credit?: BoostPlanCredit | null;
+        /** Absent from older servers. */
+        token_topup?: BoostTokenTopupInfo;
     };
 }
 export interface BoostCampaignResponse extends SingleResponse<BoostCampaign> {
@@ -80,6 +98,27 @@ export interface BoostEventResult {
     spent_micros: number;
     impressions_served: number;
 }
+/** One UTC day of a campaign's results. */
+export interface BoostDailyStats {
+    /** `YYYY-MM-DD`, UTC. */
+    date: string;
+    impressions: number;
+    clicks: number;
+}
+/** What a campaign delivered: totals and a per-day series (days with no events are absent). */
+export interface BoostCampaignStats {
+    campaign: BoostCampaign;
+    totals: {
+        impressions: number;
+        clicks: number;
+        /** clicks / impressions, or null before the first view. */
+        click_rate: number | null;
+        spent_micros: number;
+        /** Spend per 1,000 views in micro-USD, or null before the first view. */
+        cost_per_1000_micros: number | null;
+    };
+    daily: BoostDailyStats[];
+}
 export interface BoostTopupCheckout {
     /** Stripe Checkout URL to open. */
     url: string;
@@ -92,6 +131,47 @@ export interface BoostTopupConfirmation {
     credited_micros: number;
     balance_micros: number | null;
 }
+/** A feed whose boosts the app splices into its pages itself: All, a category, or the big-screen grid of either. */
+export type BoostSlotSurface = 'all' | 'category' | 'grid';
+export interface BoostSlotsParams {
+    surface: BoostSlotSurface;
+    /** A browse category id: required for `category`, allowed for `grid`, refused for `all`. */
+    category?: string;
+    /** How many posts the page has before its boosts (1..50, default 20). */
+    limit?: number;
+    /** Up to 50 post ids already on the page (and the originals they carry): never served as a boost. */
+    exclude?: readonly string[];
+    /** The Politics choice the page is served under: under one that leaves posts out, only boosts judged not political. */
+    compass?: string;
+}
+export interface PublicBoostSlotsParams extends BoostSlotsParams {
+    /** The public app whose feed it is. */
+    projectId: string;
+}
+/** One boost of a page: where it stands in the page as served, and the boosted post (labelled `boosted: true`). */
+export interface BoostSlotItem {
+    place: number;
+    post: Post;
+}
+export interface BoostSlotsResponse {
+    data: BoostSlotItem[];
+    meta: {
+        surface: BoostSlotSurface;
+        category: string | null;
+        limit: number;
+        /** One boost per `every` posts. */
+        every: number;
+        /** No boost before this place (0-based): the first two places are never a boost. */
+        first: number;
+        /** Why there are none: the key is bound to no app, or (a visitor's read) the app is not public. */
+        reason?: 'no_app' | 'not_public';
+    };
+}
+/**
+ * A page with its boosts in their places: each slot's post goes in at its `place`, in order, and one whose place the
+ * page does not reach is left out, so a short page never pulls a boost forward. The page's own posts keep their order.
+ */
+export declare function spliceBoostSlots<T>(page: readonly T[], slots: readonly BoostSlotItem[]): Array<T | Post>;
 /**
  * Boost: pay to promote your own post into the For You feed. CPM campaigns
  * funded from a prepaid balance with an append-only ledger. Top-ups run on the
@@ -126,6 +206,35 @@ export declare class BoostsResource {
     resume(campaignId: string): Promise<BoostCampaignResponse>;
     /** Cancel a campaign and refund its unspent budget to your balance (`meta.refunded_micros`). */
     cancel(campaignId: string): Promise<BoostCampaignResponse>;
+    /**
+     * One page's boosts for a feed the app splices them into itself (All, a category, or the big-screen grid), read beside
+     * the page: pass the page's own post count as `limit` and its post ids as `exclude`, then put each item's post in at
+     * its `place` (`spliceBoostSlots`). Each post is labelled `boosted: true` with `boost_campaign_id` and
+     * `boost_disclosure`; report what was seen with `recordEvent`. Never the member's own campaign, one they hid or one
+     * walled from them. Watch's boosts come on its own pages.
+     */
+    slots(params: BoostSlotsParams, options?: {
+        retry?: boolean;
+    }): Promise<BoostSlotsResponse>;
+    /**
+     * A visitor's boosts for one page of a public app's feed (tRPC `publicDiscovery.boostSlots`), as `slots` answers a
+     * member: read with no credential at all (no key, no cookie: `credentials: 'omit'`). An app that is not public answers
+     * none (`meta.reason` `not_public`).
+     */
+    publicSlots(params: PublicBoostSlotsParams, options?: {
+        timeoutMs?: number;
+    }): Promise<BoostSlotsResponse>;
+    /** Results for one of your campaigns: views, clicks, click rate, spend and a daily series. */
+    stats(campaignId: string): Promise<SingleResponse<BoostCampaignStats>>;
+    /**
+     * Turn whole tokens into Boost balance at the platform's price (`balance().meta.token_topup`).
+     * `request_id` (8 to 100 of A-Z a-z 0-9 - _) makes a retry safe: the same id debits once.
+     * Not retried automatically.
+     */
+    topupWithTokens(input: {
+        tokens: number;
+        request_id: string;
+    }): Promise<SingleResponse<BoostTokenTopupResult>>;
     /** Report an impression or click on a boosted feed entry. Idempotent per viewer per UTC day. */
     recordEvent(campaignId: string, kind: 'impression' | 'click'): Promise<SingleResponse<BoostEventResult>>;
     /**

package/dist/resources/boosts.js

@@ -1,3 +1,17 @@
+import { NotFoundError, RecursivError } from '../errors.js';
+/**
+ * A page with its boosts in their places: each slot's post goes in at its `place`, in order, and one whose place the
+ * page does not reach is left out, so a short page never pulls a boost forward. The page's own posts keep their order.
+ */
+export function spliceBoostSlots(page, slots) {
+    const out = [...page];
+    for (const slot of [...slots].sort((a, b) => a.place - b.place)) {
+        if (!Number.isInteger(slot.place) || slot.place < 0 || slot.place > out.length)
+            continue;
+        out.splice(slot.place, 0, slot.post);
+    }
+    return out;
+}
 /**
  * Boost: pay to promote your own post into the For You feed. CPM campaigns
  * funded from a prepaid balance with an append-only ledger. Top-ups run on the
@@ -39,6 +53,72 @@ export class BoostsResource {
     cancel(campaignId) {
         return this.client.post(`/boosts/${encodeURIComponent(campaignId)}/cancel`, {});
     }
+    /**
+     * One page's boosts for a feed the app splices them into itself (All, a category, or the big-screen grid), read beside
+     * the page: pass the page's own post count as `limit` and its post ids as `exclude`, then put each item's post in at
+     * its `place` (`spliceBoostSlots`). Each post is labelled `boosted: true` with `boost_campaign_id` and
+     * `boost_disclosure`; report what was seen with `recordEvent`. Never the member's own campaign, one they hid or one
+     * walled from them. Watch's boosts come on its own pages.
+     */
+    slots(params, options) {
+        return this.client.get('/boosts/slots', {
+            surface: params.surface, category: params.category, limit: params.limit,
+            exclude: params.exclude?.length ? params.exclude.join(',') : undefined, compass: params.compass,
+        }, options);
+    }
+    /**
+     * A visitor's boosts for one page of a public app's feed (tRPC `publicDiscovery.boostSlots`), as `slots` answers a
+     * member: read with no credential at all (no key, no cookie: `credentials: 'omit'`). An app that is not public answers
+     * none (`meta.reason` `not_public`).
+     */
+    async publicSlots(params, options) {
+        const input = { projectId: params.projectId, surface: params.surface, ...(params.category ? { category: params.category } : {}),
+            ...(params.limit !== undefined ? { limit: params.limit } : {}), ...(params.exclude?.length ? { exclude: [...params.exclude] } : {}),
+            ...(params.compass ? { compass: params.compass } : {}) };
+        const url = `${this.client.baseOrigin}/api/trpc/publicDiscovery.boostSlots?input=${encodeURIComponent(JSON.stringify(input))}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), options?.timeoutMs ?? this.client.requestTimeoutMs);
+        try {
+            let response;
+            try {
+                response = await fetch(url, { method: 'GET', headers: { Accept: 'application/json' }, credentials: 'omit', signal: controller.signal });
+            }
+            catch (error) {
+                throw new RecursivError(0, { type: 'api_error', code: controller.signal.aborted ? 'timeout' : 'network_error',
+                    message: controller.signal.aborted ? 'The visitor boost slots did not answer in time.' : `The visitor boost slots could not be reached (${error instanceof Error ? error.message : String(error)}).` });
+            }
+            let body = null;
+            try {
+                body = await response.json();
+            }
+            catch {
+                body = null;
+            }
+            const data = body?.result?.data;
+            if (response.ok && data && typeof data === 'object')
+                return data;
+            const error = body?.error && typeof body.error === 'object' ? body.error : undefined;
+            const said = [error?.json?.message, error?.message].find((value) => typeof value === 'string' && value.length > 0);
+            const code = typeof error?.data?.code === 'string' ? error.data.code.toLowerCase() : 'unknown_error';
+            const failure = { type: response.status === 404 ? 'not_found_error' : 'api_error', code, message: said ?? `HTTP ${response.status}` };
+            throw response.status === 404 ? new NotFoundError(failure) : new RecursivError(response.ok ? 502 : response.status, failure);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** Results for one of your campaigns: views, clicks, click rate, spend and a daily series. */
+    stats(campaignId) {
+        return this.client.get(`/boosts/${encodeURIComponent(campaignId)}/stats`);
+    }
+    /**
+     * Turn whole tokens into Boost balance at the platform's price (`balance().meta.token_topup`).
+     * `request_id` (8 to 100 of A-Z a-z 0-9 - _) makes a retry safe: the same id debits once.
+     * Not retried automatically.
+     */
+    topupWithTokens(input) {
+        return this.client.post('/boosts/topup/tokens', input, { retry: false });
+    }
     /** Report an impression or click on a boosted feed entry. Idempotent per viewer per UTC day. */
     recordEvent(campaignId, kind) {
         return this.client.post(`/boosts/${encodeURIComponent(campaignId)}/events`, { kind });

package/dist/resources/deployments.d.ts

@@ -43,6 +43,10 @@ export interface DeploymentReleaseInput {
     run_id: number;
     attempt: number;
 }
+export interface DeploymentReleaseReservationInput extends DeploymentReleaseInput {
+    /** Optional initial-run GitHub OIDC proof. Requires compatible server support; never log it or retry a refused proof. */
+    coordinator_identity_token?: string;
+}
 export interface DeploymentRelease {
     deployment_id: string;
     status: string;
@@ -183,7 +187,7 @@ export declare class DeploymentsResource {
     private client;
     constructor(client: HttpClient);
     /** Atomically block competing production deployments before promoting the API. Retry explicitly with the SAME capability. */
-    reserveRelease(input: DeploymentReleaseInput): Promise<SingleResponse<DeploymentRelease>>;
+    reserveRelease(input: DeploymentReleaseReservationInput): Promise<SingleResponse<DeploymentRelease>>;
     getRelease(deploymentId: string, projectId: string): Promise<SingleResponse<DeploymentRelease>>;
     /** Mark immediately before API mutation, then only after the existing API health gates pass. */
     advanceRelease(deploymentId: string, input: DeploymentReleaseOperation & {

package/dist/resources/discovery.d.ts

@@ -175,8 +175,11 @@ export interface CategorySurfaceSection<T> {
     ms: number;
     reason?: string;
 }
-/** A radar cluster themed into the category, with up to six members (headline or excerpt and link only). */
-export type CategoryStory = Pick<SocialRadar['clusters'][number], 'id' | 'label' | 'kind' | 'theme' | 'sources' | 'corroboration' | 'laneMix' | 'outlets' | 'velocity' | 'media' | 'freshness' | 'score' | 'members'>;
+/**
+ * A radar cluster themed into the category, with up to six members (headline or excerpt and link only). `political`
+ * (0.7.165) is the radar's own mark, what Hide politics reads; absent from an older server or a copy cached before it.
+ */
+export type CategoryStory = Pick<SocialRadar['clusters'][number], 'id' | 'label' | 'kind' | 'theme' | 'political' | 'sources' | 'corroboration' | 'laneMix' | 'outlets' | 'velocity' | 'media' | 'freshness' | 'score' | 'members'>;
 export interface CategoryClip {
     id: string;
     title: string | null;

package/dist/resources/evidence.d.ts

@@ -27,12 +27,14 @@ export interface CreateEvalInput {
 }
 export interface SimulateInput {
     target: EvidenceTarget;
-    /** The batch of cases to run through the target. */
-    cases: Array<{
+    /** The batch of cases to run through the target. Pass this or `eval_set_id`. */
+    cases?: Array<{
         input: string;
         expected?: Record<string, unknown>;
         label?: string;
     }>;
+    /** Run a saved set from {@link EvidenceResource.createEvalSet} instead of inline cases. */
+    eval_set_id?: string;
     /** Optionally attach evals for this run (also saved to the target). */
     evals?: Array<Omit<CreateEvalInput, 'target'>>;
     run_type?: 'test' | 'real';
@@ -41,6 +43,40 @@ export interface SimulateInput {
     /** Attach the run to a project so it appears there, not only on the agent. */
     project_id?: string;
 }
+/** A reusable set of cases with known answers, run with `simulate({ eval_set_id })`. */
+export interface CreateEvalSetInput {
+    name: string;
+    /** 1 to 50 cases. `weight` 1-100 (default 1); `trap` marks a case built to catch a wrong answer. */
+    cases: Array<{
+        input: string;
+        expected?: Record<string, unknown>;
+        weight?: number;
+        trap?: boolean;
+        label?: string;
+    }>;
+    description?: string;
+    scoring_mode?: 'exact' | 'judge';
+    /** For judge scoring: what a good answer looks like. */
+    rubric?: string;
+    /** Defaults to the key's organization; omit both for a personal set. */
+    organization_id?: string;
+    project_id?: string;
+}
+export interface EvalSetRow {
+    id: string;
+    name: string;
+    description: string | null;
+    scoringMode: string;
+    organizationId: string | null;
+    projectId: string | null;
+    createdAt: string;
+}
+/** A run's result matrix as a file body. */
+export interface EvalRunExport {
+    filename: string;
+    mimeType: string;
+    content: string;
+}
 export interface EvalRunRow {
     id: string;
     targetType: string;
@@ -167,6 +203,25 @@ export declare class EvidenceResource {
             reason: string;
         }>;
     }>>;
+    /**
+     * Save a reusable set of cases with known answers. Run it as often as you
+     * like with `simulate({ target, eval_set_id })`, so runs compare like with like.
+     */
+    createEvalSet(input: CreateEvalSetInput): Promise<SingleResponse<{
+        eval_set_id: string;
+        case_count: number;
+    }>>;
+    /**
+     * The saved sets you can run: an organization's (the key's own by default),
+     * or, for a personal key with no organization, the ones you made.
+     */
+    listEvalSets(opts?: {
+        organizationId?: string;
+    }): Promise<{
+        data: EvalSetRow[];
+    }>;
+    /** A run's result matrix as CSV (default) or JSON, for offline analysis. */
+    exportRun(runId: string, format?: 'csv' | 'json'): Promise<SingleResponse<EvalRunExport>>;
     /** Recent runs for a target. */
     listRuns(target: EvidenceTarget, limit?: number): Promise<{
         data: EvalRunRow[];

package/dist/resources/evidence.js

@@ -26,6 +26,25 @@ export class EvidenceResource {
     runTaskChecks(taskId) {
         return this.client.post('/evidence/task-checks/run', { task_id: taskId });
     }
+    /**
+     * Save a reusable set of cases with known answers. Run it as often as you
+     * like with `simulate({ target, eval_set_id })`, so runs compare like with like.
+     */
+    createEvalSet(input) {
+        return this.client.post('/evidence/eval-sets', input);
+    }
+    /**
+     * The saved sets you can run: an organization's (the key's own by default),
+     * or, for a personal key with no organization, the ones you made.
+     */
+    listEvalSets(opts = {}) {
+        const query = opts.organizationId ? `?organization_id=${encodeURIComponent(opts.organizationId)}` : '';
+        return this.client.get(`/evidence/eval-sets${query}`);
+    }
+    /** A run's result matrix as CSV (default) or JSON, for offline analysis. */
+    exportRun(runId, format = 'csv') {
+        return this.client.get(`/evidence/runs/${runId}/export?format=${format}`);
+    }
     /** Recent runs for a target. */
     listRuns(target, limit = 20) {
         return this.client.get(`/evidence/runs?target_type=${target.type}&target_id=${encodeURIComponent(target.id)}&limit=${limit}`);

package/dist/resources/feeds.d.ts

@@ -160,6 +160,57 @@ export interface FeedTopResponse {
     lead: FeedStory | null;
     meta: FeedTopMeta;
 }
+/** The networks a firehose item comes from: Minds, and the open networks the top's lanes carry. */
+export type FeedFirehoseNetwork = 'minds' | 'bluesky' | 'activitypub' | 'nostr';
+/**
+ * One firehose item (0.7.195): an item of the top of a feed, with its network, its state, when it was published and when
+ * the server chose it. An open-network post carries its `card` to draw (no URL on its network: open it by `target.path`).
+ */
+export interface FeedFirehoseItem extends FeedTopItem {
+    network: FeedFirehoseNetwork;
+    /** 'breaking' (its radar story broke in the last 6 hours) or 'viral'; at most one, else null. */
+    state: 'breaking' | 'viral' | null;
+    /** When the post was published (ISO). */
+    publishedAt: string;
+    /** When the server chose it for this answer (ISO, the server's clock). */
+    chosenAt: string;
+    /** An open-network post's card. */
+    card?: FeedTopNetworkCard;
+}
+export interface FeedFirehoseMeta {
+    /** The soonest to read again, in ms: longer when the answer was short or the server is busy. */
+    refillAfterMs: number;
+    /** The oldest shared snapshot the stream's pool was composed from (ISO). */
+    poolBuiltAt: string;
+    poolSize: number;
+    /** 'safe' for a member on safe defaults, 'open' for one who turned them off. */
+    safety: 'safe' | 'open';
+    /** Fewer items than asked for: supply is thin, so read again after `refillAfterMs`. */
+    short: boolean;
+    networks: Record<'bluesky' | 'activitypub' | 'nostr', 'ok' | 'unavailable'>;
+    /**
+     * Whether the server kept this session from repeating: 'on'; 'full' when the session's record is at its cap; and
+     * 'unavailable' when it could not (guard against repeats in the app, over more of what it showed).
+     */
+    sent: 'on' | 'full' | 'unavailable';
+    compass_filter?: CompassFilterMeta;
+}
+/** GET /feeds/firehose. `retract` names refs the session was sent that were taken down since: remove them wherever they are held. */
+export interface FeedFirehoseResponse {
+    items: FeedFirehoseItem[];
+    retract: string[];
+    meta: FeedFirehoseMeta;
+}
+export interface FeedFirehoseParams {
+    /** Opaque per app session ([A-Za-z0-9_-], up to 64), required: nothing is sent twice within one session. */
+    session: string;
+    /** 1..25, default 20. */
+    limit?: number;
+    /** A Politics choice, as `posts.list` takes it. */
+    compass?: string;
+    /** Only one network's items: `all` (default), `minds`, `bluesky`, `activitypub` or `nostr`. */
+    network?: 'all' | FeedFirehoseNetwork;
+}
 export interface FeedStoriesResponse {
     data: FeedStory[];
     meta: {
@@ -230,6 +281,18 @@ export declare class FeedsResource {
     top(params: FeedTopParams, options?: {
         retry?: boolean;
     }): Promise<FeedTopResponse>;
+    /**
+     * The firehose for the signed-in member, with their own key of the app (0.7.195): the next items of their live stream of
+     * the most engaged, viral and breaking posts of Minds and the open networks, every one re-checked for them on the
+     * server, none sent twice in one `session`. Reveal them one at a time; read again no sooner than `meta.refillAfterMs`.
+     * Off (404) until the app's operator turns it on; 429 `rate_limited` and 503 `firehose_unavailable` carry Retry-After.
+     * A Mix or Choose sides `compass` spends one of the member's hourly sided Politics reads at most once per `session` and
+     * choice in ten minutes; 429 `compass_rate_limited` when they are spent (choose Everything or Hide politics, or wait).
+     * Always private: never cached for anyone else.
+     */
+    firehose(params: FeedFirehoseParams, options?: {
+        retry?: boolean;
+    }): Promise<FeedFirehoseResponse>;
     /** The stories the member should meet next (the story tail), by the same ranker as the top's lead. */
     stories(params?: FeedStoriesParams, options?: {
         retry?: boolean;

package/dist/resources/feeds.js

@@ -14,6 +14,18 @@ export class FeedsResource {
     top(params, options) {
         return this.http.get('/feeds/top', { ref: params.ref, limit: params.limit, session: params.session, compass: params.compass }, options);
     }
+    /**
+     * The firehose for the signed-in member, with their own key of the app (0.7.195): the next items of their live stream of
+     * the most engaged, viral and breaking posts of Minds and the open networks, every one re-checked for them on the
+     * server, none sent twice in one `session`. Reveal them one at a time; read again no sooner than `meta.refillAfterMs`.
+     * Off (404) until the app's operator turns it on; 429 `rate_limited` and 503 `firehose_unavailable` carry Retry-After.
+     * A Mix or Choose sides `compass` spends one of the member's hourly sided Politics reads at most once per `session` and
+     * choice in ten minutes; 429 `compass_rate_limited` when they are spent (choose Everything or Hide politics, or wait).
+     * Always private: never cached for anyone else.
+     */
+    firehose(params, options) {
+        return this.http.get('/feeds/firehose', { session: params.session, limit: params.limit, compass: params.compass, network: params.network }, options);
+    }
     /** The stories the member should meet next (the story tail), by the same ranker as the top's lead. */
     stories(params = {}, options) {
         return this.http.get('/feeds/stories', { after: params.after, limit: params.limit, compass: params.compass }, options);

package/dist/resources/member-experience.d.ts

@@ -0,0 +1,24 @@
+/** A starting intent; private_ai records interest without changing chat protection or providers. */
+export type ExperienceGoal = 'build' | 'create' | 'explore' | 'connect' | 'private_ai' | 'earn';
+export type ExperienceCategory = 'news' | 'technology' | 'science' | 'business' | 'sports' | 'entertainment' | 'gaming' | 'life' | 'politics' | 'ai' | 'crypto' | 'finance' | 'space' | 'nature' | 'health' | 'fitness' | 'music' | 'film-tv' | 'art' | 'photography' | 'books' | 'food' | 'travel' | 'animals' | 'education' | 'comedy';
+export interface MemberExperience {
+    goals: ExperienceGoal[];
+    interests: ExperienceCategory[];
+    /** These categories cannot become the saved starting point; this is not a whole-feed filter. */
+    avoid_categories: ExperienceCategory[];
+    version: number;
+    can_undo: boolean;
+    applied_scope: 'saved_starting_point';
+    /** A trusted relative route into existing category results; null without a non-avoided interest. */
+    discovery: {
+        href: string;
+        category: ExperienceCategory;
+    } | null;
+}
+export interface UpdateMemberExperienceInput {
+    /** Required current version from getExperience; a stale save is refused with 409 stale_version. */
+    version: number;
+    goals?: ExperienceGoal[];
+    interests?: ExperienceCategory[];
+    avoid_categories?: ExperienceCategory[];
+}

package/dist/resources/member-experience.js

@@ -0,0 +1 @@
+export {};