import { S as SdkError, a as SdkErrorOptions, P as PlatformDoctorReport, b as PlatformProject, c as PlatformProjectServer, d as PlatformPermalinkPolicy, e as PlatformApiClient, f as PlatformEvalRunDisclosure, g as PlatformJourneyArchived, h as PlatformSwarmArchived, i as PlatformEvalRun, j as PlatformJourneyRunCanceled, k as PlatformWaveInsightsCanceled, l as PlatformRunCompare, m as PlatformEvalCheckRepoConnected, n as PlatformEvalCaseBatchResult, o as PlatformEvalCaseBatchCreated, p as PlatformEvalSuiteCreated, q as PlatformJourney, r as PlatformPersona, s as PlatformSwarm, t as PlatformTunnelGrant, u as PlatformPersonaDeleted, v as PlatformFindingDismissed, w as PlatformAdhocEnvironment, x as PlatformEnvironmentCapabilities, y as PlatformEvalCasesGenerated, z as PlatformEvalCase, A as PlatformGenerationDrafts, B as PlatformCapabilities, C as PlatformConformanceReport, D as PlatformConformanceRun, E as PlatformEvalRunDecisionSummary, F as PlatformEvalStepResult, G as PlatformJourneyRun, H as PlatformRunScorecard, I as PlatformReadinessLaneCoverage, J as PlatformReadinessStageResult, K as PlatformReadinessObservationState, L as PlatformReadinessRun, M as PlatformScenarioDetail, N as PlatformSwarmOverview, O as PlatformUserTestingScenarioDetail, Q as PlatformUserTestingSessionDetail, R as PlatformWaveInsights, T as PlatformJourneyRunLaunched, U as PlatformChatSession, V as PlatformClient, W as PlatformEnvironment, X as PlatformEvalCheckRepos, Y as PlatformEvalIteration, Z as PlatformEvalSuite, _ as PlatformHost, $ as PlatformImageBuild, a0 as PlatformImage, a1 as PlatformJourneyRunSession, a2 as PlatformPlugin, a3 as PlatformScenarioSummary, a4 as PlatformSwarmFinding, a5 as PlatformUserTestingSession, a6 as PlatformScenario, a7 as PlatformEvalRunJudgeRequested, a8 as PlatformUserTestingInsightsRequested, a9 as PlatformWaveInsightsRequested, aa as PlatformEvalRunCreated, ab as PlatformSessionSummary, ac as PlatformConformanceRunReceipt, ad as PlatformReadinessRunReceipt, ae as PlatformScenarioDeleted, af as PlatformUserTestingScenario, ag as PlatformImageBuildStarted, ah as PlatformServerConnection, ai as PlatformClientDetail, aj as PlatformHostDetail, ak as PlatformClientDeleted, al as PlatformEvalCaseDeleted, am as PlatformEvalSuiteDeleted, an as PlatformHostDeleted, ao as PlatformImageDeleted, ap as PlatformChatSessionDetail, aq as PlatformChatSessionTrace, ar as PlatformGateWaiver, as as PlatformEvalSuiteDetail, at as PlatformMe, au as PlatformPluginVersion, av as PlatformCatalogServer, aw as PlatformRegistryInstallResult, ax as PlatformPage, ay as PlatformModel, az as PlatformOrganization, aA as PlatformRegistryConnection, aB as PlatformCatalogSourceStatus, aC as PlatformRegistryServer, aD as PlatformWidgetRender, aE as PlatformComputerReset, aF as PlatformEnvironmentResolved, aG as PlatformGateWaiverWriteResult, aH as PlatformChatTurn, aI as PlatformComputerAttached, aJ as PlatformImageBlueprintValidation } from '../eval-decision-summary-chLr2s0E.js';
export { aK as DEFAULT_MCPJAM_APP_ORIGIN, aL as DEFAULT_PLATFORM_API_BASE_URL, aM as PLATFORM_PERMALINK_ROUTES, aN as PROJECT_DEEP_LINK_PARAM, aO as PermalinkAwareOperation, aP as PermalinkScopeReceiver, aQ as PlatformActionableFinding, aR as PlatformActionableFindingEvidence, aS as PlatformAdhocEnvironmentBody, aT as PlatformAdhocEnvironmentEnsured, aU as PlatformAnalysisTouchpointDisclosure, aV as PlatformApiClientOptions, aW as PlatformByokDisclosure, aX as PlatformCaptureDisclosure, aY as PlatformCaseScoreDelta, aZ as PlatformCaseScoreSide, a_ as PlatformCatalogOauthProbe, a$ as PlatformChatMessage, b0 as PlatformChatSessionTraceTurn, b1 as PlatformClientImpact, b2 as PlatformCompareCaseStatus, b3 as PlatformConformanceReportCheck, b4 as PlatformConformanceReportProfile, b5 as PlatformConformanceRunReportSummary, b6 as PlatformConformanceSuiteKind, b7 as PlatformDirectorySearchPage, b8 as PlatformDisclosedModel, b9 as PlatformDisclosureEngine, ba as PlatformDisclosureFires, bb as PlatformDisclosureRailDestination, bc as PlatformDisclosureTenantEgress, bd as PlatformEnvironmentCreateBody, be as PlatformEnvironmentNameBody, bf as PlatformEnvironmentRevisionBody, bg as PlatformEnvironmentSkillSelection, bh as PlatformEnvironmentUpdateBody, bi as PlatformEvalCaseBatchFailed, bj as PlatformEvalCaseModel, bk as PlatformEvalCaseWarning, bl as PlatformEvalCheckRepo, bm as PlatformEvalLlmTouchpointId, bn as PlatformEvalRunDisclosureLocus, bo as PlatformEvalRunEnvironment, bp as PlatformEvalRunGoalCompletionCase, bq as PlatformEvalRunGoalCompletionJudge, br as PlatformEvalRunGroundednessCase, bs as PlatformEvalRunGroundednessJudge, bt as PlatformEvalRunGroupCreated, bu as PlatformEvalRunGroupEntry, bv as PlatformEvalRunGroupTarget, bw as PlatformEvalRunInsightsRequested, bx as PlatformEvalRunJudgeCase, by as PlatformEvalRunJudgeState, bz as PlatformEvalRunJudges, bA as PlatformEvalRunSummary, bB as PlatformEvalStep, bC as PlatformEvalSuiteComputerEnvironment, bD as PlatformEvalSuiteEnvironmentAttached, bE as PlatformEvalSuiteHost, bF as PlatformEvalSuiteSchedule, bG as PlatformEvalSuiteSettings, bH as PlatformExecutionAbsenceKind, bI as PlatformExecutionDisclosure, bJ as PlatformExpectedToolCall, bK as PlatformFileOwnedEvalSuiteSynced, bL as PlatformGateWaiverRead, bM as PlatformGuestExecution, bN as PlatformInsightActionTarget, bO as PlatformInsightActionability, bP as PlatformInsightAttribution, bQ as PlatformInsightScope, bR as PlatformInsightsEnvelope, bS as PlatformInsightsStatus, bT as PlatformJourneyRunAttempt, bU as PlatformJourneyRunTarget, bV as PlatformManagedRailDisclosure, bW as PlatformNoPermalinkReason, bX as PlatformNotApplicableRailDisclosure, bY as PlatformNumericDiff, bZ as PlatformOpenAIReadinessStartBody, b_ as PlatformPermalink, b$ as PlatformPermalinkContext, c0 as PlatformPermalinkError, c1 as PlatformPluginComponentCounts, c2 as PlatformPluginServerComponent, c3 as PlatformPluginSkillComponent, c4 as PlatformRailDisclosure, c5 as PlatformReadinessKind, c6 as PlatformReadinessLaneStatus, c7 as PlatformReadinessStartBody, c8 as PlatformReadinessSubmissionMode, c9 as PlatformRegionDisclosure, ca as PlatformRegistryInstall, cb as PlatformRegistryInstallNextSteps, cc as PlatformRegistryServerTransport, cd as PlatformResourceRef, ce as PlatformResourceType, cf as PlatformRetentionDisclosure, cg as PlatformRunCompareCase, ch as PlatformRunCompareCaseSide, ci as PlatformRunCompareSide, cj as PlatformScenarioLink, ck as PlatformScenarioServer, cl as PlatformScoreContractDiff, cm as PlatformScoreContractScorer, cn as PlatformScoreContractSide, co as PlatformScorecardCriterion, cp as PlatformServerConnectionCandidate, cq as PlatformServerConnectionCreateBody, cr as PlatformServerConnectionError, cs as PlatformSessionLink, ct as PlatformSessionParentRef, cu as PlatformSessionSourceType, cv as PlatformSessionsPage, cw as PlatformSnapshotElement, cx as PlatformSubprocessorDisclosure, cy as PlatformSwarmOverviewFinding, cz as PlatformSwarmOverviewRun, cA as PlatformToolMode, cB as PlatformTranscriptMessage, cC as PlatformTunnelClosed, cD as PlatformTurnToolCall, cE as PlatformTurnTrace, cF as PlatformTurnUsage, cG as PlatformWidgetSnapshot, cH as PublicCheck, cI as PublicCheckOverride, cJ as PublicMatchOptions, cK as buildAppPermalink, cL as buildAppPermalinks, cM as derivePermalinks, cN as derivePermalinksFor, cO as formatPermalinkLines, cP as isPlatformResourceType, cQ as noPermalink, cR as permalinkProjectId, cS as readEvalRunDecisionSummary, cT as responsePermalinks, cU as runOperationWithPermalinks, cV as withPermalinkEnvelope } from '../eval-decision-summary-chLr2s0E.js';
import { z } from 'zod';
import { C as CompatVerdict, a as CompatProvenance, b as CompatFinding } from '../types-CvzKKUsd.js';
import '../index-fZyfLCHE.js';
import 'ai';
import '../public-types-CX8stXC3.js';
import '../types-HXAijHji.js';
import '../types-CI0Xyszt.js';
import '@modelcontextprotocol/client';
import '@modelcontextprotocol/client/stdio';
import '../decision-summary-CksWu77D.js';
import '../types-BBk0lTBo.js';
import '../server-doctor-core-DFaTigIr.js';

/**
 * Error codes emitted by the MCPJam Platform API (`/api/v1`) wire envelope
 * `{ code, message, details? }`. Mirrors the public contract in
 * `mcpjam-inspector/server/routes/v1/contract.ts`. New codes may be added
 * over time; treat unknown codes as non-retryable failures.
 */
declare const PLATFORM_V1_ERROR_CODES: readonly ["UNAUTHORIZED", "FORBIDDEN", "NOT_FOUND", "CONFLICT", "VALIDATION_ERROR", "RATE_LIMITED", "FEATURE_NOT_SUPPORTED", "SERVER_UNREACHABLE", "TIMEOUT", "OAUTH_REQUIRED", "INTERNAL_ERROR"];
type PlatformV1ErrorCode = (typeof PLATFORM_V1_ERROR_CODES)[number];
/**
 * Codes carried on `PlatformApiError.code`. Usually a wire code from the
 * envelope above; `NETWORK_ERROR` and `TIMEOUT` are also synthesized
 * client-side (with `status: 0`) when the request never produced a wire
 * envelope — fetch-level failures and client-side timeouts respectively.
 * Error responses with no envelope (empty bodies, proxy HTML) derive the
 * code from the HTTP status when unambiguous (401/403/404/429), else
 * `INTERNAL_ERROR`.
 *
 * `UNSUPPORTED` is also client-side (`status: 0`), and is a different claim
 * from the two above: the request SUCCEEDED, but its response showed the
 * backend does not implement a capability the caller asked for — an older
 * deployment that ignored a parameter it did not recognize. Reported as an
 * error rather than returned as data because the alternative is handing the
 * caller a well-formed answer to a question it did not ask.
 */
type PlatformApiErrorCode = PlatformV1ErrorCode | "NETWORK_ERROR" | "UNSUPPORTED";
type PlatformApiErrorOptions = SdkErrorOptions & {
    /** HTTP status of the response; 0 for client-side (network/timeout) errors. */
    status: number;
    /** Optional unstructured details bag from the wire envelope. */
    details?: Record<string, unknown>;
    /** Seconds from a `Retry-After` header, when present (429 responses). */
    retryAfter?: number;
    /** Request path that failed, for diagnostics. */
    endpoint?: string;
};
declare class PlatformApiError extends SdkError {
    readonly status: number;
    readonly details?: Record<string, unknown>;
    readonly retryAfter?: number;
    readonly endpoint?: string;
    constructor(message: string, code: string, options: PlatformApiErrorOptions);
}
declare function isPlatformApiError(error: unknown): error is PlatformApiError;

/**
 * Core logic for the `show_servers` platform operation: resolve a project,
 * inspect its servers via the Platform API's hosted doctor (one call per
 * server), and assemble a stable `ShowServersPayload`. UI-agnostic — the
 * MCP worker renders this payload as an MCP Apps widget, the CLI as text.
 */

type ServerStatus = "reachable" | "unreachable" | "skipped" | "error";
type ServerTransportType = "http" | "stdio";
type ServerInfo = {
    name?: string;
    version?: string;
};
type ServerPrimitiveListStatus = "loaded" | "skipped" | "error";
type ServerPrimitiveCollection<TItem> = {
    status: ServerPrimitiveListStatus;
    items: TItem[];
    statusDetail?: string;
};
type ServerToolInfo = {
    name: string;
    title?: string;
    description?: string;
};
type ServerResourceInfo = {
    uri: string;
    name?: string;
    title?: string;
    description?: string;
    mimeType?: string;
};
type ServerPromptArgumentInfo = {
    name: string;
    description?: string;
    required?: boolean;
};
type ServerPromptInfo = {
    name: string;
    title?: string;
    description?: string;
    arguments?: ServerPromptArgumentInfo[];
};
type ServerPrimitives = {
    tools: ServerPrimitiveCollection<ServerToolInfo>;
    resources: ServerPrimitiveCollection<ServerResourceInfo>;
    prompts: ServerPrimitiveCollection<ServerPromptInfo>;
};
type ServerEntry = {
    id: string;
    name: string;
    transportType: ServerTransportType;
    url?: string;
    status: ServerStatus;
    statusDetail?: string;
    serverInfo?: ServerInfo;
    primitives?: ServerPrimitives;
};
type ProjectInfo = {
    id: string;
    name: string;
};
type SelectedProjectInfo = ProjectInfo & {
    organizationId: string;
};
type ShowServersSummary = Record<ServerStatus, number>;
type ShowServersPayload = {
    project: SelectedProjectInfo;
    servers: ServerEntry[];
    otherProjects: ProjectInfo[];
    summary: ShowServersSummary;
    generatedAt: string;
};
declare const SHOW_SERVERS_DOCTOR_CONCURRENCY = 3;
type ProjectResolution = {
    ok: true;
    project: PlatformProject;
    sortedProjects: PlatformProject[];
} | {
    ok: false;
    message: string;
};
declare function resolveProject(projects: PlatformProject[], selector?: string): ProjectResolution;
type ShowServersDoctorFn = (args: {
    projectId: string;
    serverId: string;
    signal?: AbortSignal;
}) => Promise<PlatformDoctorReport>;
type BuildShowServersPayloadInput = {
    doctor: ShowServersDoctorFn;
    project: PlatformProject;
    projects: PlatformProject[];
    servers: PlatformProjectServer[];
    generatedAt: string;
    signal?: AbortSignal;
};
declare function buildShowServersPayload({ doctor, project, projects, servers, generatedAt, signal, }: BuildShowServersPayloadInput): Promise<ShowServersPayload>;
/**
 * Resolution failures become NOT_FOUND platform errors so every surface
 * (MCP tool, CLI) renders the same actionable message.
 */
declare function projectResolutionError(message: string): PlatformApiError;

/**
 * Curated, task-shaped operations over the Platform API. Each operation is
 * defined once and adapted per surface: MCP worker tools, CLI commands, and
 * (later) in-product agent tools. Names follow the built-in tool id
 * convention (`^[a-z][a-z0-9_]{0,63}$`) so they can be registered in the
 * product catalog unchanged.
 */

