@odigos/ui-kit 0.0.249 → 0.0.251

package/lib/contexts/odigos-api/types.d.ts

@@ -0,0 +1,831 @@
+/**
+ * Public types for the OdigosApiContext.
+ *
+ * The context provides a unified, host-agnostic API surface for all `_v2`
+ * containers in the kit. Each host app (odigos webapp, odigos-enterprise
+ * central-ui) supplies an `OdigosApiOperations` map (one entry per logical
+ * operation) plus an `ApolloConfig` describing how Apollo should be
+ * constructed. The kit owns Apollo end-to-end from there.
+ *
+ * The `Operation<TData, TVars>` shape is deliberately generic enough to
+ * support both:
+ *   - direct GraphQL execution (odigos webapp): `{ document: gql\`...\` }`
+ *   - REMOTE_FETCH-wrapped execution (central-ui): `{ document: REMOTE_FETCH,
+ *     transformVariables: (vars, ctx) => ({ proxyID, query: getVersionedQuery(...), variables: vars }),
+ *     transformResult: (raw) => parseJsonString(raw.remoteFetch).data }`
+ */
+import type { ReactNode } from 'react';
+import type { DocumentNode } from 'graphql';
+import type { InstrumentationRuleInputWire } from '@/functions/instrumentation-rule-source-scopes';
+import type { Action, ActionFormData, AllClusterSnapshots, ClusterSnapshot, ConfigYaml, CostReductionRule, CostReductionRuleInput, DataStream, DescribeOdigos, DescribeSource, Destination, DestinationFormData, DiagnoseFormData, EffectiveConfig, EffectiveConfigInput, EnableProfilingResult, ExtendedPodInfo, FetchedConfig, GatewayInfo, GetDestinationCategoriesResult, GetPotentialDestinationsResult, HighlyRelevantOperationRule, HighlyRelevantOperationRuleInput, InstrumentationRule, K8sResourceKind, LocalUiConfigInput, Metrics, Namespace, NoisyOperationRule, NoisyOperationRuleInput, NodeCollectoInfo, PlatformType, PodInfo, ProfilingSlots, SamplingRules, SamplingRulesK8sHealthConfig, ServiceMapSources, SourceFormData, SourceProfilingResult, TestConnectionResponse, Tier, TokenPayload, Workload, WorkloadId, PeerSources } from '@/types';
+import type { ApolloClient, ApolloLink, FetchPolicy, MutationFetchPolicy, NormalizedCacheObject, TypePolicies, WatchQueryFetchPolicy } from '@apollo/client';
+/**
+ * The execution context for a given operation, propagated through every
+ * `Operation.document(ctx)` / `transformVariables(vars, ctx)` /
+ * `transformResult(raw, ctx)` callback.
+ *
+ * Hosts update this context whenever the active proxy / version / tier
+ * changes (e.g. central-ui re-derives this from `useProxy()`).
+ */
+export interface OperationContext {
+    /** k8s | vm — used to pick a platform-specific GraphQL string in versioned-query maps. */
+    platformType: PlatformType;
+    /** community | onprem — used to gate enterprise-only capabilities. */
+    tier: Tier;
+    /** Backend / proxy version. Hosts that don't have proxies (odigos standalone) pass the local backend version. */
+    version: string;
+    /** Currently selected proxy id (central-ui only). Undefined when not applicable. */
+    proxyID?: string;
+    /**
+     * Whether the current user can perform writes. Hosts derive this from
+     * their own auth/role state (e.g. central-ui's `useConfig().isReadonly`,
+     * webapp's `useConfig().isReadonly`) and update the provider when it
+     * changes. Domain hooks use this to short-circuit mutations with a
+     * readonly warning toast.
+     */
+    isReadonly?: boolean;
+    /**
+     * Optional list of proxy/connection ids the current operation should
+     * fan out to. Set by `<OdigosApiConnectionsScope>` (used by bulk
+     * drawers in central-ui's `<CentralConnections>`). The host adapter
+     * reads this in `transformVariables` to route REMOTE_MULTI_FETCH
+     * across the selected clusters. Empty/undefined means "use proxyID".
+     */
+    connectionIds?: string[];
+}
+export interface MultiFetchResult<TData> {
+    proxyID: string;
+    success: boolean;
+    data?: TData;
+    error?: string;
+}
+export interface MultiFetchResponse<TData> {
+    error?: string;
+    results: MultiFetchResult<TData>[];
+    allSucceeded: boolean;
+    anySucceeded: boolean;
+    successCount: number;
+    failureCount: number;
+}
+/**
+ * Per-operation hook into version grouping for multi-cluster fan-out.
+ *
+ * Returned by `Operation.transformVariablesMulti` to allow the host to
+ * group target proxies by resolved-version and emit one Apollo call per
+ * group. The runner iterates these groups and merges results.
+ */
+export interface MultiFetchGroup {
+    /** The Apollo document to use for this group (e.g. REMOTE_MULTI_FETCH). */
+    document: DocumentNode;
+    /**
+     * Variables to send for this group. Apollo's `client.query({ variables })`
+     * accepts any keyed payload, and host adapters compose this freely (REMOTE_MULTI_FETCH,
+     * versioned variables, etc.) — typed as `Record<string, unknown>` so the
+     * runner doesn't pretend it knows the per-host shape but the field
+     * still has meaningful structure (key-value of unknown values, not raw `unknown`).
+     */
+    variables: Record<string, unknown>;
+    /** Proxy ids included in this group, in order. */
+    proxyIDs: string[];
+}
+/**
+ * A single logical operation. The host supplies one of these per
+ * `OdigosApiOperations` key. The kit calls these via `runner.ts`.
+ *
+ * Note on variance: the optional callbacks here are declared with
+ * **method-shorthand** syntax (`fn(args): R`) instead of the property
+ * form (`fn: (args) => R`). TypeScript checks method shorthand
+ * **bivariantly** rather than strictly contravariantly. This matters for
+ * `transformVariables(vars: TVars, ...)` and friends — without
+ * bivariance, a host adapter that supplies a tightly-typed
+ * `Operation<MyData, MyVars>` couldn't be assigned into the aggregate
+ * `OdigosApiOperations` slot (the assignment direction would fail strict
+ * contravariance on `TVars`). Method shorthand is the precise tool for
+ * this exact case and avoids any `any` in the operation surface.
+ */
+export interface Operation<TData = unknown, TVars = unknown> {
+    /**
+     * The Apollo document for single (non-fanout) execution.
+     * Pass a function when the document depends on the runtime context
+     * (e.g. central-ui resolves a versioned-query map per `ctx.version`).
+     * Returning undefined from the function aborts the call with an
+     * "operation not supported in this context" error.
+     */
+    document: DocumentNode | ((ctx: OperationContext) => DocumentNode | undefined);
+    /**
+     * Optional document used by `fetchMulti` (multi-cluster fan-out).
+     * Only present in central-ui's adapter (REMOTE_MULTI_FETCH).
+     * When omitted, `fetchMulti` falls back to N sequential `document` calls.
+     */
+    documentMulti?: DocumentNode | ((ctx: OperationContext) => DocumentNode | undefined);
+    /**
+     * Massage raw variables before they're sent. Returns the wire-shaped
+     * variables object — typed as `Record<string, unknown>` so adapter
+     * authors can construct any shape Apollo accepts without an `any`
+     * cast escape hatch. Use `vars: TVars` (the slot's typed input)
+     * inside the body and produce the wire-side shape.
+     */
+    transformVariables?(vars: TVars, ctx: OperationContext): Record<string, unknown>;
+    /**
+     * Group target proxy ids and produce one or more `{ document, variables, proxyIDs }`
+     * groups. Used by central-ui to split fan-out by proxy version.
+     */
+    transformVariablesMulti?(proxyIDs: string[], vars: TVars | undefined, ctx: OperationContext): MultiFetchGroup[];
+    /**
+     * Massage the raw Apollo response before it reaches the consumer.
+     *
+     * `raw` is typed `unknown` because Apollo's response is opaque to
+     * the kit — the adapter is the only place that knows the wire
+     * shape. Cast at the boundary (e.g. `(raw as { x?: T })?.x`) and
+     * return the slot's `TData`. The consumer always sees the typed
+     * `TData`, never `unknown`.
+     */
+    transformResult?(raw: unknown, ctx: OperationContext): TData | undefined;
+    /** Massage the raw Apollo response into per-proxy multi-fetch results. */
+    transformMultiResult?(raw: unknown, ctx: OperationContext): MultiFetchResult<TData>[];
+    /**
+     * Optional override of the ApolloClient this single operation runs against.
+     *
+     * The provider mounts one default client (built from `ApolloConfig`); when
+     * an operation supplies its own `client`, the runner uses it instead of
+     * the default. Use this when an operation needs to talk to a *different*
+     * GraphQL endpoint than the rest of the kit — e.g. a fully-constructed
+     * `ApolloClient` from `@odigos/vmagent-api-apollo-client` that connects
+     * directly to a vm-agent rather than going through the central proxy, or
+     * a separate cloud-provider GraphQL service for cloud-platform sources.
+     *
+     * The host can also achieve this with Apollo's `ApolloLink.split` on the
+     * default client, but per-operation overrides keep the routing rule
+     * colocated with the operation it applies to (and avoid pushing
+     * platform-aware splitter logic into the link layer).
+     */
+    client?: ApolloClient<unknown>;
+    /**
+     * Optional precondition guard. When provided and it returns `false`
+     * for the current context, the operation is treated as not runnable:
+     *
+     *   - `useApiQuery` / `useApiLazyQuery` `skip` the query (no network
+     *     request, no active Apollo observer).
+     *   - The imperative `runQuery` / `runMutation` short-circuit and
+     *     resolve to `{ data: undefined }` with no error (so domain
+     *     hooks don't surface a spurious failure toast).
+     *
+     * This is the kit-level hook for "don't dispatch this operation
+     * until its required context exists". central-ui uses it to gate
+     * every `REMOTE_FETCH`-backed operation on `ctx.proxyID`: on
+     * out-of-proxy pages (`/connections`, `/access-management`, …) there
+     * is no selected proxy, so firing a remote operation would send an
+     * empty `RemoteFetch` (missing `proxyID` + `query`) that the backend
+     * rejects. Guarding here keeps those requests from ever leaving the
+     * client.
+     *
+     * The multi-cluster fan-out path (`runMulti` /
+     * `transformVariablesMulti`) does NOT consult `canRun` — it's scoped
+     * explicitly by the supplied `proxyIDs`, so connections-scope bulk
+     * drawers keep working even though `ctx.proxyID` is empty there.
+     */
+    canRun?(ctx: OperationContext): boolean;
+}
+/** Variables for `GET_WORKLOADS` — optionally filter by instrumentation flag. */
+export interface GetWorkloadsVars {
+    filter?: {
+        markedForInstrumentation?: boolean;
+    };
+}
+/** Result of `GET_WORKLOADS`. */
+export interface GetWorkloadsData {
+    workloads: Workload[];
+}
+/** Variables for `GET_WORKLOADS_BY_IDS` (and `_SLIM`). */
+export interface GetWorkloadsByIdsVars {
+    ids: WorkloadId[];
+}
+/** Result of `GET_WORKLOADS_BY_IDS`. */
+export interface GetWorkloadsByIdsData {
+    workloadsByIds: Workload[];
+}
+/** Variables for the slim source library lookup. */
+export type GetSourceLibrariesVars = WorkloadId;
+/** Result envelope for `GET_SOURCE_LIBRARIES` (instrumentation instance components). */
+export interface GetSourceLibrariesData {
+    instrumentationInstanceComponents?: {
+        name: string;
+        nonIdentifyingAttributes?: {
+            key: string;
+            value: string;
+        }[];
+    }[];
+}
+/** Variables for the peer-sources query (used by service map). */
+export interface GetPeerSourcesVars {
+    serviceName: string;
+}
+/** Wire-shape of the bulk source-instrumentation persist mutation. */
+export interface PersistSourcesVars {
+    sources: {
+        namespace: string;
+        name: string;
+        kind: K8sResourceKind | '';
+        selected: boolean;
+        currentStreamName: string;
+    }[];
+}
+/** Wire-shape of the bulk namespace-instrumentation persist mutation. */
+export interface PersistNamespacesVars {
+    namespaces: {
+        namespace: string;
+        selected: boolean;
+        currentStreamName: string;
+    }[];
+}
+/** Variables for `UPDATE_SOURCE`. */
+export interface UpdateSourceVars {
+    sourceId: WorkloadId;
+    patchSourceRequest: SourceFormData & {
+        currentStreamName: string;
+    };
+}
+/** Variables for `RESTART_WORKLOADS`. */
+export interface RestartWorkloadsVars {
+    sourceIds: WorkloadId[];
+}
+/** Variables for `RESTART_POD`. */
+export interface RestartPodVars {
+    namespace: string;
+    name: string;
+}
+/** Variables for `RECOVER_FROM_ROLLBACK`. */
+export interface RecoverFromRollbackVars {
+    sourceId: WorkloadId;
+}
+/**
+ * `GET_DESTINATIONS` envelope — central-ui returns `{ computePlatform: { … } }`,
+ * standalone webapp returns a flat shape. Both supported.
+ */
+export interface GetDestinationsData {
+    computePlatform?: {
+        destinations?: Destination[];
+    };
+    destinations?: Destination[];
+}
+/**
+ * Wire-form of a destination form payload. `DestinationFormData.fields`
+ * is `{ key: string; value: unknown }[]` in the kit; the wire form
+ * narrows `value` to `string` (the kit pre-stringifies in
+ * `prepareDestinationFormData`).
+ */
+export interface DestinationWireInput extends Omit<DestinationFormData, 'fields'> {
+    fields: {
+        key: string;
+        value: string;
+    }[];
+}
+export interface CreateDestinationVars {
+    destination: DestinationWireInput;
+}
+export interface UpdateDestinationVars {
+    id: string;
+    destination: DestinationWireInput;
+}
+export interface UpdateDestinationData {
+    updateDestination: {
+        id: string;
+    };
+}
+export interface DeleteDestinationVars {
+    id: string;
+    currentStreamName: string;
+}
+export interface TestDestinationConnectionVars {
+    destination: DestinationWireInput;
+}
+/** Generic list envelope for backends that nest under `computePlatform`. */
+export interface GetActionsData {
+    computePlatform?: {
+        actions?: Action[];
+    };
+    actions?: Action[];
+}
+export interface CreateActionVars {
+    action: ActionFormData;
+}
+export interface UpdateActionVars {
+    id: string;
+    action: ActionFormData;
+}
+export interface DeleteActionVars {
+    id: string;
+    /** The action's `type` (e.g. `K8sAttributes`, `AddClusterInfo`). The wire
+     * mutation requires both `id` and `actionType` so the server knows which
+     * CRD type to delete — they come from different parts of the underlying
+     * resource graph and aren't derivable from the `id` alone. */
+    actionType: string;
+}
+export interface GetInstrumentationRulesData {
+    computePlatform?: {
+        instrumentationRules?: InstrumentationRule[];
+    };
+    instrumentationRules?: InstrumentationRule[];
+}
+/**
+ * Wire-shape vars for `CREATE_INSTRUMENTATION_RULE`. The kit's
+ * spec-shape `InstrumentationRuleFormData` uses `sourceScopes` (folded
+ * tri-list); the wire's `InstrumentationRuleInput` uses `sourcesScopes`
+ * (row array) — so the slot's `TVars` declares the wire type
+ * `InstrumentationRuleInputWire`. The kit's `useInstrumentationRulesApi` runs
+ * `adaptInstrumentationRuleInputForWire(input)` (in `@/functions/instrumentation-rule-source-scopes`)
+ * to convert the consumer-side spec input to this wire input before dispatch.
+ */
+export interface CreateInstrumentationRuleVars {
+    instrumentationRule: InstrumentationRuleInputWire;
+}
+export interface UpdateInstrumentationRuleVars {
+    ruleId: string;
+    instrumentationRule: InstrumentationRuleInputWire;
+}
+export interface DeleteInstrumentationRuleVars {
+    ruleId: string;
+}
+export interface GetDataStreamsData {
+    computePlatform?: {
+        dataStreams?: DataStream[];
+    };
+    dataStreams?: DataStream[];
+}
+export interface CreateDataStreamVars {
+    stream: DataStream;
+}
+export interface UpdateDataStreamVars {
+    /** Wire variable name is `$id`; the data stream's name doubles as its id. */
+    id: string;
+    /** Wire variable name is `$dataStream` — the new stream payload. */
+    dataStream: DataStream;
+}
+export interface DeleteDataStreamVars {
+    /** Wire variable name is `$id`; the data stream's name doubles as its id. */
+    id: string;
+}
+/**
+ * `GET_NAMESPACES_WITH_WORKLOADS` returns the namespaces flat at the
+ * root (the legacy `computePlatform.k8sActualNamespaces` shape was
+ * replaced with a top-level `namespaces` field as of v1.20). Adapters
+ * that talk to the legacy schema should `transformResult` into this
+ * shape; the kit's hook reads `data.namespaces` directly.
+ */
+export interface GetNamespacesWithWorkloadsData {
+    namespaces?: Namespace[];
+}
+export interface GetNamespaceVars {
+    namespaceName: string;
+}
+/** Variables for `GET_K8S_MANIFEST`. */
+export interface GetK8sManifestVars {
+    kind: K8sResourceKind | string;
+    name: string;
+    namespace?: string;
+    ext?: 'yaml' | 'json';
+}
+/**
+ * `GET_K8S_MANIFEST` returns the manifest YAML / JSON as a single
+ * string. Hosts whose wire shape is `{ k8sActualManifest: string }` or
+ * `{ manifest: string }` MUST flatten it inside `Operation.transformResult`
+ * (or via the central-ui adapter's `wrapRemote(..., extract)`) so
+ * containers see the canonical bare-string shape.
+ */
+export type GetK8sManifestData = string;
+export interface GetEffectiveConfigVars {
+    id?: string;
+}
+export interface GetConfigYamlsData {
+    configYamls: ConfigYaml[];
+}
+export interface UpdateRemoteConfigVars {
+    formData: Partial<EffectiveConfigInput>;
+    connectionIds: string[];
+}
+export interface DescribeOdigosData {
+    describeOdigos: DescribeOdigos;
+}
+export interface DescribeSourceData {
+    describeSource: DescribeSource;
+}
+/**
+ * Server response for `GET_DIAGNOSE`. Mirrors the GraphQL `Diagnose`
+ * type returned by `diagnose(input, dryRun)`. The actual download URL
+ * (if the diagnose was kicked off in non-dry-run mode) is propagated
+ * via SSE / progress store, not through this response.
+ */
+export interface DiagnoseResult {
+    stats?: {
+        fileCount: number;
+        totalSizeBytes: number;
+        totalSizeHuman: string;
+    };
+    includeProfiles?: boolean;
+    includeMetrics?: boolean;
+    includeSourceWorkloads?: boolean;
+    sourceWorkloadNamespaces?: string[];
+}
+export interface DiagnoseEnvelope {
+    diagnose?: DiagnoseResult;
+}
+/**
+ * Variables for `GET_DIAGNOSE` — wire mutation declares
+ * `($input: DiagnoseInput!, $dryRun: Boolean)`, so the form data is
+ * wrapped under `input`. The `useDescribeApi.downloadDiagnose(...)`
+ * helper takes the bare `DiagnoseFormData` and wraps it for the
+ * caller; only the slot type uses this wire-shaped variant.
+ */
+export interface DiagnoseVars {
+    input: DiagnoseFormData;
+    dryRun?: boolean;
+}
+/**
+ * @deprecated The `GET_TOKENS` slot now returns a bare `TokenPayload[]`
+ * — adapters whose wire shape is `{ tokens } | { computePlatform: { tokens } }`
+ * MUST flatten via `Operation.transformResult` (or `wrapRemote`'s
+ * `extract` callback). Kept exported for adapter authors that want to
+ * type the wire envelope explicitly inside their extract function.
+ */
+export interface GetTokensData {
+    tokens?: TokenPayload[];
+    computePlatform?: {
+        tokens?: TokenPayload[];
+    };
+}
+export interface UpdateTokenVars {
+    token: string;
+}
+export interface GetMetricsData {
+    getOverviewMetrics?: Metrics;
+}
+export interface GetServiceMapData {
+    serviceMap?: ServiceMapSources;
+}
+export interface GetProfilingSlotsData {
+    profilingSlots?: ProfilingSlots;
+}
+export interface GetSourceProfilingData {
+    sourceProfiling?: SourceProfilingResult;
+}
+export interface EnableSourceProfilingData {
+    enableSourceProfiling?: EnableProfilingResult;
+}
+export interface GetGatewayInfoData {
+    gatewayInfo?: GatewayInfo;
+}
+export interface GetGatewayPodsData {
+    gatewayPods?: PodInfo[];
+}
+export interface GetNodeCollectorInfoData {
+    nodeCollectorInfo?: NodeCollectoInfo;
+}
+export interface GetNodeCollectorPodsData {
+    nodeCollectorPods?: PodInfo[];
+}
+export interface GetCollectorPodInfoVars {
+    namespace: string;
+    name: string;
+}
+export interface GetCollectorPodInfoData {
+    extendedPodInfo?: ExtendedPodInfo;
+}
+export interface GetSamplingRulesData {
+    samplingRules?: SamplingRules[];
+    k8sHealthProbesConfig?: SamplingRulesK8sHealthConfig;
+    computePlatform?: {
+        samplingRules?: SamplingRules[];
+        k8sHealthProbesConfig?: SamplingRulesK8sHealthConfig;
+    };
+}
+export interface SamplingRuleCreateVars<TInput> {
+    samplingId: string;
+    rule: TInput;
+}
+export interface SamplingRuleUpdateVars<TInput> {
+    samplingId: string;
+    ruleId: string;
+    rule: TInput;
+}
+export interface SamplingRuleDeleteVars {
+    samplingId: string;
+    ruleId: string;
+}
+/**
+ * The wire `SamplingConfigInput` shape — the inner config payload
+ * that `UpdateLocalUiSamplingConfigVars.config` carries.
+ */
+export interface SamplingK8sHealthConfigInput {
+    enabled: boolean;
+    keepPercentage: number;
+}
+/**
+ * @deprecated alias retained for any host code that imported the old
+ * inner-config name. Prefer `SamplingK8sHealthConfigInput` for the
+ * inner shape, or `UpdateLocalUiSamplingConfigVars` for the wire vars.
+ */
+export type SamplingK8sHealthConfigVars = SamplingK8sHealthConfigInput;
+/**
+ * Variables for `UPDATE_LOCAL_UI_CONFIG` — wire mutation requires
+ * the input wrapped under `$config: LocalUiConfigInput!`.
+ */
+export interface UpdateLocalUiConfigVars {
+    config: LocalUiConfigInput;
+}
+/**
+ * Variables for `UPDATE_LOCAL_UI_SAMPLING_CONFIG` — wire mutation
+ * requires the input wrapped under `$config: SamplingConfigInput`.
+ */
+export interface UpdateLocalUiSamplingConfigVars {
+    config: SamplingK8sHealthConfigInput;
+}
+export interface GetClusterSnapshotVars {
+    clusterId: string;
+}
+export interface GetAllClusterSnapshotsData {
+    allClusterSnapshots?: AllClusterSnapshots;
+}
+export interface GetClusterSnapshotData {
+    clusterSnapshot?: ClusterSnapshot;
+}
+export interface PersistSourcesResult {
+    persistK8sSources: boolean;
+}
+export interface CreateDestinationResult {
+    createNewDestination: Destination;
+}
+export interface DeleteDestinationResult {
+    deleteDestination: boolean;
+}
+export interface CreateActionResult {
+    createAction: Action;
+}
+export interface UpdateActionResult {
+    updateAction: Action;
+}
+export interface DeleteActionResult {
+    deleteAction: boolean;
+}
+export interface CreateInstrumentationRuleResult {
+    createInstrumentationRule: InstrumentationRule;
+}
+export interface UpdateInstrumentationRuleResult {
+    updateInstrumentationRule: InstrumentationRule;
+}
+export interface DeleteInstrumentationRuleResult {
+    deleteInstrumentationRule: boolean;
+}
+export interface CreateDataStreamResult {
+    createDataStream: DataStream;
+}
+export interface UpdateDataStreamResult {
+    updateDataStream: DataStream;
+}
+export interface DeleteDataStreamResult {
+    deleteDataStream: boolean;
+}
+export interface PersistNamespacesResult {
+    persistK8sNamespaces: boolean;
+}
+export interface UpdateRemoteConfigResult {
+    updateRemoteConfig: boolean;
+}
+export interface UpdateLocalUiConfigResult {
+    updateLocalUiConfig: boolean;
+}
+export interface ResetLocalUiConfigResult {
+    resetLocalUiConfigToFactoryDefaults: boolean;
+}
+export interface UpdateTokenResult {
+    updateApiToken: boolean;
+}
+export interface CreateNoisyOperationRuleResult {
+    createNoisyOperationRule: NoisyOperationRule;
+}
+export interface UpdateNoisyOperationRuleResult {
+    updateNoisyOperationRule: NoisyOperationRule;
+}
+export interface DeleteNoisyOperationRuleResult {
+    deleteNoisyOperationRule: boolean;
+}
+export interface CreateHighlyRelevantOperationRuleResult {
+    createHighlyRelevantOperationRule: HighlyRelevantOperationRule;
+}
+export interface UpdateHighlyRelevantOperationRuleResult {
+    updateHighlyRelevantOperationRule: HighlyRelevantOperationRule;
+}
+export interface DeleteHighlyRelevantOperationRuleResult {
+    deleteHighlyRelevantOperationRule: boolean;
+}
+export interface CreateCostReductionRuleResult {
+    createCostReductionRule: CostReductionRule;
+}
+export interface UpdateCostReductionRuleResult {
+    updateCostReductionRule: CostReductionRule;
+}
+export interface DeleteCostReductionRuleResult {
+    deleteCostReductionRule: boolean;
+}
+export interface UpdateLocalUiSamplingConfigResult {
+    updateLocalUiSamplingConfig: boolean;
+}
+export interface SourceConditionEntry {
+    namespace: string;
+    name: string;
+    kind: string;
+    conditions: {
+        status: string;
+        type: string;
+        reason: string;
+        message: string;
+    }[];
+}
+export interface GetSourceConditionsData {
+    sourceConditions: SourceConditionEntry[];
+}
+export interface OdigosApiOperations {
+    GET_WORKLOADS: Operation<GetWorkloadsData, GetWorkloadsVars | undefined>;
+    GET_WORKLOADS_BY_IDS: Operation<GetWorkloadsByIdsData, GetWorkloadsByIdsVars>;
+    GET_WORKLOADS_BY_IDS_SLIM?: Operation<GetWorkloadsByIdsData, GetWorkloadsByIdsVars>;
+    GET_SOURCE: Operation<{
+        source?: Workload;
+    }, WorkloadId>;
+    /** central-ui only, legacy <v1.20 path */
+    GET_SOURCES?: Operation<GetWorkloadsData, GetWorkloadsVars | undefined>;
+    /** central-ui only, legacy <v1.20 path */
+    GET_SOURCE_CONDITIONS?: Operation<GetSourceConditionsData, WorkloadId>;
+    GET_SOURCE_LIBRARIES: Operation<GetSourceLibrariesData, GetSourceLibrariesVars>;
+    GET_PEER_SOURCES: Operation<{
+        peerSources?: PeerSources;
+    }, GetPeerSourcesVars>;
+    PERSIST_SOURCES: Operation<PersistSourcesResult, PersistSourcesVars>;
+    UPDATE_SOURCE: Operation<{
+        updateK8sActualSource: boolean;
+    }, UpdateSourceVars>;
+    RESTART_WORKLOADS: Operation<{
+        restartWorkloads: boolean;
+    }, RestartWorkloadsVars>;
+    RESTART_POD: Operation<{
+        restartPod: boolean;
+    }, RestartPodVars>;
+    RECOVER_FROM_ROLLBACK: Operation<{
+        recoverFromRollbackForWorkload: boolean;
+    }, RecoverFromRollbackVars>;
+    GET_DESTINATIONS: Operation<GetDestinationsData, undefined>;
+    GET_DESTINATION_CATEGORIES: Operation<GetDestinationCategoriesResult, undefined>;
+    GET_POTENTIAL_DESTINATIONS: Operation<GetPotentialDestinationsResult, undefined>;
+    CREATE_DESTINATION: Operation<CreateDestinationResult, CreateDestinationVars>;
+    UPDATE_DESTINATION: Operation<UpdateDestinationData, UpdateDestinationVars>;
+    DELETE_DESTINATION: Operation<DeleteDestinationResult, DeleteDestinationVars>;
+    TEST_DESTINATION_CONNECTION: Operation<TestConnectionResponse, TestDestinationConnectionVars>;
+    GET_ACTIONS: Operation<GetActionsData, undefined>;
+    CREATE_ACTION: Operation<CreateActionResult, CreateActionVars>;
+    UPDATE_ACTION: Operation<UpdateActionResult, UpdateActionVars>;
+    DELETE_ACTION: Operation<DeleteActionResult, DeleteActionVars>;
+    GET_INSTRUMENTATION_RULES: Operation<GetInstrumentationRulesData, undefined>;
+    CREATE_INSTRUMENTATION_RULE: Operation<CreateInstrumentationRuleResult, CreateInstrumentationRuleVars>;
+    UPDATE_INSTRUMENTATION_RULE: Operation<UpdateInstrumentationRuleResult, UpdateInstrumentationRuleVars>;
+    DELETE_INSTRUMENTATION_RULE: Operation<DeleteInstrumentationRuleResult, DeleteInstrumentationRuleVars>;
+    GET_DATA_STREAMS: Operation<GetDataStreamsData, undefined>;
+    /** odigos webapp only — central-ui uses UPDATE_DATA_STREAM with a synthetic input for create */
+    CREATE_DATA_STREAM?: Operation<CreateDataStreamResult, CreateDataStreamVars>;
+    UPDATE_DATA_STREAM: Operation<UpdateDataStreamResult, UpdateDataStreamVars>;
+    DELETE_DATA_STREAM: Operation<DeleteDataStreamResult, DeleteDataStreamVars>;
+    GET_NAMESPACES_WITH_WORKLOADS: Operation<GetNamespacesWithWorkloadsData, undefined>;
+    /** central-ui legacy <v1.20 path */
+    GET_NAMESPACES?: Operation<GetNamespacesWithWorkloadsData, undefined>;
+    /** central-ui legacy <v1.20 path */
+    GET_NAMESPACE?: Operation<{
+        namespace?: Namespace;
+    }, GetNamespaceVars>;
+    PERSIST_NAMESPACES: Operation<PersistNamespacesResult, PersistNamespacesVars>;
+    GET_K8S_MANIFEST: Operation<GetK8sManifestData, GetK8sManifestVars>;
+    GET_CONFIG?: Operation<FetchedConfig, undefined>;
+    GET_EFFECTIVE_CONFIG?: Operation<EffectiveConfig, GetEffectiveConfigVars>;
+    GET_CONFIG_YAMLS?: Operation<GetConfigYamlsData, undefined>;
+    UPDATE_REMOTE_CONFIG?: Operation<UpdateRemoteConfigResult, UpdateRemoteConfigVars>;
+    UPDATE_LOCAL_UI_CONFIG?: Operation<UpdateLocalUiConfigResult, UpdateLocalUiConfigVars>;
+    RESET_LOCAL_UI_CONFIG_TO_FACTORY_DEFAULTS?: Operation<ResetLocalUiConfigResult, undefined>;
+    GET_DESCRIBE_ODIGOS?: Operation<DescribeOdigosData, undefined>;
+    GET_DESCRIBE_SOURCE?: Operation<DescribeSourceData, WorkloadId>;
+    GET_DIAGNOSE?: Operation<DiagnoseResult, DiagnoseVars>;
+    GET_TOKENS?: Operation<TokenPayload[], undefined>;
+    UPDATE_TOKEN?: Operation<UpdateTokenResult, UpdateTokenVars>;
+    GET_METRICS: Operation<GetMetricsData, undefined>;
+    GET_SERVICE_MAP?: Operation<GetServiceMapData, undefined>;
+    GET_PROFILING_SLOTS?: Operation<ProfilingSlots, undefined>;
+    GET_SOURCE_PROFILING?: Operation<SourceProfilingResult, WorkloadId>;
+    ENABLE_SOURCE_PROFILING?: Operation<EnableProfilingResult, WorkloadId>;
+    GET_GATEWAY_INFO?: Operation<GatewayInfo, undefined>;
+    GET_GATEWAY_PODS?: Operation<PodInfo[], undefined>;
+    GET_NODE_COLLECTOR_INFO?: Operation<NodeCollectoInfo, undefined>;
+    GET_NODE_COLLECTOR_PODS?: Operation<PodInfo[], undefined>;
+    GET_COLLECTOR_POD_INFO?: Operation<ExtendedPodInfo, GetCollectorPodInfoVars>;
+    GET_SAMPLING_RULES?: Operation<GetSamplingRulesData, undefined>;
+    CREATE_NOISY_OPERATION_RULE?: Operation<CreateNoisyOperationRuleResult, SamplingRuleCreateVars<NoisyOperationRuleInput>>;
+    UPDATE_NOISY_OPERATION_RULE?: Operation<UpdateNoisyOperationRuleResult, SamplingRuleUpdateVars<NoisyOperationRuleInput>>;
+    DELETE_NOISY_OPERATION_RULE?: Operation<DeleteNoisyOperationRuleResult, SamplingRuleDeleteVars>;
+    CREATE_HIGHLY_RELEVANT_OPERATION_RULE?: Operation<CreateHighlyRelevantOperationRuleResult, SamplingRuleCreateVars<HighlyRelevantOperationRuleInput>>;
+    UPDATE_HIGHLY_RELEVANT_OPERATION_RULE?: Operation<UpdateHighlyRelevantOperationRuleResult, SamplingRuleUpdateVars<HighlyRelevantOperationRuleInput>>;
+    DELETE_HIGHLY_RELEVANT_OPERATION_RULE?: Operation<DeleteHighlyRelevantOperationRuleResult, SamplingRuleDeleteVars>;
+    CREATE_COST_REDUCTION_RULE?: Operation<CreateCostReductionRuleResult, SamplingRuleCreateVars<CostReductionRuleInput>>;
+    UPDATE_COST_REDUCTION_RULE?: Operation<UpdateCostReductionRuleResult, SamplingRuleUpdateVars<CostReductionRuleInput>>;
+    DELETE_COST_REDUCTION_RULE?: Operation<DeleteCostReductionRuleResult, SamplingRuleDeleteVars>;
+    UPDATE_LOCAL_UI_SAMPLING_CONFIG?: Operation<UpdateLocalUiSamplingConfigResult, UpdateLocalUiSamplingConfigVars>;
+    GET_ALL_CLUSTER_SNAPSHOTS?: Operation<AllClusterSnapshots, undefined>;
+    GET_CLUSTER_SNAPSHOT?: Operation<ClusterSnapshot, GetClusterSnapshotVars>;
+}
+/**
+ * The host's Apollo configuration. The kit constructs the ApolloClient
+ * from this shape, attaching auth/CSRF/error/SSR concerns the host
+ * passes in as callbacks. Keeps host-specific wire-format concerns in
+ * the host while letting the kit own usage.
+ */
+export interface ApolloConfig {
+    /** GraphQL HTTP endpoint. Required. */
+    httpUrl: string;
+    /**
+     * Optional WebSocket link for GraphQL subscriptions (e.g. `GraphQLWsLink`).
+     * The host constructs this — keeps `graphql-ws` out of the kit's dep tree.
+     */
+    wsLink?: ApolloLink;
+    /** Cookie credentials policy (defaults to 'same-origin'). */
+    credentials?: 'include' | 'same-origin' | 'omit';
+    /**
+     * Returns auth headers to attach to every request. May be sync or async.
+     * Used by central-ui for `Authorization: Bearer <token>` from the user store.
+     */
+    authHeader?: () => Record<string, string> | Promise<Record<string, string>>;
+    /**
+     * Returns CSRF headers to attach to every request. Used by odigos webapp.
+     * The webapp adapter resolves the CSRF token before mounting the provider,
+     * then `csrfHeader` returns the cached value synchronously.
+     */
+    csrfHeader?: () => Record<string, string>;
+    /**
+     * Called when an Apollo error is detected as an auth failure (401 or
+     * known auth-error message). Hosts use this to clear local user state
+     * and redirect to the sign-in page.
+     */
+    onAuthError?: () => void;
+    /**
+     * When true, the kit uses Apollo's Next.js SSR multipart link in the
+     * server-side branch. The webapp adapter sets this; central-ui does not.
+     * Apollo Next.js support requires `@apollo/experimental-nextjs-app-support`
+     * to be available — the host imports it and passes through `ssrAppProvider`.
+     */
+    ssr?: boolean;
+    /**
+     * When `ssr: true` and the host wants Next.js's `ApolloNextAppProvider`
+     * wrapping, supply the wrapper component here. The kit will mount it
+     * at the appropriate level.
+     */
+    ssrAppProvider?: (props: {
+        makeClient: () => unknown;
+        children?: ReactNode;
+    }) => ReactNode;
+    /**
+     * Optional override for `InMemoryCache.addTypename`. Defaults to true.
+     * webapp historically uses `addTypename: false`; central-ui uses default.
+     */
+    addTypename?: boolean;
+    /** Optional `InMemoryCache` type policies. */
+    cacheTypePolicies?: TypePolicies;
+    /** Optional override for default fetch policies. */
+    defaultFetchPolicies?: {
+        watchQuery?: WatchQueryFetchPolicy;
+        query?: FetchPolicy;
+        mutate?: MutationFetchPolicy;
+    };
+    /**
+     * Extra Apollo links composed into the chain (before HTTP/WS).
+     * Hosts can pass observability links, retry links, etc.
+     */
+    additionalLinks?: ApolloLink[];
+}
+export interface OdigosApiProviderProps {
+    apolloConfig: ApolloConfig;
+    operations: OdigosApiOperations;
+    /** Initial operation context. Hosts re-render with a new context whenever the active proxy/version changes. */
+    context: OperationContext;
+    children?: ReactNode;
+}
+export type ApolloCacheShape = NormalizedCacheObject;
+/**
+ * The minimal value the inner provider exposes — used by per-domain hooks
+ * via `useOdigosApiInternal()`.
+ */
+export interface OdigosApiInternalValue {
+    operations: OdigosApiOperations;
+    context: OperationContext;
+    /**
+     * Apollo + transport configuration propagated from
+     * `<OdigosApiProvider apolloConfig={…}>`. Exposed on the internal
+     * context so domain hooks that need to talk to non-GraphQL endpoints
+     * on the same host (e.g. the diagnose archive download) can re-use
+     * the host's `httpUrl` origin, credentials policy, auth headers,
+     * and CSRF headers — without forcing the host to wire a separate
+     * helper for each REST round-trip.
+     */
+    apolloConfig: ApolloConfig;
+}