/**
 * Log10x API client — **USER-ACTION SURFACE** (api_key / `X-10X-Auth`).
 *
 * Every request out of this file authenticates with the user's api_key
 * (composed as `<apiKey>/<envId>` for env-scoped calls, or `<apiKey>`
 * for user-scoped ones). This is the user-action half of the gateway's
 * two-surface auth model — **don't reach for the license JWT or an
 * Auth0 Bearer token here**; the `tenx_api_authorizer` will reject them.
 *
 * For engine credentials (license JWT) see `./license-api.ts`. For the
 * Auth0-token → api_key mint that bootstraps this surface see
 * `./auth-api.ts`. Canonical model: [./auth-model.ts](./auth-model.ts).
 *
 * Handles Prometheus queries, user settings, env CRUD, billing, and AI
 * analysis via the Log10x REST API.
 *
 * All HTTP reads route through `fetchWithRetry` — 3 attempts with
 * exponential backoff + jitter. Retries fire on network errors and
 * 5xx / 429 responses; 4xx errors are surfaced immediately because they
 * indicate misconfiguration rather than transient failure.
 */
import type { EnvConfig } from './environments.js';
import './auth-model.js';
/**
 * Wrap fetch with retry-on-transient-failure.
 *
 * Retries when:
 *   - the underlying fetch throws (network reset, DNS, connection refused)
 *   - the response is 5xx
 *   - the response is 429 (rate limited)
 *
 * Surfaces immediately on 4xx (other than 429) — these are caller errors
 * (auth, malformed query) and retrying won't help.
 */
export declare function fetchWithRetry(url: string, init: RequestInit, label: string): Promise<Response>;
/**
 * Raw Prometheus instant query.
 *
 * Phase 4: delegates to the env's `MetricsBackend` adapter. For
 * `kind: 'log10x'` this hits `prometheus.log10x.com` with X-10X-Auth
 * (unchanged behavior); for other kinds it hits the customer's own
 * Prom-compatible store with the appropriate auth.
 */
export declare function queryInstant(env: EnvConfig, promql: string, timeoutMs?: number): Promise<PrometheusResponse>;
/** Prometheus range query. Delegates to the env's MetricsBackend. */
export declare function queryRange(env: EnvConfig, promql: string, start: number, end: number, step: number, timeoutMs?: number): Promise<PrometheusResponse>;
/** AI analysis query. Returns the AI text response. */
export declare function queryAi(env: EnvConfig, queryResult: string, prompt: string, ingestionCost: number): Promise<string>;
/**
 * Prometheus /api/v1/labels — list all label names in the workspace.
 * Delegates to the env's MetricsBackend (phase 4).
 */
export declare function fetchLabels(env: EnvConfig): Promise<string[]>;
/**
 * Prometheus /api/v1/label/{name}/values — list distinct values for a label.
 *
 * Without `opts.windowSeconds`, returns all values ever seen (bounded by
 * Prometheus retention). That means stale series whose last sample was
 * minutes-to-hours ago still contribute values.
 *
 * **Important**: Prometheus's `start`/`end` params on this endpoint filter
 * by BLOCK intersection, not by active sample presence. The current 2h
 * block still contains old label values from services that stopped
 * emitting, so `windowSeconds` here does NOT produce a truly-live set.
 *
 * For a truly-live set (label values with samples in the last N seconds),
 * use `fetchActiveLabelValues()` below — it runs a PromQL `group by` over
 * an `increase()` window, which is the correct "currently active"
 * semantic.
 */
export declare function fetchLabelValues(env: EnvConfig, labelName: string, opts?: {
    windowSeconds?: number;
}): Promise<string[]>;
/**
 * Returns the distinct label values that have had at least one sample in
 * the last `windowSeconds` seconds — i.e., currently active, not stale.
 *
 * Implementation: `group by (<label>) (increase(all_events_summaryBytes_total[<window>]) > 0)`.
 * This is the correct semantic for "what labels are alive right now",
 * because it requires at least one non-zero sample in the window — which
 * is exactly the staleness filter `/label/values?start=&end=` fails to
 * provide (see fetchLabelValues docstring).
 *
 * Used by join-discovery to compute Jaccard over only active label values,
 * so stale replay data / decommissioned pods don't drag the similarity
 * score down and cause false `no_join_available` refusals.
 */