interface PlatformOperationContext {
    client: PlatformApiClient;
    signal?: AbortSignal;
    /**
     * The project this call actually resolved to, fired exactly once when
     * resolution succeeds.
     *
     * Permalinks need a project id and most callers do not have one. The hosted
     * route does, but an MCP host passes a project NAME or nothing at all and
     * the operation resolves the real project internally — so a permalink built
     * from the adapter's own guess would name a different project than the one
     * the operation read. This receipt is how the adapter learns which project
     * the work happened in, without the operation's RESULT changing shape
     * (`{data, scope}` would break every direct SDK caller).
     *
     * SYNCHRONOUS BY CONTRACT and best-effort, same as `onDisclosure`: it is
     * not awaited, a throwing callback is swallowed rather than failing the
     * operation, and an operation that resolves no project (list_projects,
     * get_me, the registry directory) never fires it.
     */
    onScopeResolved?: (scope: {
        projectId: string;
        organizationId?: string;
    }) => void;
    /**
     * Fired by `runEvalSuiteOperation` with the pre-run disclosure it fetched
     * for the frozen launch plan, ONE resolution before it calls
     * `createEvalRun`/`createEvalRunGroup` — so "what was disclosed" is
     * literally "what will run", not a second, independently-resolved target
     * that could drift from it. A caller that wants to show or log the
     * disclosure passes this rather than resolving targets a second time to
     * fetch it separately.
     *
     * Best-effort: a disclosure fetch failure (a backend that predates the
     * contract, a transient error) never blocks or fails the launch — this
     * callback simply does not fire, and the receipt's `disclosure` field is
     * absent. Never called for `runEvalCaseOperation`, which shares no target
     * resolution with the suite op. See `onDisclosureUnavailable` for the
     * failure counterpart.
     *
     * SYNCHRONOUS BY CONTRACT — the "ONE resolution before the create call"
     * ordering guarantee only holds for code that runs to completion before
     * this function returns. It is not awaited: a caller who ignores the type
     * and hands back an async function anyway gets its rejections swallowed
     * defensively, but only its SYNCHRONOUS prefix is guaranteed to run before
     * `createEvalRun`/`createEvalRunGroup`.
     */
    onDisclosure?: (disclosure: PlatformEvalRunDisclosure) => void;
    /**
     * Fired INSTEAD of `onDisclosure` when the fetch for the frozen launch
     * plan failed — a backend predating the contract, a timeout, a transient
     * error. Still never blocks or fails the launch (the same best-effort
     * guarantee `onDisclosure` carries); this exists so a caller can say
     * something was ATTEMPTED and failed, rather than rendering nothing at
     * all. An absent disclosure with no signal at all is indistinguishable
     * from "this build has no disclosure feature" — the same failure class
     * the backend's `executionAbsence.kind` exists to prevent one layer up.
     *
     * Never fired for a caller-initiated cancellation (the operation's own
     * `signal` aborting) — that is not a disclosure failure to report, it is
     * the whole launch being cancelled, and mislabeling it as "the disclosure
     * fetch timed out" would misdescribe an unrelated abort. Synchronous by
     * contract, same as `onDisclosure`.
     */
    onDisclosureUnavailable?: (reason: string) => void;
}
declare const getMeOperation: PlatformOperation<Record<string, never>, PlatformMe>;
declare const listModelsOperation: PlatformOperation<Record<string, never>, PlatformPage<PlatformModel>>;
declare const listOrganizationsOperation: PlatformOperation<Record<string, never>, PlatformPage<PlatformOrganization>>;
interface PlatformOperation<TInput, TOutput> {
    /** Stable wire id; doubles as the MCP/AI-SDK tool name. */
    name: string;
    title: string;
    description: string;
    /**
     * Whether the operation only reads platform state. Surfaces map this to
     * their own affordances (MCP `readOnlyHint`, CLI confirmation prompts).
     */
    readOnly: boolean;
    /**
     * True when a non-read operation's effects are unknowable upstream of the
     * call (call_server_tool runs arbitrary third-party tools). Surfaces must
     * not soften the destructive default for these — MCP clients assume
     * destructive when the hint is absent, and that absence is the honest
     * claim here.
     */
    mayBeDestructive?: boolean;
    /**
     * What kind of harm a mistaken call does, so every surface can make ONE
     * decision from one place instead of five surfaces each re-deriving it.
     *
     * `readOnly` already separates reads from writes, and that is not the
     * question the surfaces actually have. Creating an eval case and rotating a
     * share link are both writes; one is undo-able with a delete, the other
     * breaks every live link someone has already handed out. Before this field
     * the agent registry, the MCP catalog and the workspace toolset each encoded
     * that difference in their own prose, which is how `cancel_journey_run` came
     * to be excluded from one surface for a reason that only applied to another.
     *
     *   `none`        — persists, but reversible and costs nothing.
     *   `spend`       — consumes credits or quota, possibly a lot.
     *   `exposure`    — changes who can reach something.
     *   `destructive` — removes or invalidates something that existed.
     *
     * Absent means `none` on a write and is meaningless on a read. This is
     * DESCRIPTIVE metadata for surfaces to act on — it enforces nothing by
     * itself, and a surface that ignores it is no less safe than before.
     */
    risk?: "none" | "spend" | "exposure" | "destructive";
    /**
     * Which durable resources this operation's result can be opened at.
     *
     * REQUIRED, and discriminated: there is no unclassified operation. Before
     * this field every surface re-derived app URLs from result shapes it half
     * knew, three of them assembled the same eval-run URL, and the model filled
     * the remaining gaps by inventing `https://app.mcpjam.com/servers` — a link
     * that opens whatever project the RECIPIENT last selected. Making the field
     * mandatory means a new operation cannot ship having quietly skipped the
     * question; declaring `noPermalink("mutation-only")` is a decision, an
     * omitted optional field was not.
     */
    permalink: PlatformPermalinkPolicy<TInput, TOutput>;
    inputSchema: z.ZodType<TInput>;
    execute(input: TInput, context: PlatformOperationContext): Promise<TOutput>;
}
declare const listProjectsInput: z.ZodObject<{
    organizationId: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ListProjectsInput = z.infer<typeof listProjectsInput>;
declare const listProjectsOperation: PlatformOperation<ListProjectsInput, PlatformPage<PlatformProject>>;
declare const createProjectInput: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    organizationId: z.ZodOptional<z.ZodString>;
    icon: z.ZodOptional<z.ZodString>;
    visibility: z.ZodOptional<z.ZodEnum<{
        public: "public";
        private: "private";
    }>>;
}, z.core.$strip>;
type CreateProjectInput = z.infer<typeof createProjectInput>;
declare const createProjectOperation: PlatformOperation<CreateProjectInput, PlatformProject>;
declare const updateProjectInput: z.ZodObject<{
    project: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    icon: z.ZodOptional<z.ZodString>;
    visibility: z.ZodOptional<z.ZodEnum<{
        public: "public";
        private: "private";
    }>>;
}, z.core.$strip>;
type UpdateProjectInput = z.infer<typeof updateProjectInput>;
declare const updateProjectOperation: PlatformOperation<UpdateProjectInput, PlatformProject>;
declare const deleteProjectInput: z.ZodObject<{
    project: z.ZodString;
}, z.core.$strip>;
type DeleteProjectInput = z.infer<typeof deleteProjectInput>;
declare const deleteProjectOperation: PlatformOperation<DeleteProjectInput, {
    id: string;
    deleted: boolean;
}>;
declare const projectScopedInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ProjectScopedInput = z.infer<typeof projectScopedInput>;
type ListProjectServersResult = {
    project: SelectedProjectInfo;
    items: PlatformProjectServer[];
    otherProjects: ProjectInfo[];
};
declare const listProjectServersOperation: PlatformOperation<ProjectScopedInput, ListProjectServersResult>;
declare const showServersOperation: PlatformOperation<ProjectScopedInput, ShowServersPayload>;
/**
 * A case as an OPERATION returns it: the wire projection plus the suite the
 * operation resolved to reach it.
 *
 * NOT on `PlatformEvalCase` itself. That type mirrors the REST `EvalCase`
 * schema field for field (the openapi parity test enforces it), and the route
 * does not send a suite id — the OPERATION knows it because it just resolved
 * the caller's `suite` selector. Stamping it here keeps the wire contract
 * honest while giving the permalink policy the parent it needs: a case's route
 * is `/evals/suite/:suiteId/test/:testId`, and without the suite there is no
 * link to build, only a wrong one.
 */
type PlatformEvalCaseWithSuite = PlatformEvalCase & {
    suiteId: string;
};
/** `create_eval_cases`, with each created row's suite stamped on. */
type CreateEvalCasesResult = Omit<PlatformEvalCaseBatchResult, "created"> & {
    created: Array<PlatformEvalCaseBatchCreated & {
        suiteId: string;
    }>;
};
/** `generate_eval_cases`, with each generated case's suite stamped on. */
type GenerateEvalCasesResult = Omit<PlatformEvalCasesGenerated, "created"> & {
    created: PlatformEvalCaseWithSuite[];
};
declare const serverScopedInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    server: z.ZodString;
}, z.core.$strip>;
type ServerScopedInput = z.infer<typeof serverScopedInput>;
type ResolvedServerInfo = {
    id: string;
    name: string;
};
type DiagnoseServerResult = {
    project: SelectedProjectInfo;
    server: ResolvedServerInfo;
    report: PlatformDoctorReport;
};
declare const diagnoseServerOperation: PlatformOperation<ServerScopedInput, DiagnoseServerResult>;
declare const validateServerOperation: PlatformOperation<ServerScopedInput, Record<string, unknown>>;
declare const exportServerOperation: PlatformOperation<ServerScopedInput, Record<string, unknown>>;
declare const serverPagedInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    server: z.ZodString;
    cursor: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ServerPagedInput = z.infer<typeof serverPagedInput>;
type ServerPagedResult = {
    project: SelectedProjectInfo;
    server: ResolvedServerInfo;
    items: Array<Record<string, unknown>>;
    nextCursor?: string;
};
declare const listServerToolsOperation: PlatformOperation<ServerPagedInput, ServerPagedResult>;
declare const listServerPromptsOperation: PlatformOperation<ServerPagedInput, ServerPagedResult>;
declare const listServerResourcesOperation: PlatformOperation<ServerPagedInput, ServerPagedResult>;
declare const callServerToolInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    server: z.ZodString;
    toolName: z.ZodString;
    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
type CallServerToolInput = z.infer<typeof callServerToolInput>;
type CallServerToolResult = {
    project: SelectedProjectInfo;
    server: ResolvedServerInfo;
    result: Record<string, unknown>;
};
declare const renderServerWidgetInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    server: z.ZodString;
    toolName: z.ZodString;
    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    includeSnapshot: z.ZodOptional<z.ZodBoolean>;
    includeScreenshot: z.ZodOptional<z.ZodBoolean>;
    injectOpenAiCompat: z.ZodOptional<z.ZodBoolean>;
    viewport: z.ZodOptional<z.ZodObject<{
        width: z.ZodNumber;
        height: z.ZodNumber;
    }, z.core.$strip>>;
}, z.core.$strip>;
type RenderServerWidgetInput = z.infer<typeof renderServerWidgetInput>;
type RenderServerWidgetResult = {
    project: SelectedProjectInfo;
    server: ResolvedServerInfo;
    render: PlatformWidgetRender;
};
declare const renderServerWidgetOperation: PlatformOperation<RenderServerWidgetInput, RenderServerWidgetResult>;
declare const callServerToolOperation: PlatformOperation<CallServerToolInput, CallServerToolResult>;
declare const getServerPromptInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    server: z.ZodString;
    promptName: z.ZodString;
    arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
}, z.core.$strip>;
type GetServerPromptInput = z.infer<typeof getServerPromptInput>;
type GetServerPromptResult = {
    project: SelectedProjectInfo;
    server: ResolvedServerInfo;
    result: Record<string, unknown>;
};
declare const getServerPromptOperation: PlatformOperation<GetServerPromptInput, GetServerPromptResult>;
declare const readServerResourceInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    server: z.ZodString;
    uri: z.ZodString;
}, z.core.$strip>;
type ReadServerResourceInput = z.infer<typeof readServerResourceInput>;
type ReadServerResourceResult = {
    project: SelectedProjectInfo;
    server: ResolvedServerInfo;
    result: Record<string, unknown>;
};
declare const readServerResourceOperation: PlatformOperation<ReadServerResourceInput, ReadServerResourceResult>;
type HostCompatibilityVerdict = {
    hostId: string;
    hostLabel: string;
    /** Worst-wins aggregate across the apps + server lanes. */
    verdict: CompatVerdict;
    /** Weakest source backing this host's facts. */
    provenance: CompatProvenance;
    /** Machine-readable findings (each carries a stable `code`). */
    findings: CompatFinding[];
};
type CheckHostCompatibilityResult = {
    project: SelectedProjectInfo;
    server: ResolvedServerInfo;
    /** What the server demands, summarized. */
    widgets: {
        total: number;
        appOnly: number;
    };
    /** Dimensions that couldn't be analyzed (e.g. unreadable widget HTML). */
    unknownDimensions: string[];
    hosts: HostCompatibilityVerdict[];
};
declare const checkHostCompatibilityOperation: PlatformOperation<ServerScopedInput, CheckHostCompatibilityResult>;
/**
 * Grading a server against a publisher's app directory, as an operation.
 *
 * ## Why a start returns a receipt rather than a grade
 *
 * A readiness run dials somebody else's server, follows its redirects, walks
 * its listings and sometimes asks a model to read the result. That does not
 * fit in a request, so the platform runs it durably: the start answers `202`
 * with a run id and the caller polls. Every surface that offers these
 * operations has to say so — a model told "start a run" and handed a receipt
 * will otherwise report the receipt as the answer.
 *
 * ## Why the starts declare `risk: "spend"` when the default is free
 *
 * `includeLlmObservations` is the only field that costs anything and it
 * defaults off, so most runs are free. But `risk` is a static declaration read
 * by five surfaces to decide how much ceremony a call needs, and a field that
 * described the cheap case would be describing the case that does not need
 * describing. The worst case is what a spend guard has to be told; the
 * agent's `confirmSeverity` is a function precisely so the approval copy can
 * still say "this one is free" when the flag is off.
 */
declare const readinessRunScopedInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    run: z.ZodString;
}, z.core.$strip>;
type ReadinessRunScopedInput = z.infer<typeof readinessRunScopedInput>;
declare const startReadinessInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    server: z.ZodString;
    includeLlmObservations: z.ZodOptional<z.ZodBoolean>;
    idempotencyKey: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const startOpenAIReadinessInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    server: z.ZodString;
    includeLlmObservations: z.ZodOptional<z.ZodBoolean>;
    idempotencyKey: z.ZodOptional<z.ZodString>;
    submissionMode: z.ZodEnum<{
        "mcp-only": "mcp-only";
        "mcp-imported-skills": "mcp-imported-skills";
    }>;
}, z.core.$strip>;
type StartClaudeReadinessInput = z.infer<typeof startReadinessInput>;
type StartOpenAIReadinessInput = z.infer<typeof startOpenAIReadinessInput>;
type StartReadinessResult = {
    project: SelectedProjectInfo;
    server: ResolvedServerInfo;
    run: PlatformReadinessRunReceipt;
};
declare const startClaudeReadinessRunOperation: PlatformOperation<StartClaudeReadinessInput, StartReadinessResult>;
declare const startOpenAIReadinessRunOperation: PlatformOperation<StartOpenAIReadinessInput, StartReadinessResult>;
type GetReadinessRunResult = {
    project: SelectedProjectInfo;
    run: PlatformReadinessRun;
};
declare const getReadinessRunOperation: PlatformOperation<ReadinessRunScopedInput, GetReadinessRunResult>;
declare const listReadinessRunsInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    readinessKind: z.ZodOptional<z.ZodEnum<{
        claude: "claude";
        openai: "openai";
    }>>;
    server: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ListReadinessRunsInput = z.infer<typeof listReadinessRunsInput>;
type ListReadinessRunsResult = {
    project: SelectedProjectInfo;
    runs: PlatformReadinessRun[];
};
declare const listReadinessRunsOperation: PlatformOperation<ListReadinessRunsInput, ListReadinessRunsResult>;
declare const cancelReadinessRunOperation: PlatformOperation<ReadinessRunScopedInput, {
    project: SelectedProjectInfo;
    runId: string;
    status: string;
}>;
type ReadinessReportFinding = {
    id: string;
    title: string;
    lane: string;
    class: string;
    status: string;
    provenance?: string;
    remediation?: string;
    notEvaluatedReason?: string;
};
type GetReadinessReportResult = {
    project: SelectedProjectInfo;
    runId: string;
    status: string;
    summary?: string;
    lanes: PlatformReadinessLaneCoverage[];
    stages: PlatformReadinessStageResult[];
    observations: PlatformReadinessObservationState;
    findings: ReadinessReportFinding[];
    /** How many findings the run produced, before this projection capped them. */
    totalFindings: number;
    returnedFindings: number;
    /** True when `findings` is a subset. Never left for a reader to infer. */
    truncated: boolean;
};
declare const getReadinessReportOperation: PlatformOperation<ReadinessRunScopedInput, GetReadinessReportResult>;
declare const conformanceRunScopedInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    run: z.ZodString;
}, z.core.$strip>;
type ConformanceRunScopedInput = z.infer<typeof conformanceRunScopedInput>;
declare const startConformanceRunInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    server: z.ZodString;
    suites: z.ZodOptional<z.ZodArray<z.ZodEnum<{
        tasks: "tasks";
        protocol: "protocol";
        apps: "apps";
    }>>>;
    idempotencyKey: z.ZodOptional<z.ZodString>;
    protocolVersion: z.ZodOptional<z.ZodString>;
    engineVersion: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type StartConformanceRunInput = z.infer<typeof startConformanceRunInput>;
