@runloop/reflex-client 0.1.0

package/dist/react/agents.d.ts

@@ -0,0 +1,842 @@
+import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import type { Agent } from './model/agent.js';
+import type { AgentServiceStatusesResponse } from './model/agentServiceStatusesResponse.js';
+import type { AgentView } from './model/agentView.js';
+import type { AgentViewsResponse } from './model/agentViewsResponse.js';
+import type { ArchiveAllAgents200 } from './model/archiveAllAgents200.js';
+import type { ArchiveAllAgentsBody } from './model/archiveAllAgentsBody.js';
+import type { AxonEvent } from './model/axonEvent.js';
+import type { CreateAgentBody } from './model/createAgentBody.js';
+import type { CreateAgentResponse } from './model/createAgentResponse.js';
+import type { CreateAgentSnapshotBody } from './model/createAgentSnapshotBody.js';
+import type { EnqueueAgentMessage201 } from './model/enqueueAgentMessage201.js';
+import type { EnqueueAgentMessageBody } from './model/enqueueAgentMessageBody.js';
+import type { GetAgentQueue200Item } from './model/getAgentQueue200Item.js';
+import type { ListAgents200 } from './model/listAgents200.js';
+import type { ListAgentsParams } from './model/listAgentsParams.js';
+import type { RemoveQueuedAgentMessage200 } from './model/removeQueuedAgentMessage200.js';
+import type { ReorderAgentQueue200Item } from './model/reorderAgentQueue200Item.js';
+import type { ReorderAgentQueueBody } from './model/reorderAgentQueueBody.js';
+import type { SendAgentControlResponseBody } from './model/sendAgentControlResponseBody.js';
+import type { SendAgentMessageBody } from './model/sendAgentMessageBody.js';
+import type { SetAgentMarkBody } from './model/setAgentMarkBody.js';
+import type { Snapshot } from './model/snapshot.js';
+import type { SwitchAgentSubscriptionBody } from './model/switchAgentSubscriptionBody.js';
+import type { UpdateAgentBody } from './model/updateAgentBody.js';
+import type { UpdateQueuedAgentMessage200 } from './model/updateQueuedAgentMessage200.js';
+import type { UpdateQueuedAgentMessageBody } from './model/updateQueuedAgentMessageBody.js';
+import { apiFetch } from '../react-mutator.js';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+/**
+ * @summary List the agents in the active organization.
+ */
+export declare const listAgents: (params?: ListAgentsParams, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<ListAgents200>;
+export declare const getListAgentsQueryKey: (params?: ListAgentsParams) => readonly ["/agents", ...ListAgentsParams[]];
+export declare const getListAgentsQueryOptions: <TData = Awaited<ReturnType<typeof listAgents>>, TError = unknown>(params?: ListAgentsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listAgents>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof listAgents>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type ListAgentsQueryResult = NonNullable<Awaited<ReturnType<typeof listAgents>>>;
+export type ListAgentsQueryError = unknown;
+/**
+ * @summary List the agents in the active organization.
+ */
+export declare function useListAgents<TData = Awaited<ReturnType<typeof listAgents>>, TError = unknown>(params?: ListAgentsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listAgents>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Returns as soon as the run is created; the devbox provisions in the background. Watch the agent status or event stream for progress.
+ * @summary Create and launch a new agent run.
+ */
+export declare const createAgent: (createAgentBody: CreateAgentBody, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<CreateAgentResponse>;
+export declare const getCreateAgentMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createAgent>>, TError, {
+        data: CreateAgentBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof createAgent>>, TError, {
+    data: CreateAgentBody;
+}, TContext>;
+export type CreateAgentMutationResult = NonNullable<Awaited<ReturnType<typeof createAgent>>>;
+export type CreateAgentMutationBody = CreateAgentBody;
+export type CreateAgentMutationError = unknown;
+/**
+* @summary Create and launch a new agent run.
+*/
+export declare const useCreateAgent: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createAgent>>, TError, {
+        data: CreateAgentBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof createAgent>>, TError, {
+    data: CreateAgentBody;
+}, TContext>;
+/**
+* @summary Get a single agent by id.
+*/
+export declare const getAgent: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<Agent>;
+export declare const getGetAgentQueryKey: (id: string) => readonly [`/agents/${string}`];
+export declare const getGetAgentQueryOptions: <TData = Awaited<ReturnType<typeof getAgent>>, TError = unknown>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgent>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getAgent>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAgentQueryResult = NonNullable<Awaited<ReturnType<typeof getAgent>>>;
+export type GetAgentQueryError = unknown;
+/**
+ * @summary Get a single agent by id.
+ */
+export declare function useGetAgent<TData = Awaited<ReturnType<typeof getAgent>>, TError = unknown>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgent>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Update an agent's name or pinned state.
+ */
+export declare const updateAgent: (id: string, updateAgentBody: UpdateAgentBody, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<Agent>;
+export declare const getUpdateAgentMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateAgent>>, TError, {
+        id: string;
+        data: UpdateAgentBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof updateAgent>>, TError, {
+    id: string;
+    data: UpdateAgentBody;
+}, TContext>;
+export type UpdateAgentMutationResult = NonNullable<Awaited<ReturnType<typeof updateAgent>>>;
+export type UpdateAgentMutationBody = UpdateAgentBody;
+export type UpdateAgentMutationError = unknown;
+/**
+* @summary Update an agent's name or pinned state.
+*/
+export declare const useUpdateAgent: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateAgent>>, TError, {
+        id: string;
+        data: UpdateAgentBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof updateAgent>>, TError, {
+    id: string;
+    data: UpdateAgentBody;
+}, TContext>;
+/**
+* @summary Force stop the agent and shut down its devbox.
+*/
+export declare const killAgent: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<Agent>;
+export declare const getKillAgentMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof killAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof killAgent>>, TError, {
+    id: string;
+}, TContext>;
+export type KillAgentMutationResult = NonNullable<Awaited<ReturnType<typeof killAgent>>>;
+export type KillAgentMutationError = unknown;
+/**
+* @summary Force stop the agent and shut down its devbox.
+*/
+export declare const useKillAgent: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof killAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof killAgent>>, TError, {
+    id: string;
+}, TContext>;
+/**
+* @summary Archive the agent run.
+*/
+export declare const archiveAgent: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<Agent>;
+export declare const getArchiveAgentMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof archiveAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof archiveAgent>>, TError, {
+    id: string;
+}, TContext>;
+export type ArchiveAgentMutationResult = NonNullable<Awaited<ReturnType<typeof archiveAgent>>>;
+export type ArchiveAgentMutationError = unknown;
+/**
+* @summary Archive the agent run.
+*/
+export declare const useArchiveAgent: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof archiveAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof archiveAgent>>, TError, {
+    id: string;
+}, TContext>;
+/**
+* @summary Mark the agent's run as completed without shutting down its devbox.
+*/
+export declare const completeAgent: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<void>;
+export declare const getCompleteAgentMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof completeAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof completeAgent>>, TError, {
+    id: string;
+}, TContext>;
+export type CompleteAgentMutationResult = NonNullable<Awaited<ReturnType<typeof completeAgent>>>;
+export type CompleteAgentMutationError = unknown;
+/**
+* @summary Mark the agent's run as completed without shutting down its devbox.
+*/
+export declare const useCompleteAgent: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof completeAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof completeAgent>>, TError, {
+    id: string;
+}, TContext>;
+/**
+* @summary Answer a pending control request from the agent.
+*/
+export declare const sendAgentControlResponse: (id: string, sendAgentControlResponseBody: SendAgentControlResponseBody, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<void>;
+export declare const getSendAgentControlResponseMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof sendAgentControlResponse>>, TError, {
+        id: string;
+        data: SendAgentControlResponseBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof sendAgentControlResponse>>, TError, {
+    id: string;
+    data: SendAgentControlResponseBody;
+}, TContext>;
+export type SendAgentControlResponseMutationResult = NonNullable<Awaited<ReturnType<typeof sendAgentControlResponse>>>;
+export type SendAgentControlResponseMutationBody = SendAgentControlResponseBody;
+export type SendAgentControlResponseMutationError = unknown;
+/**
+* @summary Answer a pending control request from the agent.
+*/
+export declare const useSendAgentControlResponse: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof sendAgentControlResponse>>, TError, {
+        id: string;
+        data: SendAgentControlResponseBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof sendAgentControlResponse>>, TError, {
+    id: string;
+    data: SendAgentControlResponseBody;
+}, TContext>;
+/**
+* @summary Fetch the platform logs for the agent's devbox.
+*/
+export declare const getAgentDevboxLogs: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<void>;
+export declare const getGetAgentDevboxLogsQueryKey: (id: string) => readonly [`/agents/${string}/devbox-logs`];
+export declare const getGetAgentDevboxLogsQueryOptions: <TData = Awaited<ReturnType<typeof getAgentDevboxLogs>>, TError = unknown>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgentDevboxLogs>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getAgentDevboxLogs>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAgentDevboxLogsQueryResult = NonNullable<Awaited<ReturnType<typeof getAgentDevboxLogs>>>;
+export type GetAgentDevboxLogsQueryError = unknown;
+/**
+ * @summary Fetch the platform logs for the agent's devbox.
+ */
+export declare function useGetAgentDevboxLogs<TData = Awaited<ReturnType<typeof getAgentDevboxLogs>>, TError = unknown>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgentDevboxLogs>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Get the live status, size, and architecture of the agent's devbox.
+ */
+export declare const getAgentDevboxStatus: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<void>;
+export declare const getGetAgentDevboxStatusQueryKey: (id: string) => readonly [`/agents/${string}/devbox-status`];
+export declare const getGetAgentDevboxStatusQueryOptions: <TData = Awaited<ReturnType<typeof getAgentDevboxStatus>>, TError = unknown>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgentDevboxStatus>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getAgentDevboxStatus>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAgentDevboxStatusQueryResult = NonNullable<Awaited<ReturnType<typeof getAgentDevboxStatus>>>;
+export type GetAgentDevboxStatusQueryError = unknown;
+/**
+ * @summary Get the live status, size, and architecture of the agent's devbox.
+ */
+export declare function useGetAgentDevboxStatus<TData = Awaited<ReturnType<typeof getAgentDevboxStatus>>, TError = unknown>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgentDevboxStatus>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Interrupt the agent's current turn.
+ */
+export declare const interruptAgent: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<void>;
+export declare const getInterruptAgentMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof interruptAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof interruptAgent>>, TError, {
+    id: string;
+}, TContext>;
+export type InterruptAgentMutationResult = NonNullable<Awaited<ReturnType<typeof interruptAgent>>>;
+export type InterruptAgentMutationError = unknown;
+/**
+* @summary Interrupt the agent's current turn.
+*/
+export declare const useInterruptAgent: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof interruptAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof interruptAgent>>, TError, {
+    id: string;
+}, TContext>;
+/**
+* Marks a run blocked / in review / completed for triage. A null mark clears it. The server also clears the mark when the run starts its next turn or is archived.
+* @summary Set or clear the agent's triage mark.
+*/
+export declare const setAgentMark: (id: string, setAgentMarkBody: SetAgentMarkBody, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<Agent>;
+export declare const getSetAgentMarkMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof setAgentMark>>, TError, {
+        id: string;
+        data: SetAgentMarkBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof setAgentMark>>, TError, {
+    id: string;
+    data: SetAgentMarkBody;
+}, TContext>;
+export type SetAgentMarkMutationResult = NonNullable<Awaited<ReturnType<typeof setAgentMark>>>;
+export type SetAgentMarkMutationBody = SetAgentMarkBody;
+export type SetAgentMarkMutationError = unknown;
+/**
+* @summary Set or clear the agent's triage mark.
+*/
+export declare const useSetAgentMark: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof setAgentMark>>, TError, {
+        id: string;
+        data: SetAgentMarkBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof setAgentMark>>, TError, {
+    id: string;
+    data: SetAgentMarkBody;
+}, TContext>;
+/**
+* @summary Send a message to the agent's chat.
+*/
+export declare const sendAgentMessage: (id: string, sendAgentMessageBody: SendAgentMessageBody, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<AxonEvent>;
+export declare const getSendAgentMessageMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof sendAgentMessage>>, TError, {
+        id: string;
+        data: SendAgentMessageBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof sendAgentMessage>>, TError, {
+    id: string;
+    data: SendAgentMessageBody;
+}, TContext>;
+export type SendAgentMessageMutationResult = NonNullable<Awaited<ReturnType<typeof sendAgentMessage>>>;
+export type SendAgentMessageMutationBody = SendAgentMessageBody;
+export type SendAgentMessageMutationError = unknown;
+/**
+* @summary Send a message to the agent's chat.
+*/
+export declare const useSendAgentMessage: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof sendAgentMessage>>, TError, {
+        id: string;
+        data: SendAgentMessageBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof sendAgentMessage>>, TError, {
+    id: string;
+    data: SendAgentMessageBody;
+}, TContext>;
+/**
+* @summary Pin the agent.
+*/
+export declare const pinAgent: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<void>;
+export declare const getPinAgentMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof pinAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof pinAgent>>, TError, {
+    id: string;
+}, TContext>;
+export type PinAgentMutationResult = NonNullable<Awaited<ReturnType<typeof pinAgent>>>;
+export type PinAgentMutationError = unknown;
+/**
+* @summary Pin the agent.
+*/
+export declare const usePinAgent: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof pinAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof pinAgent>>, TError, {
+    id: string;
+}, TContext>;
+/**
+* @summary List the messages queued for the agent.
+*/
+export declare const getAgentQueue: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<GetAgentQueue200Item[]>;
+export declare const getGetAgentQueueQueryKey: (id: string) => readonly [`/agents/${string}/queue`];
+export declare const getGetAgentQueueQueryOptions: <TData = Awaited<ReturnType<typeof getAgentQueue>>, TError = unknown>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgentQueue>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getAgentQueue>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAgentQueueQueryResult = NonNullable<Awaited<ReturnType<typeof getAgentQueue>>>;
+export type GetAgentQueueQueryError = unknown;
+/**
+ * @summary List the messages queued for the agent.
+ */
+export declare function useGetAgentQueue<TData = Awaited<ReturnType<typeof getAgentQueue>>, TError = unknown>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgentQueue>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Queued messages are delivered one per turn whenever the agent next accepts input, even when no client is connected.
+ * @summary Add a message to the agent's queue.
+ */
+export declare const enqueueAgentMessage: (id: string, enqueueAgentMessageBody: EnqueueAgentMessageBody, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<EnqueueAgentMessage201>;
+export declare const getEnqueueAgentMessageMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof enqueueAgentMessage>>, TError, {
+        id: string;
+        data: EnqueueAgentMessageBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof enqueueAgentMessage>>, TError, {
+    id: string;
+    data: EnqueueAgentMessageBody;
+}, TContext>;
+export type EnqueueAgentMessageMutationResult = NonNullable<Awaited<ReturnType<typeof enqueueAgentMessage>>>;
+export type EnqueueAgentMessageMutationBody = EnqueueAgentMessageBody;
+export type EnqueueAgentMessageMutationError = unknown;
+/**
+* @summary Add a message to the agent's queue.
+*/
+export declare const useEnqueueAgentMessage: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof enqueueAgentMessage>>, TError, {
+        id: string;
+        data: EnqueueAgentMessageBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof enqueueAgentMessage>>, TError, {
+    id: string;
+    data: EnqueueAgentMessageBody;
+}, TContext>;
+/**
+* Edits the text and, when `attachments` is present, replaces the attachment list with the one sent.
+* @summary Edit a queued message.
+*/
+export declare const updateQueuedAgentMessage: (id: string, msgId: string, updateQueuedAgentMessageBody: UpdateQueuedAgentMessageBody, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<UpdateQueuedAgentMessage200>;
+export declare const getUpdateQueuedAgentMessageMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateQueuedAgentMessage>>, TError, {
+        id: string;
+        msgId: string;
+        data: UpdateQueuedAgentMessageBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof updateQueuedAgentMessage>>, TError, {
+    id: string;
+    msgId: string;
+    data: UpdateQueuedAgentMessageBody;
+}, TContext>;
+export type UpdateQueuedAgentMessageMutationResult = NonNullable<Awaited<ReturnType<typeof updateQueuedAgentMessage>>>;
+export type UpdateQueuedAgentMessageMutationBody = UpdateQueuedAgentMessageBody;
+export type UpdateQueuedAgentMessageMutationError = unknown;
+/**
+* @summary Edit a queued message.
+*/
+export declare const useUpdateQueuedAgentMessage: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateQueuedAgentMessage>>, TError, {
+        id: string;
+        msgId: string;
+        data: UpdateQueuedAgentMessageBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof updateQueuedAgentMessage>>, TError, {
+    id: string;
+    msgId: string;
+    data: UpdateQueuedAgentMessageBody;
+}, TContext>;
+/**
+* @summary Remove a message from the agent's queue.
+*/
+export declare const removeQueuedAgentMessage: (id: string, msgId: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<RemoveQueuedAgentMessage200>;
+export declare const getRemoveQueuedAgentMessageMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof removeQueuedAgentMessage>>, TError, {
+        id: string;
+        msgId: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof removeQueuedAgentMessage>>, TError, {
+    id: string;
+    msgId: string;
+}, TContext>;
+export type RemoveQueuedAgentMessageMutationResult = NonNullable<Awaited<ReturnType<typeof removeQueuedAgentMessage>>>;
+export type RemoveQueuedAgentMessageMutationError = unknown;
+/**
+* @summary Remove a message from the agent's queue.
+*/
+export declare const useRemoveQueuedAgentMessage: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof removeQueuedAgentMessage>>, TError, {
+        id: string;
+        msgId: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof removeQueuedAgentMessage>>, TError, {
+    id: string;
+    msgId: string;
+}, TContext>;
+/**
+* @summary Reorder the agent's queued messages.
+*/
+export declare const reorderAgentQueue: (id: string, reorderAgentQueueBody: ReorderAgentQueueBody, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<ReorderAgentQueue200Item[]>;
+export declare const getReorderAgentQueueMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof reorderAgentQueue>>, TError, {
+        id: string;
+        data: ReorderAgentQueueBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof reorderAgentQueue>>, TError, {
+    id: string;
+    data: ReorderAgentQueueBody;
+}, TContext>;
+export type ReorderAgentQueueMutationResult = NonNullable<Awaited<ReturnType<typeof reorderAgentQueue>>>;
+export type ReorderAgentQueueMutationBody = ReorderAgentQueueBody;
+export type ReorderAgentQueueMutationError = unknown;
+/**
+* @summary Reorder the agent's queued messages.
+*/
+export declare const useReorderAgentQueue: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof reorderAgentQueue>>, TError, {
+        id: string;
+        data: ReorderAgentQueueBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof reorderAgentQueue>>, TError, {
+    id: string;
+    data: ReorderAgentQueueBody;
+}, TContext>;
+/**
+* @summary Resume the agent's devbox if it is suspended.
+*/
+export declare const resumeAgent: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<void>;
+export declare const getResumeAgentMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof resumeAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof resumeAgent>>, TError, {
+    id: string;
+}, TContext>;
+export type ResumeAgentMutationResult = NonNullable<Awaited<ReturnType<typeof resumeAgent>>>;
+export type ResumeAgentMutationError = unknown;
+/**
+* @summary Resume the agent's devbox if it is suspended.
+*/
+export declare const useResumeAgent: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof resumeAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof resumeAgent>>, TError, {
+    id: string;
+}, TContext>;
+/**
+* @summary Fetch the log for one service on the agent's devbox.
+*/
+export declare const getAgentServiceLogs: (id: string, serviceId: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<void>;
+export declare const getGetAgentServiceLogsQueryKey: (id: string, serviceId: string) => readonly [`/agents/${string}/services/${string}/logs`];
+export declare const getGetAgentServiceLogsQueryOptions: <TData = Awaited<ReturnType<typeof getAgentServiceLogs>>, TError = unknown>(id: string, serviceId: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgentServiceLogs>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getAgentServiceLogs>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAgentServiceLogsQueryResult = NonNullable<Awaited<ReturnType<typeof getAgentServiceLogs>>>;
+export type GetAgentServiceLogsQueryError = unknown;
+/**
+ * @summary Fetch the log for one service on the agent's devbox.
+ */
+export declare function useGetAgentServiceLogs<TData = Awaited<ReturnType<typeof getAgentServiceLogs>>, TError = unknown>(id: string, serviceId: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgentServiceLogs>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Get the live status of every service on the agent's devbox.
+ */
+export declare const getAgentServiceStatuses: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<AgentServiceStatusesResponse>;
+export declare const getGetAgentServiceStatusesQueryKey: (id: string) => readonly [`/agents/${string}/services/status`];
+export declare const getGetAgentServiceStatusesQueryOptions: <TData = Awaited<ReturnType<typeof getAgentServiceStatuses>>, TError = unknown>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgentServiceStatuses>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getAgentServiceStatuses>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAgentServiceStatusesQueryResult = NonNullable<Awaited<ReturnType<typeof getAgentServiceStatuses>>>;
+export type GetAgentServiceStatusesQueryError = unknown;
+/**
+ * @summary Get the live status of every service on the agent's devbox.
+ */
+export declare function useGetAgentServiceStatuses<TData = Awaited<ReturnType<typeof getAgentServiceStatuses>>, TError = unknown>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgentServiceStatuses>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * This ends the run: per-run state is stripped from the disk, the capture starts asynchronously, and the devbox shuts down once it completes. Poll the snapshot's status route until the capture finishes.
+ * @summary Capture a reusable snapshot of the agent's devbox disk.
+ */
+export declare const createAgentSnapshot: (id: string, createAgentSnapshotBody: CreateAgentSnapshotBody, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<Snapshot>;
+export declare const getCreateAgentSnapshotMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createAgentSnapshot>>, TError, {
+        id: string;
+        data: CreateAgentSnapshotBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof createAgentSnapshot>>, TError, {
+    id: string;
+    data: CreateAgentSnapshotBody;
+}, TContext>;
+export type CreateAgentSnapshotMutationResult = NonNullable<Awaited<ReturnType<typeof createAgentSnapshot>>>;
+export type CreateAgentSnapshotMutationBody = CreateAgentSnapshotBody;
+export type CreateAgentSnapshotMutationError = unknown;
+/**
+* @summary Capture a reusable snapshot of the agent's devbox disk.
+*/
+export declare const useCreateAgentSnapshot: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createAgentSnapshot>>, TError, {
+        id: string;
+        data: CreateAgentSnapshotBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof createAgentSnapshot>>, TError, {
+    id: string;
+    data: CreateAgentSnapshotBody;
+}, TContext>;
+/**
+* @summary Stop the agent's run and shut down its devbox.
+*/
+export declare const stopAgent: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<Agent>;
+export declare const getStopAgentMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof stopAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof stopAgent>>, TError, {
+    id: string;
+}, TContext>;
+export type StopAgentMutationResult = NonNullable<Awaited<ReturnType<typeof stopAgent>>>;
+export type StopAgentMutationError = unknown;
+/**
+* @summary Stop the agent's run and shut down its devbox.
+*/
+export declare const useStopAgent: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof stopAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof stopAgent>>, TError, {
+    id: string;
+}, TContext>;
+/**
+* @summary Get the agent's full event history.
+*/
+export declare const getAgentStream: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<AxonEvent[]>;
+export declare const getGetAgentStreamQueryKey: (id: string) => readonly [`/agents/${string}/stream`];
+export declare const getGetAgentStreamQueryOptions: <TData = Awaited<ReturnType<typeof getAgentStream>>, TError = unknown>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgentStream>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getAgentStream>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAgentStreamQueryResult = NonNullable<Awaited<ReturnType<typeof getAgentStream>>>;
+export type GetAgentStreamQueryError = unknown;
+/**
+ * @summary Get the agent's full event history.
+ */
+export declare function useGetAgentStream<TData = Awaited<ReturnType<typeof getAgentStream>>, TError = unknown>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAgentStream>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Switch the model-provider subscription a running agent uses.
+ */
+export declare const switchAgentSubscription: (id: string, switchAgentSubscriptionBody: SwitchAgentSubscriptionBody, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<Agent>;
+export declare const getSwitchAgentSubscriptionMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof switchAgentSubscription>>, TError, {
+        id: string;
+        data: SwitchAgentSubscriptionBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof switchAgentSubscription>>, TError, {
+    id: string;
+    data: SwitchAgentSubscriptionBody;
+}, TContext>;
+export type SwitchAgentSubscriptionMutationResult = NonNullable<Awaited<ReturnType<typeof switchAgentSubscription>>>;
+export type SwitchAgentSubscriptionMutationBody = SwitchAgentSubscriptionBody;
+export type SwitchAgentSubscriptionMutationError = unknown;
+/**
+* @summary Switch the model-provider subscription a running agent uses.
+*/
+export declare const useSwitchAgentSubscription: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof switchAgentSubscription>>, TError, {
+        id: string;
+        data: SwitchAgentSubscriptionBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof switchAgentSubscription>>, TError, {
+    id: string;
+    data: SwitchAgentSubscriptionBody;
+}, TContext>;
+/**
+* @summary Unarchive the agent run.
+*/
+export declare const unarchiveAgent: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<Agent>;
+export declare const getUnarchiveAgentMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof unarchiveAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof unarchiveAgent>>, TError, {
+    id: string;
+}, TContext>;
+export type UnarchiveAgentMutationResult = NonNullable<Awaited<ReturnType<typeof unarchiveAgent>>>;
+export type UnarchiveAgentMutationError = unknown;
+/**
+* @summary Unarchive the agent run.
+*/
+export declare const useUnarchiveAgent: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof unarchiveAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof unarchiveAgent>>, TError, {
+    id: string;
+}, TContext>;
+/**
+* @summary Unpin the agent.
+*/
+export declare const unpinAgent: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<void>;
+export declare const getUnpinAgentMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof unpinAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof unpinAgent>>, TError, {
+    id: string;
+}, TContext>;
+export type UnpinAgentMutationResult = NonNullable<Awaited<ReturnType<typeof unpinAgent>>>;
+export type UnpinAgentMutationError = unknown;
+/**
+* @summary Unpin the agent.
+*/
+export declare const useUnpinAgent: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof unpinAgent>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof unpinAgent>>, TError, {
+    id: string;
+}, TContext>;
+/**
+* @summary Record that the current user has viewed the agent.
+*/
+export declare const recordAgentView: (id: string, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<AgentView>;
+export declare const getRecordAgentViewMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof recordAgentView>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof recordAgentView>>, TError, {
+    id: string;
+}, TContext>;
+export type RecordAgentViewMutationResult = NonNullable<Awaited<ReturnType<typeof recordAgentView>>>;
+export type RecordAgentViewMutationError = unknown;
+/**
+* @summary Record that the current user has viewed the agent.
+*/
+export declare const useRecordAgentView: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof recordAgentView>>, TError, {
+        id: string;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof recordAgentView>>, TError, {
+    id: string;
+}, TContext>;
+/**
+* Still running agents are stopped first, which shuts down their devboxes. The sweep can be narrowed by owner and created date range.
+* @summary Archive every matching agent run in the active organization.
+*/
+export declare const archiveAllAgents: (archiveAllAgentsBody: ArchiveAllAgentsBody, options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<ArchiveAllAgents200>;
+export declare const getArchiveAllAgentsMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof archiveAllAgents>>, TError, {
+        data: ArchiveAllAgentsBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof archiveAllAgents>>, TError, {
+    data: ArchiveAllAgentsBody;
+}, TContext>;
+export type ArchiveAllAgentsMutationResult = NonNullable<Awaited<ReturnType<typeof archiveAllAgents>>>;
+export type ArchiveAllAgentsMutationBody = ArchiveAllAgentsBody;
+export type ArchiveAllAgentsMutationError = unknown;
+/**
+* @summary Archive every matching agent run in the active organization.
+*/
+export declare const useArchiveAllAgents: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof archiveAllAgents>>, TError, {
+        data: ArchiveAllAgentsBody;
+    }, TContext>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseMutationResult<Awaited<ReturnType<typeof archiveAllAgents>>, TError, {
+    data: ArchiveAllAgentsBody;
+}, TContext>;
+/**
+* @summary List the current user's per-agent last-viewed timestamps.
+*/
+export declare const listAgentViews: (options?: SecondParameter<typeof apiFetch>, signal?: AbortSignal) => Promise<AgentViewsResponse>;
+export declare const getListAgentViewsQueryKey: () => readonly ["/agents/views"];
+export declare const getListAgentViewsQueryOptions: <TData = Awaited<ReturnType<typeof listAgentViews>>, TError = unknown>(options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listAgentViews>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof listAgentViews>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type ListAgentViewsQueryResult = NonNullable<Awaited<ReturnType<typeof listAgentViews>>>;
+export type ListAgentViewsQueryError = unknown;
+/**
+ * @summary List the current user's per-agent last-viewed timestamps.
+ */
+export declare function useListAgentViews<TData = Awaited<ReturnType<typeof listAgentViews>>, TError = unknown>(options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listAgentViews>>, TError, TData>;
+    request?: SecondParameter<typeof apiFetch>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};
+//# sourceMappingURL=agents.d.ts.map