export declare function fetchActiveLabelValues(env: EnvConfig, labelName: string, windowSeconds: number): Promise<string[]>;
/**
 * Permission level assigned to a user for a given environment.
 * Mirrors backend/lambdas/user-service-go/internal/models/environment.go.
 *   - OWNER: full rights
 *   - WRITE: can query + write
 *   - READ : can query but not modify (e.g. shared demo env)
 */
export type Permission = 'OWNER' | 'WRITE' | 'READ';
export interface RemoteTenXEnv {
    envId: string;
    name: string;
    owner: string;
    isDefault: boolean;
    permissions: Permission;
}
export interface RemoteUserProfile {
    userId: string;
    username: string;
    tier?: string;
    userType?: string;
    environments: RemoteTenXEnv[];
    metadata: Record<string, unknown>;
}
/**
 * Fetch the user profile — identity, tier, and the full list of
 * environments the API key grants access to — via GET /api/v1/user.
 *
 * This is a USER-scoped call (authed with apiKey only, no envId). The
 * authorizer at backend/lambdas/user-service-go/cmd/authorizer/main.go
 * accepts `X-10X-Auth: <apiKey>` when envId is omitted and resolves
 * the user by apiKey alone.
 *
 * Throws on network or non-2xx failures. Callers that want fallback
 * behavior should catch and decide.
 */
export declare function fetchUserProfile(apiKey: string): Promise<RemoteUserProfile>;
/**
 * Update user metadata. Wraps `POST /api/v1/user`. Idempotent — repeated
 * calls with the same payload converge to the same state. The response
 * contains the full updated user profile.
 *
 * Use cases include analyzer-cost ($/GB) update and display-name / company
 * changes. The set of accepted metadata keys is governed by the backend; the
 * MCP passes through whatever the caller supplies.
 */
export declare function updateUserMetadata(apiKey: string, metadata: Record<string, unknown>): Promise<RemoteUserProfile>;
/**
 * Create a new environment. Wraps `POST /api/v1/user/env`. NOT
 * idempotent — calling twice with the same name returns 409 Conflict
 * from the backend. Returns the full updated user profile so the
 * caller can see the new env in the list.
 */
export declare function createEnvironment(apiKey: string, name: string, isDefault?: boolean): Promise<RemoteUserProfile>;
/**
 * Update an existing environment. Wraps `PUT /api/v1/user/env`.
 * Idempotent. Caller passes `env_id` (from `/api/v1/user`) and the
 * fields to change (name, is_default).
 *
 * NOTE: requires the backend gateway to have the PUT route configured.
 * Without it the call fails at the API Gateway layer with a 4xx before
 * reaching the lambda — see the `fix(gateway)` PR on the backend repo.
 */
export declare function updateEnvironment(apiKey: string, envId: string, changes: {
    name?: string;
    is_default?: boolean;
}): Promise<RemoteUserProfile>;
/**
 * Delete an environment. Wraps `DELETE /api/v1/user/env`. Irreversible.
 * The backend rejects the call with 401 if the caller is not the env
 * owner (`existing.Owner != user.Username()` check in the lambda).
 */
export declare function deleteEnvironment(apiKey: string, envId: string): Promise<RemoteUserProfile>;
/**
 * Rotate the API key. Wraps `POST /api/v1/user/rotate-key`. Returns
 * BOTH the new api_key (returned only here, never via subsequent
 * `/api/v1/user` reads) and the user profile.
 *
 * The previous key is invalidated immediately on success; clients
 * holding the old key — including this MCP server itself if it doesn't
 * pivot to the new one — will start receiving 401 on the next request.
 *
 * Demo accounts get 403 Forbidden.
 */
export declare function rotateApiKey(apiKey: string): Promise<{
    apiKey: string;
    profile: RemoteUserProfile;
}>;
export interface PrometheusResult {
    metric: Record<string, string>;
    value?: [number, string];
    values?: [number, string][];
}
export interface PrometheusResponse {
    status: string;
    data: {
        resultType: string;
        result: PrometheusResult[];
    };
}