type StartConformanceRunResult = {
    project: SelectedProjectInfo;
    server: ResolvedServerInfo;
    run: PlatformConformanceRunReceipt;
};
declare const startConformanceRunOperation: PlatformOperation<StartConformanceRunInput, StartConformanceRunResult>;
type GetConformanceRunResult = {
    project: SelectedProjectInfo;
    run: PlatformConformanceRun;
};
declare const getConformanceRunOperation: PlatformOperation<ConformanceRunScopedInput, GetConformanceRunResult>;
declare const listConformanceRunsInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    server: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ListConformanceRunsInput = z.infer<typeof listConformanceRunsInput>;
type ListConformanceRunsResult = {
    project: SelectedProjectInfo;
    runs: PlatformConformanceRun[];
};
declare const listConformanceRunsOperation: PlatformOperation<ListConformanceRunsInput, ListConformanceRunsResult>;
type GetConformanceReportResult = {
    project: SelectedProjectInfo;
} & PlatformConformanceReport;
declare const getConformanceReportOperation: PlatformOperation<ConformanceRunScopedInput, GetConformanceReportResult>;
declare function expandComposeModelChoices(stack: {
    model?: string;
    models?: string[];
    includeClientDefault?: boolean;
}): Array<{
    modelId: string | undefined;
}>;
type ListEvalSuitesResult = {
    project: SelectedProjectInfo;
    items: PlatformEvalSuite[];
    otherProjects: ProjectInfo[];
};
declare const listEvalSuitesOperation: PlatformOperation<ProjectScopedInput, ListEvalSuitesResult>;
declare const evalSuiteScopedInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ListEvalSuiteRunsInput = z.infer<typeof evalSuiteScopedInput>;
type ListEvalSuiteRunsResult = {
    project: SelectedProjectInfo;
    suite: {
        id: string;
        name: string | null;
    };
    items: PlatformEvalRun[];
};
declare const listEvalSuiteRunsOperation: PlatformOperation<ListEvalSuiteRunsInput, ListEvalSuiteRunsResult>;
declare const runEvalSuiteInput: z.ZodObject<{
    repetitions: z.ZodOptional<z.ZodNumber>;
    iterations: z.ZodOptional<z.ZodNumber>;
    notes: z.ZodOptional<z.ZodString>;
    minPassRate: z.ZodOptional<z.ZodNumber>;
    matchOptions: z.ZodOptional<z.ZodObject<{
        toolCallOrder: z.ZodOptional<z.ZodEnum<{
            any: "any";
            exact: "exact";
            "in-order": "in-order";
        }>>;
        extraToolCalls: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"unlimited">, z.ZodNumber]>>;
        arguments: z.ZodOptional<z.ZodEnum<{
            ignore: "ignore";
            partial: "partial";
            exact: "exact";
        }>>;
    }, z.core.$strip>>;
    excludeSkills: z.ZodOptional<z.ZodBoolean>;
    idempotencyKey: z.ZodOptional<z.ZodString>;
    sourceHash: z.ZodOptional<z.ZodString>;
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    servers: z.ZodOptional<z.ZodArray<z.ZodString>>;
    environment: z.ZodOptional<z.ZodString>;
    environments: z.ZodOptional<z.ZodArray<z.ZodString>>;
    host: z.ZodOptional<z.ZodString>;
    hosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
    allAttached: z.ZodOptional<z.ZodBoolean>;
    cases: z.ZodOptional<z.ZodArray<z.ZodString>>;
    refreshSnapshot: z.ZodOptional<z.ZodBoolean>;
    compose: z.ZodOptional<z.ZodObject<{
        host: z.ZodString;
        serverGroup: z.ZodOptional<z.ZodString>;
        model: z.ZodOptional<z.ZodString>;
        models: z.ZodOptional<z.ZodArray<z.ZodString>>;
        includeClientDefault: z.ZodOptional<z.ZodBoolean>;
        saveTargets: z.ZodOptional<z.ZodBoolean>;
        computer: z.ZodOptional<z.ZodString>;
        skills: z.ZodOptional<z.ZodObject<{
            mode: z.ZodLiteral<"explicit">;
            skillIds: z.ZodArray<z.ZodString>;
        }, z.core.$strip>>;
        pluginVersionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type RunEvalSuiteInput = z.infer<typeof runEvalSuiteInput>;
/** One target's outcome, discriminated on `status`. See `targets` below. */
type RunEvalTargetResult = {
    status: "started";
    environment?: PlatformEvalRunCreated["environment"];
    host?: {
        id: string;
        name: string;
    };
    runId: string;
    runStatus: string;
    servers?: Array<{
        id: string;
        name?: string;
    }>;
    caseUpsert?: PlatformEvalRunCreated["caseUpsert"];
} | {
    status: "failed";
    environment?: PlatformEvalRunCreated["environment"];
    host?: {
        id: string;
        name: string;
    };
    error: {
        code: string;
        message: string;
    };
};
type RunEvalSuiteResult = {
    project: SelectedProjectInfo;
    suite: {
        id: string;
        name: string | null;
    };
    /**
     * `"started"` — every target launched; `"partial"` — some did and some did
     * not; `"failed"` — none did.
     *
     * A SINGLE-target run is always `"started"`, because its failures throw:
     * there is one thing the caller asked for, and reporting "it failed" in a
     * resolved value would make every caller check a field to find out whether
     * their one action happened. A multi-target launch cannot do that — aborting
     * on the first failure would strand its already-started siblings unreported —
     * so it resolves with the receipt and the caller reads `outcome`.
     */
    outcome: "started" | "partial" | "failed";
    startedCount: number;
    failedCount: number;
    /** Set only on a grouped launch. Sibling runs share it. */
    runGroupId?: string;
    /**
     * What `compose` PERSISTED, reported even when the launch itself failed.
     *
     * A compose-and-run has side effects before it spends: it ensures an ad-hoc
     * environment and attaches it to the suite. A caller whose launch then fails
     * still needs to know the suite's attachment list changed — and that a retry
     * will hit the dedupe and no-op paths rather than composing again.
     */
    composed?: {
        environment: {
            id: string;
            name: null;
            adhoc: true;
            created: boolean;
            modelId?: string;
        };
        environments?: Array<{
            id: string;
            name: null;
            adhoc: true;
            created: boolean;
            modelId?: string;
        }>;
        attachment: {
            attached: boolean;
        };
    };
    /** One entry per target, in launch order. */
    targets: RunEvalTargetResult[];
    /**
     * The pre-run disclosure fetched for this launch's frozen target plan — the
     * SAME resolution `onDisclosure` (see `PlatformOperationContext`) already
     * received, carried on the receipt so a caller that only reads the return
     * value (rather than passing a callback) still sees it. Absent when the
     * fetch failed — a backend that predates the contract, a transient error —
     * which never blocks the launch itself.
     */
    disclosure?: PlatformEvalRunDisclosure;
    /**
     * @deprecated Mirrors of the FIRST started run, kept so callers written
     * against the single-run shape keep working. Read `targets` instead — on a
     * grouped launch these describe one run out of several.
     */
    runId?: string;
    /** @deprecated See `runId`. */
    status?: string;
    /** @deprecated See `runId`. */
    servers?: Array<{
        id: string;
        name?: string;
    }>;
    /** @deprecated See `runId`. */
    environment?: PlatformEvalRunCreated["environment"];
    /** @deprecated See `runId`. */
    caseUpsert?: PlatformEvalRunCreated["caseUpsert"];
};
declare const runEvalSuiteOperation: PlatformOperation<RunEvalSuiteInput, RunEvalSuiteResult>;
declare const runEvalCaseInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    case: z.ZodString;
    servers: z.ZodOptional<z.ZodArray<z.ZodString>>;
    environment: z.ZodOptional<z.ZodString>;
    host: z.ZodOptional<z.ZodString>;
    compose: z.ZodOptional<z.ZodObject<{
        host: z.ZodString;
        serverGroup: z.ZodOptional<z.ZodString>;
        model: z.ZodOptional<z.ZodString>;
        models: z.ZodOptional<z.ZodArray<z.ZodString>>;
        includeClientDefault: z.ZodOptional<z.ZodBoolean>;
        saveTargets: z.ZodOptional<z.ZodBoolean>;
        computer: z.ZodOptional<z.ZodString>;
        skills: z.ZodOptional<z.ZodObject<{
            mode: z.ZodLiteral<"explicit">;
            skillIds: z.ZodArray<z.ZodString>;
        }, z.core.$strip>>;
        pluginVersionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
    repetitions: z.ZodOptional<z.ZodNumber>;
    iterations: z.ZodOptional<z.ZodNumber>;
    idempotencyKey: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type RunEvalCaseInput = z.infer<typeof runEvalCaseInput>;
type RunEvalCaseResult = {
    project: SelectedProjectInfo;
    suite: {
        id: string;
        name: string | null;
    };
    case: {
        id: string;
        title: string | null;
    };
    servers: Array<{
        id: string;
        name?: string;
    }>;
    /** The environment the run is pinned to; see `RunEvalSuiteResult`. */
    environment: PlatformEvalRunCreated["environment"];
    /** The attached host the run is stamped with, when one was named. */
    host?: {
        id: string;
        name: string;
    };
    /** See `RunEvalSuiteResult.composed`. */
    composed?: {
        environment: {
            id: string;
            name: null;
            adhoc: true;
            created: boolean;
            modelId?: string;
        };
        environments?: Array<{
            id: string;
            name: null;
            adhoc: true;
            created: boolean;
            modelId?: string;
        }>;
        attachment: {
            attached: boolean;
        };
    };
    runId: string;
    status: string;
};
declare const runEvalCaseOperation: PlatformOperation<RunEvalCaseInput, RunEvalCaseResult>;
declare const createEvalSuiteInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    servers: z.ZodArray<z.ZodString>;
    model: z.ZodString;
    provider: z.ZodOptional<z.ZodString>;
    cases: z.ZodArray<z.ZodObject<{
        title: z.ZodString;
        runs: z.ZodOptional<z.ZodNumber>;
        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            id: z.ZodString;
            kind: z.ZodLiteral<"prompt">;
            prompt: z.ZodString;
        }, z.core.$loose>, z.ZodObject<{
            id: z.ZodString;
            kind: z.ZodLiteral<"toolCall">;
            serverId: z.ZodOptional<z.ZodString>;
            serverName: z.ZodString;
            toolName: z.ZodString;
            arguments: z.ZodRecord<z.ZodString, z.ZodAny>;
            renderTimeoutMs: z.ZodOptional<z.ZodNumber>;
        }, z.core.$loose>, z.ZodObject<{
            id: z.ZodString;
            kind: z.ZodLiteral<"interact">;
            toolName: z.ZodString;
            action: z.ZodRecord<z.ZodString, z.ZodAny>;
        }, z.core.$loose>, z.ZodObject<{
            id: z.ZodString;
            kind: z.ZodLiteral<"assert">;
            assertion: z.ZodRecord<z.ZodString, z.ZodAny>;
        }, z.core.$loose>], "kind">>;
        expectedOutput: z.ZodOptional<z.ZodString>;
        isNegativeTest: z.ZodOptional<z.ZodBoolean>;
        scenario: z.ZodOptional<z.ZodString>;
        advancedConfig: z.ZodOptional<z.ZodObject<{
            system: z.ZodOptional<z.ZodString>;
            temperature: z.ZodOptional<z.ZodNumber>;
            toolChoice: z.ZodOptional<z.ZodAny>;
        }, z.core.$loose>>;
        matchOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        predicates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        model: z.ZodOptional<z.ZodString>;
        provider: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strict>;
type CreateEvalSuiteInput = z.infer<typeof createEvalSuiteInput>;
type CreateEvalSuiteResult = {
    project: SelectedProjectInfo;
    suite: {
        id: string;
        name: string | null;
    };
    /** The HTTP servers the suite was configured against. */
    servers: Array<{
        id: string;
        name?: string;
    }>;
    caseUpsert: PlatformEvalSuiteCreated["caseUpsert"];
};
declare const createEvalSuiteOperation: PlatformOperation<CreateEvalSuiteInput, CreateEvalSuiteResult>;
declare const getEvalSuiteInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
}, z.core.$strip>;
type GetEvalSuiteInput = z.infer<typeof getEvalSuiteInput>;
declare const getEvalSuiteOperation: PlatformOperation<GetEvalSuiteInput, PlatformEvalSuiteDetail>;
declare const getEvalRunDisclosureInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    cases: z.ZodOptional<z.ZodArray<z.ZodString>>;
    environment: z.ZodOptional<z.ZodString>;
    environments: z.ZodOptional<z.ZodArray<z.ZodString>>;
    host: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type GetEvalRunDisclosureInput = z.infer<typeof getEvalRunDisclosureInput>;
declare const getEvalRunDisclosureOperation: PlatformOperation<GetEvalRunDisclosureInput, PlatformEvalRunDisclosure>;
declare const updateEvalSuiteInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    environment: z.ZodOptional<z.ZodObject<{
        servers: z.ZodOptional<z.ZodArray<z.ZodString>>;
        computerEnvironment: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
    }, z.core.$strip>>;
    executionConfig: z.ZodOptional<z.ZodObject<{
        model: z.ZodOptional<z.ZodString>;
        systemPrompt: z.ZodOptional<z.ZodString>;
        temperature: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
    hosts: z.ZodOptional<z.ZodArray<z.ZodObject<{
        host: z.ZodString;
        servers: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>>;
    settings: z.ZodOptional<z.ZodObject<{
        minimumAccuracy: z.ZodOptional<z.ZodNumber>;
        minimumIterations: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
        matchOptions: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            toolCallOrder: z.ZodOptional<z.ZodEnum<{
                any: "any";
                exact: "exact";
                "in-order": "in-order";
            }>>;
            extraToolCalls: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"unlimited">, z.ZodNumber]>>;
            arguments: z.ZodOptional<z.ZodEnum<{
                ignore: "ignore";
                partial: "partial";
                exact: "exact";
            }>>;
        }, z.core.$strip>>>;
        checks: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
            type: z.ZodString;
        }, z.core.$loose>>>>;
        judge: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodOptional<z.ZodBoolean>;
            model: z.ZodOptional<z.ZodString>;
            autoRun: z.ZodOptional<z.ZodBoolean>;
            threshold: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
}, z.core.$strict>;
type UpdateEvalSuiteInput = z.infer<typeof updateEvalSuiteInput>;
declare const updateEvalSuiteOperation: PlatformOperation<UpdateEvalSuiteInput, PlatformEvalSuiteDetail>;
declare const deleteEvalSuiteInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
}, z.core.$strip>;
type DeleteEvalSuiteInput = z.infer<typeof deleteEvalSuiteInput>;
declare const deleteEvalSuiteOperation: PlatformOperation<DeleteEvalSuiteInput, PlatformEvalSuiteDeleted>;
declare const setEvalSuiteScheduleInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    enabled: z.ZodBoolean;
    intervalMinutes: z.ZodOptional<z.ZodNumber>;
    environment: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type SetEvalSuiteScheduleInput = z.infer<typeof setEvalSuiteScheduleInput>;
