@vibexp/api-client 0.58.0 → 0.60.0

package/dist/axios/types.gen.d.ts

@@ -3599,6 +3599,317 @@ export type MetadataValuesResponse = {
      */
     truncated: boolean;
 };
+/**
+ * One team's rule for when a resource becomes stale.
+ */
+export type FreshnessRule = {
+    /**
+     * Rule identifier.
+     */
+    id: string;
+    /**
+     * Team the rule belongs to.
+     */
+    team_id: string;
+    /**
+     * Scopes the rule to a single project. `null` means the rule applies to EVERY project in the team.
+     *
+     */
+    project_id: string | null;
+    /**
+     * Resource types the rule applies to. Never empty.
+     */
+    resource_types: Array<FreshnessRuleResourceType>;
+    /**
+     * Access mediums that count as "accessed" for this rule. An EMPTY array means ANY medium counts — it does not mean "no medium".
+     *
+     */
+    mediums: Array<FreshnessRuleMedium>;
+    /**
+     * 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;
+    /**
+     * Whether evaluation runs apply this rule.
+     */
+    enabled: boolean;
+    created_at: string;
+    updated_at: string;
+};
+/**
+ * A resource type a freshness rule can cover.
+ */
+export type FreshnessRuleResourceType = 'artifact' | 'prompt' | 'blueprint' | 'memory';
+/**
+ * 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.
+ *
+ */
+export type FreshnessRuleMedium = 'web' | 'cli' | 'mcp';
+/**
+ * The team's freshness rules, oldest first.
+ */
+export type FreshnessRuleListResponse = {
+    /**
+     * Freshness rules. Serializes as `[]` when the team has none, never `null`.
+     */
+    rules: Array<FreshnessRule>;
+};
+/**
+ * Create a freshness rule.
+ */
+export type CreateFreshnessRuleRequest = {
+    /**
+     * Scope to one project; omit or send `null` for every project in the team.
+     */
+    project_id?: string | null;
+    resource_types: Array<FreshnessRuleResourceType>;
+    /**
+     * Omit or send an empty array to match any medium.
+     */
+    mediums?: Array<FreshnessRuleMedium>;
+    threshold_days: number;
+    /**
+     * Defaults to true when omitted.
+     */
+    enabled?: boolean;
+};
+/**
+ * Replace a freshness rule in full.
+ */
+export type UpdateFreshnessRuleRequest = {
+    /**
+     * Scope to one project; `null` means every project in the team.
+     */
+    project_id: string | null;
+    resource_types: Array<FreshnessRuleResourceType>;
+    /**
+     * An empty array matches any medium.
+     */
+    mediums: Array<FreshnessRuleMedium>;
+    threshold_days: number;
+    enabled: boolean;
+};
+/**
+ * The tunable freshness-evaluation values, shared by the current settings and the defaults.
+ */
+export type FreshnessSettingsValues = {
+    /**
+     * 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;
+    /**
+     * Whether accessing or editing a stale resource clears its stale state.
+     */
+    reversibility_enabled: boolean;
+};
+/**
+ * The freshness settings in effect for a team, with their provenance. A team that has never overridden them reports `source: instance` and the defaults.
+ *
+ */
+export type TeamFreshnessSettings = {
+    /**
+     * `team` when the team stores its own settings, `instance` when it inherits the defaults.
+     *
+     */
+    source: 'instance' | 'team';
+    interval_seconds: number;
+    reversibility_enabled: boolean;
+    /**
+     * The values a DELETE would restore. Present on every read so clients can preview a reset without a second call.
+     *
+     */
+    defaults: FreshnessSettingsValues;
+};
+/**
+ * Override the team's freshness settings.
+ */
+export type UpdateTeamFreshnessSettingsRequest = {
+    /**
+     * Rejected below 3600 (one hour) or above 31536000 (365 days).
+     */
+    interval_seconds: number;
+    reversibility_enabled: boolean;
+};
+/**
+ * The reporting window for a time-series metric. The options mirror the other analytics endpoints so one range selector drives every chart.
+ *
+ */
+export type FreshnessMetricsRange = '7d' | '14d' | '30d' | '60d' | '90d' | '180d';
+/**
+ * One calendar day (UTC) of freshness activity, zero-filled: every day in the window is present even when nothing happened.
+ *
+ */
+export type FreshnessDailyStaleCount = {
+    date: string;
+    /**
+     * Resources that became stale on this day.
+     */
+    marked: number;
+    /**
+     * Resources that stopped being stale on this day, for any reason.
+     */
+    cleared: number;
+    /**
+     * 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].
+     *
+     */
+    stale_total: number;
+    /**
+     * 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.
+     *
+     */
+    total: number;
+};
+export type FreshnessOverTimeMetricsData = {
+    range: FreshnessMetricsRange;
+    /**
+     * Resources marked stale across the whole window.
+     */
+    total_marked: number;
+    /**
+     * Resources cleared across the whole window.
+     */
+    total_cleared: number;
+    /**
+     * One entry per day in the window, oldest first. Serializes as `[]`, never `null`.
+     */
+    counts: Array<FreshnessDailyStaleCount>;
+};
+export type FreshnessOverTimeMetricsResponse = {
+    status: string;
+    message: string;
+    data: FreshnessOverTimeMetricsData;
+};
+/**
+ * How many of one resource type are stale right now.
+ */
+export type FreshnessTypeCount = {
+    resource_type: FreshnessRuleResourceType;
+    count: number;
+};
+export type FreshnessByTypeMetricsData = {
+    /**
+     * Total stale resources in the team, across every type.
+     */
+    total_stale: number;
+    /**
+     * 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: Array<FreshnessTypeCount>;
+};
+export type FreshnessByTypeMetricsResponse = {
+    status: string;
+    message: string;
+    data: FreshnessByTypeMetricsData;
+};
+/**
+ * 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.
+ *
+ */
+export type FreshnessProjectCount = {
+    project_id: string;
+    name: string;
+    slug: string;
+    count: number;
+};
+export type FreshnessByProjectMetricsData = {
+    total_stale: number;
+    /**
+     * One entry per project in the team, including projects with nothing stale (0), ordered by count descending then name. Serializes as `[]`, never `null`.
+     *
+     */
+    counts: Array<FreshnessProjectCount>;
+};
+export type FreshnessByProjectMetricsResponse = {
+    status: string;
+    message: string;
+    data: FreshnessByProjectMetricsData;
+};
+/**
+ * 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.
+ *
+ */
+export type FreshnessRuleImpact = {
+    rule_id: string;
+    /**
+     * The project the rule is scoped to, or null for every project in the team.
+     */
+    project_id: string | null;
+    resource_types: Array<FreshnessRuleResourceType>;
+    threshold_days: number;
+    /**
+     * A disabled rule reports 0 — it is listed so its absence from the chart is not mistaken for deletion.
+     */
+    enabled: boolean;
+    count: number;
+};
+export type FreshnessByRuleMetricsData = {
+    /**
+     * 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;
+    /**
+     * One entry per rule the team has defined, including rules matching nothing, ordered by count descending then rule id. Serializes as `[]`, never `null`.
+     *
+     */
+    counts: Array<FreshnessRuleImpact>;
+};
+export type FreshnessByRuleMetricsResponse = {
+    status: string;
+    message: string;
+    data: FreshnessByRuleMetricsData;
+};
+/**
+ * One recorded freshness transition. The log is append-only.
+ */
+export type FreshnessAuditEntry = {
+    id: string;
+    resource_type: FreshnessRuleResourceType;
+    resource_id: string;
+    /**
+     * 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;
+    /**
+     * Whether the resource became stale or stopped being stale.
+     */
+    action: 'marked' | 'cleared';
+    /**
+     * What caused it — a scheduled evaluation, a read, or an edit.
+     */
+    reason: 'rule_run' | 'accessed' | 'edited';
+    created_at: string;
+};
+/**
+ * A page of the team's freshness audit log, newest first.
+ */
+export type FreshnessAuditListResponse = {
+    /**
+     * Serializes as `[]` when the page is empty, never `null`.
+     */
+    entries: Array<FreshnessAuditEntry>;
+    /**
+     * Total entries in the team's log, ignoring pagination.
+     */
+    total_count: number;
+    /**
+     * Current page number (1-based)
+     */
+    page: number;
+    /**
+     * Number of entries per page
+     */
+    per_page: number;
+    /**
+     * Total number of pages
+     */
+    total_pages: number;
+};
 /**
  * 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.
  *
@@ -11962,6 +12273,481 @@ export type UpdateTeamSearchSettingsResponses = {
     200: TeamSearchSettings;
 };
 export type UpdateTeamSearchSettingsResponse = UpdateTeamSearchSettingsResponses[keyof UpdateTeamSearchSettingsResponses];
+export type ListFreshnessRulesData = {
+    body?: never;
+    path: {
+        /**
+         * Team identifier
+         */
+        team_id: string;
+    };
+    query?: never;
+    url: '/api/v1/{team_id}/freshness/rules';
+};
+export type ListFreshnessRulesErrors = {
+    /**
+     * Invalid team_id
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Caller is not a member of the team
+     */
+    403: ErrorResponse;
+    /**
+     * Failed to list the team's freshness rules
+     */
+    500: ErrorResponse;
+};
+export type ListFreshnessRulesError = ListFreshnessRulesErrors[keyof ListFreshnessRulesErrors];
+export type ListFreshnessRulesResponses = {
+    /**
+     * Rules retrieved successfully
+     */
+    200: FreshnessRuleListResponse;
+};
+export type ListFreshnessRulesResponse = ListFreshnessRulesResponses[keyof ListFreshnessRulesResponses];
+export type CreateFreshnessRuleData = {
+    body: CreateFreshnessRuleRequest;
+    path: {
+        /**
+         * Team identifier
+         */
+        team_id: string;
+    };
+    query?: never;
+    url: '/api/v1/{team_id}/freshness/rules';
+};
+export type CreateFreshnessRuleErrors = {
+    /**
+     * Invalid team_id or rule definition
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Caller may not change the team's settings
+     */
+    403: ErrorResponse;
+    /**
+     * Failed to create the freshness rule
+     */
+    500: ErrorResponse;
+};
+export type CreateFreshnessRuleError = CreateFreshnessRuleErrors[keyof CreateFreshnessRuleErrors];
+export type CreateFreshnessRuleResponses = {
+    /**
+     * Rule created successfully
+     */
+    201: FreshnessRule;
+};
+export type CreateFreshnessRuleResponse = CreateFreshnessRuleResponses[keyof CreateFreshnessRuleResponses];
+export type DeleteFreshnessRuleData = {
+    body?: never;
+    path: {
+        /**
+         * Team identifier
+         */
+        team_id: string;
+        /**
+         * Freshness rule identifier
+         */
+        rule_id: string;
+    };
+    query?: never;
+    url: '/api/v1/{team_id}/freshness/rules/{rule_id}';
+};
+export type DeleteFreshnessRuleErrors = {
+    /**
+     * Invalid identifiers
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Caller may not change the team's settings
+     */
+    403: ErrorResponse;
+    /**
+     * No such rule in this team
+     */
+    404: ErrorResponse;
+    /**
+     * Failed to delete the freshness rule
+     */
+    500: ErrorResponse;
+};
+export type DeleteFreshnessRuleError = DeleteFreshnessRuleErrors[keyof DeleteFreshnessRuleErrors];
+export type DeleteFreshnessRuleResponses = {
+    /**
+     * Rule deleted (no content)
+     */
+    204: void;
+};
+export type DeleteFreshnessRuleResponse = DeleteFreshnessRuleResponses[keyof DeleteFreshnessRuleResponses];
+export type UpdateFreshnessRuleData = {
+    body: UpdateFreshnessRuleRequest;
+    path: {
+        /**
+         * Team identifier
+         */
+        team_id: string;
+        /**
+         * Freshness rule identifier
+         */
+        rule_id: string;
+    };
+    query?: never;
+    url: '/api/v1/{team_id}/freshness/rules/{rule_id}';
+};
+export type UpdateFreshnessRuleErrors = {
+    /**
+     * Invalid identifiers or rule definition
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Caller may not change the team's settings
+     */
+    403: ErrorResponse;
+    /**
+     * No such rule in this team
+     */
+    404: ErrorResponse;
+    /**
+     * Failed to update the freshness rule
+     */
+    500: ErrorResponse;
+};
+export type UpdateFreshnessRuleError = UpdateFreshnessRuleErrors[keyof UpdateFreshnessRuleErrors];
+export type UpdateFreshnessRuleResponses = {
+    /**
+     * Rule updated successfully
+     */
+    200: FreshnessRule;
+};
+export type UpdateFreshnessRuleResponse = UpdateFreshnessRuleResponses[keyof UpdateFreshnessRuleResponses];
+export type ResetTeamFreshnessSettingsData = {
+    body?: never;
+    path: {
+        /**
+         * Team identifier
+         */
+        team_id: string;
+    };
+    query?: never;
+    url: '/api/v1/{team_id}/settings/freshness';
+};
+export type ResetTeamFreshnessSettingsErrors = {
+    /**
+     * Invalid team_id
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Caller may not change the team's settings
+     */
+    403: ErrorResponse;
+    /**
+     * Failed to reset the team's freshness settings
+     */
+    500: ErrorResponse;
+};
+export type ResetTeamFreshnessSettingsError = ResetTeamFreshnessSettingsErrors[keyof ResetTeamFreshnessSettingsErrors];
+export type ResetTeamFreshnessSettingsResponses = {
+    /**
+     * Settings reset (no content); the team now inherits the defaults
+     */
+    204: void;
+};
+export type ResetTeamFreshnessSettingsResponse = ResetTeamFreshnessSettingsResponses[keyof ResetTeamFreshnessSettingsResponses];
+export type GetTeamFreshnessSettingsData = {
+    body?: never;
+    path: {
+        /**
+         * Team identifier
+         */
+        team_id: string;
+    };
+    query?: never;
+    url: '/api/v1/{team_id}/settings/freshness';
+};
+export type GetTeamFreshnessSettingsErrors = {
+    /**
+     * Invalid team_id
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Caller is not a member of the team
+     */
+    403: ErrorResponse;
+    /**
+     * Failed to read the team's freshness settings
+     */
+    500: ErrorResponse;
+};
+export type GetTeamFreshnessSettingsError = GetTeamFreshnessSettingsErrors[keyof GetTeamFreshnessSettingsErrors];
+export type GetTeamFreshnessSettingsResponses = {
+    /**
+     * Settings retrieved successfully
+     */
+    200: TeamFreshnessSettings;
+};
+export type GetTeamFreshnessSettingsResponse = GetTeamFreshnessSettingsResponses[keyof GetTeamFreshnessSettingsResponses];
+export type UpdateTeamFreshnessSettingsData = {
+    body: UpdateTeamFreshnessSettingsRequest;
+    path: {
+        /**
+         * Team identifier
+         */
+        team_id: string;
+    };
+    query?: never;
+    url: '/api/v1/{team_id}/settings/freshness';
+};
+export type UpdateTeamFreshnessSettingsErrors = {
+    /**
+     * Invalid team_id or settings
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Caller may not change the team's settings
+     */
+    403: ErrorResponse;
+    /**
+     * Failed to update the team's freshness settings
+     */
+    500: ErrorResponse;
+};
+export type UpdateTeamFreshnessSettingsError = UpdateTeamFreshnessSettingsErrors[keyof UpdateTeamFreshnessSettingsErrors];
+export type UpdateTeamFreshnessSettingsResponses = {
+    /**
+     * Settings updated successfully
+     */
+    200: TeamFreshnessSettings;
+};
+export type UpdateTeamFreshnessSettingsResponse = UpdateTeamFreshnessSettingsResponses[keyof UpdateTeamFreshnessSettingsResponses];
+export type GetFreshnessOverTimeMetricsData = {
+    body?: never;
+    path: {
+        /**
+         * Team identifier
+         */
+        team_id: string;
+    };
+    query?: {
+        /**
+         * The reporting window. Defaults to 30d.
+         */
+        range?: FreshnessMetricsRange;
+    };
+    url: '/api/v1/{team_id}/freshness/metrics/over-time';
+};
+export type GetFreshnessOverTimeMetricsErrors = {
+    /**
+     * Invalid team_id or query parameter
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Caller is not a member of the team
+     */
+    403: ErrorResponse;
+    /**
+     * Failed to build the team's freshness over-time metrics
+     */
+    500: ErrorResponse;
+};
+export type GetFreshnessOverTimeMetricsError = GetFreshnessOverTimeMetricsErrors[keyof GetFreshnessOverTimeMetricsErrors];
+export type GetFreshnessOverTimeMetricsResponses = {
+    /**
+     * Metrics retrieved successfully
+     */
+    200: FreshnessOverTimeMetricsResponse;
+};
+export type GetFreshnessOverTimeMetricsResponse = GetFreshnessOverTimeMetricsResponses[keyof GetFreshnessOverTimeMetricsResponses];
+export type GetFreshnessByTypeMetricsData = {
+    body?: never;
+    path: {
+        /**
+         * Team identifier
+         */
+        team_id: string;
+    };
+    query?: never;
+    url: '/api/v1/{team_id}/freshness/metrics/by-type';
+};
+export type GetFreshnessByTypeMetricsErrors = {
+    /**
+     * Invalid team_id or query parameter
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Caller is not a member of the team
+     */
+    403: ErrorResponse;
+    /**
+     * Failed to build the team's freshness by-type metrics
+     */
+    500: ErrorResponse;
+};
+export type GetFreshnessByTypeMetricsError = GetFreshnessByTypeMetricsErrors[keyof GetFreshnessByTypeMetricsErrors];
+export type GetFreshnessByTypeMetricsResponses = {
+    /**
+     * Metrics retrieved successfully
+     */
+    200: FreshnessByTypeMetricsResponse;
+};
+export type GetFreshnessByTypeMetricsResponse = GetFreshnessByTypeMetricsResponses[keyof GetFreshnessByTypeMetricsResponses];
+export type GetFreshnessByProjectMetricsData = {
+    body?: never;
+    path: {
+        /**
+         * Team identifier
+         */
+        team_id: string;
+    };
+    query?: never;
+    url: '/api/v1/{team_id}/freshness/metrics/by-project';
+};
+export type GetFreshnessByProjectMetricsErrors = {
+    /**
+     * Invalid team_id or query parameter
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Caller is not a member of the team
+     */
+    403: ErrorResponse;
+    /**
+     * Failed to build the team's freshness by-project metrics
+     */
+    500: ErrorResponse;
+};
+export type GetFreshnessByProjectMetricsError = GetFreshnessByProjectMetricsErrors[keyof GetFreshnessByProjectMetricsErrors];
+export type GetFreshnessByProjectMetricsResponses = {
+    /**
+     * Metrics retrieved successfully
+     */
+    200: FreshnessByProjectMetricsResponse;
+};
+export type GetFreshnessByProjectMetricsResponse = GetFreshnessByProjectMetricsResponses[keyof GetFreshnessByProjectMetricsResponses];
+export type GetFreshnessByRuleMetricsData = {
+    body?: never;
+    path: {
+        /**
+         * Team identifier
+         */
+        team_id: string;
+    };
+    query?: never;
+    url: '/api/v1/{team_id}/freshness/metrics/by-rule';
+};
+export type GetFreshnessByRuleMetricsErrors = {
+    /**
+     * Invalid team_id or query parameter
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Caller is not a member of the team
+     */
+    403: ErrorResponse;
+    /**
+     * Failed to build the team's freshness by-rule metrics
+     */
+    500: ErrorResponse;
+};
+export type GetFreshnessByRuleMetricsError = GetFreshnessByRuleMetricsErrors[keyof GetFreshnessByRuleMetricsErrors];
+export type GetFreshnessByRuleMetricsResponses = {
+    /**
+     * Metrics retrieved successfully
+     */
+    200: FreshnessByRuleMetricsResponse;
+};
+export type GetFreshnessByRuleMetricsResponse = GetFreshnessByRuleMetricsResponses[keyof GetFreshnessByRuleMetricsResponses];
+export type ListFreshnessAuditData = {
+    body?: never;
+    path: {
+        /**
+         * Team identifier
+         */
+        team_id: string;
+    };
+    query?: {
+        /**
+         * 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;
+        /**
+         * Entries per page
+         */
+        limit?: number;
+    };
+    url: '/api/v1/{team_id}/freshness/audit';
+};
+export type ListFreshnessAuditErrors = {
+    /**
+     * Invalid team_id or query parameter
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Caller is not a member of the team
+     */
+    403: ErrorResponse;
+    /**
+     * Failed to list the team's freshness audit log
+     */
+    500: ErrorResponse;
+};
+export type ListFreshnessAuditError = ListFreshnessAuditErrors[keyof ListFreshnessAuditErrors];
+export type ListFreshnessAuditResponses = {
+    /**
+     * Audit log retrieved successfully
+     */
+    200: FreshnessAuditListResponse;
+};
+export type ListFreshnessAuditResponse = ListFreshnessAuditResponses[keyof ListFreshnessAuditResponses];
 export type ListEmbeddingProvidersSettingsData = {
     body?: never;
     path: {