@vibexp/api-client 0.58.0 → 0.60.0

package/dist/schema.d.ts

@@ -3144,6 +3144,208 @@ 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}/freshness/metrics/over-time": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Freshness activity over time
+         * @description Daily marked/cleared counts and the reconstructed stale level over the requested window, zero-filled so every day in the range is present.
+         */
+        get: operations["getFreshnessOverTimeMetrics"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/{team_id}/freshness/metrics/by-type": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Stale resources by resource type
+         * @description Current stale counts per resource type. All four types are always present; one with nothing stale reports 0.
+         */
+        get: operations["getFreshnessByTypeMetrics"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/{team_id}/freshness/metrics/by-project": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Stale resources by project
+         * @description Current stale counts per project in the team, including projects with nothing stale.
+         */
+        get: operations["getFreshnessByProjectMetrics"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/{team_id}/freshness/metrics/by-rule": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Resources marked by each rule
+         * @description How many resources each of the team's rules currently marks, including rules that match nothing. This is how an over-broad rule is spotted.
+         */
+        get: operations["getFreshnessByRuleMetrics"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/{team_id}/freshness/audit": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * List the team's freshness audit log
+         * @description Every recorded mark and clear for the team, newest first and paginated. Readable by any member. The list is empty, never null, past the last page.
+         */
+        get: operations["listFreshnessAudit"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/{team_id}/settings/embedding-providers": {
         parameters: {
             query?: never;
@@ -8725,110 +8927,405 @@ export interface components {
              */
             truncated: 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: {
+        /** @description One team's rule for when a resource becomes stale. */
+        FreshnessRule: {
             /**
-             * @description Where the effective values come from. `instance` means the team has no override and inherits the deployment defaults; `team` means the team has stored its own profile.
-             * @example instance
-             * @enum {string}
+             * Format: uuid
+             * @description Rule identifier.
              */
-            source: "instance" | "team";
-            /** @description Effective value — the team's when source is `team`, otherwise the instance default. */
-            recency_ranking_enabled: boolean;
+            id: string;
             /**
-             * Format: double
-             * @description Effective value — the team's when source is `team`, otherwise the instance default.
+             * Format: uuid
+             * @description Team the rule belongs to.
              */
-            rank_weight_relevance: number;
+            team_id: string;
             /**
-             * Format: double
-             * @description Effective value — the team's when source is `team`, otherwise the instance default.
+             * Format: uuid
+             * @description Scopes the rule to a single project. `null` means the rule applies to EVERY project in the team.
              */
-            rank_weight_created: number;
+            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: double
-             * @description Effective value — the team's when source is `team`, otherwise the instance default.
+             * 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.
              */
-            rank_weight_updated: number;
+            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: double
-             * @description Effective value — the team's when source is `team`, otherwise the instance default.
+             * Format: uuid
+             * @description Scope to one project; omit or send `null` for every project in the team.
              */
-            rank_half_life_days: number;
-            /** @description The deployment-wide defaults from config.yaml, so a client can preview what "reset to defaults" would produce without a second request. Equal to the effective values when source is `instance`. */
-            instance_defaults: components["schemas"]["TeamSearchSettingsValues"];
+            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 How many top-by-relevance rows are pulled and re-ranked in memory per query. Instance-owned and NOT team-configurable — one team must not be able to raise the whole deployment's per-query cost. Exposed so clients can explain why pagination is clamped to this many results when recency ranking is on.
-             *     Deliberately NOT marked `readOnly`: the update request uses a separate schema that has no such field, which is what actually makes the cap unsettable. Marking it readOnly additionally makes oapi-codegen emit it as an optional pointer, which would let a required field serialize as absent.
-             * @example 200
+             * @description Defaults to true when omitted.
+             * @default true
              */
-            rank_candidate_cap: number;
+            enabled: boolean;
         };
-        /** @description A complete search ranking profile. The three weights are normalized by their sum at ranking time, so they need not pre-sum to 1. */
-        TeamSearchSettingsValues: {
+        /** @description Replace a freshness rule in full. */
+        UpdateFreshnessRuleRequest: {
             /**
-             * @description When false, results keep relevance-only ordering. When true they are re-ranked by a weighted blend of relevance and freshness.
-             * @example true
+             * Format: uuid
+             * @description Scope to one project; `null` means every project in the team.
              */
-            recency_ranking_enabled: boolean;
+            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: double
-             * @description Weight of semantic relevance. Expected to be the dominant weight.
-             * @example 0.5
+             * 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.
              */
-            rank_weight_relevance: number;
+            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: {
             /**
-             * Format: double
-             * @description Weight of how recently the resource was created.
-             * @example 0.3
+             * @description `team` when the team stores its own settings, `instance` when it inherits the defaults.
+             * @enum {string}
              */
-            rank_weight_created: number;
+            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: double
-             * @description Weight of how recently the resource was updated.
-             * @example 0.2
+             * Format: int32
+             * @description Rejected below 3600 (one hour) or above 31536000 (365 days).
              */
-            rank_weight_updated: number;
+            interval_seconds: number;
+            reversibility_enabled: boolean;
+        };
+        /**
+         * @description The reporting window for a time-series metric. The options mirror the other analytics endpoints so one range selector drives every chart.
+         * @example 30d
+         * @enum {string}
+         */
+        FreshnessMetricsRange: "7d" | "14d" | "30d" | "60d" | "90d" | "180d";
+        /** @description One calendar day (UTC) of freshness activity, zero-filled: every day in the window is present even when nothing happened. */
+        FreshnessDailyStaleCount: {
             /**
-             * Format: double
-             * @description Half-life in days for the exponential freshness decay applied to both created_at and updated_at. An item exactly one half-life old scores 0.5.
-             * @example 90
+             * Format: date
+             * @example 2026-05-01
              */
-            rank_half_life_days: number;
-        };
-        /** @description A complete replacement ranking profile for the team. There is no partial update: every field is required, and the whole profile is stored or replaced atomically. `rank_candidate_cap` is deliberately absent — it is instance-owned. */
-        UpdateTeamSearchSettingsRequest: {
-            /** @example true */
-            recency_ranking_enabled: boolean;
+            date: string;
             /**
-             * Format: double
-             * @example 0.5
+             * Format: int32
+             * @description Resources that became stale on this day.
              */
-            rank_weight_relevance: number;
+            marked: number;
             /**
-             * Format: double
-             * @example 0.3
+             * Format: int32
+             * @description Resources that stopped being stale on this day, for any reason.
              */
-            rank_weight_created: number;
+            cleared: number;
             /**
-             * Format: double
-             * @example 0.2
+             * Format: int32
+             * @description How many resources were stale at the END of this day — the level, not the flow. It is reconstructed by walking today's live count backwards through the recorded transitions, so it is exact only for the period the audit log covers; days before freshness evaluation first ran on this team read as the earliest known level rather than as zero. The most recent day reports the live count as of the request. The reconstruction is clamped at zero, so on a team whose rows were removed by a project or team deletion — which writes no audit entry — the series can flatten at 0 instead of satisfying stale_total[i] = stale_total[i-1] + marked[i] - cleared[i].
              */
-            rank_weight_updated: number;
+            stale_total: number;
             /**
-             * Format: double
-             * @example 90
+             * Format: int32
+             * @description The day's total ACTIVITY, marked + cleared — the sum of the two series, not the level. It is the field the shared time-series chart reads for its per-day total, which is why it is a flow rather than stale_total.
              */
-            rank_half_life_days: number;
+            total: number;
         };
-        /** @description Instance-wide totals for the top-level entities (unscoped counts). */
-        AdminInstanceCounts: {
+        FreshnessOverTimeMetricsData: {
+            range: components["schemas"]["FreshnessMetricsRange"];
             /**
-             * Format: int64
-             * @description Total number of user accounts.
-             * @example 42
+             * Format: int32
+             * @description Resources marked stale across the whole window.
              */
-            users: number;
+            total_marked: number;
+            /**
+             * Format: int32
+             * @description Resources cleared across the whole window.
+             */
+            total_cleared: number;
+            /** @description One entry per day in the window, oldest first. Serializes as `[]`, never `null`. */
+            counts: components["schemas"]["FreshnessDailyStaleCount"][];
+        };
+        FreshnessOverTimeMetricsResponse: {
+            /** @example success */
+            status: string;
+            /** @example Freshness over-time metrics retrieved successfully */
+            message: string;
+            data: components["schemas"]["FreshnessOverTimeMetricsData"];
+        };
+        /** @description How many of one resource type are stale right now. */
+        FreshnessTypeCount: {
+            resource_type: components["schemas"]["FreshnessRuleResourceType"];
+            /** Format: int32 */
+            count: number;
+        };
+        FreshnessByTypeMetricsData: {
+            /**
+             * Format: int32
+             * @description Total stale resources in the team, across every type.
+             */
+            total_stale: number;
+            /** @description One entry per resource type, always all four, in a stable order — a type with nothing stale reports 0 rather than being omitted, so the chart's bars never move. Serializes as `[]`, never `null`. */
+            counts: components["schemas"]["FreshnessTypeCount"][];
+        };
+        FreshnessByTypeMetricsResponse: {
+            /** @example success */
+            status: string;
+            /** @example Freshness by-type metrics retrieved successfully */
+            message: string;
+            data: components["schemas"]["FreshnessByTypeMetricsData"];
+        };
+        /** @description How many resources are stale right now in one project. `name` and `slug` are carried so the client can label and deep-link the bar without a second request. */
+        FreshnessProjectCount: {
+            /** Format: uuid */
+            project_id: string;
+            name: string;
+            slug: string;
+            /** Format: int32 */
+            count: number;
+        };
+        FreshnessByProjectMetricsData: {
+            /** Format: int32 */
+            total_stale: number;
+            /** @description One entry per project in the team, including projects with nothing stale (0), ordered by count descending then name. Serializes as `[]`, never `null`. */
+            counts: components["schemas"]["FreshnessProjectCount"][];
+        };
+        FreshnessByProjectMetricsResponse: {
+            /** @example success */
+            status: string;
+            /** @example Freshness by-project metrics retrieved successfully */
+            message: string;
+            data: components["schemas"]["FreshnessByProjectMetricsData"];
+        };
+        /** @description How many resources one rule currently marks. Rules have no name, so the defining fields travel with the count for the client to label the bar. */
+        FreshnessRuleImpact: {
+            /** Format: uuid */
+            rule_id: string;
+            /**
+             * Format: uuid
+             * @description The project the rule is scoped to, or null for every project in the team.
+             */
+            project_id: string | null;
+            resource_types: components["schemas"]["FreshnessRuleResourceType"][];
+            /** Format: int32 */
+            threshold_days: number;
+            /** @description A disabled rule reports 0 — it is listed so its absence from the chart is not mistaken for deletion. */
+            enabled: boolean;
+            /** Format: int32 */
+            count: number;
+        };
+        FreshnessByRuleMetricsData: {
+            /**
+             * Format: int32
+             * @description Distinct stale resources in the team. It is NOT the sum of the per-rule counts: a resource matched by two rules is counted once here and once under each rule, because staleness is a union across rules.
+             */
+            total_stale: number;
+            /** @description One entry per rule the team has defined, including rules matching nothing, ordered by count descending then rule id. Serializes as `[]`, never `null`. */
+            counts: components["schemas"]["FreshnessRuleImpact"][];
+        };
+        FreshnessByRuleMetricsResponse: {
+            /** @example success */
+            status: string;
+            /** @example Freshness by-rule metrics retrieved successfully */
+            message: string;
+            data: components["schemas"]["FreshnessByRuleMetricsData"];
+        };
+        /** @description One recorded freshness transition. The log is append-only. */
+        FreshnessAuditEntry: {
+            /** Format: uuid */
+            id: string;
+            resource_type: components["schemas"]["FreshnessRuleResourceType"];
+            /** Format: uuid */
+            resource_id: string;
+            /**
+             * Format: uuid
+             * @description The rule that caused the change, when exactly one did. Null for a reversal (caused by a read or an edit) and for a mark attributable to several rules at once — the resource's own state carries the full set.
+             */
+            rule_id: string | null;
+            /**
+             * @description Whether the resource became stale or stopped being stale.
+             * @enum {string}
+             */
+            action: "marked" | "cleared";
+            /**
+             * @description What caused it — a scheduled evaluation, a read, or an edit.
+             * @enum {string}
+             */
+            reason: "rule_run" | "accessed" | "edited";
+            /** Format: date-time */
+            created_at: string;
+        };
+        /** @description A page of the team's freshness audit log, newest first. */
+        FreshnessAuditListResponse: {
+            /** @description Serializes as `[]` when the page is empty, never `null`. */
+            entries: components["schemas"]["FreshnessAuditEntry"][];
+            /**
+             * @description Total entries in the team's log, ignoring pagination.
+             * @example 142
+             */
+            total_count: number;
+            /**
+             * @description Current page number (1-based)
+             * @example 1
+             */
+            page: number;
+            /**
+             * @description Number of entries per page
+             * @example 20
+             */
+            per_page: number;
+            /**
+             * @description Total number of pages
+             * @example 8
+             */
+            total_pages: number;
+        };
+        /** @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: {
+            /**
+             * @description Where the effective values come from. `instance` means the team has no override and inherits the deployment defaults; `team` means the team has stored its own profile.
+             * @example instance
+             * @enum {string}
+             */
+            source: "instance" | "team";
+            /** @description Effective value — the team's when source is `team`, otherwise the instance default. */
+            recency_ranking_enabled: boolean;
+            /**
+             * Format: double
+             * @description Effective value — the team's when source is `team`, otherwise the instance default.
+             */
+            rank_weight_relevance: number;
+            /**
+             * Format: double
+             * @description Effective value — the team's when source is `team`, otherwise the instance default.
+             */
+            rank_weight_created: number;
+            /**
+             * Format: double
+             * @description Effective value — the team's when source is `team`, otherwise the instance default.
+             */
+            rank_weight_updated: number;
+            /**
+             * Format: double
+             * @description Effective value — the team's when source is `team`, otherwise the instance default.
+             */
+            rank_half_life_days: number;
+            /** @description The deployment-wide defaults from config.yaml, so a client can preview what "reset to defaults" would produce without a second request. Equal to the effective values when source is `instance`. */
+            instance_defaults: components["schemas"]["TeamSearchSettingsValues"];
+            /**
+             * @description How many top-by-relevance rows are pulled and re-ranked in memory per query. Instance-owned and NOT team-configurable — one team must not be able to raise the whole deployment's per-query cost. Exposed so clients can explain why pagination is clamped to this many results when recency ranking is on.
+             *     Deliberately NOT marked `readOnly`: the update request uses a separate schema that has no such field, which is what actually makes the cap unsettable. Marking it readOnly additionally makes oapi-codegen emit it as an optional pointer, which would let a required field serialize as absent.
+             * @example 200
+             */
+            rank_candidate_cap: number;
+        };
+        /** @description A complete search ranking profile. The three weights are normalized by their sum at ranking time, so they need not pre-sum to 1. */
+        TeamSearchSettingsValues: {
+            /**
+             * @description When false, results keep relevance-only ordering. When true they are re-ranked by a weighted blend of relevance and freshness.
+             * @example true
+             */
+            recency_ranking_enabled: boolean;
+            /**
+             * Format: double
+             * @description Weight of semantic relevance. Expected to be the dominant weight.
+             * @example 0.5
+             */
+            rank_weight_relevance: number;
+            /**
+             * Format: double
+             * @description Weight of how recently the resource was created.
+             * @example 0.3
+             */
+            rank_weight_created: number;
+            /**
+             * Format: double
+             * @description Weight of how recently the resource was updated.
+             * @example 0.2
+             */
+            rank_weight_updated: number;
+            /**
+             * Format: double
+             * @description Half-life in days for the exponential freshness decay applied to both created_at and updated_at. An item exactly one half-life old scores 0.5.
+             * @example 90
+             */
+            rank_half_life_days: number;
+        };
+        /** @description A complete replacement ranking profile for the team. There is no partial update: every field is required, and the whole profile is stored or replaced atomically. `rank_candidate_cap` is deliberately absent — it is instance-owned. */
+        UpdateTeamSearchSettingsRequest: {
+            /** @example true */
+            recency_ranking_enabled: boolean;
+            /**
+             * Format: double
+             * @example 0.5
+             */
+            rank_weight_relevance: number;
+            /**
+             * Format: double
+             * @example 0.3
+             */
+            rank_weight_created: number;
+            /**
+             * Format: double
+             * @example 0.2
+             */
+            rank_weight_updated: number;
+            /**
+             * Format: double
+             * @example 90
+             */
+            rank_half_life_days: number;
+        };
+        /** @description Instance-wide totals for the top-level entities (unscoped counts). */
+        AdminInstanceCounts: {
+            /**
+             * Format: int64
+             * @description Total number of user accounts.
+             * @example 42
+             */
+            users: number;
             /**
              * Format: int64
              * @description Total number of teams.
@@ -20613,6 +21110,752 @@ 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"];
+                };
+            };
+        };
+    };
+    getFreshnessOverTimeMetrics: {
+        parameters: {
+            query?: {
+                /** @description The reporting window. Defaults to 30d. */
+                range?: components["schemas"]["FreshnessMetricsRange"];
+            };
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Metrics retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FreshnessOverTimeMetricsResponse"];
+                };
+            };
+            /** @description Invalid team_id or query parameter */
+            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 build the team's freshness over-time metrics */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getFreshnessByTypeMetrics: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Metrics retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FreshnessByTypeMetricsResponse"];
+                };
+            };
+            /** @description Invalid team_id or query parameter */
+            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 build the team's freshness by-type metrics */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getFreshnessByProjectMetrics: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Metrics retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FreshnessByProjectMetricsResponse"];
+                };
+            };
+            /** @description Invalid team_id or query parameter */
+            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 build the team's freshness by-project metrics */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getFreshnessByRuleMetrics: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Metrics retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FreshnessByRuleMetricsResponse"];
+                };
+            };
+            /** @description Invalid team_id or query parameter */
+            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 build the team's freshness by-rule metrics */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    listFreshnessAudit: {
+        parameters: {
+            query?: {
+                /** @description Page number (1-based). The upper bound is not a storage limit — it keeps page * limit inside the range the offset arithmetic can represent, so an absurd page is rejected rather than silently wrapping around to the first one. */
+                page?: number;
+                /** @description Entries per page */
+                limit?: number;
+            };
+            header?: never;
+            path: {
+                /** @description Team identifier */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Audit log retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FreshnessAuditListResponse"];
+                };
+            };
+            /** @description Invalid team_id or query parameter */
+            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 audit log */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     listEmbeddingProvidersSettings: {
         parameters: {
             query?: never;