declare const setEvalSuiteScheduleOperation: PlatformOperation<SetEvalSuiteScheduleInput, PlatformEvalSuiteDetail>;
declare const setEvalSuiteEnvironmentsInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    environments: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodNull]>;
}, z.core.$strip>;
type SetEvalSuiteEnvironmentsInput = z.infer<typeof setEvalSuiteEnvironmentsInput>;
declare const setEvalSuiteEnvironmentsOperation: PlatformOperation<SetEvalSuiteEnvironmentsInput, PlatformEvalSuiteDetail>;
declare const listEvalCasesInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
}, z.core.$strip>;
type ListEvalCasesInput = z.infer<typeof listEvalCasesInput>;
declare const listEvalCasesOperation: PlatformOperation<ListEvalCasesInput, PlatformPage<PlatformEvalCaseWithSuite>>;
declare const getEvalCaseInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    case: z.ZodString;
}, z.core.$strip>;
type GetEvalCaseInput = z.infer<typeof getEvalCaseInput>;
declare const getEvalCaseOperation: PlatformOperation<GetEvalCaseInput, PlatformEvalCaseWithSuite>;
declare const createEvalCaseInput: z.ZodObject<{
    title: z.ZodString;
    id: z.ZodOptional<z.ZodString>;
    steps: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        kind: z.ZodLiteral<"prompt">;
        prompt: z.ZodString;
    }, z.core.$loose>, z.ZodObject<{
        id: z.ZodString;
        kind: z.ZodLiteral<"toolCall">;
        serverId: z.ZodOptional<z.ZodString>;
        serverName: z.ZodString;
        toolName: z.ZodString;
        arguments: z.ZodRecord<z.ZodString, z.ZodAny>;
        renderTimeoutMs: z.ZodOptional<z.ZodNumber>;
    }, z.core.$loose>, z.ZodObject<{
        id: z.ZodString;
        kind: z.ZodLiteral<"interact">;
        toolName: z.ZodString;
        action: z.ZodRecord<z.ZodString, z.ZodAny>;
    }, z.core.$loose>, z.ZodObject<{
        id: z.ZodString;
        kind: z.ZodLiteral<"assert">;
        assertion: z.ZodRecord<z.ZodString, z.ZodAny>;
    }, z.core.$loose>], "kind">>>;
    expectedOutput: z.ZodOptional<z.ZodString>;
    iterations: z.ZodOptional<z.ZodNumber>;
    isNegative: z.ZodOptional<z.ZodBoolean>;
    scenario: z.ZodOptional<z.ZodString>;
    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
        model: z.ZodString;
        provider: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    matchOptions: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        toolCallOrder: z.ZodOptional<z.ZodEnum<{
            any: "any";
            exact: "exact";
            "in-order": "in-order";
        }>>;
        extraToolCalls: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"unlimited">, z.ZodNumber]>>;
        arguments: z.ZodOptional<z.ZodEnum<{
            ignore: "ignore";
            partial: "partial";
            exact: "exact";
        }>>;
    }, z.core.$strip>>>;
    checks: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        mode: z.ZodEnum<{
            inherit: "inherit";
            replace: "replace";
            extend: "extend";
        }>;
        list: z.ZodArray<z.ZodObject<{
            type: z.ZodString;
        }, z.core.$loose>>;
    }, z.core.$strip>>>;
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
}, z.core.$strip>;
type CreateEvalCaseInput = z.infer<typeof createEvalCaseInput>;
declare const createEvalCaseOperation: PlatformOperation<CreateEvalCaseInput, PlatformEvalCaseWithSuite>;
declare const createEvalCasesInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    cases: z.ZodArray<z.ZodObject<{
        title: z.ZodString;
        id: z.ZodOptional<z.ZodString>;
        steps: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            id: z.ZodString;
            kind: z.ZodLiteral<"prompt">;
            prompt: z.ZodString;
        }, z.core.$loose>, z.ZodObject<{
            id: z.ZodString;
            kind: z.ZodLiteral<"toolCall">;
            serverId: z.ZodOptional<z.ZodString>;
            serverName: z.ZodString;
            toolName: z.ZodString;
            arguments: z.ZodRecord<z.ZodString, z.ZodAny>;
            renderTimeoutMs: z.ZodOptional<z.ZodNumber>;
        }, z.core.$loose>, z.ZodObject<{
            id: z.ZodString;
            kind: z.ZodLiteral<"interact">;
            toolName: z.ZodString;
            action: z.ZodRecord<z.ZodString, z.ZodAny>;
        }, z.core.$loose>, z.ZodObject<{
            id: z.ZodString;
            kind: z.ZodLiteral<"assert">;
            assertion: z.ZodRecord<z.ZodString, z.ZodAny>;
        }, z.core.$loose>], "kind">>>;
        expectedOutput: z.ZodOptional<z.ZodString>;
        iterations: z.ZodOptional<z.ZodNumber>;
        isNegative: z.ZodOptional<z.ZodBoolean>;
        scenario: z.ZodOptional<z.ZodString>;
        models: z.ZodOptional<z.ZodArray<z.ZodObject<{
            model: z.ZodString;
            provider: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        matchOptions: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            toolCallOrder: z.ZodOptional<z.ZodEnum<{
                any: "any";
                exact: "exact";
                "in-order": "in-order";
            }>>;
            extraToolCalls: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"unlimited">, z.ZodNumber]>>;
            arguments: z.ZodOptional<z.ZodEnum<{
                ignore: "ignore";
                partial: "partial";
                exact: "exact";
            }>>;
        }, z.core.$strip>>>;
        checks: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            mode: z.ZodEnum<{
                inherit: "inherit";
                replace: "replace";
                extend: "extend";
            }>;
            list: z.ZodArray<z.ZodObject<{
                type: z.ZodString;
            }, z.core.$loose>>;
        }, z.core.$strip>>>;
    }, z.core.$strip>>;
    duplicatePolicy: z.ZodOptional<z.ZodEnum<{
        warn: "warn";
        block: "block";
        create_anyway: "create_anyway";
    }>>;
    overrideReason: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type CreateEvalCasesInput = z.infer<typeof createEvalCasesInput>;
declare const createEvalCasesOperation: PlatformOperation<CreateEvalCasesInput, CreateEvalCasesResult>;
declare const updateEvalCaseInput: z.ZodObject<{
    title: z.ZodOptional<z.ZodString>;
    steps: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        kind: z.ZodLiteral<"prompt">;
        prompt: z.ZodString;
    }, z.core.$loose>, z.ZodObject<{
        id: z.ZodString;
        kind: z.ZodLiteral<"toolCall">;
        serverId: z.ZodOptional<z.ZodString>;
        serverName: z.ZodString;
        toolName: z.ZodString;
        arguments: z.ZodRecord<z.ZodString, z.ZodAny>;
        renderTimeoutMs: z.ZodOptional<z.ZodNumber>;
    }, z.core.$loose>, z.ZodObject<{
        id: z.ZodString;
        kind: z.ZodLiteral<"interact">;
        toolName: z.ZodString;
        action: z.ZodRecord<z.ZodString, z.ZodAny>;
    }, z.core.$loose>, z.ZodObject<{
        id: z.ZodString;
        kind: z.ZodLiteral<"assert">;
        assertion: z.ZodRecord<z.ZodString, z.ZodAny>;
    }, z.core.$loose>], "kind">>>;
    expectedOutput: z.ZodOptional<z.ZodString>;
    iterations: z.ZodOptional<z.ZodNumber>;
    isNegative: z.ZodOptional<z.ZodBoolean>;
    scenario: z.ZodOptional<z.ZodString>;
    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
        model: z.ZodString;
        provider: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    matchOptions: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        toolCallOrder: z.ZodOptional<z.ZodEnum<{
            any: "any";
            exact: "exact";
            "in-order": "in-order";
        }>>;
        extraToolCalls: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"unlimited">, z.ZodNumber]>>;
        arguments: z.ZodOptional<z.ZodEnum<{
            ignore: "ignore";
            partial: "partial";
            exact: "exact";
        }>>;
    }, z.core.$strip>>>;
    checks: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        mode: z.ZodEnum<{
            inherit: "inherit";
            replace: "replace";
            extend: "extend";
        }>;
        list: z.ZodArray<z.ZodObject<{
            type: z.ZodString;
        }, z.core.$loose>>;
    }, z.core.$strip>>>;
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    case: z.ZodString;
}, z.core.$strip>;
type UpdateEvalCaseInput = z.infer<typeof updateEvalCaseInput>;
declare const updateEvalCaseOperation: PlatformOperation<UpdateEvalCaseInput, PlatformEvalCaseWithSuite>;
declare const deleteEvalCaseInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    case: z.ZodString;
}, z.core.$strip>;
type DeleteEvalCaseInput = z.infer<typeof deleteEvalCaseInput>;
declare const deleteEvalCaseOperation: PlatformOperation<DeleteEvalCaseInput, PlatformEvalCaseDeleted>;
declare const generateEvalCasesInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    mode: z.ZodOptional<z.ZodEnum<{
        normal: "normal";
        negative: "negative";
    }>>;
    servers: z.ZodOptional<z.ZodArray<z.ZodString>>;
    environment: z.ZodOptional<z.ZodString>;
    caseModels: z.ZodOptional<z.ZodArray<z.ZodObject<{
        model: z.ZodString;
        provider: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    caseMix: z.ZodOptional<z.ZodObject<{
        simple: z.ZodOptional<z.ZodNumber>;
        multiTool: z.ZodOptional<z.ZodNumber>;
        multiTurn: z.ZodOptional<z.ZodNumber>;
        complex: z.ZodOptional<z.ZodNumber>;
        negative: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
    varyUserStyles: z.ZodOptional<z.ZodBoolean>;
    idempotencyKey: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type GenerateEvalCasesInput = z.infer<typeof generateEvalCasesInput>;
declare const generateEvalCasesOperation: PlatformOperation<GenerateEvalCasesInput, GenerateEvalCasesResult>;
declare const evalRunScopedInput: z.ZodObject<{
    project: z.ZodString;
    runId: z.ZodString;
}, z.core.$strip>;
type EvalRunScopedInput = z.infer<typeof evalRunScopedInput>;
declare const getEvalRunInput: z.ZodObject<{
    project: z.ZodString;
    runId: z.ZodString;
    diagnosticsCursor: z.ZodOptional<z.ZodString>;
    diagnosticsLimit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type GetEvalRunInput = z.infer<typeof getEvalRunInput>;
type GetEvalRunResult = {
    project: SelectedProjectInfo;
    run: PlatformEvalRun;
    /**
     * The canonical decision summary, for a terminal run.
     *
     * ABSENT while the run is still going. Older API deployments are supported
     * through the shared iteration fallback; it is absent only when both the
     * canonical endpoint and the older iteration resource are unavailable.
     * Fallback assembly uses the same contract assembler as the API, so it does
     * not create a second verdict implementation.
     */
    decisionSummary?: PlatformEvalRunDecisionSummary;
};
declare const getEvalRunOperation: PlatformOperation<GetEvalRunInput, GetEvalRunResult>;
declare const compareEvalRunInput: z.ZodObject<{
    project: z.ZodString;
    runId: z.ZodString;
    baseRunId: z.ZodOptional<z.ZodString>;
    baseCommitSha: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type CompareEvalRunInput = z.infer<typeof compareEvalRunInput>;
type CompareEvalRunResult = {
    project: SelectedProjectInfo;
    compare: PlatformRunCompare;
};
declare const compareEvalRunOperation: PlatformOperation<CompareEvalRunInput, CompareEvalRunResult>;
declare const evalRunIterationsInput: z.ZodObject<{
    project: z.ZodString;
    runId: z.ZodString;
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ListEvalRunIterationsInput = z.infer<typeof evalRunIterationsInput>;
type ListEvalRunIterationsResult = {
    project: SelectedProjectInfo;
    runId: string;
    items: PlatformEvalIteration[];
    nextCursor?: string;
};
declare const listEvalRunIterationsOperation: PlatformOperation<ListEvalRunIterationsInput, ListEvalRunIterationsResult>;
declare const evalIterationTraceInput: z.ZodObject<{
    project: z.ZodString;
    runId: z.ZodString;
    iterationId: z.ZodString;
}, z.core.$strip>;
type GetEvalIterationTraceInput = z.infer<typeof evalIterationTraceInput>;
type GetEvalIterationTraceResult = {
    project: SelectedProjectInfo;
    runId: string;
    iterationId: string;
    trace: unknown;
};
declare const getEvalIterationTraceOperation: PlatformOperation<GetEvalIterationTraceInput, GetEvalIterationTraceResult>;
type CancelEvalRunResult = {
    project: SelectedProjectInfo;
    run: PlatformEvalRun;
};
declare const cancelEvalRunOperation: PlatformOperation<EvalRunScopedInput, CancelEvalRunResult>;
declare const waiveEvalGateInput: z.ZodObject<{
    project: z.ZodString;
    runId: z.ZodString;
    reason: z.ZodString;
    expiresAt: z.ZodNumber;
}, z.core.$strip>;
type WaiveEvalGateInput = z.infer<typeof waiveEvalGateInput>;
type WaiveEvalGateResult = {
    project: SelectedProjectInfo;
    status: PlatformGateWaiverWriteResult["status"];
    republishedChecks: number;
    waiver: PlatformGateWaiver;
};
declare const waiveEvalGateOperation: PlatformOperation<WaiveEvalGateInput, WaiveEvalGateResult>;
type GetEvalGateWaiverResult = {
    project: SelectedProjectInfo;
    runId: string;
    waiver: PlatformGateWaiver | null;
};
declare const getEvalGateWaiverOperation: PlatformOperation<EvalRunScopedInput, GetEvalGateWaiverResult>;
declare const revokeEvalGateWaiverInput: z.ZodObject<{
    project: z.ZodString;
    runId: z.ZodString;
    waiverId: z.ZodString;
}, z.core.$strip>;
type RevokeEvalGateWaiverInput = z.infer<typeof revokeEvalGateWaiverInput>;
declare const revokeEvalGateWaiverOperation: PlatformOperation<RevokeEvalGateWaiverInput, WaiveEvalGateResult>;
declare const requestEvalRunJudgeInput: z.ZodObject<{
    project: z.ZodString;
    runId: z.ZodString;
    force: z.ZodOptional<z.ZodBoolean>;
    enable: z.ZodOptional<z.ZodBoolean>;
    model: z.ZodOptional<z.ZodString>;
    threshold: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type RequestEvalRunJudgeInput = z.infer<typeof requestEvalRunJudgeInput>;
type RequestEvalRunJudgeResult = {
    project: SelectedProjectInfo;
    judge: PlatformEvalRunJudgeRequested;
};
declare const requestEvalRunJudgeOperation: PlatformOperation<RequestEvalRunJudgeInput, RequestEvalRunJudgeResult>;
declare const listEvalCheckReposInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ListEvalCheckReposInput = z.infer<typeof listEvalCheckReposInput>;
type ListEvalCheckReposResult = {
    project: SelectedProjectInfo;
    checks: PlatformEvalCheckRepos;
};
declare const listEvalCheckReposOperation: PlatformOperation<ListEvalCheckReposInput, ListEvalCheckReposResult>;
declare const connectEvalCheckRepoInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    suite: z.ZodString;
    repo: z.ZodString;
    outagePolicy: z.ZodEnum<{
        fail_open: "fail_open";
        fail_closed: "fail_closed";
    }>;
}, z.core.$strip>;
type ConnectEvalCheckRepoInput = z.infer<typeof connectEvalCheckRepoInput>;
type ConnectEvalCheckRepoResult = {
    project: SelectedProjectInfo;
    check: PlatformEvalCheckRepoConnected;
};
declare const connectEvalCheckRepoOperation: PlatformOperation<ConnectEvalCheckRepoInput, ConnectEvalCheckRepoResult>;
declare const evalRunStepsInput: z.ZodObject<{
    project: z.ZodString;
    runId: z.ZodString;
    iterationId: z.ZodString;
}, z.core.$strip>;
type GetEvalRunStepsInput = z.infer<typeof evalRunStepsInput>;
type GetEvalRunStepsResult = {
    project: SelectedProjectInfo;
    runId: string;
    iterationId: string;
    steps: PlatformEvalStepResult[];
};
declare const getEvalRunStepsOperation: PlatformOperation<GetEvalRunStepsInput, GetEvalRunStepsResult>;
declare const createTunnelInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
}, z.core.$strip>;
type CreateTunnelInput = z.infer<typeof createTunnelInput>;
type CreateTunnelResult = {
    project: SelectedProjectInfo;
    grant: PlatformTunnelGrant;
};
declare const createTunnelOperation: PlatformOperation<CreateTunnelInput, CreateTunnelResult>;
declare const closeTunnelInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    serverId: z.ZodString;
}, z.core.$strip>;
type CloseTunnelInput = z.infer<typeof closeTunnelInput>;
type CloseTunnelResult = {
    project: SelectedProjectInfo;
    serverId: string;
    status: string;
};
declare const closeTunnelOperation: PlatformOperation<CloseTunnelInput, CloseTunnelResult>;
type ListScenariosResult = {
    project: SelectedProjectInfo;
    items: PlatformScenarioSummary[];
    otherProjects: ProjectInfo[];
};
declare const listScenariosOperation: PlatformOperation<ProjectScopedInput, ListScenariosResult>;
declare const scenarioScopedInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
}, z.core.$strip>;
type GetScenarioInput = z.infer<typeof scenarioScopedInput>;
type GetScenarioResult = {
    project: SelectedProjectInfo;
    scenario: PlatformScenarioDetail;
};
declare const getScenarioOperation: PlatformOperation<GetScenarioInput, GetScenarioResult>;
declare const listChatSessionsInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    status: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
    cursor: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ListChatSessionsInput = z.infer<typeof listChatSessionsInput>;
type ListChatSessionsResult = {
    project?: SelectedProjectInfo;
    items: PlatformChatSession[];
    nextCursor?: string;
};
declare const listChatSessionsOperation: PlatformOperation<ListChatSessionsInput, ListChatSessionsResult>;
declare const sendChatMessageInput: z.ZodObject<{
    idempotencyKey: z.ZodString;
    message: z.ZodString;
    project: z.ZodOptional<z.ZodString>;
    sessionId: z.ZodOptional<z.ZodString>;
    modelId: z.ZodOptional<z.ZodString>;
    environmentId: z.ZodOptional<z.ZodString>;
    serverIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
    systemPrompt: z.ZodOptional<z.ZodString>;
    temperature: z.ZodOptional<z.ZodNumber>;
    maxSteps: z.ZodOptional<z.ZodNumber>;
    toolMode: z.ZodOptional<z.ZodEnum<{
        auto: "auto";
        read_only: "read_only";
    }>>;
    allowedServerIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
    maxToolCalls: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type SendChatMessageInput = z.infer<typeof sendChatMessageInput>;
declare const sendChatMessageOperation: PlatformOperation<SendChatMessageInput, PlatformChatTurn>;
declare const getChatSessionInput: z.ZodObject<{
    sessionId: z.ZodString;
    project: z.ZodOptional<z.ZodString>;
    afterMessageIndex: z.ZodOptional<z.ZodNumber>;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type GetChatSessionInput = z.infer<typeof getChatSessionInput>;
declare const getChatSessionOperation: PlatformOperation<GetChatSessionInput, PlatformChatSessionDetail>;
declare const getChatSessionTraceInput: z.ZodObject<{
    sessionId: z.ZodString;
    project: z.ZodOptional<z.ZodString>;
    turnId: z.ZodOptional<z.ZodString>;
    afterPromptIndex: z.ZodOptional<z.ZodNumber>;
    limit: z.ZodOptional<z.ZodNumber>;
    includeSpans: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type GetChatSessionTraceInput = z.infer<typeof getChatSessionTraceInput>;
declare const getChatSessionTraceOperation: PlatformOperation<GetChatSessionTraceInput, PlatformChatSessionTrace>;
declare const searchSessionsInput: z.ZodObject<{
    query: z.ZodString;
    scope: z.ZodOptional<z.ZodEnum<{
        titles: "titles";
        transcripts: "transcripts";
    }>>;
    project: z.ZodOptional<z.ZodString>;
    sourceTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
        eval: "eval";
        direct: "direct";
        scenario: "scenario";
        swarm: "swarm";
    }>>>;
    status: z.ZodOptional<z.ZodEnum<{
        active: "active";
        archived: "archived";
    }>>;
    limit: z.ZodOptional<z.ZodNumber>;
    cursor: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type SearchSessionsInput = z.infer<typeof searchSessionsInput>;
type SearchSessionsResult = {
    project: SelectedProjectInfo;
    scope: "titles" | "transcripts";
    items: PlatformSessionSummary[];
    nextCursor?: string;
};
declare const searchSessionsOperation: PlatformOperation<SearchSessionsInput, SearchSessionsResult>;
type ListClientsResult = {
    project: SelectedProjectInfo;
    items: PlatformClient[];
    otherProjects: ProjectInfo[];
};
declare const listClientsOperation: PlatformOperation<ProjectScopedInput, ListClientsResult>;
declare const getClientInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    client: z.ZodString;
}, z.core.$strip>;
type GetClientInput = z.infer<typeof getClientInput>;
declare const getClientOperation: PlatformOperation<GetClientInput, PlatformClientDetail>;
declare const createClientInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
    template: z.ZodOptional<z.ZodString>;
    theme: z.ZodOptional<z.ZodEnum<{
        light: "light";
        dark: "dark";
    }>>;
    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
type CreateClientInput = z.infer<typeof createClientInput>;
declare const createClientOperation: PlatformOperation<CreateClientInput, PlatformClientDetail>;
declare const updateClientInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    client: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    expectedName: z.ZodOptional<z.ZodString>;
    expectedConfigId: z.ZodOptional<z.ZodString>;
    expectedImpact: z.ZodOptional<z.ZodObject<{
        liveEnvironmentCount: z.ZodNumber;
        scenarioAttachmentCount: z.ZodNumber;
        activeLegacyJourneyCount: z.ZodNumber;
    }, z.core.$strip>>;
    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    set: z.ZodOptional<z.ZodObject<{
        modelId: z.ZodOptional<z.ZodString>;
        systemPrompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        requireToolApproval: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        connectionDefaults: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            headers: z.ZodRecord<z.ZodString, z.ZodString>;
            requestTimeout: z.ZodNumber;
        }, z.core.$strip>>>;
        respectToolVisibility: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        progressiveToolDiscovery: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        harness: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
            "claude-code": "claude-code";
            codex: "codex";
        }>>>;
        computer: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            kind: z.ZodLiteral<"personal">;
            toolset: z.ZodOptional<z.ZodLiteral<"bash">>;
            workdir: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        builtInToolIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
        skillSelection: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
            mode: z.ZodLiteral<"all-visible">;
        }, z.core.$strip>, z.ZodObject<{
            mode: z.ZodLiteral<"explicit">;
            skillIds: z.ZodArray<z.ZodString>;
        }, z.core.$strip>]>>>;
        modelVisibleMcpToolResults: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        mcpToolResultImageRendering: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        mcpProfile: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        hostCapabilitiesOverride: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        chatUiOverride: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type UpdateClientInput = z.infer<typeof updateClientInput>;
declare const updateClientOperation: PlatformOperation<UpdateClientInput, PlatformClientDetail>;
declare const deleteClientInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    client: z.ZodString;
}, z.core.$strip>;
type DeleteClientInput = z.infer<typeof deleteClientInput>;
declare const deleteClientOperation: PlatformOperation<DeleteClientInput, PlatformClientDeleted>;
declare const setClientServersInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    client: z.ZodString;
    serverIds: z.ZodArray<z.ZodString>;
    optionalServerIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
    expectedConfigId: z.ZodString;
    expectedImpact: z.ZodOptional<z.ZodObject<{
        liveEnvironmentCount: z.ZodNumber;
        scenarioAttachmentCount: z.ZodNumber;
        activeLegacyJourneyCount: z.ZodNumber;
    }, z.core.$strip>>;
}, z.core.$strip>;
type SetClientServersInput = z.infer<typeof setClientServersInput>;
declare const setClientServersOperation: PlatformOperation<SetClientServersInput, PlatformClientDetail>;
declare const duplicateClientInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    client: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type DuplicateClientInput = z.infer<typeof duplicateClientInput>;
declare const duplicateClientOperation: PlatformOperation<DuplicateClientInput, PlatformClientDetail>;
/** @deprecated Use {@link listClientsOperation}. */
type ListHostsResult = {
    project: SelectedProjectInfo;
    items: PlatformHost[];
    otherProjects: ProjectInfo[];
};
/** @deprecated Use {@link listClientsOperation}. */
declare const listHostsOperation: PlatformOperation<ProjectScopedInput, ListHostsResult>;
declare const getHostInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    host: z.ZodString;
}, z.core.$strip>;
/** @deprecated Use {@link GetClientInput}. */
type GetHostInput = z.infer<typeof getHostInput>;
/** @deprecated Use {@link getClientOperation}. */
declare const getHostOperation: PlatformOperation<GetHostInput, PlatformHostDetail>;
declare const updateHostInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    host: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
/** @deprecated Use {@link UpdateClientInput}. */
type UpdateHostInput = z.infer<typeof updateHostInput>;
/** @deprecated Use {@link updateClientOperation}, which is compare-and-set. */
declare const updateHostOperation: PlatformOperation<UpdateHostInput, PlatformHostDetail>;
declare const createHostInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
    template: z.ZodOptional<z.ZodString>;
    theme: z.ZodOptional<z.ZodEnum<{
        light: "light";
        dark: "dark";
    }>>;
    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
