@vibexp/api-client 0.58.0 → 0.59.0

package/dist/schema.d.ts

@@ -3144,6 +3144,93 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/{team_id}/freshness/rules": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * List the team's freshness rules
+         * @description Returns every freshness rule the team has defined, oldest first. Any member of the team may read them. The array is empty, never null, when the team has no rules.
+         */
+        get: operations["listFreshnessRules"];
+        put?: never;
+        /**
+         * Create a freshness rule
+         * @description Adds a rule to the team. Requires the `team.settings.update` permission. An omitted `mediums` matches any medium; an omitted or null `project_id` applies the rule to every project in the team.
+         */
+        post: operations["createFreshnessRule"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/{team_id}/freshness/rules/{rule_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+                /** @description Freshness rule identifier */
+                rule_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Replace a freshness rule
+         * @description Replaces the rule in full — every mutable field is required, because an omitted field would otherwise reset that dimension. Requires the `team.settings.update` permission.
+         */
+        put: operations["updateFreshnessRule"];
+        post?: never;
+        /**
+         * Delete a freshness rule
+         * @description Removes the rule and strips it from any freshness state that matched it, so no stale resource keeps referencing a rule that no longer exists. Requires the `team.settings.update` permission.
+         */
+        delete: operations["deleteFreshnessRule"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/{team_id}/settings/freshness": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get the team's freshness settings
+         * @description Returns the freshness evaluation settings in effect for the team, their provenance (`source`), and the defaults a reset would restore. A team that has never overridden them gets `source: instance`. Any member may read them.
+         */
+        get: operations["getTeamFreshnessSettings"];
+        /**
+         * Override the team's freshness settings
+         * @description Replaces the team's freshness settings in full. `interval_seconds` below 3600 (one hour) is rejected. Requires the `team.settings.update` permission.
+         */
+        put: operations["updateTeamFreshnessSettings"];
+        post?: never;
+        /**
+         * Reset the team's freshness settings to the defaults
+         * @description Removes the team's stored settings so it inherits the defaults again. Requires the `team.settings.update` permission. Resetting a team that has no stored settings succeeds and changes nothing.
+         */
+        delete: operations["resetTeamFreshnessSettings"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/{team_id}/settings/embedding-providers": {
         parameters: {
             query?: never;
@@ -8725,6 +8812,118 @@ export interface components {
              */
             truncated: boolean;
         };
+        /** @description One team's rule for when a resource becomes stale. */
+        FreshnessRule: {
+            /**
+             * Format: uuid
+             * @description Rule identifier.
+             */
+            id: string;
+            /**
+             * Format: uuid
+             * @description Team the rule belongs to.
+             */
+            team_id: string;
+            /**
+             * Format: uuid
+             * @description Scopes the rule to a single project. `null` means the rule applies to EVERY project in the team.
+             */
+            project_id: string | null;
+            /** @description Resource types the rule applies to. Never empty. */
+            resource_types: components["schemas"]["FreshnessRuleResourceType"][];
+            /** @description Access mediums that count as "accessed" for this rule. An EMPTY array means ANY medium counts — it does not mean "no medium". */
+            mediums: components["schemas"]["FreshnessRuleMedium"][];
+            /**
+             * Format: int32
+             * @description Days without a qualifying access after which the resource is stale. Capped at 36500 (100 years), mirroring the search-settings half-life cap: past that the rule can never fire, and the bound keeps the value inside the int32 the column and the wire format use.
+             */
+            threshold_days: number;
+            /** @description Whether evaluation runs apply this rule. */
+            enabled: boolean;
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            updated_at: string;
+        };
+        /**
+         * @description A resource type a freshness rule can cover.
+         * @enum {string}
+         */
+        FreshnessRuleResourceType: "artifact" | "prompt" | "blueprint" | "memory";
+        /**
+         * @description An access medium that counts as "accessed" for a freshness rule. Note this is narrower than the set of mediums recorded on the access path — `api` accesses are stored but are deliberately not selectable as rule criteria.
+         * @enum {string}
+         */
+        FreshnessRuleMedium: "web" | "cli" | "mcp";
+        /** @description The team's freshness rules, oldest first. */
+        FreshnessRuleListResponse: {
+            /** @description Freshness rules. Serializes as `[]` when the team has none, never `null`. */
+            rules: components["schemas"]["FreshnessRule"][];
+        };
+        /** @description Create a freshness rule. */
+        CreateFreshnessRuleRequest: {
+            /**
+             * Format: uuid
+             * @description Scope to one project; omit or send `null` for every project in the team.
+             */
+            project_id?: string | null;
+            resource_types: components["schemas"]["FreshnessRuleResourceType"][];
+            /** @description Omit or send an empty array to match any medium. */
+            mediums?: components["schemas"]["FreshnessRuleMedium"][];
+            /** Format: int32 */
+            threshold_days: number;
+            /**
+             * @description Defaults to true when omitted.
+             * @default true
+             */
+            enabled: boolean;
+        };
+        /** @description Replace a freshness rule in full. */
+        UpdateFreshnessRuleRequest: {
+            /**
+             * Format: uuid
+             * @description Scope to one project; `null` means every project in the team.
+             */
+            project_id: string | null;
+            resource_types: components["schemas"]["FreshnessRuleResourceType"][];
+            /** @description An empty array matches any medium. */
+            mediums: components["schemas"]["FreshnessRuleMedium"][];
+            /** Format: int32 */
+            threshold_days: number;
+            enabled: boolean;
+        };
+        /** @description The tunable freshness-evaluation values, shared by the current settings and the defaults. */
+        FreshnessSettingsValues: {
+            /**
+             * Format: int32
+             * @description How often the team's rules are evaluated. Storage enforces a one-hour floor, matching the scheduler's own floor; the 31536000 (365-day) ceiling keeps the value inside the int32 the column and the wire format use, and an interval longer than a year is indistinguishable from off.
+             */
+            interval_seconds: number;
+            /** @description Whether accessing or editing a stale resource clears its stale state. */
+            reversibility_enabled: boolean;
+        };
+        /** @description The freshness settings in effect for a team, with their provenance. A team that has never overridden them reports `source: instance` and the defaults. */
+        TeamFreshnessSettings: {
+            /**
+             * @description `team` when the team stores its own settings, `instance` when it inherits the defaults.
+             * @enum {string}
+             */
+            source: "instance" | "team";
+            /** Format: int32 */
+            interval_seconds: number;
+            reversibility_enabled: boolean;
+            /** @description The values a DELETE would restore. Present on every read so clients can preview a reset without a second call. */
+            defaults: components["schemas"]["FreshnessSettingsValues"];
+        };
+        /** @description Override the team's freshness settings. */
+        UpdateTeamFreshnessSettingsRequest: {
+            /**
+             * Format: int32
+             * @description Rejected below 3600 (one hour) or above 31536000 (365 days).
+             */
+            interval_seconds: number;
+            reversibility_enabled: boolean;
+        };
         /** @description The search ranking settings in effect for a team, with enough context for a client to render the whole settings surface from this one response: the effective values, where they came from, the instance defaults to preview a reset against, and the instance-owned candidate cap. */
         TeamSearchSettings: {
             /**
@@ -20613,6 +20812,449 @@ export interface operations {
             };
         };
     };
+    listFreshnessRules: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Rules retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FreshnessRuleListResponse"];
+                };
+            };
+            /** @description Invalid team_id */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Caller is not a member of the team */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Failed to list the team's freshness rules */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    createFreshnessRule: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateFreshnessRuleRequest"];
+            };
+        };
+        responses: {
+            /** @description Rule created successfully */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FreshnessRule"];
+                };
+            };
+            /** @description Invalid team_id or rule definition */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Caller may not change the team's settings */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Failed to create the freshness rule */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    updateFreshnessRule: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+                /** @description Freshness rule identifier */
+                rule_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateFreshnessRuleRequest"];
+            };
+        };
+        responses: {
+            /** @description Rule updated successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FreshnessRule"];
+                };
+            };
+            /** @description Invalid identifiers or rule definition */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Caller may not change the team's settings */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description No such rule in this team */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Failed to update the freshness rule */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    deleteFreshnessRule: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+                /** @description Freshness rule identifier */
+                rule_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Rule deleted (no content) */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Invalid identifiers */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Caller may not change the team's settings */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description No such rule in this team */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Failed to delete the freshness rule */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getTeamFreshnessSettings: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Settings retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TeamFreshnessSettings"];
+                };
+            };
+            /** @description Invalid team_id */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Caller is not a member of the team */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Failed to read the team's freshness settings */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    updateTeamFreshnessSettings: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateTeamFreshnessSettingsRequest"];
+            };
+        };
+        responses: {
+            /** @description Settings updated successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TeamFreshnessSettings"];
+                };
+            };
+            /** @description Invalid team_id or settings */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Caller may not change the team's settings */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Failed to update the team's freshness settings */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    resetTeamFreshnessSettings: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Settings reset (no content); the team now inherits the defaults */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Invalid team_id */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Caller may not change the team's settings */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Failed to reset the team's freshness settings */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     listEmbeddingProvidersSettings: {
         parameters: {
             query?: never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibexp/api-client",
-  "version": "0.58.0",
+  "version": "0.59.0",
   "description": "Typed VibeXP API client generated from the OpenAPI spec (openapi-fetch main entrypoint, axios SDK at ./axios)",
   "license": "MIT",
   "repository": {