/** @deprecated Use {@link CreateClientInput}. */
type CreateHostInput = z.infer<typeof createHostInput>;
/** @deprecated Use {@link createClientOperation}. */
declare const createHostOperation: PlatformOperation<CreateHostInput, PlatformHostDetail>;
declare const deleteHostInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    host: z.ZodString;
}, z.core.$strip>;
/** @deprecated Use {@link DeleteClientInput}. */
type DeleteHostInput = z.infer<typeof deleteHostInput>;
/** @deprecated Use {@link deleteClientOperation}. */
declare const deleteHostOperation: PlatformOperation<DeleteHostInput, PlatformHostDeleted>;
declare const setHostServersInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    host: z.ZodString;
    serverIds: z.ZodArray<z.ZodString>;
    optionalServerIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
/** @deprecated Use {@link SetClientServersInput}. */
type SetHostServersInput = z.infer<typeof setHostServersInput>;
/** @deprecated Use {@link setClientServersOperation}. */
declare const setHostServersOperation: PlatformOperation<SetHostServersInput, PlatformHostDetail>;
declare const duplicateHostInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    host: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
/** @deprecated Use {@link DuplicateClientInput}. */
type DuplicateHostInput = z.infer<typeof duplicateHostInput>;
/** @deprecated Use {@link duplicateClientOperation}. */
declare const duplicateHostOperation: PlatformOperation<DuplicateHostInput, PlatformHostDetail>;
declare const listEnvironmentsInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    includeArchived: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type ListEnvironmentsInput = z.infer<typeof listEnvironmentsInput>;
type ListEnvironmentsResult = {
    project: SelectedProjectInfo;
    items: PlatformEnvironment[];
    otherProjects: ProjectInfo[];
};
declare const listEnvironmentsOperation: PlatformOperation<ListEnvironmentsInput, ListEnvironmentsResult>;
declare const environmentCapabilitiesInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type EnvironmentCapabilitiesInput = z.infer<typeof environmentCapabilitiesInput>;
type EnvironmentCapabilitiesResult = {
    project: SelectedProjectInfo;
    capabilities: PlatformEnvironmentCapabilities;
};
declare const getEnvironmentCapabilitiesOperation: PlatformOperation<EnvironmentCapabilitiesInput, EnvironmentCapabilitiesResult>;
declare const environmentSelectorInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    environment: z.ZodString;
}, z.core.$strip>;
type EnvironmentSelectorInput = z.infer<typeof environmentSelectorInput>;
declare const getEnvironmentOperation: PlatformOperation<EnvironmentSelectorInput, PlatformEnvironment>;
declare const resolveEnvironmentOperation: PlatformOperation<EnvironmentSelectorInput, PlatformEnvironmentResolved>;
declare const createEnvironmentInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    hostId: z.ZodString;
    serverAttachmentId: z.ZodOptional<z.ZodString>;
    modelId: z.ZodOptional<z.ZodString>;
    skillSelection: z.ZodOptional<z.ZodObject<{
        mode: z.ZodLiteral<"explicit">;
        skillIds: z.ZodArray<z.ZodString>;
    }, z.core.$strip>>;
    pluginVersionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
    sandboxImageId: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type CreateEnvironmentInput = z.infer<typeof createEnvironmentInput>;
declare const createEnvironmentOperation: PlatformOperation<CreateEnvironmentInput, PlatformEnvironment>;
declare const ensureAdhocEnvironmentInput: z.ZodObject<{
    host: z.ZodString;
    serverGroup: z.ZodOptional<z.ZodString>;
    model: z.ZodOptional<z.ZodString>;
    computer: z.ZodOptional<z.ZodString>;
    skills: z.ZodOptional<z.ZodObject<{
        mode: z.ZodLiteral<"explicit">;
        skillIds: z.ZodArray<z.ZodString>;
    }, z.core.$strip>>;
    pluginVersionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
    project: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type EnsureAdhocEnvironmentInput = z.infer<typeof ensureAdhocEnvironmentInput>;
type EnsureAdhocEnvironmentResult = {
    project: SelectedProjectInfo;
    environment: PlatformAdhocEnvironment;
    /** False when this stack had already been composed — see the op description. */
    created: boolean;
};
declare const ensureAdhocEnvironmentOperation: PlatformOperation<EnsureAdhocEnvironmentInput, EnsureAdhocEnvironmentResult>;
declare const nameEnvironmentInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    environment: z.ZodString;
    expectedRevision: z.ZodNumber;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type NameEnvironmentInput = z.infer<typeof nameEnvironmentInput>;
declare const nameEnvironmentOperation: PlatformOperation<NameEnvironmentInput, PlatformEnvironment>;
declare const updateEnvironmentInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    environment: z.ZodString;
    expectedRevision: z.ZodNumber;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    hostId: z.ZodOptional<z.ZodString>;
    serverAttachmentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    modelId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    skillSelection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        mode: z.ZodLiteral<"explicit">;
        skillIds: z.ZodArray<z.ZodString>;
    }, z.core.$strip>>>;
    pluginVersionIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
    sandboxImageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
}, z.core.$strip>;
type UpdateEnvironmentInput = z.infer<typeof updateEnvironmentInput>;
declare const updateEnvironmentOperation: PlatformOperation<UpdateEnvironmentInput, PlatformEnvironment>;
declare const environmentRevisionInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    environment: z.ZodString;
    expectedRevision: z.ZodNumber;
}, z.core.$strip>;
type EnvironmentRevisionInput = z.infer<typeof environmentRevisionInput>;
declare const archiveEnvironmentOperation: PlatformOperation<EnvironmentRevisionInput, PlatformEnvironment>;
declare const restoreEnvironmentOperation: PlatformOperation<EnvironmentRevisionInput, PlatformEnvironment>;
declare const listProjectPluginsInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ListProjectPluginsInput = z.infer<typeof listProjectPluginsInput>;
type ListProjectPluginsResult = {
    project: SelectedProjectInfo;
    items: PlatformPlugin[];
    otherProjects: ProjectInfo[];
};
declare const listProjectPluginsOperation: PlatformOperation<ListProjectPluginsInput, ListProjectPluginsResult>;
declare const getPluginVersionInput: z.ZodObject<{
    pluginVersionId: z.ZodString;
}, z.core.$strip>;
type GetPluginVersionInput = z.infer<typeof getPluginVersionInput>;
declare const getPluginVersionOperation: PlatformOperation<GetPluginVersionInput, PlatformPluginVersion>;
declare const imageSelectorInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    image: z.ZodString;
}, z.core.$strip>;
type ImageSelectorInput = z.infer<typeof imageSelectorInput>;
type ListImagesResult = {
    project: SelectedProjectInfo;
    items: PlatformImage[];
    otherProjects: ProjectInfo[];
};
declare const listImagesOperation: PlatformOperation<ProjectScopedInput, ListImagesResult>;
declare const getImageOperation: PlatformOperation<ImageSelectorInput, PlatformImage>;
declare const createImageInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
    blueprint: z.ZodString;
}, z.core.$strip>;
type CreateImageInput = z.infer<typeof createImageInput>;
declare const createImageOperation: PlatformOperation<CreateImageInput, PlatformImage>;
declare const updateImageInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    image: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    blueprint: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type UpdateImageInput = z.infer<typeof updateImageInput>;
declare const updateImageOperation: PlatformOperation<UpdateImageInput, PlatformImage>;
declare const validateImageBlueprintInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    blueprint: z.ZodString;
}, z.core.$strip>;
type ValidateImageBlueprintInput = z.infer<typeof validateImageBlueprintInput>;
declare const validateImageBlueprintOperation: PlatformOperation<ValidateImageBlueprintInput, PlatformImageBlueprintValidation>;
declare const buildImageOperation: PlatformOperation<ImageSelectorInput, PlatformImageBuildStarted>;
type ListImageBuildsResult = {
    project: SelectedProjectInfo;
    imageId: string;
    items: PlatformImageBuild[];
};
declare const listImageBuildsOperation: PlatformOperation<ImageSelectorInput, ListImageBuildsResult>;
declare const promoteImageOperation: PlatformOperation<ImageSelectorInput, PlatformImage>;
declare const useImageOperation: PlatformOperation<ImageSelectorInput, PlatformComputerAttached>;
declare const resetComputerOperation: PlatformOperation<ProjectScopedInput, PlatformComputerReset>;
declare const deleteImageOperation: PlatformOperation<ImageSelectorInput, PlatformImageDeleted>;
declare const serverWriteBody: z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    enabled: z.ZodOptional<z.ZodBoolean>;
    transportType: z.ZodOptional<z.ZodEnum<{
        http: "http";
        stdio: "stdio";
    }>>;
    command: z.ZodOptional<z.ZodString>;
    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    url: z.ZodOptional<z.ZodString>;
    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    timeout: z.ZodOptional<z.ZodNumber>;
    useOAuth: z.ZodOptional<z.ZodBoolean>;
    oauthScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
    clientId: z.ZodOptional<z.ZodString>;
    clientSecret: z.ZodOptional<z.ZodString>;
    clearClientSecret: z.ZodOptional<z.ZodBoolean>;
    clearXaaConfig: z.ZodOptional<z.ZodBoolean>;
}, z.core.$loose>;
type CreateProjectServerInput = {
    project?: string;
    body: z.infer<typeof serverWriteBody> & {
        name: string;
        enabled: boolean;
        transportType: "stdio" | "http";
    };
};
declare const createProjectServerOperation: PlatformOperation<CreateProjectServerInput, PlatformProjectServer>;
type GetProjectServerInput = ProjectScopedInput & {
    serverId: string;
};
declare const getProjectServerOperation: PlatformOperation<GetProjectServerInput, PlatformProjectServer>;
type UpdateProjectServerInput = GetProjectServerInput & {
    body: z.infer<typeof serverWriteBody>;
};
declare const updateProjectServerOperation: PlatformOperation<UpdateProjectServerInput, PlatformProjectServer>;
declare const deleteProjectServerOperation: PlatformOperation<GetProjectServerInput, {
    id: string;
    deleted: boolean;
}>;
/** Any catalog operation with its input/output types erased. */
type AnyPlatformOperation = PlatformOperation<any, unknown>;
declare const listJourneysInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ListJourneysInput = z.infer<typeof listJourneysInput>;
type ListJourneysResult = {
    project: SelectedProjectInfo;
    items: PlatformJourney[];
    otherProjects: ProjectInfo[];
};
declare const listJourneysOperation: PlatformOperation<ListJourneysInput, ListJourneysResult>;
declare const journeyRunsInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    journey: z.ZodString;
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ListJourneyRunsInput = z.infer<typeof journeyRunsInput>;
type ListJourneyRunsResult = {
    project: SelectedProjectInfo;
    items: PlatformJourneyRun[];
    nextCursor?: string;
};
declare const listJourneyRunsOperation: PlatformOperation<ListJourneyRunsInput, ListJourneyRunsResult>;
declare const journeyRunSelectorInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    run: z.ZodString;
}, z.core.$strip>;
type GetJourneyRunInput = z.infer<typeof journeyRunSelectorInput>;
type GetJourneyRunResult = {
    project: SelectedProjectInfo;
    run: PlatformJourneyRun;
};
declare const getJourneyRunOperation: PlatformOperation<GetJourneyRunInput, GetJourneyRunResult>;
declare const journeyRunSessionsInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    run: z.ZodString;
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ListJourneyRunSessionsInput = z.infer<typeof journeyRunSessionsInput>;
type ListJourneyRunSessionsResult = {
    project: SelectedProjectInfo;
    items: PlatformJourneyRunSession[];
    nextCursor?: string;
};
declare const listJourneyRunSessionsOperation: PlatformOperation<ListJourneyRunSessionsInput, ListJourneyRunSessionsResult>;
type CancelJourneyRunInput = z.infer<typeof journeyRunSelectorInput>;
type CancelJourneyRunResult = {
    project: SelectedProjectInfo;
    run: PlatformJourneyRunCanceled;
};
declare const launchJourneyRunInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    journey: z.ZodString;
    idempotencyKey: z.ZodOptional<z.ZodString>;
    waveId: z.ZodOptional<z.ZodString>;
    environmentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
type LaunchJourneyRunInput = z.infer<typeof launchJourneyRunInput>;
type LaunchJourneyRunResult = {
    project: SelectedProjectInfo;
    run: PlatformJourneyRunLaunched;
};
declare const launchJourneyRunOperation: PlatformOperation<LaunchJourneyRunInput, LaunchJourneyRunResult>;
declare const cancelJourneyRunOperation: PlatformOperation<CancelJourneyRunInput, CancelJourneyRunResult>;
declare const scenarioSelectorInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    environment: z.ZodString;
}, z.core.$strip>;
declare const publishScenarioInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    environment: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    mode: z.ZodOptional<z.ZodEnum<{
        project_members: "project_members";
        invited_only: "invited_only";
        anyone_with_link: "anyone_with_link";
    }>>;
}, z.core.$strip>;
type PublishScenarioInput = z.infer<typeof publishScenarioInput>;
type PublishScenarioResult = {
    project: SelectedProjectInfo;
    scenario: PlatformScenario;
    /**
     * True when overrides were sent but the environment was ALREADY published,
     * so they were ignored upstream. The scenario in the result carries the real
     * name and mode — a caller who asked for `invited_only` must not conclude
     * the link is restricted when it is not.
     */
    overridesIgnored?: boolean;
};
declare const publishScenarioOperation: PlatformOperation<PublishScenarioInput, PublishScenarioResult>;
type UnpublishScenarioInput = z.infer<typeof scenarioSelectorInput>;
type UnpublishScenarioResult = {
    project: SelectedProjectInfo;
    result: PlatformScenarioDeleted;
};
declare const unpublishScenarioOperation: PlatformOperation<UnpublishScenarioInput, UnpublishScenarioResult>;
declare const personaSelectorInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    persona: z.ZodString;
}, z.core.$strip>;
declare const listPersonasInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ListPersonasInput = z.infer<typeof listPersonasInput>;
type ListPersonasResult = {
    project: SelectedProjectInfo;
    items: PlatformPersona[];
};
declare const listPersonasOperation: PlatformOperation<ListPersonasInput, ListPersonasResult>;
type GetPersonaInput = z.infer<typeof personaSelectorInput>;
type GetPersonaResult = {
    project: SelectedProjectInfo;
    persona: PlatformPersona;
};
declare const getPersonaOperation: PlatformOperation<GetPersonaInput, GetPersonaResult>;
declare const createPersonaInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
    role: z.ZodString;
    notes: z.ZodOptional<z.ZodString>;
    idempotencyKey: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type CreatePersonaInput = z.infer<typeof createPersonaInput>;
type CreatePersonaResult = {
    project: SelectedProjectInfo;
    persona: PlatformPersona;
};
declare const createPersonaOperation: PlatformOperation<CreatePersonaInput, CreatePersonaResult>;
declare const updatePersonaInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    persona: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    role: z.ZodOptional<z.ZodString>;
    notes: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type UpdatePersonaInput = z.infer<typeof updatePersonaInput>;
type UpdatePersonaResult = CreatePersonaResult;
declare const updatePersonaOperation: PlatformOperation<UpdatePersonaInput, UpdatePersonaResult>;
type DeletePersonaInput = z.infer<typeof personaSelectorInput>;
type DeletePersonaResult = {
    project: SelectedProjectInfo;
    persona: PlatformPersonaDeleted;
};
declare const deletePersonaOperation: PlatformOperation<DeletePersonaInput, DeletePersonaResult>;
declare const journeySelectorInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    journey: z.ZodString;
}, z.core.$strip>;
type GetJourneyInput = z.infer<typeof journeySelectorInput>;
type GetJourneyResult = {
    project: SelectedProjectInfo;
    journey: PlatformJourney;
};
declare const getJourneyOperation: PlatformOperation<GetJourneyInput, GetJourneyResult>;
declare const createJourneyInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    goal: z.ZodString;
    persona: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    swarm: z.ZodOptional<z.ZodString>;
    environmentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
    sessionsPerTarget: z.ZodNumber;
    maxTurns: z.ZodNumber;
    idempotencyKey: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type CreateJourneyInput = z.infer<typeof createJourneyInput>;
type CreateJourneyResult = {
    project: SelectedProjectInfo;
    journey: PlatformJourney;
};
declare const createJourneyOperation: PlatformOperation<CreateJourneyInput, CreateJourneyResult>;
declare const updateJourneyInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    journey: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    goal: z.ZodOptional<z.ZodString>;
    environmentIds: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodNull]>>;
    sessionsPerTarget: z.ZodOptional<z.ZodNumber>;
    maxTurns: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type UpdateJourneyInput = z.infer<typeof updateJourneyInput>;
type UpdateJourneyResult = CreateJourneyResult;
declare const updateJourneyOperation: PlatformOperation<UpdateJourneyInput, UpdateJourneyResult>;
type ArchiveJourneyInput = z.infer<typeof journeySelectorInput>;
type ArchiveJourneyResult = {
    project: SelectedProjectInfo;
    journey: PlatformJourneyArchived;
};
declare const archiveJourneyOperation: PlatformOperation<ArchiveJourneyInput, ArchiveJourneyResult>;
declare const swarmSelectorInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    swarm: z.ZodString;
}, z.core.$strip>;
type ListSwarmsInput = z.infer<typeof listPersonasInput>;
type ListSwarmsResult = {
    project: SelectedProjectInfo;
    items: PlatformSwarm[];
};
declare const listSwarmsOperation: PlatformOperation<ListSwarmsInput, ListSwarmsResult>;
type GetSwarmInput = z.infer<typeof swarmSelectorInput>;
type GetSwarmResult = {
    project: SelectedProjectInfo;
    swarm: PlatformSwarm;
};
declare const getSwarmOperation: PlatformOperation<GetSwarmInput, GetSwarmResult>;
declare const createSwarmInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    environmentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
    sessionsPerTarget: z.ZodNumber;
    maxTurns: z.ZodNumber;
    idempotencyKey: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type CreateSwarmInput = z.infer<typeof createSwarmInput>;
type CreateSwarmResult = {
    project: SelectedProjectInfo;
    swarm: PlatformSwarm;
};
declare const createSwarmOperation: PlatformOperation<CreateSwarmInput, CreateSwarmResult>;
declare const updateSwarmInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    swarm: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
    environmentIds: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodNull]>>;
    sessionsPerTarget: z.ZodOptional<z.ZodNumber>;
    maxTurns: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type UpdateSwarmInput = z.infer<typeof updateSwarmInput>;
type UpdateSwarmResult = CreateSwarmResult;
declare const updateSwarmOperation: PlatformOperation<UpdateSwarmInput, UpdateSwarmResult>;
type ArchiveSwarmInput = z.infer<typeof swarmSelectorInput>;
type ArchiveSwarmResult = {
    project: SelectedProjectInfo;
    swarm: PlatformSwarmArchived;
};
declare const archiveSwarmOperation: PlatformOperation<ArchiveSwarmInput, ArchiveSwarmResult>;
declare const generatePersonasInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    environmentId: z.ZodOptional<z.ZodString>;
    serverAttachmentId: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    journeyCount: z.ZodOptional<z.ZodNumber>;
    personaCount: z.ZodOptional<z.ZodNumber>;
    existingPersonas: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        role: z.ZodString;
    }, z.core.$strip>>>;
}, z.core.$strip>;
type GeneratePersonasInput = z.infer<typeof generatePersonasInput>;
type GeneratePersonasResult = {
    project: SelectedProjectInfo;
    drafts: PlatformGenerationDrafts;
};
declare const generatePersonasOperation: PlatformOperation<GeneratePersonasInput, GeneratePersonasResult>;
declare const generateJourneysInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    environmentId: z.ZodOptional<z.ZodString>;
    serverAttachmentId: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    journeyCount: z.ZodOptional<z.ZodNumber>;
    persona: z.ZodObject<{
        name: z.ZodString;
        role: z.ZodString;
        notes: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
}, z.core.$strip>;
type GenerateJourneysInput = z.infer<typeof generateJourneysInput>;
type GenerateJourneysResult = {
    project: SelectedProjectInfo;
    drafts: PlatformGenerationDrafts;
};
declare const generateJourneysOperation: PlatformOperation<GenerateJourneysInput, GenerateJourneysResult>;
type GetSwarmOverviewInput = z.infer<typeof listPersonasInput>;
type GetSwarmOverviewResult = {
    project: SelectedProjectInfo;
    overview: PlatformSwarmOverview;
};
declare const getSwarmOverviewOperation: PlatformOperation<GetSwarmOverviewInput, GetSwarmOverviewResult>;
type GetJourneyRunScorecardInput = z.infer<typeof journeyRunSelectorInput>;
type GetJourneyRunScorecardResult = {
    project: SelectedProjectInfo;
    scorecard: PlatformRunScorecard;
};
declare const getJourneyRunScorecardOperation: PlatformOperation<GetJourneyRunScorecardInput, GetJourneyRunScorecardResult>;
type ListSwarmFindingsInput = z.infer<typeof listPersonasInput>;
type ListSwarmFindingsResult = {
    project: SelectedProjectInfo;
    items: PlatformSwarmFinding[];
};
declare const listSwarmFindingsOperation: PlatformOperation<ListSwarmFindingsInput, ListSwarmFindingsResult>;
declare const findingSelectorInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    finding: z.ZodString;
}, z.core.$strip>;
type DismissSwarmFindingInput = z.infer<typeof findingSelectorInput>;
type DismissSwarmFindingResult = {
    project: SelectedProjectInfo;
    finding: PlatformFindingDismissed;
};
declare const dismissSwarmFindingOperation: PlatformOperation<DismissSwarmFindingInput, DismissSwarmFindingResult>;
type UndismissSwarmFindingInput = DismissSwarmFindingInput;
type UndismissSwarmFindingResult = DismissSwarmFindingResult;
declare const undismissSwarmFindingOperation: PlatformOperation<UndismissSwarmFindingInput, UndismissSwarmFindingResult>;
declare const waveSelectorInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    wave: z.ZodString;
}, z.core.$strip>;
type GetWaveInsightsInput = z.infer<typeof waveSelectorInput>;
type GetWaveInsightsResult = {
    project: SelectedProjectInfo;
    insights: PlatformWaveInsights;
};
declare const getWaveInsightsOperation: PlatformOperation<GetWaveInsightsInput, GetWaveInsightsResult>;
declare const requestWaveInsightsInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    wave: z.ZodString;
    force: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type RequestWaveInsightsInput = z.infer<typeof requestWaveInsightsInput>;
type RequestWaveInsightsResult = {
    project: SelectedProjectInfo;
    request: PlatformWaveInsightsRequested;
};
declare const requestWaveInsightsOperation: PlatformOperation<RequestWaveInsightsInput, RequestWaveInsightsResult>;
type CancelWaveInsightsInput = z.infer<typeof waveSelectorInput>;
type CancelWaveInsightsResult = {
    project: SelectedProjectInfo;
    canceled: PlatformWaveInsightsCanceled;
};
declare const cancelWaveInsightsOperation: PlatformOperation<CancelWaveInsightsInput, CancelWaveInsightsResult>;
type GetCapabilitiesInput = z.infer<typeof listPersonasInput>;
type GetCapabilitiesResult = {
    project: SelectedProjectInfo;
    capabilities: PlatformCapabilities;
};
declare const getCapabilitiesOperation: PlatformOperation<GetCapabilitiesInput, GetCapabilitiesResult>;
declare const userTestingScenarioSelectorInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
}, z.core.$strip>;
type GetUserTestingScenarioInput = z.infer<typeof userTestingScenarioSelectorInput>;
type GetUserTestingScenarioResult = {
    project: SelectedProjectInfo;
    scenario: PlatformUserTestingScenarioDetail;
};
declare const getUserTestingScenarioOperation: PlatformOperation<GetUserTestingScenarioInput, GetUserTestingScenarioResult>;
declare const updateUserTestingScenarioInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    mode: z.ZodOptional<z.ZodEnum<{
        project_members: "project_members";
        invited_only: "invited_only";
        anyone_with_link: "anyone_with_link";
    }>>;
}, z.core.$strip>;
type UpdateUserTestingScenarioInput = z.infer<typeof updateUserTestingScenarioInput>;
type UpdateUserTestingScenarioResult = {
    project: SelectedProjectInfo;
    scenario: PlatformUserTestingScenario;
};
declare const updateUserTestingScenarioOperation: PlatformOperation<UpdateUserTestingScenarioInput, UpdateUserTestingScenarioResult>;
declare const listUserTestingSessionsInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ListUserTestingSessionsInput = z.infer<typeof listUserTestingSessionsInput>;
type ListUserTestingSessionsResult = {
    project: SelectedProjectInfo;
    items: PlatformUserTestingSession[];
    nextCursor?: string;
};
declare const listUserTestingSessionsOperation: PlatformOperation<ListUserTestingSessionsInput, ListUserTestingSessionsResult>;
declare const getUserTestingSessionInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
    session: z.ZodString;
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type GetUserTestingSessionInput = z.infer<typeof getUserTestingSessionInput>;
type GetUserTestingSessionResult = {
    project: SelectedProjectInfo;
    session: PlatformUserTestingSessionDetail;
};
declare const getUserTestingSessionOperation: PlatformOperation<GetUserTestingSessionInput, GetUserTestingSessionResult>;
declare const userTestingMetricsInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
    population: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type GetUserTestingMetricsInput = z.infer<typeof userTestingMetricsInput>;
type GetUserTestingMetricsResult = {
    project: SelectedProjectInfo;
    metrics: Record<string, unknown>;
};
declare const getUserTestingMetricsOperation: PlatformOperation<GetUserTestingMetricsInput, GetUserTestingMetricsResult>;
type GetUserTestingUsageInput = z.infer<typeof userTestingScenarioSelectorInput>;
type GetUserTestingUsageResult = {
    project: SelectedProjectInfo;
    usage: Record<string, unknown>;
};
declare const getUserTestingUsageOperation: PlatformOperation<GetUserTestingUsageInput, GetUserTestingUsageResult>;
type ListUserTestingFindingsInput = z.infer<typeof userTestingScenarioSelectorInput>;
type ListUserTestingFindingsResult = {
    project: SelectedProjectInfo;
    items: Array<Record<string, unknown>>;
};
declare const listUserTestingFindingsOperation: PlatformOperation<ListUserTestingFindingsInput, ListUserTestingFindingsResult>;
type GetUserTestingSignalsInput = z.infer<typeof userTestingScenarioSelectorInput>;
type GetUserTestingSignalsResult = {
    project: SelectedProjectInfo;
    signals: Record<string, unknown>;
};
declare const getUserTestingSignalsOperation: PlatformOperation<GetUserTestingSignalsInput, GetUserTestingSignalsResult>;
declare const userTestingWindowInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
    window: z.ZodString;
}, z.core.$strip>;
type GetUserTestingInsightsInput = z.infer<typeof userTestingWindowInput>;
type GetUserTestingInsightsResult = {
    project: SelectedProjectInfo;
    insights: Record<string, unknown>;
};
declare const getUserTestingInsightsOperation: PlatformOperation<GetUserTestingInsightsInput, GetUserTestingInsightsResult>;
declare const requestUserTestingInsightsInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
    force: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type RequestUserTestingInsightsInput = z.infer<typeof requestUserTestingInsightsInput>;
type RequestUserTestingInsightsResult = {
    project: SelectedProjectInfo;
    request: PlatformUserTestingInsightsRequested;
};
declare const requestUserTestingInsightsOperation: PlatformOperation<RequestUserTestingInsightsInput, RequestUserTestingInsightsResult>;
type CancelUserTestingInsightsInput = z.infer<typeof userTestingWindowInput>;
type CancelUserTestingInsightsResult = {
    project: SelectedProjectInfo;
    canceled: Record<string, unknown>;
};
declare const cancelUserTestingInsightsOperation: PlatformOperation<CancelUserTestingInsightsInput, CancelUserTestingInsightsResult>;
declare const userTestingFindingInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
    finding: z.ZodString;
}, z.core.$strip>;
type DismissUserTestingFindingInput = z.infer<typeof userTestingFindingInput>;
type DismissUserTestingFindingResult = {
    project: SelectedProjectInfo;
    finding: Record<string, unknown>;
};
declare const dismissUserTestingFindingOperation: PlatformOperation<DismissUserTestingFindingInput, DismissUserTestingFindingResult>;
type UndismissUserTestingFindingInput = DismissUserTestingFindingInput;
type UndismissUserTestingFindingResult = DismissUserTestingFindingResult;
declare const undismissUserTestingFindingOperation: PlatformOperation<UndismissUserTestingFindingInput, UndismissUserTestingFindingResult>;
declare const setGuestExecutionInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
    enabled: z.ZodBoolean;
    computerEnabled: z.ZodBoolean;
    sharedSkillsEnabled: z.ZodBoolean;
    dailyCreditCap: z.ZodNumber;
    dailyComputerStartCap: z.ZodNumber;
    maxConcurrentComputers: z.ZodNumber;
    harnessEnabled: z.ZodOptional<z.ZodBoolean>;
    dailyHarnessSpendCapMicros: z.ZodOptional<z.ZodNumber>;
    dailyHarnessCallCap: z.ZodOptional<z.ZodNumber>;
    maxConcurrentHarnessRuns: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type SetUserTestingGuestExecutionInput = z.infer<typeof setGuestExecutionInput>;
type SetUserTestingGuestExecutionResult = {
    project: SelectedProjectInfo;
    result: Record<string, unknown>;
};
declare const setUserTestingGuestExecutionOperation: PlatformOperation<SetUserTestingGuestExecutionInput, SetUserTestingGuestExecutionResult>;
type RotateUserTestingLinkInput = z.infer<typeof userTestingScenarioSelectorInput>;
type RotateUserTestingLinkResult = {
    project: SelectedProjectInfo;
    result: Record<string, unknown>;
};
declare const rotateUserTestingLinkOperation: PlatformOperation<RotateUserTestingLinkInput, RotateUserTestingLinkResult>;
declare const upsertUserTestingMemberInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
    email: z.ZodString;
    sendInviteEmail: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type UpsertUserTestingMemberInput = z.infer<typeof upsertUserTestingMemberInput>;
type UpsertUserTestingMemberResult = {
    project: SelectedProjectInfo;
    result: Record<string, unknown>;
};
declare const upsertUserTestingMemberOperation: PlatformOperation<UpsertUserTestingMemberInput, UpsertUserTestingMemberResult>;
declare const removeUserTestingMemberInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
    member: z.ZodString;
}, z.core.$strip>;
type RemoveUserTestingMemberInput = z.infer<typeof removeUserTestingMemberInput>;
type RemoveUserTestingMemberResult = UpsertUserTestingMemberResult;
declare const removeUserTestingMemberOperation: PlatformOperation<RemoveUserTestingMemberInput, RemoveUserTestingMemberResult>;
declare const rebindUserTestingScenarioInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    scenario: z.ZodString;
    environmentId: z.ZodString;
}, z.core.$strip>;
type RebindUserTestingScenarioInput = z.infer<typeof rebindUserTestingScenarioInput>;
type RebindUserTestingScenarioResult = UpsertUserTestingMemberResult;
declare const rebindUserTestingScenarioOperation: PlatformOperation<RebindUserTestingScenarioInput, RebindUserTestingScenarioResult>;
declare const connectProjectServerInput: z.ZodObject<{
    url: z.ZodString;
    project: z.ZodOptional<z.ZodString>;
    serverId: z.ZodOptional<z.ZodString>;
    name: z.ZodOptional<z.ZodString>;
    reauthorize: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type ConnectProjectServerInput = z.infer<typeof connectProjectServerInput>;
declare const getProjectServerConnectionStatusInput: z.ZodObject<{
    connectionRequestId: z.ZodString;
}, z.core.$strip>;
type GetProjectServerConnectionStatusInput = z.infer<typeof getProjectServerConnectionStatusInput>;
/**
 * Connect an MCP server URL to a project — the handoff-first flow.
 *
 * WHAT MAKES THIS OPERATION UNUSUAL: it usually cannot finish on its own. A
 * server that needs OAuth needs a human at a browser, and a request with no
 * project needs someone to choose one. So the honest result of a successful
 * call is often `awaiting_authorization` plus a link, not a connected server.
 * Callers are expected to present the link and then poll
 * `get_project_server_connection_status`.
 *
 * `handoffUrl` IS A PRIVATE CAPABILITY. Anyone holding it can complete the
 * authorization, so a surface must deliver it to the requester alone —
 * ephemerally in Slack, behind an owner-checked button in Discord — and never
 * let a model repeat it in prose. The agent adapter strips it from
 * model-visible text for exactly this reason.
 */
declare const connectProjectServerOperation: PlatformOperation<ConnectProjectServerInput, PlatformServerConnection>;
/**
 * Poll one connection request.
 *
 * Read-only and cheap by design — the status path carries no rate-limit
 * bucket, so a caller never has to choose between polling responsively and
 * tripping a budget.
 */
declare const getProjectServerConnectionStatusOperation: PlatformOperation<GetProjectServerConnectionStatusInput, PlatformServerConnection>;
declare const shareResourceSelectorInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    resourceType: z.ZodEnum<{
        scenario: "scenario";
        evalRun: "evalRun";
        conformanceRun: "conformanceRun";
    }>;
    resourceId: z.ZodString;
}, z.core.$strip>;
type GetShareSettingsInput = z.infer<typeof shareResourceSelectorInput>;
type GetShareSettingsResult = {
    project: SelectedProjectInfo;
    settings: Record<string, unknown>;
};
declare const getShareSettingsOperation: PlatformOperation<GetShareSettingsInput, GetShareSettingsResult>;
declare const setShareModeInput: z.ZodObject<{
    project: z.ZodOptional<z.ZodString>;
    resourceType: z.ZodEnum<{
        scenario: "scenario";
        evalRun: "evalRun";
        conformanceRun: "conformanceRun";
    }>;
    resourceId: z.ZodString;
    mode: z.ZodEnum<{
        project_members: "project_members";
        invited_only: "invited_only";
        anyone_with_link: "anyone_with_link";
    }>;
    allowGuestAccess: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type SetShareModeInput = z.infer<typeof setShareModeInput>;
type SetShareModeResult = {
    project: SelectedProjectInfo;
    settings: Record<string, unknown>;
};
declare const setShareModeOperation: PlatformOperation<SetShareModeInput, SetShareModeResult>;
type RotateShareLinkInput = z.infer<typeof shareResourceSelectorInput>;
type RotateShareLinkResult = {
    project: SelectedProjectInfo;
    settings: Record<string, unknown>;
};
declare const rotateShareLinkOperation: PlatformOperation<RotateShareLinkInput, RotateShareLinkResult>;
declare const searchRegistryDirectoryOperation: PlatformOperation<{
    q?: string;
    source?: string;
    rowType?: string;
    endpointKind?: string;
    verifiedTier?: string;
    connectableOnly?: boolean;
    cursor?: string;
    limit?: number;
}, PlatformPage<PlatformCatalogServer>>;
declare const getRegistryDirectoryServerInput: z.ZodObject<{
    catalogServerId: z.ZodOptional<z.ZodString>;
    name: z.ZodOptional<z.ZodString>;
    source: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const getRegistryDirectoryServerOperation: PlatformOperation<z.infer<typeof getRegistryDirectoryServerInput>, PlatformCatalogServer>;
declare const listRegistryDirectorySourcesOperation: PlatformOperation<Record<string, never>, PlatformPage<PlatformCatalogSourceStatus>>;
declare const listRegistryServersOperation: PlatformOperation<{
    project?: string;
    scope?: "global" | "organization" | "all";
}, {
    project: SelectedProjectInfo;
    items: PlatformRegistryServer[];
}>;
declare const listRegistryConnectionsOperation: PlatformOperation<{
    project?: string;
}, {
    project: SelectedProjectInfo;
    items: PlatformRegistryConnection[];
}>;
declare const installRegistryDirectoryServerOperation: PlatformOperation<{
    project?: string;
    catalogServerId: string;
    endpointUrl?: string;
    expectedContentHash?: string;
}, PlatformRegistryInstallResult>;
declare const installRegistryServerOperation: PlatformOperation<{
    project?: string;
    registryServerId: string;
    endpointUrl?: string;
    expectedUpdatedAt?: number;
}, PlatformRegistryInstallResult>;
declare const uninstallRegistryServerOperation: PlatformOperation<{
    project?: string;
    registryServerId: string;
}, {
    deleted?: boolean;
}>;
declare const ALL_OPERATIONS: readonly AnyPlatformOperation[];

/**
 * Which targets one `run_eval_suite` call launches.
 *
 * FAN-OUT IS EXPLICIT AND NEVER INFERRED FROM OMISSION. A bare "run this
 * suite" against a suite with three attached hosts is ambiguous — it could
 * reasonably mean "the default one", "the first one", or "all three", and the
 * last of those spends three times as much as the caller may have meant.
 * Guessing is the one thing this must not do, so:
 *
 *   - zero attachments   → one run on the suite's saved selection (today's
 *                          behaviour, unchanged, byte-for-byte);
 *   - exactly one        → one run on IT, automatically. This is not a guess:
 *                          there is only one thing the run could target, and
 *                          the platform resolves it that way regardless. It is
 *                          also the fix for the old silent mis-attribution, in
 *                          which a single-host suite ran under the suite's
 *                          default host config and reported the wrong host;
 *   - more than one      → `target-required`. The caller picks, or asks for all
 *                          of them explicitly.
 *
 * ONE AXIS, never a cross product. Environments win over hosts when a suite has
 * both, matching the web fan-out's own precedence — an environment already
 * resolves a host, so running "every host × every environment" would execute
 * combinations the suite never described.
 *
 * Pure and dependency-free so the rules can be tested without a client, and so
 * the surfaces that present them (CLI flags, MCP tool schema, the agent's
 * approval copy) all read the same decision.
 */
/** A suite-attached host, as `getEvalSuite` reports it. */
interface RunTargetHost {
    id: string;
    name: string;
}
/** One resolved launch target. Exactly one of the two ids is set. */
type RunTarget = {
    kind: "environment";
    id: string;
    name?: string;
} | {
    kind: "host";
    id: string;
    name: string;
};
type RunTargetPlan = 
/**
 * One run. `target` absent means the suite's own saved selection (the legacy
 * path, and the only shape that carries an explicit `serverIds` override).
 */
{
    kind: "single";
    target?: RunTarget;
    serverIds?: string[];
}
/** One run per target, launched as a group. */
 | {
    kind: "group";
    targets: RunTarget[];
}
/**
 * The caller has to choose. Carries both axes so the message can enumerate
 * exactly what is pickable instead of saying "be more specific".
 */
 | {
    kind: "target-required";
    attachedEnvironments: RunTarget[];
    attachedHosts: RunTarget[];
};
interface ComputeRunTargetsInput {
    /** The suite's attached environments, in attach order. */
    attachedEnvironments: Array<{
        id: string;
        name?: string;
    }>;
    /** The suite's attached hosts, in attach order. */
    attachedHosts: RunTargetHost[];
    /** Environments the caller named explicitly, already resolved to ids. */
    selectedEnvironments?: Array<{
        id: string;
        name?: string;
    }>;
    /** Hosts the caller named explicitly, already resolved to ids. */
    selectedHosts?: RunTargetHost[];
    /** "Run every attached target." */
    allAttached?: boolean;
    /** An explicit server override, which is a single legacy-path run. */
    serverIds?: string[];
}
declare function computeRunTargets(input: ComputeRunTargetsInput): RunTargetPlan;

/**
 * Pulling the visual evidence out of an eval run's steps.
 *
 * A browser eval's steps carry `evidence.screenshotUrl` — already RESOLVED by
 * the platform, so a consumer gets a fetchable URL rather than a storage key it
 * would have to know how to sign. This module is the small amount of shape
 * knowledge that sits between "a page of steps" and "the pictures a person
 * wants to see", kept here so every surface that shows run evidence agrees on
 * what counts as evidence and in what order.
 *
 * NOT THE CLI'S TRACE EXTRACTOR. The CLI reads a different payload (the
 * iteration trace) with a different shape. Sharing a name between the two would
 * invite one to be "fixed" to match the other, and they are not the same thing.
 *
 * Pure and runtime-agnostic on purpose (no fetch, no Node built-ins): the
 * caller decides how to fetch and how to display, which is the part that
 * differs per surface.
 */

/** One screenshot, with enough context for a caption. */
interface StepScreenshot {
    url: string;
    stepId: string;
    stepIndex: number;
    status: PlatformEvalStepResult["status"];
    /** The interaction target, when the step recorded one (a button label). */
    label?: string;
}
interface CollectScreenshotsOptions {
    /**
     * Stop after this many. A run can have hundreds of steps and every surface
     * that shows them has a limit; taking it here keeps the cap in one place
     * instead of each caller slicing a list it already paid to build.
     */
    limit?: number;
    /**
     * Only steps that FAILED. When a run fails, the failing step is what someone
     * wants to look at, and the twenty green ones before it are noise.
     */
    failedOnly?: boolean;
}
/**
 * Screenshot URLs from a page of steps, in author order.
 *
 * Order is the steps' own `stepIndex`, not their arrival order: the list is the
 * story of what the run did, and out-of-order pictures tell it wrong.
 * Duplicates are dropped — a video-backed run can repeat one frame URL across
 * steps, and the same picture twice reads as two things having happened.
 */
declare function collectStepScreenshots(steps: readonly PlatformEvalStepResult[], options?: CollectScreenshotsOptions): StepScreenshot[];
/**
 * The steps worth showing, preferring failures.
 *
 * When anything failed, those steps ARE the answer and the passing ones are
 * noise. When nothing failed, the run still deserves a picture — so fall back
 * to the whole sequence rather than returning nothing, which a caller would
 * have to special-case to avoid reporting "no evidence" for a healthy run.
 */
declare function selectStepScreenshots(steps: readonly PlatformEvalStepResult[], limit: number): StepScreenshot[];

export { ALL_OPERATIONS, type AnyPlatformOperation, type ArchiveJourneyInput, type ArchiveJourneyResult, type ArchiveSwarmInput, type ArchiveSwarmResult, type BuildShowServersPayloadInput, type CallServerToolInput, type CallServerToolResult, type CancelEvalRunResult, type CancelJourneyRunInput, type CancelJourneyRunResult, type CancelUserTestingInsightsInput, type CancelUserTestingInsightsResult, type CancelWaveInsightsInput, type CancelWaveInsightsResult, type CheckHostCompatibilityResult, type CloseTunnelInput, type CloseTunnelResult, type CollectScreenshotsOptions, type CompareEvalRunInput, type CompareEvalRunResult, type ComputeRunTargetsInput, type ConformanceRunScopedInput, type ConnectEvalCheckRepoInput, type ConnectEvalCheckRepoResult, type ConnectProjectServerInput, type CreateClientInput, type CreateEnvironmentInput, type CreateEvalCaseInput, type CreateEvalCasesInput, type CreateEvalCasesResult, type CreateEvalSuiteInput, type CreateEvalSuiteResult, type CreateHostInput, type CreateImageInput, type CreateJourneyInput, type CreateJourneyResult, type CreatePersonaInput, type CreatePersonaResult, type CreateProjectInput, type CreateProjectServerInput, type CreateSwarmInput, type CreateSwarmResult, type CreateTunnelInput, type CreateTunnelResult, type DeleteClientInput, type DeleteEvalCaseInput, type DeleteEvalSuiteInput, type DeleteHostInput, type DeletePersonaInput, type DeletePersonaResult, type DeleteProjectInput, type DiagnoseServerResult, type DismissSwarmFindingInput, type DismissSwarmFindingResult, type DismissUserTestingFindingInput, type DismissUserTestingFindingResult, type DuplicateClientInput, type DuplicateHostInput, type EnsureAdhocEnvironmentInput, type EnsureAdhocEnvironmentResult, type EnvironmentCapabilitiesInput, type EnvironmentCapabilitiesResult, type EnvironmentRevisionInput, type EnvironmentSelectorInput, type EvalRunScopedInput, type GenerateEvalCasesInput, type GenerateEvalCasesResult, type GenerateJourneysInput, type GenerateJourneysResult, type GeneratePersonasInput, type GeneratePersonasResult, type GetCapabilitiesInput, type GetCapabilitiesResult, type GetChatSessionInput, type GetChatSessionTraceInput, type GetClientInput, type GetConformanceReportResult, type GetConformanceRunResult, type GetEvalCaseInput, type GetEvalIterationTraceInput, type GetEvalIterationTraceResult, type GetEvalRunDisclosureInput, type GetEvalRunResult, type GetEvalRunStepsInput, type GetEvalRunStepsResult, type GetEvalSuiteInput, type GetHostInput, type GetJourneyInput, type GetJourneyResult, type GetJourneyRunInput, type GetJourneyRunResult, type GetJourneyRunScorecardInput, type GetJourneyRunScorecardResult, type GetPersonaInput, type GetPersonaResult, type GetPluginVersionInput, type GetProjectServerConnectionStatusInput, type GetProjectServerInput, type GetReadinessReportResult, type GetReadinessRunResult, type GetScenarioInput, type GetScenarioResult, type GetServerPromptInput, type GetServerPromptResult, type GetSwarmInput, type GetSwarmOverviewInput, type GetSwarmOverviewResult, type GetSwarmResult, type GetUserTestingInsightsInput, type GetUserTestingInsightsResult, type GetUserTestingMetricsInput, type GetUserTestingMetricsResult, type GetUserTestingScenarioInput, type GetUserTestingScenarioResult, type GetUserTestingSessionInput, type GetUserTestingSessionResult, type GetUserTestingSignalsInput, type GetUserTestingSignalsResult, type GetUserTestingUsageInput, type GetUserTestingUsageResult, type GetWaveInsightsInput, type GetWaveInsightsResult, type HostCompatibilityVerdict, type ImageSelectorInput, type LaunchJourneyRunInput, type LaunchJourneyRunResult, type ListChatSessionsInput, type ListChatSessionsResult, type ListClientsResult, type ListConformanceRunsInput, type ListConformanceRunsResult, type ListEnvironmentsInput, type ListEnvironmentsResult, type ListEvalCasesInput, type ListEvalCheckReposInput, type ListEvalCheckReposResult, type ListEvalRunIterationsInput, type ListEvalRunIterationsResult, type ListEvalSuiteRunsInput, type ListEvalSuiteRunsResult, type ListEvalSuitesResult, type ListHostsResult, type ListImageBuildsResult, type ListImagesResult, type ListJourneyRunSessionsInput, type ListJourneyRunSessionsResult, type ListJourneyRunsInput, type ListJourneyRunsResult, type ListJourneysInput, type ListJourneysResult, type ListPersonasInput, type ListPersonasResult, type ListProjectPluginsInput, type ListProjectPluginsResult, type ListProjectServersResult, type ListProjectsInput, type ListReadinessRunsInput, type ListReadinessRunsResult, type ListScenariosResult, type ListSwarmFindingsInput, type ListSwarmFindingsResult, type ListSwarmsInput, type ListSwarmsResult, type ListUserTestingFindingsInput, type ListUserTestingFindingsResult, type ListUserTestingSessionsInput, type ListUserTestingSessionsResult, type NameEnvironmentInput, PLATFORM_V1_ERROR_CODES, PlatformAdhocEnvironment, PlatformApiClient, PlatformApiError, type PlatformApiErrorCode, type PlatformApiErrorOptions, PlatformCapabilities, PlatformCatalogServer, PlatformCatalogSourceStatus, PlatformChatSession, PlatformChatSessionDetail, PlatformChatSessionTrace, PlatformChatTurn, PlatformClient, PlatformClientDeleted, PlatformClientDetail, PlatformComputerAttached, PlatformComputerReset, PlatformConformanceReport, PlatformConformanceRun, PlatformConformanceRunReceipt, PlatformDoctorReport, PlatformEnvironment, PlatformEnvironmentCapabilities, PlatformEnvironmentResolved, PlatformEvalCase, PlatformEvalCaseBatchCreated, PlatformEvalCaseBatchResult, PlatformEvalCaseDeleted, type PlatformEvalCaseWithSuite, PlatformEvalCasesGenerated, PlatformEvalCheckRepoConnected, PlatformEvalCheckRepos, PlatformEvalIteration, PlatformEvalRun, PlatformEvalRunCreated, PlatformEvalRunDecisionSummary, PlatformEvalRunDisclosure, PlatformEvalRunJudgeRequested, PlatformEvalSuite, PlatformEvalSuiteCreated, PlatformEvalSuiteDeleted, PlatformEvalSuiteDetail, PlatformFindingDismissed, PlatformGateWaiver, PlatformGateWaiverWriteResult, PlatformGenerationDrafts, PlatformHost, PlatformHostDeleted, PlatformHostDetail, PlatformImage, PlatformImageBlueprintValidation, PlatformImageBuild, PlatformImageBuildStarted, PlatformImageDeleted, PlatformJourney, PlatformJourneyArchived, PlatformJourneyRun, PlatformJourneyRunCanceled, PlatformJourneyRunSession, PlatformMe, PlatformModel, type PlatformOperation, type PlatformOperationContext, PlatformOrganization, PlatformPage, PlatformPermalinkPolicy, PlatformPersona, PlatformPersonaDeleted, PlatformPlugin, PlatformPluginVersion, PlatformProject, PlatformProjectServer, PlatformReadinessLaneCoverage, PlatformReadinessObservationState, PlatformReadinessRun, PlatformReadinessRunReceipt, PlatformReadinessStageResult, PlatformRegistryConnection, PlatformRegistryInstallResult, PlatformRegistryServer, PlatformRunCompare, PlatformRunScorecard, PlatformScenario, PlatformScenarioDeleted, PlatformScenarioDetail, PlatformScenarioSummary, PlatformServerConnection, PlatformSessionSummary, PlatformSwarm, PlatformSwarmArchived, PlatformSwarmFinding, PlatformSwarmOverview, PlatformTunnelGrant, PlatformUserTestingInsightsRequested, PlatformUserTestingScenario, PlatformUserTestingScenarioDetail, PlatformUserTestingSession, PlatformUserTestingSessionDetail, type PlatformV1ErrorCode, PlatformWaveInsights, PlatformWaveInsightsCanceled, PlatformWaveInsightsRequested, PlatformWidgetRender, type ProjectInfo, type ProjectResolution, type ProjectScopedInput, type PublishScenarioInput, type PublishScenarioResult, type ReadServerResourceInput, type ReadServerResourceResult, type ReadinessReportFinding, type ReadinessRunScopedInput, type RebindUserTestingScenarioInput, type RebindUserTestingScenarioResult, type RemoveUserTestingMemberInput, type RemoveUserTestingMemberResult, type RequestEvalRunJudgeInput, type RequestEvalRunJudgeResult, type RequestUserTestingInsightsInput, type RequestUserTestingInsightsResult, type RequestWaveInsightsInput, type RequestWaveInsightsResult, type ResolvedServerInfo, type RotateUserTestingLinkInput, type RotateUserTestingLinkResult, type RunEvalCaseInput, type RunEvalCaseResult, type RunEvalSuiteInput, type RunEvalSuiteResult, type RunTarget, type RunTargetHost, type RunTargetPlan, SHOW_SERVERS_DOCTOR_CONCURRENCY, type SearchSessionsInput, type SearchSessionsResult, type SelectedProjectInfo, type SendChatMessageInput, type ServerEntry, type ServerInfo, type ServerPagedInput, type ServerPagedResult, type ServerPrimitiveCollection, type ServerPrimitiveListStatus, type ServerPrimitives, type ServerPromptArgumentInfo, type ServerPromptInfo, type ServerResourceInfo, type ServerScopedInput, type ServerStatus, type ServerToolInfo, type ServerTransportType, type SetClientServersInput, type SetEvalSuiteEnvironmentsInput, type SetEvalSuiteScheduleInput, type SetHostServersInput, type SetUserTestingGuestExecutionInput, type SetUserTestingGuestExecutionResult, type ShowServersDoctorFn, type ShowServersPayload, type ShowServersSummary, type StartClaudeReadinessInput, type StartConformanceRunInput, type StartConformanceRunResult, type StartOpenAIReadinessInput, type StartReadinessResult, type StepScreenshot, type UndismissSwarmFindingInput, type UndismissSwarmFindingResult, type UndismissUserTestingFindingInput, type UndismissUserTestingFindingResult, type UnpublishScenarioInput, type UnpublishScenarioResult, type UpdateClientInput, type UpdateEnvironmentInput, type UpdateEvalCaseInput, type UpdateEvalSuiteInput, type UpdateHostInput, type UpdateImageInput, type UpdateJourneyInput, type UpdateJourneyResult, type UpdatePersonaInput, type UpdatePersonaResult, type UpdateProjectInput, type UpdateProjectServerInput, type UpdateSwarmInput, type UpdateSwarmResult, type UpdateUserTestingScenarioInput, type UpdateUserTestingScenarioResult, type UpsertUserTestingMemberInput, type UpsertUserTestingMemberResult, type ValidateImageBlueprintInput, archiveEnvironmentOperation, archiveJourneyOperation, archiveSwarmOperation, buildImageOperation, buildShowServersPayload, callServerToolOperation, cancelEvalRunOperation, cancelJourneyRunOperation, cancelReadinessRunOperation, cancelUserTestingInsightsOperation, cancelWaveInsightsOperation, checkHostCompatibilityOperation, closeTunnelOperation, collectStepScreenshots, compareEvalRunOperation, computeRunTargets, connectEvalCheckRepoOperation, connectProjectServerOperation, createClientOperation, createEnvironmentOperation, createEvalCaseOperation, createEvalCasesOperation, createEvalSuiteOperation, createHostOperation, createImageOperation, createJourneyOperation, createPersonaOperation, createProjectOperation, createProjectServerOperation, createSwarmOperation, createTunnelOperation, deleteClientOperation, deleteEvalCaseOperation, deleteEvalSuiteOperation, deleteHostOperation, deleteImageOperation, deletePersonaOperation, deleteProjectOperation, deleteProjectServerOperation, diagnoseServerOperation, dismissSwarmFindingOperation, dismissUserTestingFindingOperation, duplicateClientOperation, duplicateHostOperation, ensureAdhocEnvironmentOperation, expandComposeModelChoices, exportServerOperation, generateEvalCasesOperation, generateJourneysOperation, generatePersonasOperation, getCapabilitiesOperation, getChatSessionOperation, getChatSessionTraceOperation, getClientOperation, getConformanceReportOperation, getConformanceRunOperation, getEnvironmentCapabilitiesOperation, getEnvironmentOperation, getEvalCaseOperation, getEvalGateWaiverOperation, getEvalIterationTraceOperation, getEvalRunDisclosureOperation, getEvalRunOperation, getEvalRunStepsOperation, getEvalSuiteOperation, getHostOperation, getImageOperation, getJourneyOperation, getJourneyRunOperation, getJourneyRunScorecardOperation, getMeOperation, getPersonaOperation, getPluginVersionOperation, getProjectServerConnectionStatusOperation, getProjectServerOperation, getReadinessReportOperation, getReadinessRunOperation, getRegistryDirectoryServerOperation, getScenarioOperation, getServerPromptOperation, getShareSettingsOperation, getSwarmOperation, getSwarmOverviewOperation, getUserTestingInsightsOperation, getUserTestingMetricsOperation, getUserTestingScenarioOperation, getUserTestingSessionOperation, getUserTestingSignalsOperation, getUserTestingUsageOperation, getWaveInsightsOperation, installRegistryDirectoryServerOperation, installRegistryServerOperation, isPlatformApiError, launchJourneyRunOperation, listChatSessionsOperation, listClientsOperation, listConformanceRunsOperation, listEnvironmentsOperation, listEvalCasesOperation, listEvalCheckReposOperation, listEvalRunIterationsOperation, listEvalSuiteRunsOperation, listEvalSuitesOperation, listHostsOperation, listImageBuildsOperation, listImagesOperation, listJourneyRunSessionsOperation, listJourneyRunsOperation, listJourneysOperation, listModelsOperation, listOrganizationsOperation, listPersonasOperation, listProjectPluginsOperation, listProjectServersOperation, listProjectsOperation, listReadinessRunsOperation, listRegistryConnectionsOperation, listRegistryDirectorySourcesOperation, listRegistryServersOperation, listScenariosOperation, listServerPromptsOperation, listServerResourcesOperation, listServerToolsOperation, listSwarmFindingsOperation, listSwarmsOperation, listUserTestingFindingsOperation, listUserTestingSessionsOperation, nameEnvironmentOperation, projectResolutionError, promoteImageOperation, publishScenarioOperation, readServerResourceOperation, rebindUserTestingScenarioOperation, removeUserTestingMemberOperation, renderServerWidgetOperation, requestEvalRunJudgeOperation, requestUserTestingInsightsOperation, requestWaveInsightsOperation, resetComputerOperation, resolveEnvironmentOperation, resolveProject, restoreEnvironmentOperation, revokeEvalGateWaiverOperation, rotateShareLinkOperation, rotateUserTestingLinkOperation, runEvalCaseOperation, runEvalSuiteOperation, searchRegistryDirectoryOperation, searchSessionsOperation, selectStepScreenshots, sendChatMessageOperation, setClientServersOperation, setEvalSuiteEnvironmentsOperation, setEvalSuiteScheduleOperation, setHostServersOperation, setShareModeOperation, setUserTestingGuestExecutionOperation, showServersOperation, startClaudeReadinessRunOperation, startConformanceRunOperation, startOpenAIReadinessRunOperation, undismissSwarmFindingOperation, undismissUserTestingFindingOperation, uninstallRegistryServerOperation, unpublishScenarioOperation, updateClientOperation, updateEnvironmentOperation, updateEvalCaseOperation, updateEvalSuiteOperation, updateHostOperation, updateImageOperation, updateJourneyOperation, updatePersonaOperation, updateProjectOperation, updateProjectServerOperation, updateSwarmOperation, updateUserTestingScenarioOperation, upsertUserTestingMemberOperation, useImageOperation, validateImageBlueprintOperation, validateServerOperation, waiveEvalGateOperation };