type AuthToken = string | undefined;
interface Auth {
    /**
     * Which part of the request do we use to send the auth?
     *
     * @default 'header'
     */
    in?: "header" | "query" | "cookie";
    /**
     * A unique identifier for the security scheme.
     *
     * Defined only when there are multiple security schemes whose `Auth`
     * shape would otherwise be identical.
     */
    key?: string;
    /**
     * Header or query parameter name.
     *
     * @default 'Authorization'
     */
    name?: string;
    scheme?: "basic" | "bearer";
    type: "apiKey" | "http";
}

interface SerializerOptions<T> {
    /**
     * @default true
     */
    explode: boolean;
    style: T;
}
type ArrayStyle = "form" | "spaceDelimited" | "pipeDelimited";
type ObjectStyle = "form" | "deepObject";

type QuerySerializer = (query: Record<string, unknown>) => string;
type BodySerializer = (body: unknown) => unknown;
type QuerySerializerOptionsObject = {
    allowReserved?: boolean;
    array?: Partial<SerializerOptions<ArrayStyle>>;
    object?: Partial<SerializerOptions<ObjectStyle>>;
};
type QuerySerializerOptions = QuerySerializerOptionsObject & {
    /**
     * Per-parameter serialization overrides. When provided, these settings
     * override the global array/object settings for specific parameter names.
     */
    parameters?: Record<string, QuerySerializerOptionsObject>;
};

type HttpMethod = "connect" | "delete" | "get" | "head" | "options" | "patch" | "post" | "put" | "trace";
type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
    /**
     * Returns the final request URL.
     */
    buildUrl: BuildUrlFn;
    getConfig: () => Config;
    request: RequestFn;
    setConfig: (config: Config) => Config;
} & {
    [K in HttpMethod]: MethodFn;
} & ([SseFn] extends [never] ? {
    sse?: never;
} : {
    sse: {
        [K in HttpMethod]: SseFn;
    };
});
interface Config$1 {
    /**
     * Auth token or a function returning auth token. The resolved value will be
     * added to the request payload as defined by its `security` array.
     */
    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
    /**
     * A function for serializing request body parameter. By default,
     * {@link JSON.stringify()} will be used.
     */
    bodySerializer?: BodySerializer | null;
    /**
     * An object containing any HTTP headers that you want to pre-populate your
     * `Headers` object with.
     *
     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
     */
    headers?: RequestInit["headers"] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
    /**
     * The request method.
     *
     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
     */
    method?: Uppercase<HttpMethod>;
    /**
     * A function for serializing request query parameters. By default, arrays
     * will be exploded in form style, objects will be exploded in deepObject
     * style, and reserved characters are percent-encoded.
     *
     * This method will have no effect if the native `paramsSerializer()` Axios
     * API function is used.
     *
     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
     */
    querySerializer?: QuerySerializer | QuerySerializerOptions;
    /**
     * A function validating request data. This is useful if you want to ensure
     * the request conforms to the desired shape, so it can be safely sent to
     * the server.
     */
    requestValidator?: (data: unknown) => Promise<unknown>;
    /**
     * A function transforming response data before it's returned. This is useful
     * for post-processing data, e.g., converting ISO strings into Date objects.
     */
    responseTransformer?: (data: unknown) => Promise<unknown>;
    /**
     * A function validating response data. This is useful if you want to ensure
     * the response conforms to the desired shape, so it can be safely passed to
     * the transformers and returned to the user.
     */
    responseValidator?: (data: unknown) => Promise<unknown>;
}
/**
 * Arbitrary metadata passed through the `meta` request option.
 */
interface ClientMeta {
}

type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, "method"> & Pick<Config$1, "method" | "responseTransformer" | "responseValidator"> & {
    /**
     * Fetch API implementation. You can use this option to provide a custom
     * fetch instance.
     *
     * @default globalThis.fetch
     */
    fetch?: typeof fetch;
    /**
     * Implementing clients can call request interceptors inside this hook.
     */
    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
    /**
     * Callback invoked when a network or parsing error occurs during streaming.
     *
     * This option applies only if the endpoint returns a stream of events.
     *
     * @param error The error that occurred.
     */
    onSseError?: (error: unknown) => void;
    /**
     * Callback invoked when an event is streamed from the server.
     *
     * This option applies only if the endpoint returns a stream of events.
     *
     * @param event Event streamed from the server.
     * @returns Nothing (void).
     */
    onSseEvent?: (event: StreamEvent<TData>) => void;
    serializedBody?: RequestInit["body"];
    /**
     * Default retry delay in milliseconds.
     *
     * This option applies only if the endpoint returns a stream of events.
     *
     * @default 3000
     */
    sseDefaultRetryDelay?: number;
    /**
     * Maximum number of retry attempts before giving up.
     */
    sseMaxRetryAttempts?: number;
    /**
     * Maximum retry delay in milliseconds.
     *
     * Applies only when exponential backoff is used.
     *
     * This option applies only if the endpoint returns a stream of events.
     *
     * @default 30000
     */
    sseMaxRetryDelay?: number;
    /**
     * Optional sleep function for retry backoff.
     *
     * Defaults to using `setTimeout`.
     */
    sseSleepFn?: (ms: number) => Promise<void>;
    url: string;
};
interface StreamEvent<TData = unknown> {
    data: TData;
    event?: string;
    id?: string;
    retry?: number;
}
type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
};

type ErrInterceptor<Err, Res, Req, Options> = (error: Err, 
/** response may be undefined due to a network error where no response object is produced */
response: Res | undefined, 
/** request may be undefined, because error may be from building the request object itself */
request: Req | undefined, options: Options) => Err | Promise<Err>;
type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
declare class Interceptors<Interceptor> {
    fns: Array<Interceptor | null>;
    clear(): void;
    eject(id: number | Interceptor): void;
    exists(id: number | Interceptor): boolean;
    getInterceptorIndex(id: number | Interceptor): number;
    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
    use(fn: Interceptor): number;
}
interface Middleware<Req, Res, Err, Options> {
    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
    request: Interceptors<ReqInterceptor<Req, Options>>;
    response: Interceptors<ResInterceptor<Res, Req, Options>>;
}

type ResponseStyle = "data" | "fields";
interface Config<T extends ClientOptions$1 = ClientOptions$1> extends Omit<RequestInit, "body" | "headers" | "method">, Config$1 {
    /**
     * Base URL for all requests made by this client.
     */
    baseUrl?: T["baseUrl"];
    /**
     * Fetch API implementation. You can use this option to provide a custom
     * fetch instance.
     *
     * @default globalThis.fetch
     */
    fetch?: typeof fetch;
    /**
     * Please don't use the Fetch client for Next.js applications. The `next`
     * options won't have any effect.
     *
     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
     */
    next?: never;
    /**
     * Return the response data parsed in a specified format. By default, `auto`
     * will infer the appropriate method from the `Content-Type` response header.
     * You can override this behavior with any of the {@link Body} methods.
     * Select `stream` if you don't want to parse response data at all.
     *
     * @default 'auto'
     */
    parseAs?: "arrayBuffer" | "auto" | "blob" | "formData" | "json" | "stream" | "text";
    /**
     * Should we return only data or multiple fields (data, error, response, etc.)?
     *
     * @default 'fields'
     */
    responseStyle?: ResponseStyle;
    /**
     * Throw an error instead of returning it in the response?
     *
     * @default false
     */
    throwOnError?: T["throwOnError"];
}
interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = "fields", ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
    responseStyle: TResponseStyle;
    throwOnError: ThrowOnError;
}>, Pick<ServerSentEventsOptions<TData>, "onRequest" | "onSseError" | "onSseEvent" | "sseDefaultRetryDelay" | "sseMaxRetryAttempts" | "sseMaxRetryDelay"> {
    /**
     * Any body that you want to add to your request.
     *
     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
     */
    body?: unknown;
    path?: Record<string, unknown>;
    query?: Record<string, unknown>;
    /**
     * Security mechanism(s) to use for the request.
     */
    security?: ReadonlyArray<Auth>;
    url: Url;
}
interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = "fields", ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
    headers: Headers;
    serializedBody?: string;
}
type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = "fields"> = ThrowOnError extends true ? Promise<TResponseStyle extends "data" ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
    request: Request;
    response: Response;
}> : Promise<TResponseStyle extends "data" ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
    error: undefined;
} | {
    data: undefined;
    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
}) & {
    /** request may be undefined, because error may be from building the request object itself */
    request?: Request;
    /** response may be undefined, because error may be from building the request object itself or from a network error */
    response?: Response;
}>;
interface ClientOptions$1 {
    baseUrl?: string;
    responseStyle?: ResponseStyle;
    throwOnError?: boolean;
}
type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData>>;
type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method"> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
type BuildUrlFn = <TData extends {
    body?: unknown;
    path?: Record<string, unknown>;
    query?: Record<string, unknown>;
    url: string;
}>(options: TData & Options$1<TData>) => string;
type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
};
interface TDataShape {
    body?: unknown;
    headers?: unknown;
    path?: unknown;
    query?: unknown;
    url: string;
}
type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = "fields"> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, "body" | "path" | "query" | "url"> & ([TData] extends [never] ? unknown : Omit<TData, "url">);

type ClientOptions = {
    baseUrl: "https://odyssey.asteroid.ai/agents/v2" | (string & {});
};
type AgentsAgentAgentDuplicateRequest = {
    /**
     * The ID of the organization the duplicated agent is created in. The source agent is left untouched.
     */
    organizationId: CommonUuid;
    /**
     * Optional name for the duplicated agent. Letters, digits, spaces, and punctuation excluding _ < > : " / \ | ? and *. Defaults to the source agent's name with a " (Copy)" suffix.
     */
    name?: string;
};
type AgentsAgentAgentDuplicateResponse = {
    /**
     * The ID of the newly created agent
     */
    id: CommonUuid;
    /**
     * The ID of the new agent's initial workflow version
     */
    workflowId: CommonUuid;
};
type AgentsAgentAvailableTool = {
    name: string;
    description: string;
    capability: string;
    isRequired: boolean;
};
type AgentsAgentAvailableToolsResponse = {
    tools: Array<AgentsAgentAvailableTool>;
};
type AgentsAgentBase = {
    id: CommonUuid;
    name: string;
    createdAt: string;
    organizationId?: CommonUuid;
    userId: CommonUuid;
};
type AgentsAgentCreateResponse = {
    id: CommonUuid;
};
type AgentsAgentExecuteAgentRequest = {
    /**
     * The ID of the agent profile to use for this execution. Mutually exclusive with agentProfilePoolId.
     */
    agentProfileId?: CommonUuid;
    /**
     * The ID of the agent profile pool to select a profile from. Mutually exclusive with agentProfileId.
     */
    agentProfilePoolId?: CommonUuid;
    /**
     * Inputs to be merged into the placeholders defined in prompts
     */
    inputs?: {
        [key: string]: unknown;
    };
    /**
     * Deprecated: Use 'inputs' instead. Inputs to be merged into the placeholders defined in prompts
     *
     * @deprecated
     */
    dynamicData?: {
        [key: string]: unknown;
    };
    /**
     * Array of temporary files to attach to the execution. Must have been pre-uploaded using the stage file endpoint
     */
    tempFiles?: Array<AgentsFilesTempFile>;
    /**
     * Optional metadata key-value pairs (string keys and string values) for organizing and filtering executions
     */
    metadata?: {
        [key: string]: unknown;
    };
    /**
     * The version of the agent to execute. If not provided, the published version will be used.
     */
    version?: number;
    /**
     * Per-execution runtime options that override or extend the agent's default settings.
     */
    executionOptions?: AgentsAgentExecutionOptions;
    /**
     * What to do when the execution cannot start right now because the organisation is at
     * its concurrency limit or every profile in the pool is in use. "reject" (the default)
     * fails the request as today. "queue" accepts it: the execution is created in the
     * "queued" status under the returned ID and starts automatically, oldest first, as
     * capacity frees. Temp files cannot be queued.
     */
    onCapacityLimit?: AgentsAgentOnCapacityLimit;
};
type AgentsAgentExecuteAgentResponse = {
    /**
     * The ID of the newly created execution
     */
    executionId: CommonUuid;
    /**
     * The execution's initial status: "starting" when it began immediately, "queued" when it
     * is waiting for capacity (only with onCapacityLimit: "queue"). Poll the execution by ID
     * to follow it either way.
     */
    status?: AgentsExecutionStatus;
};
/**
 * Per-execution runtime options.
 */
type AgentsAgentExecutionOptions = {
    /**
     * Identifies which variant this execution is for, scoping its shared files and scripts to a per-variant subdirectory under each node's shared folder. It does not change which agent or workflow runs. Normalised to a filesystem-safe slug by the server. Requires the agent to have `variant_mode` enabled, and a variant-mode agent requires it on every execution.
     */
    variantKey?: string;
    /**
     * Soft timeout in minutes. When the execution has been running longer than this value, a message is injected on every subsequent step urging the agent to wrap up and produce output. Must be greater than 0 and less than the agent's hard timeout (max_timeout_mins).
     */
    softTimeoutMins?: number;
};
type AgentsAgentExecutionStats = {
    timeSeries: Array<AgentsAgentTimeSeriesDataPoint>;
    summary: AgentsAgentExecutionSummary;
};
type AgentsAgentExecutionSummary = {
    totalExecutions: number;
    outcomes: {
        [key: string]: unknown;
    };
    averageDurationSeconds?: number;
    totalDurationSeconds?: number;
};
type AgentsAgentExternalCreateRequest = {
    organizationId: CommonUuid;
    /**
     * Name for the new agent. Characters outside the agent-name charset (letters, digits, spaces, hyphens) are sanitized server-side — create flows carry defaulted names (templates, prebuilt states) the user never typed, which must not fail validation.
     */
    name: string;
    workflow: AgentsWorkflowExternalCreateWorkflowRequest;
};
type AgentsAgentExternalDetail = {
    agent: AgentsAgentBase;
    workflow: AgentsWorkflowExternalWorkflowSnapshot;
    versionsMetadata: Array<AgentsAgentWorkflowVersionMetadata>;
};
/**
 * Behaviour when the organisation or profile pool has no capacity for the execution
 */
type AgentsAgentOnCapacityLimit = "reject" | "queue";
type AgentsAgentSortField = "name" | "created_at";
type AgentsAgentTimeSeriesDataPoint = {
    date: string;
    outcomes: {
        [key: string]: unknown;
    };
    averageDurations?: {
        [key: string]: unknown;
    };
};
type AgentsAgentUpdateRequest = {
    /**
     * New name for the agent. Letters, digits, spaces, and punctuation excluding _ < > : " / \ | ? and *.
     */
    name?: string;
};
type AgentsAgentWorkflowVersionMetadata = {
    id: CommonUuid;
    parentId?: CommonUuid;
    authorId?: CommonUuid;
    version: number;
    isPublished: boolean;
    createdAt: string;
};
type AgentsContextUserContextResponse = {
    userId: CommonUuid;
    email: string;
    organizations: Array<AgentsContextUserOrganization>;
};
type AgentsContextUserOrganization = {
    id: CommonUuid;
    name: string;
};
/**
 * Engagement-activity rows for every organisation that has run an execution or built an agent.
 */
type AgentsCustomerActivityCustomerActivityList = {
    rows: Array<AgentsCustomerActivityCustomerActivityRow>;
    /**
     * When the snapshot was computed (server time).
     */
    computedAt: string;
};
/**
 * Per-organisation engagement-activity row for the admin customers dashboard. Owned by the agents service; the frontend joins it onto billing identity on organisationId.
 */
type AgentsCustomerActivityCustomerActivityRow = {
    /**
     * Organisation ID (usersdb organisation UUID).
     */
    organisationId: CommonUuid;
    /**
     * Timestamp of the most recent execution. Absent when the org never ran one.
     */
    lastActivityAt?: string;
    /**
     * Total agents (workflow groups) ever created by the org.
     */
    agentCount: number;
    /**
     * Executions created in the last 7 days.
     */
    execs7d: number;
    /**
     * Executions created in the last 30 days.
     */
    execs30d: number;
    /**
     * Distinct UTC days with at least one execution created in the last 14 days. Raw baseline for the digest's sudden-stop signal.
     */
    activeDays14d: number;
    /**
     * Count of ExecutionFailed/ExecutionActionFailed events carrying an os_error (infrastructure/sandbox failure, as opposed to a task failure) in the last 7 days.
     */
    osErrorCount7d: number;
    /**
     * completed / (completed+failed) over runs that ended in the last 7 days, 0..1. Absent when fewer than 5 finished runs (volume floor).
     */
    successRate7d?: number;
    /**
     * Risk from inactivity: red >14d, amber 7-14d, green <7d since last activity. Never-active orgs are red.
     */
    inactivityRisk: AgentsCustomerActivityRiskLevel;
    /**
     * Risk from success rate: red <30%, amber 30-70%, green >70%. Absent below the volume floor.
     */
    qualityRisk?: AgentsCustomerActivityRiskLevel;
    /**
     * Worse of the two risks. The frontend weights this by MRR to derive the dashboard priority sort.
     */
    overallRisk: AgentsCustomerActivityRiskLevel;
};
/**
 * Window-stats rows for every org with executions in the trailing baseline.
 */
type AgentsCustomerActivityCustomerWindowStatsList = {
    rows: Array<AgentsCustomerActivityCustomerWindowStatsRow>;
    computedAt: string;
};
/**
 * Per-org trailing 7-day windows for the customer-health digest deltas.
 */
type AgentsCustomerActivityCustomerWindowStatsRow = {
    organisationId: CommonUuid;
    windows: Array<AgentsCustomerActivityOrgWindowStat>;
};
/**
 * Kind of high-intent activity event surfaced in the customer-health digest.
 */
type AgentsCustomerActivityNotableActivityKind = "first_scheduled_agent" | "first_api_execution" | "first_agent_built" | "first_successful_execution" | "friction";
/**
 * Notable-activity events in the lookback window. Used by the customer-health Slack digest.
 */
type AgentsCustomerActivityNotableActivityList = {
    events: Array<AgentsCustomerActivityNotableActivityRow>;
    /**
     * Inclusive lower bound on occurredAt (UTC).
     */
    since: string;
};
/**
 * An org tripped a high-intent activity event within the lookback window.
 */
type AgentsCustomerActivityNotableActivityRow = {
    /**
     * Organisation ID (usersdb organisation UUID).
     */
    organisationId: CommonUuid;
    /**
     * Which event was tripped.
     */
    kind: AgentsCustomerActivityNotableActivityKind;
    /**
     * When the event occurred (for friction: the most recent qualifying run).
     */
    occurredAt: string;
    /**
     * Optional human-readable detail for the digest line. Absent when no detail applies.
     */
    detail?: string;
};
/**
 * One 7-day window of an org's execution activity for digest deltas. windowIndex 0 = most recent complete 7 days; 1..12 = trailing baseline.
 */
type AgentsCustomerActivityOrgWindowStat = {
    windowIndex: number;
    execCount: number;
    /**
     * Runs that produced an execution_result outcome in the window.
     */
    outcomeTotal: number;
    /**
     * Agent-recorded outcome label -> count. Label-agnostic; never assume a fixed set.
     */
    outcomeCounts: {
        [key: string]: unknown;
    };
};
/**
 * Traffic-light engagement-risk level derived from execution activity.
 */
type AgentsCustomerActivityRiskLevel = "red" | "amber" | "green";
/**
 * Request to search Asteroid documentation
 */
type AgentsDocsSearchDocsRequest = {
    /**
     * Search query to find relevant documentation
     */
    query: string;
};
/**
 * Response containing documentation search results
 */
type AgentsDocsSearchDocsResponse = {
    /**
     * Search results matching the query
     */
    results: Array<AgentsDocsSearchResult>;
};
/**
 * A single documentation search result
 */
type AgentsDocsSearchResult = {
    /**
     * Result title
     */
    title: string;
    /**
     * Result content/snippet
     */
    content: string;
    /**
     * Source URL
     */
    url?: string;
};
/**
 * An astro build conversation owns the environment: it lives as long as the chat driving it.
 */
type AgentsEnvironmentAstroEnvironmentOwner = {
    type: "astro";
    /**
     * The agent the conversation is building.
     */
    agentId: CommonUuid;
    /**
     * The astro chat that booted the environment.
     */
    chatId: CommonUuid;
};
/**
 * A single environment: what it is, its provider state, and how to drive it. `state` is the same shape the execution endpoint returns, so the LiveView/OsLiveView components render either without branching.
 */
type AgentsEnvironmentEnvironment = {
    /**
     * Environment identifier.
     */
    id: CommonUuid;
    /**
     * The organisation the environment belongs to.
     */
    organizationId: CommonUuid;
    /**
     * Who the environment belongs to, and the identity that owner carries.
     */
    owner: AgentsEnvironmentEnvironmentOwner;
    /**
     * Browser or OS.
     */
    environmentType: AgentsWorkflowEnvironmentType;
    /**
     * Operating system for OS environments. Absent for browser environments; linux when an OS environment predates explicit osType storage.
     */
    osType?: AgentsWorkflowOsType;
    /**
     * Current status, terminal states included. Lists exclude terminal environments unless `includeTerminal` is set.
     */
    status: AgentsEnvironmentEnvironmentStatus;
    /**
     * Profile snapshot the environment was booted against, if any.
     */
    agentProfileId?: CommonUuid;
    /**
     * Whether a playable recording has been persisted (GCS object or provider URL). The playable URL itself is minted on the by-id read.
     */
    hasRecording: boolean;
    /**
     * When the environment row was created.
     */
    createdAt: string;
    /**
     * When the environment first became ready, if it reached that state.
     */
    readyAt?: string;
    /**
     * When the environment reached a terminal state. Set after Stop runs.
     */
    stoppedAt?: string;
    /**
     * When the reaper will tear the environment down if no graceful Stop arrives first.
     */
    expiresAt: string;
    /**
     * Environment state (browser or OS): live-view URL, viewport, provider config and a freshly-minted recording URL when one exists.
     */
    state: AgentsExecutionEnvironmentState;
    /**
     * How to connect to it.
     */
    connection: AgentsEnvironmentEnvironmentConnection;
};
/**
 * How to drive a running environment. All fields are optional — an env that is still bootstrapping has no CDP URL yet, and a caller can proceed without browser tools.
 */
type AgentsEnvironmentEnvironmentConnection = {
    /**
     * Chrome DevTools Protocol websocket URL. Present only for browser environments with a ready CDP endpoint. Proxied on the browser and API-key surfaces; the raw provider URL is only ever handed to service-to-service callers.
     */
    cdpUrl?: string;
};
/**
 * Which lifecycle states a list should return. A coarser handle than the status enum, and the one a caller actually wants: what is still usable, what is finished, or everything.
 */
type AgentsEnvironmentEnvironmentLifecycle = "running" | "terminal" | "all";
/**
 * Who the environment belongs to. Discriminated on `type`, mirroring the storage-side agent_environment.owner_type, so each owner kind carries exactly the identity it has — an execution id only exists for execution-owned envs, a chat id only for astro-owned ones. A future owner kind joins as a member rather than as another optional column.
 */
type AgentsEnvironmentEnvironmentOwner = ({
    type: "execution";
} & AgentsEnvironmentExecutionEnvironmentOwner) | ({
    type: "astro";
} & AgentsEnvironmentAstroEnvironmentOwner) | ({
    type: "external";
} & AgentsEnvironmentExternalEnvironmentOwner) | ({
    type: "organization";
} & AgentsEnvironmentOrganizationEnvironmentOwner) | ({
    type: "warm_pool";
} & AgentsEnvironmentWarmPoolEnvironmentOwner);
/**
 * Where the environment spec comes from: copied from a workflow, or supplied inline.
 */
type AgentsEnvironmentEnvironmentSource = ({
    kind: "workflow";
} & AgentsEnvironmentWorkflowEnvironmentSource) | ({
    kind: "spec";
} & AgentsEnvironmentExplicitEnvironmentSource);
/**
 * Every state an environment can be in, terminal included.
 */
type AgentsEnvironmentEnvironmentStatus = "requested" | "provisioning" | "ready" | "stopping" | "stopped" | "failed" | "dead";
/**
 * An environment as it appears in a list. Carries everything a row needs; the provider `state` is fetched with the environment itself, because resolving it mints a signed recording URL per environment and a list would mint one per row.
 */
type AgentsEnvironmentEnvironmentSummary = {
    /**
     * Environment identifier.
     */
    id: CommonUuid;
    /**
     * The organisation the environment belongs to.
     */
    organizationId: CommonUuid;
    /**
     * Who the environment belongs to, and the identity that owner carries.
     */
    owner: AgentsEnvironmentEnvironmentOwner;
    /**
     * Browser or OS.
     */
    environmentType: AgentsWorkflowEnvironmentType;
    /**
     * Operating system for OS environments. Absent for browser environments; linux when an OS environment predates explicit osType storage.
     */
    osType?: AgentsWorkflowOsType;
    /**
     * Current status, terminal states included. Lists exclude terminal environments unless `includeTerminal` is set.
     */
    status: AgentsEnvironmentEnvironmentStatus;
    /**
     * Profile snapshot the environment was booted against, if any.
     */
    agentProfileId?: CommonUuid;
    /**
     * Whether a playable recording has been persisted (GCS object or provider URL). The playable URL itself is minted on the by-id read.
     */
    hasRecording: boolean;
    /**
     * When the environment row was created.
     */
    createdAt: string;
    /**
     * When the environment first became ready, if it reached that state.
     */
    readyAt?: string;
    /**
     * When the environment reached a terminal state. Set after Stop runs.
     */
    stoppedAt?: string;
    /**
     * When the reaper will tear the environment down if no graceful Stop arrives first.
     */
    expiresAt: string;
};
/**
 * An execution owns the environment: it was booted to run that execution and dies with it.
 */
type AgentsEnvironmentExecutionEnvironmentOwner = {
    type: "execution";
    /**
     * The agent the execution runs on behalf of.
     */
    agentId: CommonUuid;
    /**
     * The execution that booted the environment.
     */
    executionId: CommonUuid;
};
/**
 * Environment spec supplied inline — provisioning does not read any workflow. This is how a live env is started without touching (or even having) a workflow definition.
 */
type AgentsEnvironmentExplicitEnvironmentSource = {
    kind: "spec";
    /**
     * Environment template. Omit entirely for the server default (browser).
     */
    template?: AgentsEnvironmentSpecEnvironmentTemplate;
    /**
     * Viewport width in pixels. Omit for the default (1280, the computer-use resolution). Ignored for OS environments — they always run at the fixed computer-use resolution.
     */
    viewportWidth?: number;
    /**
     * Viewport height in pixels. Omit for the default (800, the computer-use resolution). Ignored for OS environments — they always run at the fixed computer-use resolution.
     */
    viewportHeight?: number;
    /**
     * Session lifetime in minutes before the reaper tears the env down. Clamped server-side to the owner's ceiling: 60 minutes for an astro-owned env, which lives only as long as its build conversation, and 1440 for a standalone one, which is parked deliberately. Omit for the owner's default — 60 and 720 respectively.
     */
    sessionTimeoutMins?: number;
};
/**
 * A standalone environment: it belongs to the organisation rather than to a chat or an execution, and outlives both. Booted by an API key today; the agent binding arrives with the workflow it was started from.
 */
type AgentsEnvironmentExternalEnvironmentOwner = {
    type: "external";
    /**
     * The agent the environment is bound to.
     */
    agentId: CommonUuid;
    /**
     * The API key that booted it, when one did. Absent for environments booted by a signed-in user.
     */
    createdByApiKeyId?: CommonUuid;
};
/**
 * Response for the list endpoint, ordered by createdAt DESC. Empty array when nothing matches the filters.
 */
type AgentsEnvironmentListEnvironmentsResponse = {
    /**
     * The matching environments.
     */
    environments: Array<AgentsEnvironmentEnvironmentSummary>;
};
/**
 * An environment owned by the organisation itself: it has no agent binding at all — the organisation on the environment is its whole identity.
 */
type AgentsEnvironmentOrganizationEnvironmentOwner = {
    type: "organization";
};
/**
 * Browser template for the explicit spec arm. Every field is optional with a server default.
 */
type AgentsEnvironmentSpecBrowserTemplate = {
    type: "browser";
    /**
     * Browser provider. Omit for the server's configured default provider.
     */
    provider?: AgentsWorkflowBrowserProvider;
};
/**
 * Environment template for the explicit spec arm — a looser sibling of the workflow's own EnvironmentTemplate where every field has a server default, so callers can say as little as `{type: "os"}`.
 */
type AgentsEnvironmentSpecEnvironmentTemplate = ({
    type: "browser";
} & AgentsEnvironmentSpecBrowserTemplate) | ({
    type: "os";
} & AgentsEnvironmentSpecOsTemplate);
/**
 * OS template for the explicit spec arm. Every field is optional with a server default.
 */
type AgentsEnvironmentSpecOsTemplate = {
    type: "os";
    /**
     * OS provider. Omit for the default (daytona).
     */
    provider?: AgentsWorkflowOsProvider;
    /**
     * Snapshot to boot. Omit for the configured default snapshot for the chosen osType.
     */
    snapshotName?: string;
    /**
     * Whether the sandbox is publicly reachable. Omit for false.
     */
    public?: boolean;
    /**
     * Operating system the sandbox runs. Omit for linux.
     */
    osType?: AgentsWorkflowOsType;
    /**
     * Daytona region to boot the sandbox in. Omit for us.
     */
    region?: AgentsWorkflowOsRegion;
};
/**
 * Request to start an environment. An environment belongs to an organisation; the agent is an optional binding carried in the body, not a path segment. With an agent, the environment is stamped external-owned and the agent's workflow/profile drive provisioning; without one, it is organization-owned and provisions from the explicit spec alone.
 */
type AgentsEnvironmentStartEnvironmentRequest = {
    /**
     * The organisation the environment belongs to. Required even when an agent is given — the server verifies the agent belongs to it, so a mismatched binding fails instead of stamping the wrong organisation.
     */
    organizationId: CommonUuid;
    /**
     * The agent to bind the environment to. Gates access to that agent's workflow. Omit for an organization-owned environment with no agent binding.
     */
    agentId?: CommonUuid;
    /**
     * Where the environment spec comes from. Omit for the server default (a browser env at the computer-use resolution). The workflow arm needs an agent to resolve against, so it requires `agentId`.
     */
    source?: AgentsEnvironmentEnvironmentSource;
    /**
     * Optional agent profile to attach. The profile id is stamped onto the env row for the session's lifetime, so later reads resolve against the stamped profile rather than the agent's current one. Its decrypted credentials come back on the response's `connection` only for service-to-service callers — they are never returned to an API key or a browser.
     */
    agentProfileId?: CommonUuid;
};
/**
 * A warm pool owns the environment for its whole life; executions borrow it without ever taking ownership.
 */
type AgentsEnvironmentWarmPoolEnvironmentOwner = {
    type: "warm_pool";
    /**
     * The warm pool the environment belongs to.
     */
    warmPoolId: CommonUuid;
};
/**
 * Environment spec derived from a workflow. The workflow's environment_template + settings (viewport, timeout) drive provisioning.
 */
type AgentsEnvironmentWorkflowEnvironmentSource = {
    kind: "workflow";
    /**
     * The workflow whose environment_template + settings drive provisioning. Omit to use the agent's editable head — the server resolves the head anyway, so passing an explicit id only matters for agents without one.
     */
    workflowId?: CommonUuid;
};
/**
 * API key reference used for authentication
 */
type AgentsExecutionApiKeyRef = {
    /**
     * API key ID
     */
    id: CommonUuid;
    /**
     * API key name
     */
    name: string;
};
/**
 * API-triggered execution context
 */
type AgentsExecutionApiTriggerContext = {
    /**
     * Trigger source discriminator
     */
    source: "api";
    /**
     * Runner information
     */
    runner: AgentsExecutionTriggerRunner;
    /**
     * API key used for authentication (may be hidden for privacy when admin-triggered)
     */
    apiKey?: AgentsExecutionApiKeyRef;
};
type AgentsExecutionActionName = "element_click" | "element_type" | "element_select" | "element_hover" | "element_drag" | "element_wait" | "element_fill_form" | "element_get_text" | "element_file_upload" | "coord_move" | "coord_click" | "coord_double_click" | "coord_triple_click" | "coord_drag" | "coord_scroll" | "nav_to" | "nav_back" | "nav_refresh" | "nav_tabs" | "nav_close_browser" | "nav_resize_browser" | "nav_install_browser" | "nav_zoom_in" | "nav_zoom_out" | "obs_snapshot" | "obs_snapshot_with_selectors" | "obs_screenshot" | "obs_console_messages" | "obs_network_requests" | "obs_extract_html" | "script_eval" | "script_playwright" | "script_playwright_llm_vars" | "script_hybrid_playwright" | "browser_run_code" | "browser_press_key" | "browser_handle_dialog" | "browser_read_clipboard" | "browser_solve_captcha" | "file_list" | "file_read" | "file_stage" | "file_download" | "file_pdf_save" | "scratchpad_read" | "scratchpad_write" | "scriptpad_run_function" | "scriptpad_search_replace" | "scriptpad_read" | "scriptpad_write" | "ext_google_sheets_get_data" | "ext_google_sheets_set_data" | "ext_get_mail" | "ext_send_mail" | "ext_api_call" | "util_wait_time" | "util_get_datetime" | "util_generate_totp_secret" | "util_send_user_message" | "agent_query_context" | "agent_compile_workflow" | "llm_call" | "sdk_bash" | "sdk_read" | "sdk_write" | "sdk_edit" | "sdk_glob" | "sdk_grep" | "sdk_skill" | "handoff_prepare" | "read_file";
type AgentsExecutionActivity = {
    id: CommonUuid;
    payload: AgentsExecutionActivityPayloadUnion;
    executionId: CommonUuid;
    timestamp: string;
};
type AgentsExecutionActivityActionCompletedInfo = ({
    actionName: "ext_api_call";
} & AgentsExecutionExtApiCallCompletedDetails) | ({
    actionName: "scratchpad_read";
} & AgentsExecutionScratchpadReadCompletedDetails) | ({
    actionName: "scratchpad_write";
} & AgentsExecutionScratchpadWriteCompletedDetails) | ({
    actionName: "script_playwright";
} & AgentsExecutionScriptPlaywrightCompletedDetails) | ({
    actionName: "script_hybrid_playwright";
} & AgentsExecutionScriptHybridPlaywrightCompletedDetails) | ({
    actionName: "browser_run_code";
} & AgentsExecutionBrowserRunCodeCompletedDetails) | ({
    actionName: "script_eval";
} & AgentsExecutionScriptEvalCompletedDetails) | ({
    actionName: "file_read";
} & AgentsExecutionFileReadCompletedDetails) | ({
    actionName: "file_list";
} & AgentsExecutionFileListCompletedDetails) | ({
    actionName: "file_stage";
} & AgentsExecutionFileStageCompletedDetails) | ({
    actionName: "element_file_upload";
} & AgentsExecutionElementFileUploadCompletedDetails) | ({
    actionName: "ext_get_mail";
} & AgentsExecutionExtGetMailCompletedDetails) | ({
    actionName: "scriptpad_run_function";
} & AgentsExecutionScriptPadRunFunctionCompletedDetails) | ({
    actionName: "scriptpad_read";
} & AgentsExecutionScriptpadReadCompletedDetails) | ({
    actionName: "scriptpad_write";
} & AgentsExecutionScriptpadWriteCompletedDetails) | ({
    actionName: "scriptpad_search_replace";
} & AgentsExecutionScriptpadSearchReplaceCompletedDetails) | ({
    actionName: "obs_snapshot_with_selectors";
} & AgentsExecutionObsSnapshotWithSelectorsCompletedDetails) | ({
    actionName: "util_get_datetime";
} & AgentsExecutionUtilGetDatetimeCompletedDetails) | ({
    actionName: "nav_to";
} & AgentsExecutionNavToCompletedDetails) | ({
    actionName: "agent_query_context";
} & AgentsExecutionAgentQueryContextCompletedDetails) | ({
    actionName: "sdk_bash";
} & AgentsExecutionSdkBashCompletedDetails) | ({
    actionName: "sdk_read";
} & AgentsExecutionSdkReadCompletedDetails) | ({
    actionName: "sdk_write";
} & AgentsExecutionSdkWriteCompletedDetails) | ({
    actionName: "sdk_edit";
} & AgentsExecutionSdkEditCompletedDetails) | ({
    actionName: "sdk_glob";
} & AgentsExecutionSdkGlobCompletedDetails) | ({
    actionName: "sdk_grep";
} & AgentsExecutionSdkGrepCompletedDetails) | ({
    actionName: "sdk_skill";
} & AgentsExecutionSdkSkillCompletedDetails) | ({
    actionName: "read_file";
} & AgentsExecutionReadFileCompletedDetails) | ({
    actionName: "handoff_prepare";
} & AgentsExecutionHandoffPrepareCompletedDetails) | ({
    actionName: "ext_send_mail";
} & AgentsExecutionExtSendMailCompletedDetails);
type AgentsExecutionActivityActionCompletedPayload = {
    activityType: "action_completed";
    message: string;
    actionId: string;
    actionName: AgentsExecutionActionName;
    duration?: number;
    info?: AgentsExecutionActivityActionCompletedInfo;
    display?: AgentsExecutionActivityDisplay;
};
type AgentsExecutionActivityActionFailedPayload = {
    activityType: "action_failed";
    message: string;
    actionName: AgentsExecutionActionName;
    actionId: string;
    duration?: number;
    display?: AgentsExecutionActivityDisplay;
};
type AgentsExecutionActivityActionStartedInfo = ({
    actionName: "nav_to";
} & AgentsExecutionNavToStartedDetails) | ({
    actionName: "scratchpad_read";
} & AgentsExecutionScratchpadReadStartedDetails) | ({
    actionName: "scratchpad_write";
} & AgentsExecutionScratchpadWriteStartedDetails) | ({
    actionName: "scriptpad_run_function";
} & AgentsExecutionScriptpadRunFunctionStartedDetails) | ({
    actionName: "script_playwright";
} & AgentsExecutionScriptPlaywrightStartedDetails) | ({
    actionName: "script_hybrid_playwright";
} & AgentsExecutionScriptHybridPlaywrightStartedDetails) | ({
    actionName: "browser_run_code";
} & AgentsExecutionBrowserRunCodeStartedDetails) | ({
    actionName: "script_eval";
} & AgentsExecutionScriptEvalStartedDetails) | ({
    actionName: "scriptpad_search_replace";
} & AgentsExecutionScriptpadSearchReplaceStartedDetails) | ({
    actionName: "util_get_datetime";
} & AgentsExecutionUtilGetDatetimeStartedDetails) | ({
    actionName: "scriptpad_read";
} & AgentsExecutionScriptpadReadStartedDetails) | ({
    actionName: "llm_call";
} & AgentsExecutionLlmCallStartedDetails) | ({
    actionName: "agent_query_context";
} & AgentsExecutionAgentQueryContextStartedDetails) | ({
    actionName: "sdk_bash";
} & AgentsExecutionSdkBashStartedDetails) | ({
    actionName: "sdk_read";
} & AgentsExecutionSdkReadStartedDetails) | ({
    actionName: "sdk_write";
} & AgentsExecutionSdkWriteStartedDetails) | ({
    actionName: "sdk_edit";
} & AgentsExecutionSdkEditStartedDetails) | ({
    actionName: "sdk_glob";
} & AgentsExecutionSdkGlobStartedDetails) | ({
    actionName: "sdk_grep";
} & AgentsExecutionSdkGrepStartedDetails) | ({
    actionName: "sdk_skill";
} & AgentsExecutionSdkSkillStartedDetails) | ({
    actionName: "read_file";
} & AgentsExecutionReadFileStartedDetails) | ({
    actionName: "handoff_prepare";
} & AgentsExecutionHandoffPrepareStartedDetails) | ({
    actionName: "ext_send_mail";
} & AgentsExecutionExtSendMailStartedDetails);
type AgentsExecutionActivityActionStartedPayload = {
    activityType: "action_started";
    message: string;
    actionName: AgentsExecutionActionName;
    actionId: string;
    info?: AgentsExecutionActivityActionStartedInfo;
    display?: AgentsExecutionActivityDisplay;
};
type AgentsExecutionActivityCompactionPerformedPayload = {
    activityType: "compaction_performed";
    summaryTokens: number;
    durationMs: number;
    display?: AgentsExecutionActivityDisplay;
};
type AgentsExecutionActivityCompactionStartedPayload = {
    activityType: "compaction_started";
    display?: AgentsExecutionActivityDisplay;
};
type AgentsExecutionActivityDisplay = {
    turnId?: string;
    groupId?: string;
    summaryText?: string;
    presentationLevel?: AgentsExecutionActivityPresentationLevel;
};
type AgentsExecutionActivityFileAddedPayload = {
    activityType: "file_added";
    fileId: CommonUuid;
    fileName: string;
    mimeType: string;
    fileSize: number;
    source: "upload" | "download" | "agent";
    presignedUrl: string;
};
type AgentsExecutionActivityGenericPayload = {
    activityType: "generic";
    message: string;
    display?: AgentsExecutionActivityDisplay;
};
type AgentsExecutionActivityInputSchemaResolvedPayload = {
    activityType: "input_schema_resolved";
    nodeId: CommonUuid;
    nodeName: string;
    properties: Array<string>;
    resolved: {
        [key: string]: unknown;
    };
    resolvedBy?: {
        [key: string]: unknown;
    };
    display?: AgentsExecutionActivityDisplay;
};
type AgentsExecutionActivityOutputSchemaResolvedPayload = {
    activityType: "output_schema_resolved";
    nodeId: CommonUuid;
    nodeName: string;
    properties: Array<string>;
    resolved: {
        [key: string]: unknown;
    };
    resolvedBy?: {
        [key: string]: unknown;
    };
    display?: AgentsExecutionActivityDisplay;
};
type AgentsExecutionActivityPayloadUnion = ({
    activityType: "terminal";
} & AgentsExecutionTerminalPayload) | ({
    activityType: "generic";
} & AgentsExecutionActivityGenericPayload) | ({
    activityType: "reasoning";
} & AgentsExecutionActivityReasoningPayload) | ({
    activityType: "compaction_started";
} & AgentsExecutionActivityCompactionStartedPayload) | ({
    activityType: "compaction_performed";
} & AgentsExecutionActivityCompactionPerformedPayload) | ({
    activityType: "step_started";
} & AgentsExecutionActivityStepStartedPayload) | ({
    activityType: "step_completed";
} & AgentsExecutionActivityStepCompletedPayload) | ({
    activityType: "transitioned_node";
} & AgentsExecutionActivityTransitionedNodePayload) | ({
    activityType: "status_changed";
} & AgentsExecutionActivityStatusChangedPayload) | ({
    activityType: "action_started";
} & AgentsExecutionActivityActionStartedPayload) | ({
    activityType: "action_completed";
} & AgentsExecutionActivityActionCompletedPayload) | ({
    activityType: "action_failed";
} & AgentsExecutionActivityActionFailedPayload) | ({
    activityType: "user_message_received";
} & AgentsExecutionActivityUserMessageReceivedPayload) | ({
    activityType: "file_added";
} & AgentsExecutionActivityFileAddedPayload) | ({
    activityType: "playwright_script_generated";
} & AgentsExecutionActivityPlaywrightScriptGeneratedPayload) | ({
    activityType: "script_variables_substituted";
} & AgentsExecutionActivityScriptVariablesSubstitutedPayload) | ({
    activityType: "input_schema_resolved";
} & AgentsExecutionActivityInputSchemaResolvedPayload) | ({
    activityType: "output_schema_resolved";
} & AgentsExecutionActivityOutputSchemaResolvedPayload) | ({
    activityType: "todos_updated";
} & AgentsExecutionActivityTodosUpdatedPayload);
type AgentsExecutionActivityPlaywrightScriptGeneratedPayload = {
    activityType: "playwright_script_generated";
    nodeId: CommonUuid;
    nodeName: string;
    script: string;
    llmVars?: Array<AgentsGraphModelsNodesPropertiesPlaywrightScriptLlmVar>;
    context: string;
    oldScript?: string;
};
type AgentsExecutionActivityPresentationLevel = "primary" | "secondary" | "system";
type AgentsExecutionActivityReasoningPayload = {
    activityType: "reasoning";
    reasoning: string;
    display?: AgentsExecutionActivityDisplay;
};
type AgentsExecutionActivityScriptVariablesSubstitutedPayload = {
    activityType: "script_variables_substituted";
    nodeId: CommonUuid;
    nodeName: string;
    scriptFileName: string;
    placeholders: Array<string>;
    variables: {
        [key: string]: unknown;
    };
    substituted: boolean;
    display?: AgentsExecutionActivityDisplay;
};
type AgentsExecutionActivityStatusChangedPayload = {
    activityType: "status_changed";
    status: AgentsExecutionStatus;
    completedPayload?: AgentsExecutionCompletedPayload;
    failedPayload?: AgentsExecutionFailedPayload;
    pausedPayload?: AgentsExecutionPausedPayload;
    awaitingConfirmationPayload?: AgentsExecutionAwaitingConfirmationPayload;
    cancelledPayload?: AgentsExecutionCancelledPayload;
};
type AgentsExecutionActivityStepCompletedPayload = {
    activityType: "step_completed";
    stepNumber: number;
};
type AgentsExecutionActivityStepStartedPayload = {
    activityType: "step_started";
    stepNumber: number;
};
type AgentsExecutionActivityTodosUpdatedPayload = {
    activityType: "todos_updated";
    todos: Array<AgentsExecutionTodo>;
    display?: AgentsExecutionActivityDisplay;
};
type AgentsExecutionActivityTransitionedNodePayload = {
    activityType: "transitioned_node";
    newNodeUUID: CommonUuid;
    newNodeName: string;
    newNodeType: string;
    fromNodeDuration?: number;
    transitionType?: AgentsGraphModelsTransitionsTransitionType;
    /**
     * Output variables provided by the from node
     */
    fromNodeOutput?: Array<AgentsExecutionNodeOutputItem>;
    /**
     * A summary of the work done in the previous node
     */
    fromNodeSummary?: string;
};
type AgentsExecutionActivityUserMessageReceivedPayload = {
    activityType: "user_message_received";
    message: string;
    userUUID: CommonUuid;
};
type AgentsExecutionAgentQueryContextCompletedDetails = {
    actionName: "agent_query_context";
    query: string;
    answer: string;
};
type AgentsExecutionAgentQueryContextStartedDetails = {
    actionName: "agent_query_context";
    query: string;
};
/**
 * Anchor browser provider configuration
 */
type AgentsExecutionAnchorProviderConfig = {
    /**
     * Provider type discriminator
     */
    type: "anchor";
    /**
     * Anchor session ID
     */
    sessionId?: CommonUuid;
    /**
     * Anchor session URL
     */
    sessionUrl?: string;
};
type AgentsExecutionAskUserQuestion = {
    questions: Array<AgentsExecutionQuestionItem>;
};
type AgentsExecutionAwaitingConfirmationPayload = {
    reason: string;
};
/**
 * Browser provider configuration (discriminated by type)
 */
type AgentsExecutionBrowserProviderConfig = ({
    type: "anchor";
} & AgentsExecutionAnchorProviderConfig) | ({
    type: "steel";
} & AgentsExecutionSteelProviderConfig);
type AgentsExecutionBrowserRunCodeCompletedDetails = {
    actionName: "browser_run_code";
    success: boolean;
    result: string;
    consoleLogs: Array<string>;
    failedLine?: number;
};
type AgentsExecutionBrowserRunCodeStartedDetails = {
    actionName: "browser_run_code";
    code: string;
};
/**
 * Browser environment state
 */
type AgentsExecutionBrowserState = {
    /**
     * Environment type discriminator
     */
    environmentType: "browser";
    /**
     * Browser provider name
     */
    provider: AgentsWorkflowBrowserProvider;
    /**
     * Browser viewport width
     */
    width: number;
    /**
     * Browser viewport height
     */
    height: number;
    /**
     * Live view/debugger URL
     */
    liveViewUrl?: string;
    /**
     * Recording URL (available after execution completes)
     */
    recordingUrl?: string;
    /**
     * Whether a recording exists (provider URL or durable GCS object persisted). Use this to gate the player rather than recordingUrl, which is empty for GCS-only recordings.
     */
    hasRecording: boolean;
    /**
     * When the environment recording started (video time-zero anchor)
     */
    recordingStartedAt?: string;
    /**
     * Browser's public IP address (detected at startup)
     */
    browserIp?: string;
    /**
     * Provider-specific configuration
     */
    providerConfig?: AgentsExecutionBrowserProviderConfig;
};
type AgentsExecutionCancelReason = "timeout" | "max_steps" | "user_requested" | "script_failed" | "no_activity" | "budget_exceeded" | "no_warm_environment";
type AgentsExecutionCancelledPayload = {
    reason: AgentsExecutionCancelReason;
};
/**
 * User comment on an execution
 */
type AgentsExecutionComment = {
    /**
     * Unique identifier for the comment
     */
    id: CommonUuid;
    /**
     * Execution this comment belongs to
     */
    executionId: CommonUuid;
    /**
     * User who created the comment
     */
    userId: CommonUuid;
    /**
     * Comment content
     */
    content: string;
    /**
     * Whether the comment is public
     */
    public: boolean;
    /**
     * When the comment was created
     */
    createdAt: string;
    /**
     * When the comment was last updated
     */
    updatedAt?: string;
};
type AgentsExecutionCompletedPayload = {
    outcome: string;
    reasoning: string;
    result: unknown;
};
/**
 * Daytona OS provider configuration
 */
type AgentsExecutionDaytonaProviderConfig = {
    /**
     * Daytona sandbox ID
     */
    sandboxId?: string;
    /**
     * Sandbox URL
     */
    sandboxUrl?: string;
};
type AgentsExecutionElementFileUploadCompletedDetails = {
    actionName: "element_file_upload";
    fileNames: Array<string>;
};
/**
 * Discriminated union of environment states (discriminated by environmentType)
 */
type AgentsExecutionEnvironmentState = AgentsExecutionBrowserState | AgentsExecutionOsState;
type AgentsExecutionExecutionAggregates = {
    /**
     * Counts grouped by execution status
     */
    status_counts: AgentsExecutionStatusCounts;
    /**
     * Top outcome labels and their counts
     */
    outcome_counts: AgentsExecutionExecutionOutcomeCounts;
};
type AgentsExecutionExecutionOutcomeCounts = {
    /**
     * Every outcome matching the filter, by count descending. Long-tail outcomes are included so none are hidden.
     */
    items: Array<AgentsExecutionOutcomeCount>;
};
/**
 * Execution result containing outcome, reasoning, and result data
 */
type AgentsExecutionExecutionResult = {
    /**
     * Unique identifier for the result
     */
    id: CommonUuid;
    /**
     * Execution this result belongs to
     */
    executionId: CommonUuid;
    /**
     * Outcome of the execution (success or failure)
     */
    outcome: string;
    /**
     * AI reasoning for the outcome
     */
    reasoning: string;
    /**
     * Result data as JSON
     */
    result: unknown;
    /**
     * When the result was created
     */
    createdAt: string;
};
type AgentsExecutionExtApiCallCompletedDetails = {
    actionName: "ext_api_call";
    statusCode: string;
    responseBody: string;
    requestMethod?: string;
    requestUrl?: string;
};
type AgentsExecutionExtGetMailCompletedDetails = {
    actionName: "ext_get_mail";
    emailCount: number;
    emails: Array<unknown>;
};
type AgentsExecutionExtSendMailCompletedDetails = {
    actionName: "ext_send_mail";
    success: boolean;
    emailId?: string;
};
type AgentsExecutionExtSendMailStartedDetails = {
    actionName: "ext_send_mail";
    to: Array<string>;
    subject: string;
    cc?: Array<string>;
    bcc?: Array<string>;
    bodyPreview?: string;
};
type AgentsExecutionFailedPayload = {
    reason: string;
    os_error?: CommonOsError;
};
type AgentsExecutionFileListCompletedDetails = {
    actionName: "file_list";
    fileNames: Array<string>;
};
type AgentsExecutionFileReadCompletedDetails = {
    actionName: "file_read";
    fileNames: Array<string>;
    errorCount?: number;
    totalSizeBytes?: number;
};
type AgentsExecutionFileStageCompletedDetails = {
    actionName: "file_stage";
    fileNames: Array<string>;
};
type AgentsExecutionHandoffPrepareCompletedDetails = {
    actionName: "handoff_prepare";
    success: boolean;
};
type AgentsExecutionHandoffPrepareStartedDetails = {
    actionName: "handoff_prepare";
    target?: string;
    summary?: string;
    variables?: Array<AgentsExecutionHandoffPrepareVariable>;
};
type AgentsExecutionHandoffPrepareVariable = {
    name: string;
    value: string;
};
/**
 * Human-applied label for categorizing executions
 */
type AgentsExecutionHumanLabel = {
    /**
     * Unique identifier for the label
     */
    id: CommonUuid;
    /**
     * Organization this label belongs to
     */
    organizationId: CommonUuid;
    /**
     * Display name of the label
     */
    name: string;
    /**
     * Hex color code for the label (e.g., #FF5733)
     */
    color: string;
    /**
     * When the label was created
     */
    createdAt: string;
};
type AgentsExecutionInputResolutionSource = "workflow_input" | "node_output" | "llm";
type AgentsExecutionLlmCallPurpose = "iris_pick_next_action" | "transition_pick_next_node" | "output_populate_result" | "generate_hybrid_playwright_code" | "generate_playwright_variables";
type AgentsExecutionLlmCallStartedDetails = {
    actionName: "llm_call";
    purpose: AgentsExecutionLlmCallPurpose;
};
/**
 * Represents a single execution in a list view
 */
type AgentsExecutionListItem = {
    /**
     * The unique identifier of the execution
     */
    id: CommonUuid;
    /**
     * The ID of the agent that was executed
     */
    agentId: CommonUuid;
    /**
     * The ID of the workflow that was executed
     */
    workflowId: CommonUuid;
    /**
     * The current status of the execution
     */
    status: AgentsExecutionStatus;
    /**
     * When the execution was created
     */
    createdAt: string;
    /**
     * When the execution actually started running; absent while queued. createdAt means "enqueued at" for executions that waited in the queue.
     */
    startedAt?: string;
    /**
     * When the execution reached a terminal state (if applicable)
     */
    terminalAt?: string;
    /**
     * The organization this execution belongs to
     */
    organizationId: CommonUuid;
    /**
     * The agent display name
     */
    agentName: string;
    /**
     * The name of the agent profile used for this execution (if any)
     */
    agentProfileName?: string;
    /**
     * The ID of the agent profile used for this execution (if any)
     */
    agentProfileId?: CommonUuid;
    /**
     * Input variables used for this execution
     */
    inputs?: {
        [key: string]: unknown;
    };
    /**
     * Execution result with outcome, reasoning, and result data
     */
    executionResult?: AgentsExecutionExecutionResult;
    /**
     * Execution duration in seconds (only present for terminal executions)
     */
    duration?: number;
    /**
     * Human-applied labels for this execution
     */
    humanLabels: Array<AgentsExecutionHumanLabel>;
    /**
     * Comments on this execution
     */
    comments: Array<AgentsExecutionComment>;
    /**
     * Optional metadata key-value pairs attached to this execution
     */
    metadata?: {
        [key: string]: unknown;
    };
    /**
     * Recording URL for playback (if an environment was used and execution is terminal)
     */
    recordingUrl?: string;
    /**
     * Live view URL for debugging (if an environment is active and execution is running)
     */
    liveViewUrl?: string;
    /**
     * Deep link to this execution in the Asteroid platform UI
     */
    platformUrl?: string;
    /**
     * Deprecated: Use 'recordingUrl' instead.
     *
     * @deprecated
     */
    browserRecordingUrl?: string;
    /**
     * Deprecated: Use 'liveViewUrl' instead.
     *
     * @deprecated
     */
    browserLiveViewUrl?: string;
    /**
     * Context about how and by whom this execution was triggered (discriminated by source)
     */
    triggerContext?: AgentsExecutionTriggerContext;
    /**
     * Per-execution runtime options (e.g. variant key)
     */
    executionOptions?: AgentsAgentExecutionOptions;
    /**
     * Whether this execution has been rerun at least once
     */
    hasBeenRerun: boolean;
    /**
     * ID of the execution this was rerun from, if applicable
     */
    parentExecutionId?: CommonUuid;
    /**
     * Script failures recorded for this execution (omitted when none occurred)
     */
    scriptFailures?: Array<AgentsExecutionScriptFailure>;
    /**
     * When the retention purge removed this execution's data. Inputs, activities, files and recordings are gone; the row is a tombstone.
     */
    purgedAt?: string;
};
type AgentsExecutionNavToCompletedDetails = {
    actionName: "nav_to";
    pageTitle?: string;
};
type AgentsExecutionNavToStartedDetails = {
    actionName: "nav_to";
    url: string;
};
/**
 * A single output variable with a name and value
 */
type AgentsExecutionNodeOutputItem = {
    /**
     * The name of the output variable
     */
    name: string;
    /**
     * The value of the output variable
     */
    value: string;
};
type AgentsExecutionObsSnapshotWithSelectorsCompletedDetails = {
    actionName: "obs_snapshot_with_selectors";
    url: string;
    title: string;
};
/**
 * OS environment state
 */
type AgentsExecutionOsState = {
    /**
     * Environment type discriminator
     */
    environmentType: "os";
    /**
     * OS provider name
     */
    provider: AgentsWorkflowOsProvider;
    /**
     * Screen width
     */
    width: number;
    /**
     * Screen height
     */
    height: number;
    /**
     * Live view URL
     */
    liveViewUrl?: string;
    /**
     * Recording URL
     */
    recordingUrl?: string;
    /**
     * Whether a recording exists (provider URL or durable GCS object persisted). Use this to gate the player rather than recordingUrl, which is empty for GCS-only recordings.
     */
    hasRecording: boolean;
    /**
     * When the environment recording started (video time-zero anchor)
     */
    recordingStartedAt?: string;
    /**
     * Environment's public egress IP address (detected at startup)
     */
    egressIp?: string;
    /**
     * Provider-specific configuration
     */
    providerConfig?: AgentsExecutionDaytonaProviderConfig;
};
type AgentsExecutionOutcomeCount = {
    /**
     * The outcome label as set on the execution result
     */
    label: string;
    /**
     * Number of executions with this outcome (within the requested filter)
     */
    count: number;
};
type AgentsExecutionPausedPayload = {
    reason: string;
    question?: AgentsExecutionAskUserQuestion;
};
/**
 * Execution lifecycle phase, derived from status. Every status belongs to exactly one phase.
 */
type AgentsExecutionPhase = "pending" | "active" | "terminal";
type AgentsExecutionQuestionItem = {
    question: string;
    header: string;
    options: Array<AgentsExecutionQuestionOption>;
    multiSelect?: boolean;
};
type AgentsExecutionQuestionOption = {
    label: string;
    description: string;
};
type AgentsExecutionReadFileCompletedDetails = {
    actionName: "read_file";
    contentType: "image" | "document" | "text" | "unknown";
    mimeType?: string;
    content?: string;
};
type AgentsExecutionReadFileStartedDetails = {
    actionName: "read_file";
    filePath: string;
};
/**
 * Schedule reference for schedule-triggered executions
 */
type AgentsExecutionScheduleRef = {
    /**
     * Schedule ID
     */
    id: CommonUuid;
    /**
     * Cron expression of the schedule
     */
    cronExpression: string;
};
/**
 * Schedule-triggered execution context
 */
type AgentsExecutionScheduleTriggerContext = {
    /**
     * Trigger source discriminator
     */
    source: "schedule";
    /**
     * Schedule that triggered the execution
     */
    schedule: AgentsExecutionScheduleRef;
};
type AgentsExecutionScratchpadReadCompletedDetails = {
    actionName: "scratchpad_read";
    content?: string;
    contentTruncated?: boolean;
};
type AgentsExecutionScratchpadReadStartedDetails = {
    actionName: "scratchpad_read";
    operation: "read";
};
type AgentsExecutionScratchpadWriteCompletedDetails = {
    actionName: "scratchpad_write";
    linesChanged: number;
    totalLines: number;
    patchesApplied: number;
    content?: string;
    contentTruncated?: boolean;
};
type AgentsExecutionScratchpadWriteStartedDetails = {
    actionName: "scratchpad_write";
    operation: "write";
};
type AgentsExecutionScriptEvalCompletedDetails = {
    actionName: "script_eval";
    result: unknown;
};
type AgentsExecutionScriptEvalStartedDetails = {
    actionName: "script_eval";
    element?: string;
    ref?: string;
    function: string;
};
/**
 * A single failed run of a scripted iris node's script
 */
type AgentsExecutionScriptFailure = {
    /**
     * ID of the node whose script failed
     */
    nodeId?: string;
    /**
     * Display name of the node whose script failed
     */
    nodeName?: string;
    /**
     * Relative path of the script file that failed
     */
    scriptFilepath?: string;
    /**
     * Error message reported by the failed script
     */
    error?: string;
    /**
     * 1-based line number where the script failed, if known
     */
    failedLine?: number;
    /**
     * Execution step (iteration) at which the failure occurred
     */
    step?: number;
    /**
     * Identifier correlating this failure to its activity event
     */
    actionId?: string;
    /**
     * When the failure occurred
     */
    occurredAt: string;
};
type AgentsExecutionScriptHybridPlaywrightCompletedDetails = {
    actionName: "script_hybrid_playwright";
    success: boolean;
    result: string;
    consoleLogs: Array<string>;
    failedLine?: number;
};
type AgentsExecutionScriptHybridPlaywrightStartedDetails = {
    actionName: "script_hybrid_playwright";
    llmVars?: Array<string>;
};
type AgentsExecutionScriptPadRunFunctionCompletedDetails = {
    actionName: "scriptpad_run_function";
    success: boolean;
    result: string;
    consoleLogs: Array<string>;
    failedLine?: number;
};
type AgentsExecutionScriptPlaywrightCompletedDetails = {
    actionName: "script_playwright";
    success: boolean;
    result: string;
    consoleLogs: Array<string>;
    failedLine?: number;
};
type AgentsExecutionScriptPlaywrightStartedDetails = {
    actionName: "script_playwright";
    llmVars?: Array<string>;
};
type AgentsExecutionScriptpadReadCompletedDetails = {
    actionName: "scriptpad_read";
    content: string;
};
type AgentsExecutionScriptpadReadStartedDetails = {
    actionName: "scriptpad_read";
    offset: number;
    limit: number;
};
type AgentsExecutionScriptpadRunFunctionStartedDetails = {
    actionName: "scriptpad_run_function";
    functionName: string;
    arguments: unknown;
};
type AgentsExecutionScriptpadSearchReplaceCompletedDetails = {
    actionName: "scriptpad_search_replace";
    linesReplaced: number;
    linesReplacedWith: number;
    oldTotalLines: number;
    newTotalLines: number;
    oldScriptpad?: string;
    newScriptpad?: string;
};
type AgentsExecutionScriptpadSearchReplaceStartedDetails = {
    actionName: "scriptpad_search_replace";
    search: string;
    replace: string;
    replaceAll: boolean;
};
type AgentsExecutionScriptpadWriteCompletedDetails = {
    actionName: "scriptpad_write";
    linesChanged: number;
    totalLines: number;
    patchesApplied: number;
    scriptpad?: string;
};
type AgentsExecutionSdkBashCompletedDetails = {
    actionName: "sdk_bash";
    output: string;
    exitCode?: number;
};
type AgentsExecutionSdkBashStartedDetails = {
    actionName: "sdk_bash";
    command: string;
    description?: string;
};
type AgentsExecutionSdkEditCompletedDetails = {
    actionName: "sdk_edit";
    success: boolean;
};
type AgentsExecutionSdkEditStartedDetails = {
    actionName: "sdk_edit";
    filePath: string;
    oldString: string;
    newString: string;
    replaceAll?: boolean;
};
type AgentsExecutionSdkGlobCompletedDetails = {
    actionName: "sdk_glob";
    files: Array<string>;
};
type AgentsExecutionSdkGlobStartedDetails = {
    actionName: "sdk_glob";
    pattern: string;
    path?: string;
};
type AgentsExecutionSdkGrepCompletedDetails = {
    actionName: "sdk_grep";
    output: string;
    outputMode?: string;
};
type AgentsExecutionSdkGrepStartedDetails = {
    actionName: "sdk_grep";
    pattern: string;
    path?: string;
    glob?: string;
    outputMode?: string;
};
type AgentsExecutionSdkReadCompletedDetails = {
    actionName: "sdk_read";
    content: string;
};
type AgentsExecutionSdkReadStartedDetails = {
    actionName: "sdk_read";
    filePath: string;
    offset?: number;
    limit?: number;
};
type AgentsExecutionSdkSkillCompletedDetails = {
    actionName: "sdk_skill";
    output?: string;
};
type AgentsExecutionSdkSkillStartedDetails = {
    actionName: "sdk_skill";
    skill: string;
    args?: string;
};
type AgentsExecutionSdkWriteCompletedDetails = {
    actionName: "sdk_write";
    success: boolean;
};
type AgentsExecutionSdkWriteStartedDetails = {
    actionName: "sdk_write";
    filePath: string;
};
/**
 * Fields that can be used for sorting executions
 */
type AgentsExecutionSortField = "created_at" | "status" | "started_at";
type AgentsExecutionStatus = "queued" | "starting" | "running" | "paused" | "awaiting_confirmation" | "completed" | "cancelled" | "failed" | "paused_by_agent";
type AgentsExecutionStatusCounts = {
    queued?: number;
    starting: number;
    running: number;
    paused: number;
    awaiting_confirmation: number;
    completed: number;
    cancelled: number;
    failed: number;
    paused_by_agent: number;
};
/**
 * Steel browser provider configuration
 */
type AgentsExecutionSteelProviderConfig = {
    /**
     * Provider type discriminator
     */
    type: "steel";
    /**
     * Steel session ID
     */
    sessionId?: string;
};
type AgentsExecutionTerminalPayload = {
    activityType: "terminal";
    reason: "unsubscribe" | "complete" | "error";
    message?: string;
};
type AgentsExecutionTodo = {
    id: string;
    content: string;
    status: AgentsExecutionTodoStatus;
    outcome?: string;
};
type AgentsExecutionTodoStatus = "pending" | "in_progress" | "completed" | "blocked" | "failed" | "canceled";
/**
 * Discriminated union of trigger contexts (discriminated by source)
 */
type AgentsExecutionTriggerContext = ({
    source: "api";
} & AgentsExecutionApiTriggerContext) | ({
    source: "ui";
} & AgentsExecutionUiTriggerContext) | ({
    source: "schedule";
} & AgentsExecutionScheduleTriggerContext) | ({
    source: "warmup";
} & AgentsExecutionWarmupTriggerContext);
/**
 * Runner information - who triggered the execution
 */
type AgentsExecutionTriggerRunner = {
    /**
     * User ID of the runner
     */
    userId: CommonUuid;
    /**
     * Email of the runner
     */
    email: string;
    /**
     * Whether the user is an admin (may be hidden for privacy)
     */
    isAdmin?: boolean;
};
/**
 * UI-triggered execution context
 */
type AgentsExecutionUiTriggerContext = {
    /**
     * Trigger source discriminator
     */
    source: "ui";
    /**
     * Runner information
     */
    runner: AgentsExecutionTriggerRunner;
};
type AgentsExecutionUpdateExecutionStatusRequest = {
    /**
     * The new status to set for the execution
     */
    status: AgentsExecutionUpdateableStatus;
};
/**
 * Status values that can be set via the update endpoint
 */
type AgentsExecutionUpdateableStatus = "running" | "paused" | "cancelled";
type AgentsExecutionUserMessagesAddTextBody = {
    message: string;
};
type AgentsExecutionUtilGetDatetimeCompletedDetails = {
    actionName: "util_get_datetime";
    usedBrowserTimezone: boolean;
    datetime: string;
    tzTimezoneIdentifier: string;
};
type AgentsExecutionUtilGetDatetimeStartedDetails = {
    actionName: "util_get_datetime";
    tzTimezoneIdentifier: string;
};
/**
 * Warmup-triggered execution context: launched by a warm pool's replenisher
 */
type AgentsExecutionWarmupTriggerContext = {
    /**
     * Trigger source discriminator
     */
    source: "warmup";
    /**
     * Warm pool whose replenisher launched the execution
     */
    warmPoolId: CommonUuid;
};
/**
 * Execution batch with status counts
 */
type AgentsExecutionBatchBase = {
    /**
     * Unique identifier for the batch
     */
    id: CommonUuid;
    /**
     * Agent ID this batch belongs to
     */
    agentId: CommonUuid;
    /**
     * Human-readable name for the batch
     */
    name: string;
    /**
     * When to start triggering executions
     */
    startAt: string;
    /**
     * Batch configuration
     */
    config: AgentsExecutionBatchBatchConfig;
    /**
     * Batches sharing a group share one concurrency budget rather than each getting
     * its own. Equals the batch's own id for a one-off batch; a recurring batch
     * carries the id of the schedule that produced it.
     */
    concurrencyGroupId: CommonUuid;
    /**
     * Current batch status
     */
    status: AgentsExecutionBatchStatus;
    /**
     * Number of pending items
     */
    pendingCount: number;
    /**
     * Number of triggered items
     */
    triggeredCount: number;
    /**
     * Number of cancelled items
     */
    cancelledCount: number;
    /**
     * Number of items awaiting capacity
     */
    awaitingCapacityCount: number;
    /**
     * Number of items that could not be triggered and will not be retried
     */
    failedCount: number;
    /**
     * Total number of items
     */
    totalCount: number;
    /**
     * Creation timestamp
     */
    createdAt: string;
    /**
     * Last update timestamp
     */
    updatedAt: string;
};
/**
 * Discriminated union of batch configuration types (discriminated by type)
 */
type AgentsExecutionBatchBatchConfig = ({
    type: "timeBatching";
} & AgentsExecutionBatchTimeBatchingConfig) | ({
    type: "maxConcurrent";
} & AgentsExecutionBatchMaxConcurrentConfig);
/**
 * Item to be executed in a batch
 */
type AgentsExecutionBatchBatchItem = {
    /**
     * Workflow ID to execute
     */
    workflowId: CommonUuid;
    /**
     * Optional agent profile to use. Mutually exclusive with agentProfilePoolId.
     */
    agentProfileId?: CommonUuid;
    /**
     * The ID of the agent profile pool to select a profile from when this item is
     * triggered. Mutually exclusive with agentProfileId.
     */
    agentProfilePoolId?: CommonUuid;
    /**
     * Input variables for the execution
     */
    inputVars?: {
        [key: string]: unknown;
    };
    /**
     * Metadata for the execution
     */
    metadata?: {
        [key: string]: unknown;
    };
    /**
     * Per-execution runtime options for this item, such as its variant key.
     */
    executionOptions?: AgentsAgentExecutionOptions;
};
/**
 * Request to create a new execution batch
 */
type AgentsExecutionBatchCreateRequest = {
    /**
     * Agent ID for this batch
     */
    agentId: CommonUuid;
    /**
     * Human-readable name for the batch
     */
    name: string;
    /**
     * When to start triggering executions
     */
    startAt: string;
    /**
     * Batch configuration
     */
    config: AgentsExecutionBatchBatchConfig;
    /**
     * Items to execute in this batch
     */
    items: Array<AgentsExecutionBatchBatchItem>;
};
/**
 * Max concurrent execution configuration
 */
type AgentsExecutionBatchMaxConcurrentConfig = {
    /**
     * Config type discriminator
     */
    type: "maxConcurrent";
    /**
     * Maximum number of executions running at the same time
     */
    maxConcurrent: number;
};
/**
 * Execution batch status
 */
type AgentsExecutionBatchStatus = "pending" | "running" | "paused" | "completed" | "cancelled";
/**
 * Time-based batching configuration
 */
type AgentsExecutionBatchTimeBatchingConfig = {
    /**
     * Config type discriminator
     */
    type: "timeBatching";
    /**
     * Maximum number of executions to trigger in each batch
     */
    batchSize: number;
    /**
     * Seconds to wait between each batch of executions
     */
    batchInterval: number;
};
/**
 * A file tracked in the agent filesystem
 */
type AgentsFilesAgentFile = {
    id: CommonUuid;
    agentId: CommonUuid;
    filePath: string;
    fileName: string;
    fileSize: number;
    mimeType?: string;
    createdAt: string;
    updatedAt: string;
    executionId: CommonUuid;
    directory: AgentsFilesAgentFileDirectory;
    createdBy: AgentsFilesAgentFileCreatedBy;
    downloadUrl: string;
};
/**
 * Creator of the file
 */
type AgentsFilesAgentFileCreatedBy = "user" | "agent" | "environment" | "system";
/**
 * Directory types within the agent filesystem
 */
type AgentsFilesAgentFileDirectory = "uploads" | "downloads" | "workspace" | "shared" | "debug" | "tracing";
/**
 * Files grouped by their agent directory
 */
type AgentsFilesAgentFilesDirectoryListing = {
    uploads?: Array<AgentsFilesAgentFile>;
    downloads?: Array<AgentsFilesAgentFile>;
    workspace?: Array<AgentsFilesAgentFile>;
    shared?: Array<AgentsFilesAgentFile>;
    debug?: Array<AgentsFilesAgentFile>;
    /**
     * Reserved for internal use.
     */
    tracing?: Array<AgentsFilesAgentFile>;
};
/**
 * Response containing all agent files for an execution, grouped by directory
 */
type AgentsFilesAgentFilesResponse = {
    directories: AgentsFilesAgentFilesDirectoryListing;
    lastUpdated?: string;
};
type AgentsFilesFile = {
    id: CommonUuid;
    executionId: CommonUuid;
    agentId: CommonUuid;
    filePath: string;
    fileName: string;
    fileExt: string;
    fileSize: number;
    fileType: string;
    mimeType: string;
    createdAt: string;
    downloadUrl: string;
    /**
     * @deprecated
     */
    signedUrl: string;
};
type AgentsFilesFilePart = Blob | File;
/**
 * Response containing a short-lived signed URL for direct file download from storage
 */
type AgentsFilesSignedUrlResponse = {
    url: string;
};
type AgentsFilesTempFile = {
    id: CommonUuid;
    name: string;
};
type AgentsFilesTempFilesResponse = {
    tempFiles: Array<AgentsFilesTempFile>;
};
type AgentsGraphModelsAgentGraph = {
    nodes: Array<AgentsGraphModelsNodesNode>;
    transitions: Array<AgentsGraphModelsTransitionsTransition>;
    sticky_notes: Array<AgentsGraphModelsStickyNote>;
};
/**
 * Configuration settings for workflow execution
 */
type AgentsGraphModelsExternalSettings = {
    /**
     * Browser viewport width in pixels
     */
    viewport_width: number;
    /**
     * Browser viewport height in pixels
     */
    viewport_height: number;
    /**
     * Maximum timeout in minutes
     */
    max_timeout_mins: number;
};
type AgentsGraphModelsNodesNode = {
    id: CommonUuid;
    /**
     * Display name. New and renamed nodes accept letters, digits, spaces, and hyphens only (historical versions may carry other characters, so responses are not pattern-constrained).
     */
    name: string;
    type: AgentsGraphModelsNodesNodeType;
    properties: AgentsGraphModelsNodesNodePropertiesUnion;
    position?: AgentsGraphModelsNodesPosition;
    /**
     * Deprecated: field is no longer populated and will be removed.
     *
     * @deprecated
     */
    description?: string;
};
type AgentsGraphModelsNodesNodePropertiesUnion = ({
    type: "start";
} & AgentsGraphModelsNodesPropertiesStartProperties) | ({
    type: "iris";
} & AgentsGraphModelsNodesPropertiesIrisProperties) | ({
    type: "playwright_script";
} & AgentsGraphModelsNodesPropertiesPlaywrightScriptProperties) | ({
    type: "api";
} & AgentsGraphModelsNodesPropertiesApiProperties) | ({
    type: "url";
} & AgentsGraphModelsNodesPropertiesUrlProperties) | ({
    type: "output";
} & AgentsGraphModelsNodesPropertiesOutputProperties);
type AgentsGraphModelsNodesNodeType = "start" | "iris" | "playwright_script" | "api" | "url" | "output";
type AgentsGraphModelsNodesPosition = {
    x: number;
    y: number;
};
type AgentsGraphModelsNodesPropertiesApiMethod = "GET" | "POST" | "PUT" | "DELETE";
/**
 * @deprecated
 */
type AgentsGraphModelsNodesPropertiesApiProperties = {
    type: "api";
    method: AgentsGraphModelsNodesPropertiesApiMethod;
    url: string;
    body: {
        [key: string]: unknown;
    };
    headers: {
        [key: string]: unknown;
    };
};
type AgentsGraphModelsNodesPropertiesIrisPlaywrightScriptProperties = {
    script: string;
    llm_vars: Array<AgentsGraphModelsNodesPropertiesPlaywrightScriptLlmVar>;
    freeze_script: boolean;
};
type AgentsGraphModelsNodesPropertiesIrisProperties = {
    type: "iris";
    instructions: string;
    capabilities?: AgentsGraphModelsNodesPropertiesNodeCapabilities;
    compression_strategies?: Array<string>;
    playwright_script_properties?: AgentsGraphModelsNodesPropertiesIrisPlaywrightScriptProperties;
    input_schema?: {
        [key: string]: unknown;
    };
    /**
     * Relative path (within the node's own shared directory) of the
     * Playwright script that the runtime should execute before the LLM.
     * Setting this turns the node into a fast-path scripted node — combine
     * with `script_failure_action: "cancel_execution"` to skip the LLM
     * entirely on success and cancel on failure.
     *
     * The path is resolved at runtime against the node's shared
     * directory — i.e. `shared/<node-key>/<script_filepath>` on disk in
     * the sandbox. `<node-key>` is owned by the runtime (currently the
     * node's slug, may move to its UUID), so authors do not have to
     * encode it and renaming a node does not break the path.
     *
     * Examples (typical):
     * - `./scripts/main.js`
     * - `./scripts/login.js`
     *
     * A leading `./` is optional but canonical — both `scripts/main.js` and
     * `./scripts/main.js` are accepted, and the platform normalizes to the
     * `./`-prefixed form when it writes this value back out.
     *
     * Constraints:
     * - Must be relative (no leading `/`).
     * - Must NOT start with `shared/` — it is already relative to the
     * node's shared directory; the runtime adds the `shared/<node-key>/`
     * prefix.
     * - Must end in `.js`.
     * - Must not contain `..` segments or duplicate slashes.
     * - May contain a single `{{variant_key}}` placeholder, which the
     * runtime substitutes with the execution's `variant_key` so a single
     * workflow can target per-tenant script trees (e.g.
     * `./variants/{{variant_key}}/scripts/main.js` →
     * `shared/<node-key>/variants/<variant-key>/scripts/main.js`).
     * Requires the agent to have `variant_mode` enabled, and the
     * placeholder must be the segment directly under `variants/`.
     */
    script_filepath?: string;
    /**
     * What happens when a script fails on a scripted node.
     * `fallback_to_ai` (default): fall back to LLM-driven execution.
     * `cancel_execution`: cancel the execution immediately.
     */
    script_failure_action?: "fallback_to_ai" | "cancel_execution";
    thinking_mode?: "adaptive" | "enabled" | "disabled";
    thinking_budget_tokens?: number;
    thinking_effort?: "low" | "medium" | "high" | "max";
    model: string;
};
/**
 * Coarse environment-level capability toggles for an AI node.
 */
type AgentsGraphModelsNodesPropertiesNodeCapabilities = {
    browser_use: boolean;
    computer_use: boolean;
    ask_user_question: boolean;
};
type AgentsGraphModelsNodesPropertiesOutcomeString = string;
type AgentsGraphModelsNodesPropertiesOutputProperties = {
    type: "output";
    instructionsEnabled?: boolean;
    instructions?: string;
    schema?: {
        [key: string]: unknown;
    };
    outcomes: Array<AgentsGraphModelsNodesPropertiesOutcomeString>;
    model?: string;
};
type AgentsGraphModelsNodesPropertiesPlaywrightScriptLlmVar = {
    name: string;
    type: AgentsGraphModelsNodesPropertiesPlaywrightScriptLlmVarType;
    description: string;
};
type AgentsGraphModelsNodesPropertiesPlaywrightScriptLlmVarType = "string" | "number" | "boolean";
type AgentsGraphModelsNodesPropertiesPlaywrightScriptProperties = {
    type: "playwright_script";
    script: string;
    llm_vars: Array<AgentsGraphModelsNodesPropertiesPlaywrightScriptLlmVar>;
};
type AgentsGraphModelsNodesPropertiesStartProperties = {
    type: "start";
};
/**
 * @deprecated
 */
type AgentsGraphModelsNodesPropertiesUrlProperties = {
    type: "url";
    url: string;
};
type AgentsGraphModelsNodesSize = {
    width: number;
    height: number;
};
type AgentsGraphModelsStickyNote = {
    id: CommonUuid;
    content: string;
    color?: string;
    position?: AgentsGraphModelsNodesPosition;
    size?: AgentsGraphModelsNodesSize;
};
type AgentsGraphModelsTransitionsPropertiesIrisProperties = {
    type: "iris";
};
type AgentsGraphModelsTransitionsPropertiesOutcomeSuccessProperties = {
    type: "outcome_success";
};
type AgentsGraphModelsTransitionsPropertiesSelectorProperties = {
    type: "selector";
    name: string;
    selectors: Array<string>;
};
type AgentsGraphModelsTransitionsTransition = {
    id: CommonUuid;
    from: CommonUuid;
    to: CommonUuid;
    type: AgentsGraphModelsTransitionsTransitionType;
    require_confirmation: boolean;
    description?: string;
    schema?: {
        [key: string]: unknown;
    };
    properties: AgentsGraphModelsTransitionsTransitionPropertiesUnion;
};
type AgentsGraphModelsTransitionsTransitionPropertiesUnion = ({
    type: "iris";
} & AgentsGraphModelsTransitionsPropertiesIrisProperties) | ({
    type: "selector";
} & AgentsGraphModelsTransitionsPropertiesSelectorProperties) | ({
    type: "outcome_success";
} & AgentsGraphModelsTransitionsPropertiesOutcomeSuccessProperties);
type AgentsGraphModelsTransitionsTransitionType = "iris" | "selector" | "outcome_success";
/**
 * Metadata about a language model
 */
type AgentsModelsModelMetadata = {
    /**
     * Unique identifier (UUID)
     */
    id: CommonUuid;
    /**
     * Model slug (e.g., 'asteroid-fast')
     */
    slug: string;
    /**
     * Display name for the model
     */
    displayName: string;
    /**
     * Detailed description of the model's characteristics and use cases
     */
    description: string;
    /**
     * Model supports computer use
     */
    supportsComputerUse: boolean;
    /**
     * The provider. Absent for Asteroid aliases, which resolve to a concrete model at runtime.
     */
    provider?: AgentsModelsModelProvider;
};
/**
 * Provider for a language model
 */
type AgentsModelsModelProvider = "openai" | "anthropic" | "google";
/**
 * Response containing all available models
 */
type AgentsModelsModelsResponse = {
    /**
     * List of all available models
     */
    models: Array<AgentsModelsModelMetadata>;
};
/**
 * Request to add profiles to a pool
 */
type AgentsProfileAddProfilesToPoolRequest = {
    /**
     * Profile IDs to add to the pool
     */
    profileIds: Array<CommonUuid>;
};
/**
 * An agent profile containing browser configuration and credentials
 */
type AgentsProfileAgentProfile = {
    /**
     * Unique identifier for the agent profile
     */
    id: CommonUuid;
    /**
     * Name of the agent profile (unique within organization)
     */
    name: string;
    /**
     * Description of the agent profile
     */
    description: string;
    /**
     * The ID of the organization that owns this profile
     */
    organizationId: CommonUuid;
    /**
     * Proxy configuration mode
     */
    proxyMode: AgentsProfileProxyMode;
    /**
     * Country code for proxy location (for managed proxy mode)
     */
    proxyCC?: AgentsProfileCountryCode;
    /**
     * Type of managed proxy to use (for managed proxy mode)
     */
    proxyType?: AgentsProfileProxyType;
    /**
     * Custom proxy configuration (for custom proxy mode, password excluded)
     */
    customProxy?: AgentsProfileCustomProxyConfigOutput;
    /**
     * Proxy gateway preset ID (for gateway proxy mode)
     */
    proxyGatewayPresetId?: CommonUuid;
    /**
     * Whether the captcha solver is active for this profile (managed proxy only)
     */
    captchaSolverActive: boolean;
    /**
     * Whether to use the same IP address for all executions (managed proxy only)
     */
    stickyIP: boolean;
    /**
     * Operating system to emulate
     */
    operatingSystem?: AgentsProfileOperatingSystem;
    /**
     * Whether extra stealth mode is enabled
     */
    extraStealth: boolean;
    /**
     * Whether to allow third-party cookies
     */
    allow3rdCookies: boolean;
    /**
     * Whether to persist browser cache between sessions
     */
    cachePersistence: boolean;
    /**
     * Whether to enable ad blocking
     */
    adblockActive: boolean;
    /**
     * Whether to enable popup blocking (requires adblock to be active)
     */
    popupBlockerActive: boolean;
    /**
     * Whether to force popups to open as tabs
     */
    forcePopupsAsTabsActive: boolean;
    /**
     * Whether to enable media blocking (images, videos, etc.)
     */
    mediaBlockerActive: boolean;
    /**
     * Whether to enable the built-in PDF viewer (if disabled, PDFs are downloaded)
     */
    pdfViewerActive: boolean;
    /**
     * Whether browser tracing is enabled (admin only)
     */
    tracingEnabled: boolean;
    /**
     * Anchor browser fingerprint ID applied at session create (admin only). Absent or null when unset.
     */
    fingerprintId?: string | null;
    /**
     * Stable org extension IDs attached to this profile
     */
    extensionIds: Array<CommonUuid>;
    /**
     * Org vault items attached to this profile. Deleted items are omitted.
     */
    vaultItems: Array<AgentsProfileAgentProfileVaultItemRef>;
    /**
     * Optional custom prefix for the agent's inbox email address. If set, the inbox will be {prefix}@agentmail.asteroid.ai. If not set, defaults to the first 8 characters of the profile ID.
     */
    inboxEmailPrefix?: string;
    /**
     * The resolved inbox email address for this profile
     */
    inboxEmail: string;
    /**
     * Legacy credential names mirrored from attached vault items. Dual-write continues; consumers should use vaultItems.
     */
    credentials: Array<AgentsProfileCredential>;
    /**
     * List of cookies associated with this profile
     */
    cookies: Array<AgentsProfileCookie>;
    /**
     * When the profile was created
     */
    createdAt: string;
    /**
     * When the profile was last updated
     */
    updatedAt: string;
};
/**
 * Response for listing the emails in an agent profile's inbox
 */
type AgentsProfileAgentProfileInboxEmailsResponse = {
    /**
     * Emails addressed to this profile's inbox
     */
    emails: Array<AgentsProfileProfileInboxEmail>;
    /**
     * Number of emails returned
     */
    emailCount: number;
    /**
     * Whether Resend has more emails beyond this page
     */
    hasMore: boolean;
};
/**
 * A pool of agent profiles that can be used for credential rotation
 */
type AgentsProfileAgentProfilePool = {
    /**
     * Unique identifier for the agent profile pool
     */
    id: CommonUuid;
    /**
     * Name of the agent profile pool (unique within organization)
     */
    name: string;
    /**
     * The ID of the organization that owns this pool
     */
    organizationId: CommonUuid;
    /**
     * Strategy for selecting an available profile from the pool
     */
    selectionStrategy: AgentsProfileSelectionStrategy;
    /**
     * Whether multiple executions can use the same profile concurrently
     */
    allowConcurrentUse: boolean;
    /**
     * When the pool was created
     */
    createdAt: string;
    /**
     * When the pool was last updated
     */
    updatedAt: string;
};
/**
 * An agent profile that is a member of a pool
 */
type AgentsProfileAgentProfilePoolMember = {
    /**
     * Unique identifier for the agent profile
     */
    id: CommonUuid;
    /**
     * Name of the agent profile
     */
    name: string;
    /**
     * The ID of the organization that owns this profile
     */
    organizationId: CommonUuid;
    /**
     * When the profile was created
     */
    createdAt: string;
    /**
     * When the profile was last updated
     */
    updatedAt: string;
};
/**
 * A field on an attached vault item. Values are omitted.
 */
type AgentsProfileAgentProfileVaultItemFieldRef = {
    key: AgentsVaultFieldKey;
    type: AgentsVaultFieldType;
    /**
     * Canonical placeholder, e.g. ##MY_PORTAL.USERNAME##
     */
    placeholder: string;
    /**
     * Legacy ##NAME## placeholder when this field was mirrored from an older profile credential.
     */
    legacyPlaceholder?: string;
};
/**
 * Summary of an org vault item attached to an agent profile. Field values are not included.
 */
type AgentsProfileAgentProfileVaultItemRef = {
    id: CommonUuid;
    itemKey: AgentsVaultItemKey;
    name: string;
    kind: AgentsVaultItemKind;
    fields: Array<AgentsProfileAgentProfileVaultItemFieldRef>;
};
/**
 * A browser cookie stored for an agent profile
 */
type AgentsProfileCookie = {
    /**
     * Unique identifier for the cookie
     */
    id?: CommonUuid;
    /**
     * Display name for the cookie
     */
    name: string;
    /**
     * The cookie key/name as sent in HTTP headers
     */
    key: string;
    /**
     * The cookie value
     */
    value: string;
    /**
     * When the cookie expires (optional)
     */
    expiry?: string;
    /**
     * The domain for which the cookie is valid
     */
    domain: string;
    /**
     * Whether the cookie should only be sent over HTTPS
     */
    secure: boolean;
    /**
     * SameSite attribute for the cookie
     */
    sameSite: AgentsProfileSameSite;
    /**
     * Whether the cookie should be accessible only via HTTP(S)
     */
    httpOnly: boolean;
    /**
     * When the cookie was created
     */
    createdAt?: string;
};
/**
 * Two-letter country code for proxy location
 */
type AgentsProfileCountryCode = "us" | "uk" | "fr" | "it" | "jp" | "au" | "de" | "fi" | "ca";
/**
 * Request to create a new agent profile pool
 */
type AgentsProfileCreateAgentProfilePoolRequest = {
    /**
     * Name of the agent profile pool (must be unique within organization)
     */
    name: string;
    /**
     * The ID of the organization that the pool belongs to
     */
    organizationId: CommonUuid;
    /**
     * Strategy for selecting an available profile from the pool
     */
    selectionStrategy?: AgentsProfileSelectionStrategy;
    /**
     * Whether multiple executions can use the same profile concurrently
     */
    allowConcurrentUse?: boolean;
};
/**
 * Request to create a new agent profile
 */
type AgentsProfileCreateAgentProfileRequest = {
    /**
     * Name of the agent profile (must be unique within organization)
     */
    name: string;
    /**
     * Description of the agent profile
     */
    description: string;
    /**
     * The ID of the organization that the profile belongs to
     */
    organizationId: CommonUuid;
    /**
     * Proxy configuration mode
     */
    proxyMode?: AgentsProfileProxyMode;
    /**
     * Country code for proxy location (for managed proxy mode)
     */
    proxyCC?: AgentsProfileCountryCode;
    /**
     * Type of managed proxy to use (required for managed proxy mode)
     */
    proxyType?: AgentsProfileProxyType;
    /**
     * Custom proxy configuration (required for custom proxy mode)
     */
    customProxy?: AgentsProfileCustomProxyConfigInput;
    /**
     * Proxy gateway preset ID (required for gateway proxy mode)
     */
    proxyGatewayPresetId?: CommonUuid;
    /**
     * Whether the captcha solver should be active (managed proxy only)
     */
    captchaSolverActive?: boolean;
    /**
     * Whether to use the same IP address for all executions (managed proxy only)
     */
    stickyIP?: boolean;
    /**
     * Operating system to emulate
     */
    operatingSystem?: AgentsProfileOperatingSystem;
    /**
     * Whether to enable extra stealth mode
     */
    extraStealth?: boolean;
    /**
     * Whether to allow third-party cookies
     */
    allow3rdCookies?: boolean;
    /**
     * Whether to persist browser cache between sessions
     */
    cachePersistence?: boolean;
    /**
     * Whether to enable ad blocking
     */
    adblockActive?: boolean;
    /**
     * Whether to enable popup blocking (requires adblock to be active)
     */
    popupBlockerActive?: boolean;
    /**
     * Whether to force popups to open as tabs
     */
    forcePopupsAsTabsActive?: boolean;
    /**
     * Whether to enable media blocking (images, videos, etc.)
     */
    mediaBlockerActive?: boolean;
    /**
     * Whether to enable the built-in PDF viewer (if disabled, PDFs are downloaded)
     */
    pdfViewerActive?: boolean;
    /**
     * Whether browser tracing is enabled (admin only, defaults to true)
     */
    tracingEnabled?: boolean;
    /**
     * Anchor browser fingerprint ID to apply at session create (admin only). Requires extra stealth and a proxy. Empty or null means unset.
     */
    fingerprintId?: AgentsProfileFingerprintIdInput | null;
    /**
     * Stable org extension IDs to attach to this profile
     */
    extensionIds?: Array<CommonUuid>;
    /**
     * Org vault item IDs attached to this profile.
     */
    vaultItemIds?: Array<CommonUuid>;
    /**
     * Optional custom prefix for the agent's inbox email address. If set, the inbox will be {prefix}@agentmail.asteroid.ai.
     */
    inboxEmailPrefix?: string;
    /**
     * Initial credentials to create with the profile
     */
    credentials?: Array<AgentsProfileCredential>;
    /**
     * Initial cookies to create with the profile
     */
    cookies?: Array<AgentsProfileCookie>;
};
/**
 * A credential stored for an agent profile
 */
type AgentsProfileCredential = {
    /**
     * Unique identifier for the credential
     */
    id?: CommonUuid;
    /**
     * Display name for the credential (will be uppercased)
     */
    name: string;
    /**
     * The credential value (plaintext - will be encrypted server-side)
     */
    data: string;
    /**
     * When the credential was created
     */
    createdAt?: string;
};
/**
 * Request to update an existing credential by name
 */
type AgentsProfileCredentialUpdate = {
    /**
     * Name of the credential to update (case-insensitive, will be matched as uppercase)
     */
    name: string;
    /**
     * New credential value (plaintext - will be encrypted server-side)
     */
    data: string;
};
/**
 * Custom proxy server configuration for input (includes password)
 */
type AgentsProfileCustomProxyConfigInput = {
    /**
     * Proxy server address including protocol and port (e.g., 'socks5://proxy.example.com:1080' or 'http://proxy.example.com:8080')
     */
    server: string;
    /**
     * Proxy authentication username
     */
    username: string;
    /**
     * Proxy authentication password
     */
    password: string;
};
/**
 * Custom proxy server configuration for output (excludes password)
 */
type AgentsProfileCustomProxyConfigOutput = {
    /**
     * Proxy server address
     */
    server: string;
    /**
     * Proxy authentication username
     */
    username: string;
};
/**
 * Request to duplicate an agent profile
 */
type AgentsProfileDuplicateAgentProfileRequest = {
    /**
     * Target organization ID. Defaults to the source profile's organization if omitted.
     */
    organizationId?: CommonUuid;
};
/**
 * Browser feature toggles on an agent profile that can be filtered on
 */
type AgentsProfileFeature = "extraStealth" | "allow3rdCookies" | "captchaSolverActive" | "stickyIP" | "cachePersistence" | "adblockActive" | "popupBlockerActive" | "forcePopupsAsTabsActive" | "mediaBlockerActive";
/**
 * Anchor browser fingerprint ID (24-character hex). An empty string means unset (create) or clear (update).
 */
type AgentsProfileFingerprintIdInput = string;
/**
 * Operating system to emulate in the browser
 */
type AgentsProfileOperatingSystem = "macos" | "windows";
/**
 * Available fields for sorting agent profile pools
 */
type AgentsProfilePoolSortField = "name" | "created_at" | "updated_at";
/**
 * A single email in the agent profile's inbox (summary only — use the detail endpoint to fetch the body)
 */
type AgentsProfileProfileInboxEmail = {
    /**
     * Unique email ID from Resend
     */
    id: string;
    /**
     * Sender address
     */
    from: string;
    /**
     * Recipient addresses
     */
    to: Array<string>;
    /**
     * Email subject
     */
    subject: string;
    /**
     * When the email was received
     */
    createdAt: string;
};
/**
 * Full content of a single email in the agent profile's inbox
 */
type AgentsProfileProfileInboxEmailDetail = {
    /**
     * Unique email ID from Resend
     */
    id: string;
    /**
     * Sender address
     */
    from: string;
    /**
     * Recipient addresses
     */
    to: Array<string>;
    /**
     * Email subject
     */
    subject: string;
    /**
     * When the email was received
     */
    createdAt: string;
    /**
     * Plain-text body, if available
     */
    text?: string;
    /**
     * HTML body, if available
     */
    html?: string;
    /**
     * CC recipients, if any
     */
    cc?: Array<string>;
    /**
     * BCC recipients, if any
     */
    bcc?: Array<string>;
    /**
     * Reply-to addresses, if any
     */
    replyTo?: Array<string>;
};
/**
 * Proxy configuration mode
 */
type AgentsProfileProxyMode = "none" | "managed" | "custom" | "gateway";
/**
 * Type of managed proxy to use for browser sessions
 */
type AgentsProfileProxyType = "basic";
/**
 * Request to remove profiles from a pool
 */
type AgentsProfileRemoveProfilesFromPoolRequest = {
    /**
     * Profile IDs to remove from the pool
     */
    profileIds: Array<CommonUuid>;
};
/**
 * SameSite attribute for cookies
 */
type AgentsProfileSameSite = "Strict" | "Lax" | "None";
/**
 * Strategy for selecting an available profile from a pool
 */
type AgentsProfileSelectionStrategy = "least_recently_used" | "most_recently_used";
/**
 * Available fields for sorting agent profiles
 */
type AgentsProfileSortField = "name" | "created_at" | "updated_at";
/**
 * Request to update an existing agent profile pool
 */
type AgentsProfileUpdateAgentProfilePoolRequest = {
    /**
     * New name for the pool
     */
    name?: string;
    /**
     * New selection strategy for the pool
     */
    selectionStrategy?: AgentsProfileSelectionStrategy;
    /**
     * Whether multiple executions can use the same profile concurrently
     */
    allowConcurrentUse?: boolean;
};
/**
 * Request to update an existing agent profile
 */
type AgentsProfileUpdateAgentProfileRequest = {
    /**
     * New name for the profile
     */
    name?: string;
    /**
     * New description for the profile
     */
    description?: string;
    /**
     * Proxy configuration mode
     */
    proxyMode?: AgentsProfileProxyMode;
    /**
     * Country code for proxy location (for managed proxy mode)
     */
    proxyCC?: AgentsProfileCountryCode;
    /**
     * Type of managed proxy to use (for managed proxy mode)
     */
    proxyType?: AgentsProfileProxyType;
    /**
     * Custom proxy configuration (for custom proxy mode)
     */
    customProxy?: AgentsProfileCustomProxyConfigInput;
    /**
     * Proxy gateway preset ID (for gateway proxy mode)
     */
    proxyGatewayPresetId?: CommonUuid;
    /**
     * Whether the captcha solver should be active (managed proxy only)
     */
    captchaSolverActive?: boolean;
    /**
     * Operating system to emulate
     */
    operatingSystem?: AgentsProfileOperatingSystem;
    /**
     * Whether to enable extra stealth mode
     */
    extraStealth?: boolean;
    /**
     * Whether to allow third-party cookies
     */
    allow3rdCookies?: boolean;
    /**
     * Whether to persist browser cache between sessions
     */
    cachePersistence?: boolean;
    /**
     * Whether to enable ad blocking
     */
    adblockActive?: boolean;
    /**
     * Whether to enable popup blocking (requires adblock to be active)
     */
    popupBlockerActive?: boolean;
    /**
     * Whether to force popups to open as tabs
     */
    forcePopupsAsTabsActive?: boolean;
    /**
     * Whether to enable media blocking (images, videos, etc.)
     */
    mediaBlockerActive?: boolean;
    /**
     * Whether to enable the built-in PDF viewer (if disabled, PDFs are downloaded)
     */
    pdfViewerActive?: boolean;
    /**
     * Whether browser tracing is enabled (admin only)
     */
    tracingEnabled?: boolean;
    /**
     * Anchor browser fingerprint ID to apply at session create (admin only). Requires extra stealth and a proxy. An empty string clears it; omit to leave unchanged. Null is rejected — the generated servers cannot tell null from an omitted field, so accepting it would turn an intended clear into a silent no-op.
     */
    fingerprintId?: AgentsProfileFingerprintIdInput;
    /**
     * Stable org extension IDs to attach to this profile
     */
    extensionIds?: Array<CommonUuid>;
    /**
     * Org vault item IDs attached to this profile.
     */
    vaultItemIds?: Array<CommonUuid>;
    /**
     * Optional custom prefix for the agent's inbox email address. If set, the inbox will be {prefix}@agentmail.asteroid.ai.
     */
    inboxEmailPrefix?: string;
    /**
     * Credentials to add to the profile
     */
    credentialsToAdd?: Array<AgentsProfileCredential>;
    /**
     * Credentials to update by name (matched case-insensitively)
     */
    credentialsToUpdate?: Array<AgentsProfileCredentialUpdate>;
    /**
     * IDs of credentials to remove from the profile
     */
    credentialsToDelete?: Array<CommonUuid>;
    /**
     * Cookies to add to the profile
     */
    cookiesToAdd?: Array<AgentsProfileCookie>;
    /**
     * IDs of cookies to remove from the profile
     */
    cookiesToDelete?: Array<CommonUuid>;
};
type AgentsScheduleBase = {
    id: CommonUuid;
    agentId: CommonUuid;
    agentProfileId?: CommonUuid;
    /**
     * Pool to select a profile from for each execution. Mutually exclusive with agentProfileId.
     */
    agentProfilePoolId?: CommonUuid;
    name: string;
    cronExpression: string;
    /**
     * IANA time zone the cron expression is evaluated in, such as America/New_York. Local wall-clock time holds across daylight saving changes.
     */
    timezone: string;
    enabled: boolean;
    /**
     * When true, enabling the schedule runs it immediately instead of waiting for the next cron tick.
     */
    runOnEnable: boolean;
    version: number;
    inputs: {
        [key: string]: unknown;
    };
    /**
     * Set when this schedule runs a batch from a spreadsheet rather than a single execution
     */
    batchSource?: AgentsScheduleBatchSource;
    /**
     * Per-execution runtime options applied to every run this schedule triggers.
     */
    executionOptions?: AgentsAgentExecutionOptions;
    nextRunAt?: string;
    /**
     * When the schedule last fired.
     */
    lastRunAt?: string;
    /**
     * Why the last tick failed, or absent when it succeeded. Set when a tick could not start its execution or batch, for example a sheet with more rows than one run may queue.
     */
    lastRunError?: string;
    createdAt: string;
    updatedAt: string;
};
/**
 * Makes a schedule fan out into an execution batch instead of a single execution.
 * The sheet is re-read on every tick, so the batch is sized by whatever valid rows
 * exist at that moment.
 */
type AgentsScheduleBatchSource = {
    /**
     * Google Sheets URL. The gid selects the tab; without one the first tab is used.
     */
    sheetUrl: string;
    /**
     * Maps a sheet column header to the workflow input it fills. Unmapped columns are ignored.
     */
    columnMappings: {
        [key: string]: unknown;
    };
    /**
     * Inputs a row must supply non-empty to count as valid. Rows missing any of them
     * are skipped for that tick rather than failing the whole run.
     */
    requiredInputs?: Array<string>;
    /**
     * How the resulting batch paces its executions
     */
    config: AgentsExecutionBatchBatchConfig;
};
type AgentsScheduleCreateRequest = {
    name: string;
    agentProfileId?: CommonUuid;
    /**
     * Pool to select a profile from for each execution. Mutually exclusive with agentProfileId.
     */
    agentProfilePoolId?: CommonUuid;
    cronExpression: string;
    /**
     * IANA time zone the cron expression is evaluated in. Defaults to UTC.
     */
    timezone?: string;
    enabled?: boolean;
    runOnEnable?: boolean;
    version?: number;
    inputs?: {
        [key: string]: unknown;
    };
    /**
     * Set to make each tick create a batch from a spreadsheet instead of one execution
     */
    batchSource?: AgentsScheduleBatchSource;
    /**
     * Per-execution runtime options applied to every run this schedule triggers.
     */
    executionOptions?: AgentsAgentExecutionOptions;
};
type AgentsScheduleUpdateRequest = {
    name?: string;
    agentProfileId?: CommonUuid;
    /**
     * Pool to select a profile from for each execution. Mutually exclusive with agentProfileId.
     */
    agentProfilePoolId?: CommonUuid;
    cronExpression?: string;
    /**
     * IANA time zone the cron expression is evaluated in.
     */
    timezone?: string;
    enabled?: boolean;
    runOnEnable?: boolean;
    version?: number;
    inputs?: {
        [key: string]: unknown;
    };
    /**
     * Replaces the batch source. Omit to leave it unchanged; use clearBatchSource to remove it.
     */
    batchSource?: AgentsScheduleBatchSource;
    /**
     * Converts a batch schedule back into a single-execution one
     */
    clearBatchSource?: boolean;
    /**
     * Detaches both the profile and the pool. Omitting the ids on their own means
     * "leave unchanged", so this is the only way back to no profile.
     */
    clearProfileSelection?: boolean;
    /**
     * Per-execution runtime options applied to every run this schedule triggers. Replaces the stored options in full, so send every field you want to keep.
     */
    executionOptions?: AgentsAgentExecutionOptions;
};
type AgentsScheduledExecutionBase = {
    id: CommonUuid;
    workflowId: CommonUuid;
    agentId: CommonUuid;
    agentProfileId?: CommonUuid;
    /**
     * Set when the profile is chosen from a pool at trigger time rather than pinned up front
     */
    agentProfilePoolId?: CommonUuid;
    batchId?: CommonUuid;
    inputVars: {
        [key: string]: unknown;
    };
    metadata: {
        [key: string]: unknown;
    };
    executeAt?: string;
    status: AgentsScheduledExecutionStatus;
    executionId?: CommonUuid;
    triggeredAt?: string;
    /**
     * Why this scheduled execution could not be triggered. Only set when status is `failed`.
     */
    failureReason?: string;
    /**
     * Variant key the queued execution will run under. Read-only; set via `executionOptions` at create time.
     */
    variantKey?: string;
    createdAt: string;
    updatedAt: string;
};
type AgentsScheduledExecutionCreateRequest = {
    workflowId: CommonUuid;
    agentProfileId?: CommonUuid;
    inputVars?: {
        [key: string]: unknown;
    };
    metadata?: {
        [key: string]: unknown;
    };
    executeAt: string;
    /**
     * Per-execution runtime options applied when this execution is triggered.
     */
    executionOptions?: AgentsAgentExecutionOptions;
};
type AgentsScheduledExecutionRescheduleRequest = {
    executeAt: string;
};
type AgentsScheduledExecutionStatus = "pending" | "triggered" | "cancelled" | "awaiting_capacity" | "batch_paused" | "failed";
/**
 * Request to validate a JSON schema against OpenAI structured output requirements
 */
type AgentsSchemaValidateSchemaRequest = {
    /**
     * The JSON schema to validate
     */
    schema: {
        [key: string]: unknown;
    };
};
/**
 * Response from schema validation
 */
type AgentsSchemaValidateSchemaResponse = {
    /**
     * Whether the schema is valid
     */
    valid: boolean;
    /**
     * List of validation error messages (empty if valid)
     */
    errors: Array<string>;
};
/**
 * A tag addressed by group and name, both matched case-insensitively. The group and the tag are created when missing.
 */
type AgentsTagAgentWorkflowTagName = {
    /**
     * Group name. Protected group names resolve to the protected group; anything else is a user-defined group.
     */
    group: string;
    /**
     * Tag name
     */
    name: string;
};
/**
 * Exactly one of groupId and protectedGroupKey selects the group.
 */
type AgentsTagCreateWorkflowTagRequest = {
    /**
     * Group to create the tag in
     */
    groupId?: CommonUuid;
    /**
     * Protected group to create the tag in, materializing its row if needed
     */
    protectedGroupKey?: AgentsTagWorkflowTagProtectedGroupKey;
    /**
     * Tag name; must not contain '::'
     */
    name: string;
    /**
     * Catalog portal to link (portal group only). When absent on a portal tag, a live portal with the same name links automatically.
     */
    catalogPortalId?: CommonUuid;
};
/**
 * Removals apply before additions, so a tag in both ends up on the agent. Adding an assigned tag or removing an unassigned one is a no-op.
 */
type AgentsTagPatchAgentWorkflowTagsRequest = {
    /**
     * Existing tag ids to add; all must be in the agent's organization
     */
    add?: Array<CommonUuid>;
    /**
     * Tags to add by name, created when missing
     */
    create?: Array<AgentsTagAgentWorkflowTagName>;
    /**
     * Tag ids to remove
     */
    remove?: Array<CommonUuid>;
};
type AgentsTagSetAgentWorkflowTagsRequest = {
    /**
     * Full set of tag ids for the agent; replaces the current set. All tags must be in the agent's organization.
     */
    tagIds: Array<CommonUuid>;
};
type AgentsTagUpdateWorkflowTagGroupRequest = {
    /**
     * New group name; must not contain '::'
     */
    name?: string;
    /**
     * New lucide icon name; empty string clears it
     */
    icon?: string;
};
type AgentsTagUpdateWorkflowTagRequest = {
    /**
     * New tag name; must not contain '::'. An unlinked portal tag shows a matching live portal's logo automatically; the stored link changes only through explicit linking.
     */
    name?: string;
    /**
     * Catalog portal to link (portal group only)
     */
    catalogPortalId?: CommonUuid;
    /**
     * True unlinks the tag from its catalog portal and stops automatic relinking. Exclusive with catalogPortalId.
     */
    unlinkPortal?: boolean;
};
/**
 * Org-scoped workflow tag. Portal-group tags can link to a catalog portal, which supplies the logo.
 */
type AgentsTagWorkflowTag = {
    /**
     * Unique identifier for the tag
     */
    id: CommonUuid;
    /**
     * Organization this tag belongs to
     */
    organizationId: CommonUuid;
    /**
     * Group the tag belongs to
     */
    groupId: CommonUuid;
    /**
     * Tag name, unique per group case-insensitively
     */
    name: string;
    /**
     * Catalog portal a portal tag is linked to. The name was copied at creation and does not follow catalog renames.
     */
    catalogPortalId?: CommonUuid;
    /**
     * Signed URL for the tag's display portal logo: the linked portal's, or for an unlinked portal tag a unique live name match. Read-only, derived on read; absent when nothing resolves or the portal has no logo.
     */
    logoUrl?: string;
    /**
     * Number of agents carrying this tag. Present on the organization list only.
     */
    agentCount?: number;
    /**
     * When the tag was created
     */
    createdAt: string;
    /**
     * When the tag was last updated
     */
    updatedAt: string;
};
/**
 * Org-scoped group of workflow tags. A tag renders as group::tag, so names may not contain '::'.
 */
type AgentsTagWorkflowTagGroup = {
    /**
     * Unique identifier for the group
     */
    id: CommonUuid;
    /**
     * Organization this group belongs to
     */
    organizationId: CommonUuid;
    /**
     * Group name, unique per organization case-insensitively
     */
    name: string;
    /**
     * Set on the code-defined protected groups. Protected groups cannot be renamed or deleted.
     */
    protectedKey?: AgentsTagWorkflowTagProtectedGroupKey;
    /**
     * Lucide icon name shown next to the group name. User-defined groups only; protected groups' icons are fixed client-side.
     */
    icon?: string;
    /**
     * Number of tags in the group. Present on the organization list only.
     */
    tagCount?: number;
    /**
     * When the group was created
     */
    createdAt: string;
    /**
     * When the group was last updated
     */
    updatedAt: string;
};
/**
 * Key of a code-defined protected tag group. Protected groups exist for every organization; their rows materialize on first tag.
 */
type AgentsTagWorkflowTagProtectedGroupKey = "portal" | "client" | "task";
/**
 * UPPER_SNAKE field key, unique within a template or item.
 */
type AgentsVaultFieldKey = string;
/**
 * Type of a vault field. Sensitivity is derived from the type: username, email, url, phone, text, card_expiry, and cardholder_name are readable; password, hidden, totp_seed, api_key, card_number, and card_cvv are write-only. There is no separate hidden flag.
 */
type AgentsVaultFieldType = "username" | "email" | "url" | "phone" | "text" | "password" | "hidden" | "totp_seed" | "api_key" | "card_number" | "card_expiry" | "card_cvv" | "cardholder_name";
/**
 * Kebab-case vault item key, unique per organisation. Derived from name on write.
 */
type AgentsVaultItemKey = string;
/**
 * Kind of vault item. Templates and items need at least one field. Completeness is per-field required.
 */
type AgentsVaultItemKind = "login" | "api_key" | "card" | "custom";
/**
 * Browser provider type
 */
type AgentsWorkflowBrowserProvider = "anchor" | "steel";
/**
 * Browser environment template configuration
 */
type AgentsWorkflowBrowserTemplateConfig = {
    /**
     * Browser provider type
     */
    provider: AgentsWorkflowBrowserProvider;
};
/**
 * Response after creating a workflow
 */
type AgentsWorkflowCreateWorkflowResponse = {
    /**
     * The ID of the newly created workflow
     */
    workflowId: CommonUuid;
};
/**
 * Type of execution environment
 */
type AgentsWorkflowEnvironmentType = "browser" | "os";
/**
 * Request to execute a workflow by ID
 */
type AgentsWorkflowExecuteWorkflowRequest = {
    /**
     * Input variables to be merged into the placeholders defined in prompts
     */
    inputVariables?: {
        [key: string]: unknown;
    };
    /**
     * Optional metadata key-value pairs for organizing and filtering executions
     */
    metadata?: {
        [key: string]: unknown;
    };
    /**
     * The ID of the agent profile to use. Note this is not the agent ID
     */
    agentProfileId?: CommonUuid;
    /**
     * The ID of the agent profile pool to select a profile from. Mutually exclusive with agentProfileId.
     */
    agentProfilePoolId?: CommonUuid;
    /**
     * Array of temporary files to attach to the execution. Must have been pre-uploaded using the stage file endpoint
     */
    tempFiles?: Array<AgentsFilesTempFile>;
    /**
     * Per-execution runtime options that override or extend the agent's default settings.
     */
    executionOptions?: AgentsAgentExecutionOptions;
    /**
     * ID of the execution this is a rerun of. Sets parent_execution_id on the new execution and has_been_rerun on the parent.
     */
    parentExecutionId?: CommonUuid;
};
/**
 * Response after starting workflow execution
 */
type AgentsWorkflowExecuteWorkflowResponse = {
    /**
     * The ID of the newly created execution
     */
    executionId: CommonUuid;
};
/**
 * Request to create a new unpublished workflow
 */
type AgentsWorkflowExternalCreateWorkflowRequest = {
    /**
     * Optional parent workflow ID to derive from
     */
    parentId?: CommonUuid;
    /**
     * The rules/instructions for this workflow
     */
    rules: string;
    /**
     * The workflow graph
     */
    graph: AgentsGraphModelsAgentGraph;
    /**
     * Typed input definitions for this workflow. Names referenced in prompts but omitted here default to optional strings.
     */
    inputs?: Array<AgentsWorkflowInput>;
    /**
     * The settings for this workflow
     */
    settings: AgentsGraphModelsExternalSettings;
    /**
     * Optional environment template. Defaults to browser/anchor if not provided. Omits admin-only OS fields.
     */
    environmentTemplate?: AgentsWorkflowExternalEnvironmentTemplate;
};
/**
 * Environment template on the external API. Omits admin-only OS fields.
 */
type AgentsWorkflowExternalEnvironmentTemplate = {
    /**
     * Type of environment (browser or os)
     */
    type: AgentsWorkflowEnvironmentType;
    /**
     * Environment-specific configuration
     */
    config: AgentsWorkflowBrowserTemplateConfig | AgentsWorkflowExternalOsTemplateConfig;
};
/**
 * Customer-facing OS environment template configuration. Admin-only fields live on OsTemplateConfig.
 */
type AgentsWorkflowExternalOsTemplateConfig = {
    /**
     * OS provider type
     */
    provider: AgentsWorkflowOsProvider;
    /**
     * Name of the snapshot to use. If omitted or empty, the server uses the configured default snapshot for the selected osType.
     */
    snapshotName?: string;
    /**
     * Whether the snapshot is public
     */
    public: boolean;
    /**
     * Operating system the sandbox runs. Defaults to linux. Setting to windows is admin-only and selects the Windows snapshot/image.
     */
    osType?: AgentsWorkflowOsType;
};
/**
 * A workflow (commit) representing an immutable snapshot of agent configuration
 */
type AgentsWorkflowExternalWorkflowSnapshot = {
    /**
     * The unique ID of this workflow
     */
    id: CommonUuid;
    /**
     * The agent ID this workflow belongs to
     */
    agentId: CommonUuid;
    /**
     * The ID of the parent workflow this was derived from (for lineage tracking)
     */
    parentId?: CommonUuid;
    /**
     * The monotonic per-agent snapshot version number.
     */
    version: number;
    /**
     * Whether this snapshot is the agent's published version (the API default). At most one snapshot per agent is published.
     */
    isPublished: boolean;
    /**
     * The rules/instructions for this workflow
     */
    rules: string;
    /**
     * The workflow graph
     */
    graph: AgentsGraphModelsAgentGraph;
    /**
     * Typed input definitions for workflow execution. Includes names referenced in prompts, which default to optional strings.
     */
    inputs: Array<AgentsWorkflowInput>;
    /**
     * The files stored on this workflow version. Empty when the workflow has no files.
     */
    files: Array<AgentsWorkflowWorkflowFile>;
    /**
     * When this workflow was created. For the editable head this is restamped on each in-place edit, so it doubles as the last-edited time.
     */
    createdAt: string;
    /**
     * The email of the user who created this workflow.
     */
    author?: string;
    /**
     * Monotonic optimistic-concurrency revision. Only meaningful for the editable head: supply it as baseRev on the next head patch. Agent-file-only patches overlay the current head if it has moved; structural-file patches are rejected with 409 when stale. Frozen snapshots never receive in-place patches.
     */
    rev: number;
    /**
     * The settings for this workflow
     */
    settings: AgentsGraphModelsExternalSettings;
    /**
     * Optional environment template. Defaults to browser/anchor if not provided. Omits admin-only OS fields.
     */
    environmentTemplate?: AgentsWorkflowExternalEnvironmentTemplate;
};
/**
 * A typed input variable a workflow declares. Referenced as {{.name}} in prompts.
 */
type AgentsWorkflowInput = {
    /**
     * The variable name. Matches [a-zA-Z_][a-zA-Z0-9_]* and is unique within the workflow.
     */
    name: string;
    /**
     * A single-field JSON Schema fragment describing the input's type, e.g. {type: "string"}, {type: "number"}, {type: "object", properties: {...}}. Validated adaptively at execution time.
     */
    schema: {
        [key: string]: unknown;
    };
    /**
     * Whether a value must be supplied at execution time. Defaults to false.
     */
    required: boolean;
    /**
     * Optional value used when the input is omitted at execution time.
     */
    defaultValue?: unknown;
    /**
     * Optional human-readable description of the input.
     */
    description?: string;
};
/**
 * OS provider type
 */
type AgentsWorkflowOsProvider = "daytona" | "local";
/**
 * Daytona region the sandbox boots in. Omit for us.
 */
type AgentsWorkflowOsRegion = "us" | "us-west-4";
/**
 * Operating system the environment sandbox runs
 */
type AgentsWorkflowOsType = "linux" | "windows";
/**
 * Response after publishing a workflow
 */
type AgentsWorkflowPublishWorkflowResponse = {
    /**
     * The ID of the published workflow
     */
    workflowId: CommonUuid;
    /**
     * The assigned version number
     */
    version: number;
};
/**
 * Request to revert the editable head to an existing snapshot so it can be edited
 */
type AgentsWorkflowRevertWorkflowHeadRequest = {
    /**
     * The snapshot (workflow) ID to copy over the editable head
     */
    snapshotId: CommonUuid;
};
/**
 * A file stored on a workflow version. Content is fetched via the workflow-scoped shared-file download endpoints using this id.
 */
type AgentsWorkflowWorkflowFile = {
    /**
     * The unique ID of this file within the workflow version
     */
    id: CommonUuid;
    /**
     * The file path, relative to the agent's shared directory
     */
    filePath: string;
    /**
     * The file's base name
     */
    fileName: string;
    /**
     * The file size in bytes
     */
    fileSize: number;
    /**
     * The file's MIME type, when known
     */
    mimeType?: string;
    /**
     * Hex-encoded SHA-256 of the file contents, when known
     */
    checksum?: string;
    /**
     * When this file was first added to the workflow lineage
     */
    createdAt: string;
    /**
     * When this file was last modified
     */
    updatedAt: string;
};
/**
 * Which file contents a tree read carries inline.
 */
type AgentsWorkflowWorkflowFileContentsMode = "none" | "structural" | "all";
/**
 * A single entry in a workflow's directory-of-files representation.
 */
type AgentsWorkflowWorkflowFileEntry = {
    /**
     * The file path, relative to the workflow root (e.g. `settings.yaml`, `nodes/login/instructions.md`).
     */
    path: string;
    /**
     * Whether this is a derived structural file (content inlined) or a user agent file (referenced by fileId).
     */
    kind: AgentsWorkflowWorkflowFileKind;
    /**
     * Inline UTF-8 content. Present for structural files only, and omitted under `contents=none`; agent files carry their bytes in contentBase64, since arbitrary uploads are not guaranteed to be valid UTF-8.
     */
    content?: string;
    /**
     * Base64-encoded file bytes. Present only for agent files, and only when `contents=all` and the file fits the response budget. Absent when contents were not requested, the file exceeded the budget, or storage could not be read — fall back to the workflow agent-file download endpoints using fileId.
     */
    contentBase64?: string;
    /**
     * The file size in bytes.
     */
    size: number;
    /**
     * The file's MIME type, when known.
     */
    mimeType?: string;
    /**
     * Hex-encoded SHA-256 of the file contents, when known. Lets a client materialising the directory skip files it already has. Absent for structural files, whose content is inlined anyway.
     */
    checksum?: string;
    /**
     * For an agent file: the id used to fetch its content via the workflow agent-file endpoints.
     */
    fileId?: CommonUuid;
    /**
     * For an agent file: the object key of its blob in the agents bucket. A caller with bucket access (astro-agent) reads a file the response budget skipped straight from storage, instead of a signed-URL mint plus a download redirect. Absent for structural files, which have no blob.
     */
    storageObjectKey?: string;
    /**
     * For an agent file: a URL that redirects to a short-lived signed URL for the file's bytes. Browser clients with no bucket access use this to preview, download and diff files the response did not inline. Absent for structural files, whose content is inlined, and on the internal surface, whose callers read a skipped file straight from storage by `storageObjectKey`.
     */
    downloadUrl?: string;
    /**
     * For an agent file: when its contents were last written.
     */
    updatedAt?: string;
};
/**
 * The kind of file in a workflow's directory representation.
 */
type AgentsWorkflowWorkflowFileKind = "structural" | "agent_file";
/**
 * A workflow rendered as a directory of files. Structural files are derived from the structured workflow and carry inline content; user agent files are referenced by id.
 */
type AgentsWorkflowWorkflowFileTree = {
    /**
     * The revision the tree reflects. For the editable head, supply this as `baseRev` when patching. Agent-file-only patches overlay the current head if it has moved; structural-file patches are rejected with 409 when stale.
     */
    rev: number;
    /**
     * The id of the workflow this tree renders. Lets a client that materialises the directory record what it holds without a second fetch.
     */
    workflowId: CommonUuid;
    /**
     * The workflow's version number, absent for a draft that has never been published.
     */
    version?: number;
    /**
     * The owning agent's name. The directory is rendered relative to the workflow root, so a client that lays it out under a per-agent folder needs the name to derive that folder — and would otherwise have to fetch the agent for it.
     */
    agentName: string;
    /**
     * Hex-encoded SHA-256 over the workflow's whole file directory: every structural file's path and content, and every agent file's path and checksum. It covers the whole workflow regardless of any paths, variants or contents narrowing on the read, so two reads of the same workflow always agree. A client keeping the directory in version control compares this one string to answer "does the published agent still match my checkout?" instead of diffing every file. Absent when an agent file has no checksum yet, since the tree cannot then be hashed in full.
     */
    contentHash?: string;
    /**
     * The files in the workflow, sorted by path.
     */
    files: Array<AgentsWorkflowWorkflowFileEntry>;
    /**
     * Every variant key the workflow's files carry, sorted, regardless of any variants filter on the read — a narrowed tree still names what it could ask for. Absent unless the workflow has variant mode enabled.
     */
    variantKeys?: Array<string>;
};
/**
 * A single file write in a files patch: upsert the file at `path`. Content is base64 uniformly — structural files decode as UTF-8, agent files are arbitrary bytes — so one write shape carries both.
 */
type AgentsWorkflowWorkflowFileWrite = {
    /**
     * The file path, relative to the workflow root — the same paths the file tree returns.
     */
    path: string;
    /**
     * Base64-encoded file content.
     */
    contentBase64: string;
};
/**
 * Request to patch the editable head's file representation. The server classifies each path: structural files re-derive the structured workflow, the agent's own files (memory, uploads, node scripts) go to their blob store. Agent-file writes overlay the head resolved under the edit lock, so a stale baseRev is not rejected. Structural-file writes still require a matching baseRev; a stale value is rejected with 409.
 */
type AgentsWorkflowWorkflowFilesPatchRequest = {
    /**
     * The revision this edit is based on. Agent-file-only patches overlay the current head even when this is stale. A structural-file patch is rejected with 409 when it does not match the stored head revision.
     */
    baseRev: number;
    /**
     * Files to upsert.
     */
    writes: Array<AgentsWorkflowWorkflowFileWrite>;
    /**
     * Paths of files to delete.
     */
    deletes: Array<string>;
};
/**
 * The typed inputs a workflow declares
 */
type AgentsWorkflowWorkflowInputs = {
    /**
     * Typed input definitions the workflow accepts at execution time
     */
    inputs: Array<AgentsWorkflowInput>;
};
/**
 * Output schemas keyed by output node name. Only output nodes that have a schema configured are included; the value is that node's JSON schema.
 */
type AgentsWorkflowWorkflowOutputSchemas = {
    [key: string]: unknown;
};
/**
 * Lightweight workflow reference for listing workflows without full data
 */
type AgentsWorkflowWorkflowRef = {
    /**
     * The unique ID of this workflow
     */
    id: CommonUuid;
    /**
     * The ID of the parent workflow this was derived from (for lineage tracking)
     */
    parentId?: CommonUuid;
    /**
     * The monotonic per-agent snapshot version number.
     */
    version: number;
    /**
     * Whether this snapshot is the agent's published version (the API default). At most one snapshot per agent is published.
     */
    isPublished: boolean;
    /**
     * When this workflow was created
     */
    createdAt: string;
    /**
     * The email of the user who created this workflow.
     */
    author?: string;
    /**
     * Whether this snapshot can be deleted (not published and never executed)
     */
    isDeletable: boolean;
};
/**
 * A single workflow validation finding.
 */
type AgentsWorkflowWorkflowValidationIssue = {
    /**
     * Whether this issue blocks running the workflow (error) or is advisory (warning).
     */
    severity: AgentsWorkflowWorkflowValidationSeverity;
    /**
     * Human-readable description of the problem.
     */
    message: string;
    /**
     * Path to the offending field, e.g. ["nodes", "My Node", "model"].
     */
    path: Array<string>;
};
/**
 * Result of validating a workflow spec without persisting it.
 */
type AgentsWorkflowWorkflowValidationResponse = {
    /**
     * All validation issues found. The workflow can run only if none have error severity.
     */
    issues: Array<AgentsWorkflowWorkflowValidationIssue>;
};
/**
 * Severity of a workflow validation issue. Error-severity issues make the workflow un-runnable; warnings are advisory.
 */
type AgentsWorkflowWorkflowValidationSeverity = "error" | "warning";
type CommonBadRequestErrorBody = {
    code: 400;
    message: string;
};
type CommonConflictErrorBody = {
    code: 409;
    message: string;
};
type CommonError = {
    code: number;
    message: string;
};
type CommonForbiddenErrorBody = {
    code: 403;
    message: string;
};
type CommonInternalServerErrorBody = {
    code: 500;
    message: string;
};
type CommonNotFoundErrorBody = {
    code: 404;
    message: string;
};
type CommonOsError = {
    message: string;
};
type CommonPaymentRequiredErrorBody = {
    code: 402;
    message: string;
};
type CommonSortDirection = "asc" | "desc";
type CommonTooManyRequestsErrorBody = {
    code: 429;
    message: string;
};
type CommonUnauthorizedErrorBody = {
    code: 401;
    message: string;
};
type CommonUuid = string;
type Version = "v1";
type AgentsAgentSearch = string;
/**
 * Filter by agent ID
 */
type AgentsExecutionSearchAgentId = CommonUuid;
/**
 * Filter by agent profile IDs (can specify multiple, there is an 'OR' condition applied to these)
 */
type AgentsExecutionSearchAgentProfileIds = Array<CommonUuid>;
/**
 * Filter executions created after this timestamp
 */
type AgentsExecutionSearchCreatedAfter = string;
/**
 * Filter executions created before this timestamp
 */
type AgentsExecutionSearchCreatedBefore = string;
/**
 * Search by execution ID (partial, case-insensitive match)
 */
type AgentsExecutionSearchExecutionId = string;
/**
 * Filter by whether the execution recorded any script failures
 */
type AgentsExecutionSearchHasScriptFailures = boolean;
/**
 * Filter by human labels (can specify multiple label IDs, there is an 'OR' condition applied to these)
 */
type AgentsExecutionSearchHumanLabels = Array<CommonUuid>;
/**
 * Filter by input variable key - must be used together with inputsValue
 */
type AgentsExecutionSearchInputsKey = string;
/**
 * Filter by input variable value (partial, case-insensitive match) - must be used together with inputsKey
 */
type AgentsExecutionSearchInputsValue = string;
/**
 * Filter by metadata key - must be used together with metadataValue
 */
type AgentsExecutionSearchMetadataKey = string;
/**
 * Filter by metadata value - must be used together with metadataKey
 */
type AgentsExecutionSearchMetadataValue = string;
/**
 * Filter by execution result outcome (partial, case-insensitive match)
 */
type AgentsExecutionSearchOutcomeLabel = string;
/**
 * Filter by lifecycle phase, derived from status (can specify multiple, OR across values). Composes with the status filter as AND. pending = queued; active = starting, running, awaiting_confirmation, paused, paused_by_agent; terminal = completed, cancelled, failed.
 */
type AgentsExecutionSearchPhase = Array<AgentsExecutionPhase>;
/**
 * Filter by execution status (can specify multiple, there is an 'OR' condition applied to these)
 */
type AgentsExecutionSearchStatus = Array<AgentsExecutionStatus>;
/**
 * Filter by how the execution was triggered (can specify multiple, there is an 'OR' condition applied to these)
 */
type AgentsExecutionSearchTriggerSource = Array<"api" | "ui" | "schedule" | "warmup">;
/**
 * Filter by workflow version number
 */
type AgentsExecutionSearchWorkflowVersion = number;
/**
 * Filter by agent ID
 */
type AgentsExecutionBatchListFilterAgentId = CommonUuid;
/**
 * Filter by batch status
 */
type AgentsExecutionBatchListFilterStatus = AgentsExecutionBatchStatus;
/**
 * Search pools by name (partial match)
 */
type AgentsProfilePoolSearch = string;
/**
 * Filter by active browser features (can specify multiple, there is an 'AND' condition applied to these — every listed feature must be enabled)
 */
type AgentsProfileSearchFeature = Array<AgentsProfileFeature>;
/**
 * Filter by emulated operating system (can specify multiple, there is an 'OR' condition applied to these). Profiles without an explicit operating system count as macOS.
 */
type AgentsProfileSearchOperatingSystem = Array<AgentsProfileOperatingSystem>;
/**
 * Filter by proxy mode (can specify multiple, there is an 'OR' condition applied to these)
 */
type AgentsProfileSearchProxyMode = Array<AgentsProfileProxyMode>;
/**
 * Search profiles by name (partial match)
 */
type AgentsProfileSearchSearchName = string;
type AgentsScheduledExecutionListFilterAgentId = CommonUuid;
type AgentsScheduledExecutionListFilterBatchId = CommonUuid;
/**
 * Sort order for scheduled executions by execute_at timestamp
 */
type AgentsScheduledExecutionListFilterOrder = "asc" | "desc";
type AgentsScheduledExecutionListFilterStatus = AgentsScheduledExecutionStatus;
type AgentsScheduledExecutionListFilterWorkflowId = CommonUuid;
type CommonPaginationPage = number;
type CommonPaginationPageSize = number;
type AdminCustomerActivityListData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/admin/customer-activity";
};
type AdminCustomerActivityListErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AdminCustomerActivityListError = AdminCustomerActivityListErrors[keyof AdminCustomerActivityListErrors];
type AdminCustomerActivityListResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsCustomerActivityCustomerActivityList;
};
type AdminCustomerActivityListResponse = AdminCustomerActivityListResponses[keyof AdminCustomerActivityListResponses];
type AdminCustomerActivityNotableListData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Lookback in hours. Defaults to 24.
         */
        lookbackHours?: number;
    };
    url: "/admin/customer-activity/notable";
};
type AdminCustomerActivityNotableListErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AdminCustomerActivityNotableListError = AdminCustomerActivityNotableListErrors[keyof AdminCustomerActivityNotableListErrors];
type AdminCustomerActivityNotableListResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsCustomerActivityNotableActivityList;
};
type AdminCustomerActivityNotableListResponse = AdminCustomerActivityNotableListResponses[keyof AdminCustomerActivityNotableListResponses];
type AdminCustomerActivityWindowStatsListData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/admin/customer-activity/window-stats";
};
type AdminCustomerActivityWindowStatsListErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AdminCustomerActivityWindowStatsListError = AdminCustomerActivityWindowStatsListErrors[keyof AdminCustomerActivityWindowStatsListErrors];
type AdminCustomerActivityWindowStatsListResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsCustomerActivityCustomerWindowStatsList;
};
type AdminCustomerActivityWindowStatsListResponse = AdminCustomerActivityWindowStatsListResponses[keyof AdminCustomerActivityWindowStatsListResponses];
type AgentProfilePoolsListData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Filter by organization ID
         */
        organizationId?: CommonUuid;
        pageSize?: number;
        page?: number;
        /**
         * Search pools by name (partial match)
         */
        searchName?: string;
        sortField?: AgentsProfilePoolSortField;
        sortDirection?: CommonSortDirection;
    };
    url: "/agent-profile-pools";
};
type AgentProfilePoolsListErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfilePoolsListError = AgentProfilePoolsListErrors[keyof AgentProfilePoolsListErrors];
type AgentProfilePoolsListResponses = {
    /**
     * The request has succeeded.
     */
    200: {
        items: Array<AgentsProfileAgentProfilePool>;
        page: number;
        pageSize: number;
        total: number;
    };
};
type AgentProfilePoolsListResponse = AgentProfilePoolsListResponses[keyof AgentProfilePoolsListResponses];
type AgentProfilePoolsCreateData = {
    /**
     * Agent profile pool to create
     */
    body: AgentsProfileCreateAgentProfilePoolRequest;
    path?: never;
    query?: never;
    url: "/agent-profile-pools";
};
type AgentProfilePoolsCreateErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfilePoolsCreateError = AgentProfilePoolsCreateErrors[keyof AgentProfilePoolsCreateErrors];
type AgentProfilePoolsCreateResponses = {
    /**
     * The request has succeeded and a new resource has been created as a result.
     */
    201: AgentsProfileAgentProfilePool;
};
type AgentProfilePoolsCreateResponse = AgentProfilePoolsCreateResponses[keyof AgentProfilePoolsCreateResponses];
type AgentProfilePoolDeleteData = {
    body?: never;
    path: {
        /**
         * The ID of the agent profile pool
         */
        poolId: CommonUuid;
    };
    query?: never;
    url: "/agent-profile-pools/{poolId}";
};
type AgentProfilePoolDeleteErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfilePoolDeleteError = AgentProfilePoolDeleteErrors[keyof AgentProfilePoolDeleteErrors];
type AgentProfilePoolDeleteResponses = {
    /**
     * There is no content to send for this request, but the headers may be useful.
     */
    204: void;
};
type AgentProfilePoolDeleteResponse = AgentProfilePoolDeleteResponses[keyof AgentProfilePoolDeleteResponses];
type AgentProfilePoolGetData = {
    body?: never;
    path: {
        /**
         * The ID of the agent profile pool
         */
        poolId: CommonUuid;
    };
    query?: never;
    url: "/agent-profile-pools/{poolId}";
};
type AgentProfilePoolGetErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfilePoolGetError = AgentProfilePoolGetErrors[keyof AgentProfilePoolGetErrors];
type AgentProfilePoolGetResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsProfileAgentProfilePool;
};
type AgentProfilePoolGetResponse = AgentProfilePoolGetResponses[keyof AgentProfilePoolGetResponses];
type AgentProfilePoolUpdateData = {
    /**
     * Fields to update
     */
    body: AgentsProfileUpdateAgentProfilePoolRequest;
    path: {
        /**
         * The ID of the agent profile pool
         */
        poolId: CommonUuid;
    };
    query?: never;
    url: "/agent-profile-pools/{poolId}";
};
type AgentProfilePoolUpdateErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfilePoolUpdateError = AgentProfilePoolUpdateErrors[keyof AgentProfilePoolUpdateErrors];
type AgentProfilePoolUpdateResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsProfileAgentProfilePool;
};
type AgentProfilePoolUpdateResponse = AgentProfilePoolUpdateResponses[keyof AgentProfilePoolUpdateResponses];
type AgentProfilePoolMembersRemoveData = {
    /**
     * Profile IDs to remove
     */
    body: AgentsProfileRemoveProfilesFromPoolRequest;
    path: {
        /**
         * The ID of the agent profile pool
         */
        poolId: CommonUuid;
    };
    query?: never;
    url: "/agent-profile-pools/{poolId}/members";
};
type AgentProfilePoolMembersRemoveErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfilePoolMembersRemoveError = AgentProfilePoolMembersRemoveErrors[keyof AgentProfilePoolMembersRemoveErrors];
type AgentProfilePoolMembersRemoveResponses = {
    /**
     * There is no content to send for this request, but the headers may be useful.
     */
    204: void;
};
type AgentProfilePoolMembersRemoveResponse = AgentProfilePoolMembersRemoveResponses[keyof AgentProfilePoolMembersRemoveResponses];
type AgentProfilePoolMembersListData = {
    body?: never;
    path: {
        /**
         * The ID of the agent profile pool
         */
        poolId: CommonUuid;
    };
    query?: {
        pageSize?: number;
        page?: number;
    };
    url: "/agent-profile-pools/{poolId}/members";
};
type AgentProfilePoolMembersListErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfilePoolMembersListError = AgentProfilePoolMembersListErrors[keyof AgentProfilePoolMembersListErrors];
type AgentProfilePoolMembersListResponses = {
    /**
     * The request has succeeded.
     */
    200: {
        items: Array<AgentsProfileAgentProfilePoolMember>;
        page: number;
        pageSize: number;
        total: number;
    };
};
type AgentProfilePoolMembersListResponse = AgentProfilePoolMembersListResponses[keyof AgentProfilePoolMembersListResponses];
type AgentProfilePoolMembersAddData = {
    /**
     * Profile IDs to add
     */
    body: AgentsProfileAddProfilesToPoolRequest;
    path: {
        /**
         * The ID of the agent profile pool
         */
        poolId: CommonUuid;
    };
    query?: never;
    url: "/agent-profile-pools/{poolId}/members";
};
type AgentProfilePoolMembersAddErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfilePoolMembersAddError = AgentProfilePoolMembersAddErrors[keyof AgentProfilePoolMembersAddErrors];
type AgentProfilePoolMembersAddResponses = {
    /**
     * There is no content to send for this request, but the headers may be useful.
     */
    204: void;
};
type AgentProfilePoolMembersAddResponse = AgentProfilePoolMembersAddResponses[keyof AgentProfilePoolMembersAddResponses];
type AgentProfilesListData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Filter by organization ID
         */
        organizationId?: CommonUuid;
        pageSize?: number;
        page?: number;
        /**
         * Search profiles by name (partial match)
         */
        searchName?: string;
        /**
         * Filter by proxy mode (can specify multiple, there is an 'OR' condition applied to these)
         */
        proxyMode?: Array<AgentsProfileProxyMode>;
        /**
         * Filter by emulated operating system (can specify multiple, there is an 'OR' condition applied to these). Profiles without an explicit operating system count as macOS.
         */
        operatingSystem?: Array<AgentsProfileOperatingSystem>;
        /**
         * Filter by active browser features (can specify multiple, there is an 'AND' condition applied to these — every listed feature must be enabled)
         */
        feature?: Array<AgentsProfileFeature>;
        sortField?: AgentsProfileSortField;
        sortDirection?: CommonSortDirection;
    };
    url: "/agent-profiles";
};
type AgentProfilesListErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfilesListError = AgentProfilesListErrors[keyof AgentProfilesListErrors];
type AgentProfilesListResponses = {
    /**
     * The request has succeeded.
     */
    200: {
        items: Array<AgentsProfileAgentProfile>;
        page: number;
        pageSize: number;
        total: number;
    };
};
type AgentProfilesListResponse = AgentProfilesListResponses[keyof AgentProfilesListResponses];
type AgentProfilesCreateData = {
    /**
     * Agent profile to create
     */
    body: AgentsProfileCreateAgentProfileRequest;
    path?: never;
    query?: never;
    url: "/agent-profiles";
};
type AgentProfilesCreateErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfilesCreateError = AgentProfilesCreateErrors[keyof AgentProfilesCreateErrors];
type AgentProfilesCreateResponses = {
    /**
     * The request has succeeded and a new resource has been created as a result.
     */
    201: AgentsProfileAgentProfile;
};
type AgentProfilesCreateResponse = AgentProfilesCreateResponses[keyof AgentProfilesCreateResponses];
type AgentProfileDeleteData = {
    body?: never;
    path: {
        /**
         * The ID of the agent profile
         */
        profileId: CommonUuid;
    };
    query?: never;
    url: "/agent-profiles/{profileId}";
};
type AgentProfileDeleteErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfileDeleteError = AgentProfileDeleteErrors[keyof AgentProfileDeleteErrors];
type AgentProfileDeleteResponses = {
    /**
     * There is no content to send for this request, but the headers may be useful.
     */
    204: void;
};
type AgentProfileDeleteResponse = AgentProfileDeleteResponses[keyof AgentProfileDeleteResponses];
type AgentProfileGetData = {
    body?: never;
    path: {
        /**
         * The ID of the agent profile
         */
        profileId: CommonUuid;
    };
    query?: never;
    url: "/agent-profiles/{profileId}";
};
type AgentProfileGetErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfileGetError = AgentProfileGetErrors[keyof AgentProfileGetErrors];
type AgentProfileGetResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsProfileAgentProfile;
};
type AgentProfileGetResponse = AgentProfileGetResponses[keyof AgentProfileGetResponses];
type AgentProfileUpdateData = {
    /**
     * Fields to update
     */
    body: AgentsProfileUpdateAgentProfileRequest;
    path: {
        /**
         * The ID of the agent profile
         */
        profileId: CommonUuid;
    };
    query?: never;
    url: "/agent-profiles/{profileId}";
};
type AgentProfileUpdateErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfileUpdateError = AgentProfileUpdateErrors[keyof AgentProfileUpdateErrors];
type AgentProfileUpdateResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsProfileAgentProfile;
};
type AgentProfileUpdateResponse = AgentProfileUpdateResponses[keyof AgentProfileUpdateResponses];
type AgentProfileClearBrowserCacheData = {
    body?: never;
    path: {
        /**
         * The ID of the agent profile
         */
        profileId: CommonUuid;
    };
    query?: never;
    url: "/agent-profiles/{profileId}/clear-browser-cache";
};
type AgentProfileClearBrowserCacheErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfileClearBrowserCacheError = AgentProfileClearBrowserCacheErrors[keyof AgentProfileClearBrowserCacheErrors];
type AgentProfileClearBrowserCacheResponses = {
    /**
     * The request has succeeded.
     */
    200: {
        message: string;
    };
};
type AgentProfileClearBrowserCacheResponse = AgentProfileClearBrowserCacheResponses[keyof AgentProfileClearBrowserCacheResponses];
type AgentProfileDuplicateData = {
    /**
     * Optional request body for cross-org duplication
     */
    body?: AgentsProfileDuplicateAgentProfileRequest;
    path: {
        /**
         * The ID of the agent profile to duplicate
         */
        profileId: CommonUuid;
    };
    query?: never;
    url: "/agent-profiles/{profileId}/duplicate";
};
type AgentProfileDuplicateErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfileDuplicateError = AgentProfileDuplicateErrors[keyof AgentProfileDuplicateErrors];
type AgentProfileDuplicateResponses = {
    /**
     * The request has succeeded and a new resource has been created as a result.
     */
    201: AgentsProfileAgentProfile;
};
type AgentProfileDuplicateResponse = AgentProfileDuplicateResponses[keyof AgentProfileDuplicateResponses];
type AgentProfileGetInboxEmailsData = {
    body?: never;
    path: {
        /**
         * The ID of the agent profile
         */
        profileId: CommonUuid;
    };
    query?: {
        /**
         * Maximum number of emails to return
         */
        limit?: number;
    };
    url: "/agent-profiles/{profileId}/inbox-emails";
};
type AgentProfileGetInboxEmailsErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfileGetInboxEmailsError = AgentProfileGetInboxEmailsErrors[keyof AgentProfileGetInboxEmailsErrors];
type AgentProfileGetInboxEmailsResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsProfileAgentProfileInboxEmailsResponse;
};
type AgentProfileGetInboxEmailsResponse = AgentProfileGetInboxEmailsResponses[keyof AgentProfileGetInboxEmailsResponses];
type AgentProfileGetInboxEmailData = {
    body?: never;
    path: {
        /**
         * The ID of the agent profile
         */
        profileId: CommonUuid;
        /**
         * The Resend email ID
         */
        emailId: string;
    };
    query?: never;
    url: "/agent-profiles/{profileId}/inbox-emails/{emailId}";
};
type AgentProfileGetInboxEmailErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentProfileGetInboxEmailError = AgentProfileGetInboxEmailErrors[keyof AgentProfileGetInboxEmailErrors];
type AgentProfileGetInboxEmailResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsProfileProfileInboxEmailDetail;
};
type AgentProfileGetInboxEmailResponse = AgentProfileGetInboxEmailResponses[keyof AgentProfileGetInboxEmailResponses];
type AgentListData = {
    body?: never;
    path?: never;
    query?: {
        organizationId?: CommonUuid;
        pageSize?: number;
        page?: number;
        searchName?: string;
        sortField?: AgentsAgentSortField;
        sortDirection?: CommonSortDirection;
    };
    url: "/agents";
};
type AgentListErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: "Invalid request parameters.";
    /**
     * The server cannot find the requested resource.
     */
    404: "Organization not found.";
    /**
     * An unexpected error response.
     */
    default: CommonError;
};
type AgentListError = AgentListErrors[keyof AgentListErrors];
type AgentListResponses = {
    /**
     * The request has succeeded.
     */
    200: {
        items: Array<AgentsAgentBase>;
        page: number;
        pageSize: number;
        total: number;
    };
};
type AgentListResponse = AgentListResponses[keyof AgentListResponses];
type AgentCreateData = {
    body: AgentsAgentExternalCreateRequest;
    path?: never;
    query?: never;
    url: "/agents";
};
type AgentCreateErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * The request conflicts with the current state of the server.
     */
    409: CommonConflictErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentCreateError = AgentCreateErrors[keyof AgentCreateErrors];
type AgentCreateResponses = {
    /**
     * The request has succeeded and a new resource has been created as a result.
     */
    201: AgentsAgentCreateResponse;
};
type AgentCreateResponse = AgentCreateResponses[keyof AgentCreateResponses];
type AvailableToolsListData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/agents/available-tools";
};
type AvailableToolsListErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AvailableToolsListError = AvailableToolsListErrors[keyof AvailableToolsListErrors];
type AvailableToolsListResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsAgentAvailableToolsResponse;
};
type AvailableToolsListResponse = AvailableToolsListResponses[keyof AvailableToolsListResponses];
type AgentByIdDeleteData = {
    body?: never;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}";
};
type AgentByIdDeleteErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentByIdDeleteError = AgentByIdDeleteErrors[keyof AgentByIdDeleteErrors];
type AgentByIdDeleteResponses = {
    /**
     * There is no content to send for this request, but the headers may be useful.
     */
    204: void;
};
type AgentByIdDeleteResponse = AgentByIdDeleteResponses[keyof AgentByIdDeleteResponses];
type AgentByIdUpdateData = {
    body: AgentsAgentUpdateRequest;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}";
};
type AgentByIdUpdateErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * The request conflicts with the current state of the server.
     */
    409: CommonConflictErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentByIdUpdateError = AgentByIdUpdateErrors[keyof AgentByIdUpdateErrors];
type AgentByIdUpdateResponses = {
    /**
     * The request has succeeded.
     */
    200: unknown;
};
type AgentExecutePostData = {
    /**
     * Execution request parameters
     */
    body: AgentsAgentExecuteAgentRequest;
    path: {
        /**
         * The ID of the agent to execute
         */
        agentId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}/execute";
};
type AgentExecutePostErrors = {
    /**
     * An unexpected error response.
     */
    default: CommonError;
};
type AgentExecutePostError = AgentExecutePostErrors[keyof AgentExecutePostErrors];
type AgentExecutePostResponses = {
    /**
     * The request has been accepted for processing, but processing has not yet completed.
     */
    202: AgentsAgentExecuteAgentResponse;
};
type AgentExecutePostResponse = AgentExecutePostResponses[keyof AgentExecutePostResponses];
type AgentWorkflowHeadGetFilesData = {
    body?: never;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
    };
    query?: {
        /**
         * Which contents come inline: none (a pure manifest), structural (the default), or all (structural plus agent-file bytes within the response budget).
         */
        contents?: AgentsWorkflowWorkflowFileContentsMode;
        /**
         * Return only the files at these exact tree paths. A path that names nothing yields no entry. The inline budget applies to the filtered set, so a narrow read can inline files a whole-tree read would have to skip.
         */
        paths?: Array<string>;
        /**
         * Narrow which variants/<key>/ files the tree carries: "none" strips every variant, a comma-separated list keeps only those variant keys. Files outside variants/ are always kept, and the response's variantKeys still names every variant. Ignored unless the workflow has variant mode enabled; absent keeps every variant.
         */
        variants?: string;
        /**
         * Per-file ceiling, in bytes, for inlined agent-file contents. Clamped to the server maximum; a caller with tighter limits of its own passes them here so the response does not carry bytes it will discard. Files above the ceiling stay references.
         */
        maxFileBytes?: number;
        /**
         * Ceiling, in bytes, on the total inlined agent-file contents in one response. Clamped to the server maximum. Files are admitted in path order until the ceiling is reached; the rest stay references.
         */
        maxTotalBytes?: number;
    };
    url: "/agents/{agentId}/workflow-head/files";
};
type AgentWorkflowHeadGetFilesErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowHeadGetFilesError = AgentWorkflowHeadGetFilesErrors[keyof AgentWorkflowHeadGetFilesErrors];
type AgentWorkflowHeadGetFilesResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsWorkflowWorkflowFileTree;
};
type AgentWorkflowHeadGetFilesResponse = AgentWorkflowHeadGetFilesResponses[keyof AgentWorkflowHeadGetFilesResponses];
type AgentWorkflowHeadPatchFilesData = {
    /**
     * The file writes and deletes to apply
     */
    body: AgentsWorkflowWorkflowFilesPatchRequest;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}/workflow-head/files";
};
type AgentWorkflowHeadPatchFilesErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * The request conflicts with the current state of the server.
     */
    409: CommonConflictErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowHeadPatchFilesError = AgentWorkflowHeadPatchFilesErrors[keyof AgentWorkflowHeadPatchFilesErrors];
type AgentWorkflowHeadPatchFilesResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsWorkflowExternalWorkflowSnapshot;
};
type AgentWorkflowHeadPatchFilesResponse = AgentWorkflowHeadPatchFilesResponses[keyof AgentWorkflowHeadPatchFilesResponses];
type AgentWorkflowHeadPublishHeadData = {
    body?: never;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}/workflow-head/publish";
};
type AgentWorkflowHeadPublishHeadErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowHeadPublishHeadError = AgentWorkflowHeadPublishHeadErrors[keyof AgentWorkflowHeadPublishHeadErrors];
type AgentWorkflowHeadPublishHeadResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsWorkflowPublishWorkflowResponse;
};
type AgentWorkflowHeadPublishHeadResponse = AgentWorkflowHeadPublishHeadResponses[keyof AgentWorkflowHeadPublishHeadResponses];
type AgentWorkflowsListData = {
    body?: never;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}/workflows";
};
type AgentWorkflowsListErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowsListError = AgentWorkflowsListErrors[keyof AgentWorkflowsListErrors];
type AgentWorkflowsListResponses = {
    /**
     * The request has succeeded.
     */
    200: Array<AgentsWorkflowWorkflowRef>;
};
type AgentWorkflowsListResponse = AgentWorkflowsListResponses[keyof AgentWorkflowsListResponses];
type AgentWorkflowsCreateData = {
    /**
     * Workflow creation request
     */
    body: AgentsWorkflowExternalCreateWorkflowRequest;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}/workflows";
};
type AgentWorkflowsCreateErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowsCreateError = AgentWorkflowsCreateErrors[keyof AgentWorkflowsCreateErrors];
type AgentWorkflowsCreateResponses = {
    /**
     * The request has succeeded and a new resource has been created as a result.
     */
    201: AgentsWorkflowCreateWorkflowResponse;
};
type AgentWorkflowsCreateResponse = AgentWorkflowsCreateResponses[keyof AgentWorkflowsCreateResponses];
type AgentWorkflowsValidateData = {
    /**
     * The workflow spec to validate
     */
    body: AgentsWorkflowExternalCreateWorkflowRequest;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}/workflows/validate";
};
type AgentWorkflowsValidateErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowsValidateError = AgentWorkflowsValidateErrors[keyof AgentWorkflowsValidateErrors];
type AgentWorkflowsValidateResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsWorkflowWorkflowValidationResponse;
};
type AgentWorkflowsValidateResponse = AgentWorkflowsValidateResponses[keyof AgentWorkflowsValidateResponses];
type AgentWorkflowsDeleteWorkflowData = {
    body?: never;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
        /**
         * The ID of the workflow to delete
         */
        workflowId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}/workflows/{workflowId}";
};
type AgentWorkflowsDeleteWorkflowErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowsDeleteWorkflowError = AgentWorkflowsDeleteWorkflowErrors[keyof AgentWorkflowsDeleteWorkflowErrors];
type AgentWorkflowsDeleteWorkflowResponses = {
    /**
     * There is no content to send for this request, but the headers may be useful.
     */
    204: void;
};
type AgentWorkflowsDeleteWorkflowResponse = AgentWorkflowsDeleteWorkflowResponses[keyof AgentWorkflowsDeleteWorkflowResponses];
type AgentWorkflowsGetData = {
    body?: never;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
        /**
         * The ID of the workflow
         */
        workflowId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}/workflows/{workflowId}";
};
type AgentWorkflowsGetErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowsGetError = AgentWorkflowsGetErrors[keyof AgentWorkflowsGetErrors];
type AgentWorkflowsGetResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsWorkflowExternalWorkflowSnapshot;
};
type AgentWorkflowsGetResponse = AgentWorkflowsGetResponses[keyof AgentWorkflowsGetResponses];
type AgentWorkflowsExecuteData = {
    /**
     * Execution request parameters
     */
    body: AgentsWorkflowExecuteWorkflowRequest;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
        /**
         * The ID of the workflow to execute
         */
        workflowId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}/workflows/{workflowId}/execute";
};
type AgentWorkflowsExecuteErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Client error
     */
    402: CommonPaymentRequiredErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowsExecuteError = AgentWorkflowsExecuteErrors[keyof AgentWorkflowsExecuteErrors];
type AgentWorkflowsExecuteResponses = {
    /**
     * The request has been accepted for processing, but processing has not yet completed.
     */
    202: AgentsWorkflowExecuteWorkflowResponse;
};
type AgentWorkflowsExecuteResponse = AgentWorkflowsExecuteResponses[keyof AgentWorkflowsExecuteResponses];
type AgentWorkflowsGetFilesByVersionData = {
    body?: never;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
        /**
         * The ID of the workflow
         */
        workflowId: CommonUuid;
    };
    query?: {
        /**
         * Which contents come inline: none (a pure manifest), structural (the default), or all (structural plus agent-file bytes within the response budget).
         */
        contents?: AgentsWorkflowWorkflowFileContentsMode;
        /**
         * Return only the files at these exact tree paths. A path that names nothing yields no entry. The inline budget applies to the filtered set, so a narrow read can inline files a whole-tree read would have to skip.
         */
        paths?: Array<string>;
        /**
         * Narrow which variants/<key>/ files the tree carries: "none" strips every variant, a comma-separated list keeps only those variant keys. Files outside variants/ are always kept, and the response's variantKeys still names every variant. Ignored unless the workflow has variant mode enabled; absent keeps every variant.
         */
        variants?: string;
        /**
         * Per-file ceiling, in bytes, for inlined agent-file contents. Clamped to the server maximum; a caller with tighter limits of its own passes them here so the response does not carry bytes it will discard. Files above the ceiling stay references.
         */
        maxFileBytes?: number;
        /**
         * Ceiling, in bytes, on the total inlined agent-file contents in one response. Clamped to the server maximum. Files are admitted in path order until the ceiling is reached; the rest stay references.
         */
        maxTotalBytes?: number;
    };
    url: "/agents/{agentId}/workflows/{workflowId}/files";
};
type AgentWorkflowsGetFilesByVersionErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowsGetFilesByVersionError = AgentWorkflowsGetFilesByVersionErrors[keyof AgentWorkflowsGetFilesByVersionErrors];
type AgentWorkflowsGetFilesByVersionResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsWorkflowWorkflowFileTree;
};
type AgentWorkflowsGetFilesByVersionResponse = AgentWorkflowsGetFilesByVersionResponses[keyof AgentWorkflowsGetFilesByVersionResponses];
type AgentWorkflowsGetInputsData = {
    body?: never;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
        /**
         * The ID of the workflow
         */
        workflowId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}/workflows/{workflowId}/inputs";
};
type AgentWorkflowsGetInputsErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowsGetInputsError = AgentWorkflowsGetInputsErrors[keyof AgentWorkflowsGetInputsErrors];
type AgentWorkflowsGetInputsResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsWorkflowWorkflowInputs;
};
type AgentWorkflowsGetInputsResponse = AgentWorkflowsGetInputsResponses[keyof AgentWorkflowsGetInputsResponses];
type AgentWorkflowsGetOutputSchemasData = {
    body?: never;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
        /**
         * The ID of the workflow
         */
        workflowId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}/workflows/{workflowId}/output-schemas";
};
type AgentWorkflowsGetOutputSchemasErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowsGetOutputSchemasError = AgentWorkflowsGetOutputSchemasErrors[keyof AgentWorkflowsGetOutputSchemasErrors];
type AgentWorkflowsGetOutputSchemasResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsWorkflowWorkflowOutputSchemas;
};
type AgentWorkflowsGetOutputSchemasResponse = AgentWorkflowsGetOutputSchemasResponses[keyof AgentWorkflowsGetOutputSchemasResponses];
type AgentWorkflowsPublishData = {
    body?: never;
    path: {
        /**
         * The ID of the agent
         */
        agentId: CommonUuid;
        /**
         * The ID of the workflow to publish
         */
        workflowId: CommonUuid;
    };
    query?: never;
    url: "/agents/{agentId}/workflows/{workflowId}/publish";
};
type AgentWorkflowsPublishErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type AgentWorkflowsPublishError = AgentWorkflowsPublishErrors[keyof AgentWorkflowsPublishErrors];
type AgentWorkflowsPublishResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsWorkflowPublishWorkflowResponse;
};
type AgentWorkflowsPublishResponse = AgentWorkflowsPublishResponses[keyof AgentWorkflowsPublishResponses];
type ContextGetData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/context";
};
type ContextGetErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type ContextGetError = ContextGetErrors[keyof ContextGetErrors];
type ContextGetResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsContextUserContextResponse;
};
type ContextGetResponse = ContextGetResponses[keyof ContextGetResponses];
type DocsSearchSearchData = {
    /**
     * The search request
     */
    body: AgentsDocsSearchDocsRequest;
    path?: never;
    query?: never;
    url: "/docs/search";
};
type DocsSearchSearchErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type DocsSearchSearchError = DocsSearchSearchErrors[keyof DocsSearchSearchErrors];
type DocsSearchSearchResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsDocsSearchDocsResponse;
};
type DocsSearchSearchResponse = DocsSearchSearchResponses[keyof DocsSearchSearchResponses];
type ExecutionsListData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Optional organization ID filter (required for customer queries)
         */
        organizationId?: CommonUuid;
        pageSize?: number;
        page?: number;
        /**
         * Search by execution ID (partial, case-insensitive match)
         */
        executionId?: string;
        /**
         * Filter by agent ID
         */
        agentId?: CommonUuid;
        /**
         * Filter by agent profile IDs (can specify multiple, there is an 'OR' condition applied to these)
         */
        agentProfileIds?: Array<CommonUuid>;
        /**
         * Filter by execution status (can specify multiple, there is an 'OR' condition applied to these)
         */
        status?: Array<AgentsExecutionStatus>;
        /**
         * Filter executions created after this timestamp
         */
        createdAfter?: string;
        /**
         * Filter executions created before this timestamp
         */
        createdBefore?: string;
        /**
         * Filter by human labels (can specify multiple label IDs, there is an 'OR' condition applied to these)
         */
        humanLabels?: Array<CommonUuid>;
        /**
         * Filter by execution result outcome (partial, case-insensitive match)
         */
        outcomeLabel?: string;
        /**
         * Filter by metadata key - must be used together with metadataValue
         */
        metadataKey?: string;
        /**
         * Filter by metadata value - must be used together with metadataKey
         */
        metadataValue?: string;
        /**
         * Filter by input variable key - must be used together with inputsValue
         */
        inputsKey?: string;
        /**
         * Filter by input variable value (partial, case-insensitive match) - must be used together with inputsKey
         */
        inputsValue?: string;
        /**
         * Filter by workflow version number
         */
        workflowVersion?: number;
        /**
         * Filter by whether the execution recorded any script failures
         */
        hasScriptFailures?: boolean;
        /**
         * Filter by how the execution was triggered (can specify multiple, there is an 'OR' condition applied to these)
         */
        triggerSource?: Array<"api" | "ui" | "schedule" | "warmup">;
        /**
         * Filter by lifecycle phase, derived from status (can specify multiple, OR across values). Composes with the status filter as AND. pending = queued; active = starting, running, awaiting_confirmation, paused, paused_by_agent; terminal = completed, cancelled, failed.
         */
        phase?: Array<AgentsExecutionPhase>;
        sortField?: AgentsExecutionSortField;
        sortDirection?: CommonSortDirection;
    };
    url: "/executions";
};
type ExecutionsListErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type ExecutionsListError = ExecutionsListErrors[keyof ExecutionsListErrors];
type ExecutionsListResponses = {
    /**
     * The request has succeeded.
     */
    200: {
        items: Array<AgentsExecutionListItem>;
        page: number;
        pageSize: number;
        total: number;
    };
};
type ExecutionsListResponse = ExecutionsListResponses[keyof ExecutionsListResponses];
type ExecutionGetData = {
    body?: never;
    path: {
        /**
         * The unique identifier of the execution
         */
        executionId: CommonUuid;
    };
    query?: never;
    url: "/executions/{executionId}";
};
type ExecutionGetErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type ExecutionGetError = ExecutionGetErrors[keyof ExecutionGetErrors];
type ExecutionGetResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsExecutionListItem;
};
type ExecutionGetResponse = ExecutionGetResponses[keyof ExecutionGetResponses];
type ExecutionActivitiesGetData = {
    body?: never;
    path: {
        /**
         * The unique identifier of the execution
         */
        executionId: CommonUuid;
    };
    query?: {
        /**
         * Sort order for activities by timestamp
         */
        order?: "asc" | "desc";
        /**
         * Maximum number of activities to return
         */
        limit?: number;
    };
    url: "/executions/{executionId}/activities";
};
type ExecutionActivitiesGetErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type ExecutionActivitiesGetError = ExecutionActivitiesGetErrors[keyof ExecutionActivitiesGetErrors];
type ExecutionActivitiesGetResponses = {
    /**
     * The request has succeeded.
     */
    200: Array<AgentsExecutionActivity>;
};
type ExecutionActivitiesGetResponse = ExecutionActivitiesGetResponses[keyof ExecutionActivitiesGetResponses];
type ExecutionAgentFilesGetData = {
    body?: never;
    path: {
        executionId: CommonUuid;
    };
    query?: never;
    url: "/executions/{executionId}/agent-files";
};
type ExecutionAgentFilesGetErrors = {
    /**
     * The server cannot find the requested resource.
     */
    404: "Execution not found.";
};
type ExecutionAgentFilesGetError = ExecutionAgentFilesGetErrors[keyof ExecutionAgentFilesGetErrors];
type ExecutionAgentFilesGetResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsFilesAgentFilesResponse;
};
type ExecutionAgentFilesGetResponse = ExecutionAgentFilesGetResponses[keyof ExecutionAgentFilesGetResponses];
type ExecutionAgentFileDownloadRedirectData = {
    body?: never;
    path: {
        executionId: CommonUuid;
        fileId: CommonUuid;
    };
    query?: never;
    url: "/executions/{executionId}/agent-files/{fileId}/download";
};
type ExecutionAgentFileDownloadRedirectErrors = {
    /**
     * The server cannot find the requested resource.
     */
    404: "File not found.";
};
type ExecutionAgentFileDownloadRedirectError = ExecutionAgentFileDownloadRedirectErrors[keyof ExecutionAgentFileDownloadRedirectErrors];
type ExecutionContextFilesGetData = {
    body?: never;
    path: {
        executionId: CommonUuid;
    };
    query?: never;
    url: "/executions/{executionId}/context-files";
};
type ExecutionContextFilesGetErrors = {
    /**
     * The server cannot find the requested resource.
     */
    404: "Execution files not found.";
};
type ExecutionContextFilesGetError = ExecutionContextFilesGetErrors[keyof ExecutionContextFilesGetErrors];
type ExecutionContextFilesGetResponses = {
    /**
     * The request has succeeded.
     */
    200: Array<AgentsFilesFile>;
};
type ExecutionContextFilesGetResponse = ExecutionContextFilesGetResponses[keyof ExecutionContextFilesGetResponses];
type ExecutionContextFilesUploadData = {
    body: {
        files: Array<AgentsFilesFilePart>;
    };
    path: {
        executionId: CommonUuid;
    };
    query?: never;
    url: "/executions/{executionId}/context-files";
};
type ExecutionContextFilesUploadErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: "Invalid file upload request.";
    /**
     * The server cannot find the requested resource.
     */
    404: "Execution not found.";
};
type ExecutionContextFilesUploadError = ExecutionContextFilesUploadErrors[keyof ExecutionContextFilesUploadErrors];
type ExecutionContextFilesUploadResponses = {
    /**
     * The request has succeeded.
     */
    200: "Files uploaded.";
};
type ExecutionContextFilesUploadResponse = ExecutionContextFilesUploadResponses[keyof ExecutionContextFilesUploadResponses];
type ExecutionContextFileDownloadRedirectData = {
    body?: never;
    path: {
        executionId: CommonUuid;
        fileId: CommonUuid;
    };
    query?: never;
    url: "/executions/{executionId}/context-files/{fileId}/download";
};
type ExecutionContextFileDownloadRedirectErrors = {
    /**
     * The server cannot find the requested resource.
     */
    404: "File not found.";
};
type ExecutionContextFileDownloadRedirectError = ExecutionContextFileDownloadRedirectErrors[keyof ExecutionContextFileDownloadRedirectErrors];
type ExecutionDebugFileDownloadRedirectData = {
    body?: never;
    path: {
        executionId: CommonUuid;
        fileId: CommonUuid;
    };
    query?: never;
    url: "/executions/{executionId}/debug-files/{fileId}/download";
};
type ExecutionDebugFileDownloadRedirectErrors = {
    /**
     * The server cannot find the requested resource.
     */
    404: "File not found.";
};
type ExecutionDebugFileDownloadRedirectError = ExecutionDebugFileDownloadRedirectErrors[keyof ExecutionDebugFileDownloadRedirectErrors];
type ExecutionFilesGetData = {
    body?: never;
    path: {
        executionId: CommonUuid;
    };
    query?: never;
    url: "/executions/{executionId}/files";
};
type ExecutionFilesGetErrors = {
    /**
     * The server cannot find the requested resource.
     */
    404: "Execution not found.";
};
type ExecutionFilesGetError = ExecutionFilesGetErrors[keyof ExecutionFilesGetErrors];
type ExecutionFilesGetResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsFilesAgentFilesResponse;
};
type ExecutionFilesGetResponse = ExecutionFilesGetResponses[keyof ExecutionFilesGetResponses];
type ExecutionFileDownloadRedirectData = {
    body?: never;
    path: {
        executionId: CommonUuid;
        fileId: CommonUuid;
    };
    query?: never;
    url: "/executions/{executionId}/files/{fileId}/download";
};
type ExecutionFileDownloadRedirectErrors = {
    /**
     * The server cannot find the requested resource.
     */
    404: "File not found.";
};
type ExecutionFileDownloadRedirectError = ExecutionFileDownloadRedirectErrors[keyof ExecutionFileDownloadRedirectErrors];
type ExecutionRecordingRedirectData = {
    body?: never;
    path: {
        /**
         * The unique identifier of the execution
         */
        executionId: CommonUuid;
    };
    query?: {
        /**
         * Optional token for authentication. Use this when the client cannot set Authorization headers (e.g., native video elements).
         */
        token?: string;
    };
    url: "/executions/{executionId}/recording";
};
type ExecutionRecordingRedirectErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type ExecutionRecordingRedirectError = ExecutionRecordingRedirectErrors[keyof ExecutionRecordingRedirectErrors];
type ExecutionStatusUpdateData = {
    /**
     * The status update request
     */
    body: AgentsExecutionUpdateExecutionStatusRequest;
    path: {
        /**
         * The unique identifier of the execution
         */
        executionId: CommonUuid;
    };
    query?: never;
    url: "/executions/{executionId}/status";
};
type ExecutionStatusUpdateErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type ExecutionStatusUpdateError = ExecutionStatusUpdateErrors[keyof ExecutionStatusUpdateErrors];
type ExecutionStatusUpdateResponses = {
    /**
     * The request has succeeded.
     */
    200: "Execution status updated.";
};
type ExecutionStatusUpdateResponse = ExecutionStatusUpdateResponses[keyof ExecutionStatusUpdateResponses];
type ExecutionUserMessagesAddData = {
    /**
     * The message content to send
     */
    body: AgentsExecutionUserMessagesAddTextBody;
    path: {
        /**
         * The unique identifier of the execution
         */
        executionId: CommonUuid;
    };
    query?: never;
    url: "/executions/{executionId}/user-messages";
};
type ExecutionUserMessagesAddErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type ExecutionUserMessagesAddError = ExecutionUserMessagesAddErrors[keyof ExecutionUserMessagesAddErrors];
type ExecutionUserMessagesAddResponses = {
    /**
     * The request has succeeded and a new resource has been created as a result.
     */
    201: "User message added.";
};
type ExecutionUserMessagesAddResponse = ExecutionUserMessagesAddResponses[keyof ExecutionUserMessagesAddResponses];
type SchemaValidationValidateData = {
    /**
     * The schema to validate
     */
    body: AgentsSchemaValidateSchemaRequest;
    path?: never;
    query?: never;
    url: "/schema/validate";
};
type SchemaValidationValidateErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type SchemaValidationValidateError = SchemaValidationValidateErrors[keyof SchemaValidationValidateErrors];
type SchemaValidationValidateResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsSchemaValidateSchemaResponse;
};
type SchemaValidationValidateResponse = SchemaValidationValidateResponses[keyof SchemaValidationValidateResponses];
type TempFilesStageData = {
    body: {
        files: Array<AgentsFilesFilePart>;
    };
    path: {
        organizationId: CommonUuid;
    };
    query?: never;
    url: "/temp-files/{organizationId}";
};
type TempFilesStageErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: "Invalid file upload request.";
    /**
     * Access is forbidden.
     */
    403: "User is not a member of the organization.";
    /**
     * Server error
     */
    500: "Internal server error.";
};
type TempFilesStageError = TempFilesStageErrors[keyof TempFilesStageErrors];
type TempFilesStageResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsFilesTempFilesResponse;
};
type TempFilesStageResponse = TempFilesStageResponses[keyof TempFilesStageResponses];
type WorkflowSpecValidationValidateData = {
    /**
     * The workflow spec to validate
     */
    body: AgentsWorkflowExternalCreateWorkflowRequest;
    path?: never;
    query?: never;
    url: "/workflows/validate";
};
type WorkflowSpecValidationValidateErrors = {
    /**
     * The server could not understand the request due to invalid syntax.
     */
    400: CommonBadRequestErrorBody;
    /**
     * Access is unauthorized.
     */
    401: CommonUnauthorizedErrorBody;
    /**
     * Access is forbidden.
     */
    403: CommonForbiddenErrorBody;
    /**
     * The server cannot find the requested resource.
     */
    404: CommonNotFoundErrorBody;
    /**
     * Server error
     */
    500: CommonInternalServerErrorBody;
};
type WorkflowSpecValidationValidateError = WorkflowSpecValidationValidateErrors[keyof WorkflowSpecValidationValidateErrors];
type WorkflowSpecValidationValidateResponses = {
    /**
     * The request has succeeded.
     */
    200: AgentsWorkflowWorkflowValidationResponse;
};
type WorkflowSpecValidationValidateResponse = WorkflowSpecValidationValidateResponses[keyof WorkflowSpecValidationValidateResponses];

/**
 * The `createClientConfig()` function will be called on client initialization
 * and the returned object will become the client's initial configuration.
 *
 * You may want to initialize your client this way instead of calling
 * `setConfig()`. This is useful for example if you're using Next.js
 * to ensure your client always has the correct values.
 */
type CreateClientConfig<T extends ClientOptions$1 = ClientOptions> = (override?: Config<ClientOptions$1 & T>) => Config<Required<ClientOptions$1> & T>;
declare const client: Client;

type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options$1<TData, ThrowOnError, TResponse> & {
    /**
     * You can provide a client instance returned by `createClient()` instead of
     * individual options. This might be also useful if you want to implement a
     * custom client.
     */
    client?: Client;
    /**
     * You can pass arbitrary values through the `meta` object. This can be
     * used to access values that aren't defined as part of the SDK function.
     */
    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
};
/**
 * List customer activity for all orgs
 *
 * Engagement-activity metrics (execution volume, success rate, agent count, risk) for every active organisation. Admin-only.
 */
declare const adminCustomerActivityList: <ThrowOnError extends boolean = false>(options?: Options<AdminCustomerActivityListData, ThrowOnError>) => RequestResult<AdminCustomerActivityListResponses, AdminCustomerActivityListErrors, ThrowOnError>;
/**
 * List notable activity in a lookback window
 *
 * List orgs that tripped a high-intent activity event within the lookback window. Admin-only. Feeds the customer-health Slack digest.
 */
declare const adminCustomerActivityNotableList: <ThrowOnError extends boolean = false>(options?: Options<AdminCustomerActivityNotableListData, ThrowOnError>) => RequestResult<AdminCustomerActivityNotableListResponses, AdminCustomerActivityNotableListErrors, ThrowOnError>;
/**
 * List per-org window stats
 *
 * Per-org trailing 7-day execution + outcome windows for digest deltas. Admin-only.
 */
declare const adminCustomerActivityWindowStatsList: <ThrowOnError extends boolean = false>(options?: Options<AdminCustomerActivityWindowStatsListData, ThrowOnError>) => RequestResult<AdminCustomerActivityWindowStatsListResponses, AdminCustomerActivityWindowStatsListErrors, ThrowOnError>;
/**
 * List Agent Profile Pools
 *
 * List all agent profile pools for an organization
 */
declare const agentProfilePoolsList: <ThrowOnError extends boolean = false>(options?: Options<AgentProfilePoolsListData, ThrowOnError>) => RequestResult<AgentProfilePoolsListResponses, AgentProfilePoolsListErrors, ThrowOnError>;
/**
 * Create Agent Profile Pool
 *
 * Create a new agent profile pool
 */
declare const agentProfilePoolsCreate: <ThrowOnError extends boolean = false>(options: Options<AgentProfilePoolsCreateData, ThrowOnError>) => RequestResult<AgentProfilePoolsCreateResponses, AgentProfilePoolsCreateErrors, ThrowOnError>;
/**
 * Delete Agent Profile Pool
 *
 * Delete an agent profile pool
 */
declare const agentProfilePoolDelete: <ThrowOnError extends boolean = false>(options: Options<AgentProfilePoolDeleteData, ThrowOnError>) => RequestResult<AgentProfilePoolDeleteResponses, AgentProfilePoolDeleteErrors, ThrowOnError>;
/**
 * Get Agent Profile Pool
 *
 * Get an agent profile pool by ID
 */
declare const agentProfilePoolGet: <ThrowOnError extends boolean = false>(options: Options<AgentProfilePoolGetData, ThrowOnError>) => RequestResult<AgentProfilePoolGetResponses, AgentProfilePoolGetErrors, ThrowOnError>;
/**
 * Update Agent Profile Pool
 *
 * Update an existing agent profile pool
 */
declare const agentProfilePoolUpdate: <ThrowOnError extends boolean = false>(options: Options<AgentProfilePoolUpdateData, ThrowOnError>) => RequestResult<AgentProfilePoolUpdateResponses, AgentProfilePoolUpdateErrors, ThrowOnError>;
/**
 * Remove Profiles from Pool
 *
 * Remove profiles from a pool
 */
declare const agentProfilePoolMembersRemove: <ThrowOnError extends boolean = false>(options: Options<AgentProfilePoolMembersRemoveData, ThrowOnError>) => RequestResult<AgentProfilePoolMembersRemoveResponses, AgentProfilePoolMembersRemoveErrors, ThrowOnError>;
/**
 * List Pool Members
 *
 * List all profiles in a pool
 */
declare const agentProfilePoolMembersList: <ThrowOnError extends boolean = false>(options: Options<AgentProfilePoolMembersListData, ThrowOnError>) => RequestResult<AgentProfilePoolMembersListResponses, AgentProfilePoolMembersListErrors, ThrowOnError>;
/**
 * Add Profiles to Pool
 *
 * Add profiles to a pool
 */
declare const agentProfilePoolMembersAdd: <ThrowOnError extends boolean = false>(options: Options<AgentProfilePoolMembersAddData, ThrowOnError>) => RequestResult<AgentProfilePoolMembersAddResponses, AgentProfilePoolMembersAddErrors, ThrowOnError>;
/**
 * List Agent Profiles
 *
 * List all agent profiles for an organization
 */
declare const agentProfilesList: <ThrowOnError extends boolean = false>(options?: Options<AgentProfilesListData, ThrowOnError>) => RequestResult<AgentProfilesListResponses, AgentProfilesListErrors, ThrowOnError>;
/**
 * Create Agent Profile
 *
 * Create a new agent profile
 */
declare const agentProfilesCreate: <ThrowOnError extends boolean = false>(options: Options<AgentProfilesCreateData, ThrowOnError>) => RequestResult<AgentProfilesCreateResponses, AgentProfilesCreateErrors, ThrowOnError>;
/**
 * Delete Agent Profile
 *
 * Delete an agent profile
 */
declare const agentProfileDelete: <ThrowOnError extends boolean = false>(options: Options<AgentProfileDeleteData, ThrowOnError>) => RequestResult<AgentProfileDeleteResponses, AgentProfileDeleteErrors, ThrowOnError>;
/**
 * Get Agent Profile
 *
 * Get an agent profile by ID
 */
declare const agentProfileGet: <ThrowOnError extends boolean = false>(options: Options<AgentProfileGetData, ThrowOnError>) => RequestResult<AgentProfileGetResponses, AgentProfileGetErrors, ThrowOnError>;
/**
 * Update Agent Profile
 *
 * Update an existing agent profile
 */
declare const agentProfileUpdate: <ThrowOnError extends boolean = false>(options: Options<AgentProfileUpdateData, ThrowOnError>) => RequestResult<AgentProfileUpdateResponses, AgentProfileUpdateErrors, ThrowOnError>;
/**
 * Clear Browser Cache
 *
 * Clears the browser profile/cache for the specified agent profile by deleting its browser profile
 */
declare const agentProfileClearBrowserCache: <ThrowOnError extends boolean = false>(options: Options<AgentProfileClearBrowserCacheData, ThrowOnError>) => RequestResult<AgentProfileClearBrowserCacheResponses, AgentProfileClearBrowserCacheErrors, ThrowOnError>;
/**
 * Duplicate Agent Profile
 *
 * Duplicate an agent profile with all settings, credentials, and cookies
 */
declare const agentProfileDuplicate: <ThrowOnError extends boolean = false>(options: Options<AgentProfileDuplicateData, ThrowOnError>) => RequestResult<AgentProfileDuplicateResponses, AgentProfileDuplicateErrors, ThrowOnError>;
/**
 * Get Agent Profile Inbox Emails
 *
 * List emails in the agent profile's inbox
 */
declare const agentProfileGetInboxEmails: <ThrowOnError extends boolean = false>(options: Options<AgentProfileGetInboxEmailsData, ThrowOnError>) => RequestResult<AgentProfileGetInboxEmailsResponses, AgentProfileGetInboxEmailsErrors, ThrowOnError>;
/**
 * Get Agent Profile Inbox Email
 *
 * Get a single email from the agent profile's inbox by ID
 */
declare const agentProfileGetInboxEmail: <ThrowOnError extends boolean = false>(options: Options<AgentProfileGetInboxEmailData, ThrowOnError>) => RequestResult<AgentProfileGetInboxEmailResponses, AgentProfileGetInboxEmailErrors, ThrowOnError>;
/**
 * List Agents
 *
 * List all agents for an organization
 */
declare const agentList: <ThrowOnError extends boolean = false>(options?: Options<AgentListData, ThrowOnError>) => RequestResult<AgentListResponses, AgentListErrors, ThrowOnError>;
/**
 * Create agent
 *
 * Create an agent and its initial workflow.
 */
declare const agentCreate: <ThrowOnError extends boolean = false>(options: Options<AgentCreateData, ThrowOnError>) => RequestResult<AgentCreateResponses, AgentCreateErrors, ThrowOnError>;
/**
 * List Available Tools
 *
 * List all available tools/capabilities for AI Task nodes in workflows
 */
declare const availableToolsList: <ThrowOnError extends boolean = false>(options?: Options<AvailableToolsListData, ThrowOnError>) => RequestResult<AvailableToolsListResponses, AvailableToolsListErrors, ThrowOnError>;
/**
 * Delete an agent
 *
 * Deletes an agent. Only allowed when all executions are in terminal status (completed, cancelled, or failed).
 */
declare const agentByIdDelete: <ThrowOnError extends boolean = false>(options: Options<AgentByIdDeleteData, ThrowOnError>) => RequestResult<AgentByIdDeleteResponses, AgentByIdDeleteErrors, ThrowOnError>;
/**
 * Update agent
 *
 * Update mutable agent fields.
 */
declare const agentByIdUpdate: <ThrowOnError extends boolean = false>(options: Options<AgentByIdUpdateData, ThrowOnError>) => RequestResult<AgentByIdUpdateResponses, AgentByIdUpdateErrors, ThrowOnError>;
/**
 * Execute an agent
 *
 * Start an execution for the given agent.
 */
declare const agentExecutePost: <ThrowOnError extends boolean = false>(options: Options<AgentExecutePostData, ThrowOnError>) => RequestResult<AgentExecutePostResponses, AgentExecutePostErrors, ThrowOnError>;
/**
 * Get workflow head files
 *
 * Get the editable head rendered as a directory of files. Structural files carry inline content; user agent files are referenced by id. The returned `rev` can be supplied as `baseRev` to patch without a second fetch.
 */
declare const agentWorkflowHeadGetFiles: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowHeadGetFilesData, ThrowOnError>) => RequestResult<AgentWorkflowHeadGetFilesResponses, AgentWorkflowHeadGetFilesErrors, ThrowOnError>;
/**
 * Patch workflow head files
 *
 * Patch the editable head's file representation in place: apply file writes/deletes, re-derive the structured workflow, and persist it. Structural files re-derive the graph; agent files go to the blob store. Agent-file writes overlay the current head even when baseRev is stale. Structural-file writes still require a matching baseRev. When the head is frozen (published or executed) the edit forks a fresh version behind the scenes.
 */
declare const agentWorkflowHeadPatchFiles: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowHeadPatchFilesData, ThrowOnError>) => RequestResult<AgentWorkflowHeadPatchFilesResponses, AgentWorkflowHeadPatchFilesErrors, ThrowOnError>;
/**
 * Publish workflow head
 *
 * Publish the editable head, assigning it as the agent's published version
 */
declare const agentWorkflowHeadPublishHead: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowHeadPublishHeadData, ThrowOnError>) => RequestResult<AgentWorkflowHeadPublishHeadResponses, AgentWorkflowHeadPublishHeadErrors, ThrowOnError>;
/**
 * List workflow references
 *
 * List all workflows for an agent with lightweight metadata (IDs, parents, versions)
 */
declare const agentWorkflowsList: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowsListData, ThrowOnError>) => RequestResult<AgentWorkflowsListResponses, AgentWorkflowsListErrors, ThrowOnError>;
/**
 * Create workflow
 *
 * Create a new unpublished workflow for an agent
 */
declare const agentWorkflowsCreate: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowsCreateData, ThrowOnError>) => RequestResult<AgentWorkflowsCreateResponses, AgentWorkflowsCreateErrors, ThrowOnError>;
/**
 * Validate workflow
 *
 * Validate a workflow spec for an existing agent without persisting it, returning blocking errors and advisory warnings
 */
declare const agentWorkflowsValidate: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowsValidateData, ThrowOnError>) => RequestResult<AgentWorkflowsValidateResponses, AgentWorkflowsValidateErrors, ThrowOnError>;
/**
 * Delete workflow
 *
 * Delete an unpublished workflow that has no executions
 */
declare const agentWorkflowsDeleteWorkflow: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowsDeleteWorkflowData, ThrowOnError>) => RequestResult<AgentWorkflowsDeleteWorkflowResponses, AgentWorkflowsDeleteWorkflowErrors, ThrowOnError>;
/**
 * Get workflow by ID
 *
 * Get a workflow by its ID. `files` is this version's manifest — file edits create a new version, so fetch the id returned by the agent-files endpoints to see the updated list.
 */
declare const agentWorkflowsGet: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowsGetData, ThrowOnError>) => RequestResult<AgentWorkflowsGetResponses, AgentWorkflowsGetErrors, ThrowOnError>;
/**
 * Execute workflow
 *
 * Execute a workflow by its ID (can be published or unpublished)
 */
declare const agentWorkflowsExecute: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowsExecuteData, ThrowOnError>) => RequestResult<AgentWorkflowsExecuteResponses, AgentWorkflowsExecuteErrors, ThrowOnError>;
/**
 * Get workflow version files
 *
 * Get a workflow version rendered as a directory of files. Structural files carry inline content; user agent files are referenced by id.
 */
declare const agentWorkflowsGetFilesByVersion: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowsGetFilesByVersionData, ThrowOnError>) => RequestResult<AgentWorkflowsGetFilesByVersionResponses, AgentWorkflowsGetFilesByVersionErrors, ThrowOnError>;
/**
 * Get workflow inputs
 *
 * Get the input variable names a workflow accepts at execution time
 */
declare const agentWorkflowsGetInputs: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowsGetInputsData, ThrowOnError>) => RequestResult<AgentWorkflowsGetInputsResponses, AgentWorkflowsGetInputsErrors, ThrowOnError>;
/**
 * Get workflow output schemas
 *
 * Get the output schemas configured for a workflow's output nodes, keyed by output node name
 */
declare const agentWorkflowsGetOutputSchemas: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowsGetOutputSchemasData, ThrowOnError>) => RequestResult<AgentWorkflowsGetOutputSchemasResponses, AgentWorkflowsGetOutputSchemasErrors, ThrowOnError>;
/**
 * Publish workflow
 *
 * Publish an unpublished workflow, assigning it a version number
 */
declare const agentWorkflowsPublish: <ThrowOnError extends boolean = false>(options: Options<AgentWorkflowsPublishData, ThrowOnError>) => RequestResult<AgentWorkflowsPublishResponses, AgentWorkflowsPublishErrors, ThrowOnError>;
/**
 * Get Context
 *
 * Get the current user's context including organization memberships
 */
declare const contextGet: <ThrowOnError extends boolean = false>(options?: Options<ContextGetData, ThrowOnError>) => RequestResult<ContextGetResponses, ContextGetErrors, ThrowOnError>;
/**
 * Search documentation
 *
 * Search Asteroid documentation for guides on building agents, node types, and best practices
 */
declare const docsSearchSearch: <ThrowOnError extends boolean = false>(options: Options<DocsSearchSearchData, ThrowOnError>) => RequestResult<DocsSearchSearchResponses, DocsSearchSearchErrors, ThrowOnError>;
/**
 * List executions
 *
 * List executions with filtering and pagination
 */
declare const executionsList: <ThrowOnError extends boolean = false>(options?: Options<ExecutionsListData, ThrowOnError>) => RequestResult<ExecutionsListResponses, ExecutionsListErrors, ThrowOnError>;
/**
 * Get execution
 *
 * Get a single execution by ID with all details
 */
declare const executionGet: <ThrowOnError extends boolean = false>(options: Options<ExecutionGetData, ThrowOnError>) => RequestResult<ExecutionGetResponses, ExecutionGetErrors, ThrowOnError>;
/**
 * Retrieve execution activities
 *
 * Get activities for an execution
 */
declare const executionActivitiesGet: <ThrowOnError extends boolean = false>(options: Options<ExecutionActivitiesGetData, ThrowOnError>) => RequestResult<ExecutionActivitiesGetResponses, ExecutionActivitiesGetErrors, ThrowOnError>;
/**
 * Get Agent Files
 *
 * Deprecated: Use /executions/{executionId}/files instead.
 *
 * @deprecated
 */
declare const executionAgentFilesGet: <ThrowOnError extends boolean = false>(options: Options<ExecutionAgentFilesGetData, ThrowOnError>) => RequestResult<ExecutionAgentFilesGetResponses, ExecutionAgentFilesGetErrors, ThrowOnError>;
/**
 * Download agent file
 *
 * Deprecated: Use /executions/{executionId}/files/{fileId}/download instead.
 *
 * @deprecated
 */
declare const executionAgentFileDownloadRedirect: <ThrowOnError extends boolean = false>(options: Options<ExecutionAgentFileDownloadRedirectData, ThrowOnError>) => RequestResult<unknown, ExecutionAgentFileDownloadRedirectErrors, ThrowOnError>;
/**
 * Get Execution Context Files
 *
 * Get all context files attached to an execution
 */
declare const executionContextFilesGet: <ThrowOnError extends boolean = false>(options: Options<ExecutionContextFilesGetData, ThrowOnError>) => RequestResult<ExecutionContextFilesGetResponses, ExecutionContextFilesGetErrors, ThrowOnError>;
/**
 * Upload Execution Context Files
 *
 * Upload files to a running execution that is already in progress. If you want to attach files to an execution that is not yet running, see the /temp-files endpoint.
 */
declare const executionContextFilesUpload: <ThrowOnError extends boolean = false>(options: Options<ExecutionContextFilesUploadData, ThrowOnError>) => RequestResult<ExecutionContextFilesUploadResponses, ExecutionContextFilesUploadErrors, ThrowOnError>;
/**
 * Download context file
 *
 * Redirects to a short-lived signed URL for downloading the file.
 */
declare const executionContextFileDownloadRedirect: <ThrowOnError extends boolean = false>(options: Options<ExecutionContextFileDownloadRedirectData, ThrowOnError>) => RequestResult<unknown, ExecutionContextFileDownloadRedirectErrors, ThrowOnError>;
/**
 * Download debug file
 *
 * Redirects to a short-lived signed URL for downloading the file.
 */
declare const executionDebugFileDownloadRedirect: <ThrowOnError extends boolean = false>(options: Options<ExecutionDebugFileDownloadRedirectData, ThrowOnError>) => RequestResult<unknown, ExecutionDebugFileDownloadRedirectErrors, ThrowOnError>;
/**
 * Get Execution Files
 *
 * Get all files for an execution, grouped by directory. Files are tracked by the file syncer daemon during execution.
 */
declare const executionFilesGet: <ThrowOnError extends boolean = false>(options: Options<ExecutionFilesGetData, ThrowOnError>) => RequestResult<ExecutionFilesGetResponses, ExecutionFilesGetErrors, ThrowOnError>;
/**
 * Download execution file
 *
 * Redirects to a short-lived signed URL for downloading the file.
 */
declare const executionFileDownloadRedirect: <ThrowOnError extends boolean = false>(options: Options<ExecutionFileDownloadRedirectData, ThrowOnError>) => RequestResult<unknown, ExecutionFileDownloadRedirectErrors, ThrowOnError>;
/**
 * Get recording redirect
 *
 * Redirect to the recording playback URL. Returns a 307 with a short-lived signed URL. Embed this endpoint in <video> tags — the player will follow the redirect and re-fetch on expiry.
 */
declare const executionRecordingRedirect: <ThrowOnError extends boolean = false>(options: Options<ExecutionRecordingRedirectData, ThrowOnError>) => RequestResult<unknown, ExecutionRecordingRedirectErrors, ThrowOnError>;
/**
 * Update execution status
 *
 * Update the status of an execution. Use this to pause, resume, or cancel an execution.
 */
declare const executionStatusUpdate: <ThrowOnError extends boolean = false>(options: Options<ExecutionStatusUpdateData, ThrowOnError>) => RequestResult<ExecutionStatusUpdateResponses, ExecutionStatusUpdateErrors, ThrowOnError>;
/**
 * Send user message to execution
 *
 * Add a user message to an execution
 */
declare const executionUserMessagesAdd: <ThrowOnError extends boolean = false>(options: Options<ExecutionUserMessagesAddData, ThrowOnError>) => RequestResult<ExecutionUserMessagesAddResponses, ExecutionUserMessagesAddErrors, ThrowOnError>;
/**
 * Validate schema
 *
 * Validate a JSON schema against OpenAI structured output requirements
 */
declare const schemaValidationValidate: <ThrowOnError extends boolean = false>(options: Options<SchemaValidationValidateData, ThrowOnError>) => RequestResult<SchemaValidationValidateResponses, SchemaValidationValidateErrors, ThrowOnError>;
/**
 * Stage a file for an execution
 *
 * Stage a file prior to starting an execution, so that it can be used when the execution is started. See the /agents/{agentId}/execute to understand how to pass the returned file information to the execution endpoint.
 */
declare const tempFilesStage: <ThrowOnError extends boolean = false>(options: Options<TempFilesStageData, ThrowOnError>) => RequestResult<TempFilesStageResponses, TempFilesStageErrors, ThrowOnError>;
/**
 * Validate workflow spec
 *
 * Validate a workflow spec that does not belong to an agent yet, returning blocking errors and advisory warnings. The pre-agentCreate counterpart of /agents/{agentId}/workflows/validate.
 */
declare const workflowSpecValidationValidate: <ThrowOnError extends boolean = false>(options: Options<WorkflowSpecValidationValidateData, ThrowOnError>) => RequestResult<WorkflowSpecValidationValidateResponses, WorkflowSpecValidationValidateErrors, ThrowOnError>;

export { type AdminCustomerActivityListData, type AdminCustomerActivityListError, type AdminCustomerActivityListErrors, type AdminCustomerActivityListResponse, type AdminCustomerActivityListResponses, type AdminCustomerActivityNotableListData, type AdminCustomerActivityNotableListError, type AdminCustomerActivityNotableListErrors, type AdminCustomerActivityNotableListResponse, type AdminCustomerActivityNotableListResponses, type AdminCustomerActivityWindowStatsListData, type AdminCustomerActivityWindowStatsListError, type AdminCustomerActivityWindowStatsListErrors, type AdminCustomerActivityWindowStatsListResponse, type AdminCustomerActivityWindowStatsListResponses, type AgentByIdDeleteData, type AgentByIdDeleteError, type AgentByIdDeleteErrors, type AgentByIdDeleteResponse, type AgentByIdDeleteResponses, type AgentByIdUpdateData, type AgentByIdUpdateError, type AgentByIdUpdateErrors, type AgentByIdUpdateResponses, type AgentCreateData, type AgentCreateError, type AgentCreateErrors, type AgentCreateResponse, type AgentCreateResponses, type AgentExecutePostData, type AgentExecutePostError, type AgentExecutePostErrors, type AgentExecutePostResponse, type AgentExecutePostResponses, type AgentListData, type AgentListError, type AgentListErrors, type AgentListResponse, type AgentListResponses, type AgentProfileClearBrowserCacheData, type AgentProfileClearBrowserCacheError, type AgentProfileClearBrowserCacheErrors, type AgentProfileClearBrowserCacheResponse, type AgentProfileClearBrowserCacheResponses, type AgentProfileDeleteData, type AgentProfileDeleteError, type AgentProfileDeleteErrors, type AgentProfileDeleteResponse, type AgentProfileDeleteResponses, type AgentProfileDuplicateData, type AgentProfileDuplicateError, type AgentProfileDuplicateErrors, type AgentProfileDuplicateResponse, type AgentProfileDuplicateResponses, type AgentProfileGetData, type AgentProfileGetError, type AgentProfileGetErrors, type AgentProfileGetInboxEmailData, type AgentProfileGetInboxEmailError, type AgentProfileGetInboxEmailErrors, type AgentProfileGetInboxEmailResponse, type AgentProfileGetInboxEmailResponses, type AgentProfileGetInboxEmailsData, type AgentProfileGetInboxEmailsError, type AgentProfileGetInboxEmailsErrors, type AgentProfileGetInboxEmailsResponse, type AgentProfileGetInboxEmailsResponses, type AgentProfileGetResponse, type AgentProfileGetResponses, type AgentProfilePoolDeleteData, type AgentProfilePoolDeleteError, type AgentProfilePoolDeleteErrors, type AgentProfilePoolDeleteResponse, type AgentProfilePoolDeleteResponses, type AgentProfilePoolGetData, type AgentProfilePoolGetError, type AgentProfilePoolGetErrors, type AgentProfilePoolGetResponse, type AgentProfilePoolGetResponses, type AgentProfilePoolMembersAddData, type AgentProfilePoolMembersAddError, type AgentProfilePoolMembersAddErrors, type AgentProfilePoolMembersAddResponse, type AgentProfilePoolMembersAddResponses, type AgentProfilePoolMembersListData, type AgentProfilePoolMembersListError, type AgentProfilePoolMembersListErrors, type AgentProfilePoolMembersListResponse, type AgentProfilePoolMembersListResponses, type AgentProfilePoolMembersRemoveData, type AgentProfilePoolMembersRemoveError, type AgentProfilePoolMembersRemoveErrors, type AgentProfilePoolMembersRemoveResponse, type AgentProfilePoolMembersRemoveResponses, type AgentProfilePoolUpdateData, type AgentProfilePoolUpdateError, type AgentProfilePoolUpdateErrors, type AgentProfilePoolUpdateResponse, type AgentProfilePoolUpdateResponses, type AgentProfilePoolsCreateData, type AgentProfilePoolsCreateError, type AgentProfilePoolsCreateErrors, type AgentProfilePoolsCreateResponse, type AgentProfilePoolsCreateResponses, type AgentProfilePoolsListData, type AgentProfilePoolsListError, type AgentProfilePoolsListErrors, type AgentProfilePoolsListResponse, type AgentProfilePoolsListResponses, type AgentProfileUpdateData, type AgentProfileUpdateError, type AgentProfileUpdateErrors, type AgentProfileUpdateResponse, type AgentProfileUpdateResponses, type AgentProfilesCreateData, type AgentProfilesCreateError, type AgentProfilesCreateErrors, type AgentProfilesCreateResponse, type AgentProfilesCreateResponses, type AgentProfilesListData, type AgentProfilesListError, type AgentProfilesListErrors, type AgentProfilesListResponse, type AgentProfilesListResponses, type AgentWorkflowHeadGetFilesData, type AgentWorkflowHeadGetFilesError, type AgentWorkflowHeadGetFilesErrors, type AgentWorkflowHeadGetFilesResponse, type AgentWorkflowHeadGetFilesResponses, type AgentWorkflowHeadPatchFilesData, type AgentWorkflowHeadPatchFilesError, type AgentWorkflowHeadPatchFilesErrors, type AgentWorkflowHeadPatchFilesResponse, type AgentWorkflowHeadPatchFilesResponses, type AgentWorkflowHeadPublishHeadData, type AgentWorkflowHeadPublishHeadError, type AgentWorkflowHeadPublishHeadErrors, type AgentWorkflowHeadPublishHeadResponse, type AgentWorkflowHeadPublishHeadResponses, type AgentWorkflowsCreateData, type AgentWorkflowsCreateError, type AgentWorkflowsCreateErrors, type AgentWorkflowsCreateResponse, type AgentWorkflowsCreateResponses, type AgentWorkflowsDeleteWorkflowData, type AgentWorkflowsDeleteWorkflowError, type AgentWorkflowsDeleteWorkflowErrors, type AgentWorkflowsDeleteWorkflowResponse, type AgentWorkflowsDeleteWorkflowResponses, type AgentWorkflowsExecuteData, type AgentWorkflowsExecuteError, type AgentWorkflowsExecuteErrors, type AgentWorkflowsExecuteResponse, type AgentWorkflowsExecuteResponses, type AgentWorkflowsGetData, type AgentWorkflowsGetError, type AgentWorkflowsGetErrors, type AgentWorkflowsGetFilesByVersionData, type AgentWorkflowsGetFilesByVersionError, type AgentWorkflowsGetFilesByVersionErrors, type AgentWorkflowsGetFilesByVersionResponse, type AgentWorkflowsGetFilesByVersionResponses, type AgentWorkflowsGetInputsData, type AgentWorkflowsGetInputsError, type AgentWorkflowsGetInputsErrors, type AgentWorkflowsGetInputsResponse, type AgentWorkflowsGetInputsResponses, type AgentWorkflowsGetOutputSchemasData, type AgentWorkflowsGetOutputSchemasError, type AgentWorkflowsGetOutputSchemasErrors, type AgentWorkflowsGetOutputSchemasResponse, type AgentWorkflowsGetOutputSchemasResponses, type AgentWorkflowsGetResponse, type AgentWorkflowsGetResponses, type AgentWorkflowsListData, type AgentWorkflowsListError, type AgentWorkflowsListErrors, type AgentWorkflowsListResponse, type AgentWorkflowsListResponses, type AgentWorkflowsPublishData, type AgentWorkflowsPublishError, type AgentWorkflowsPublishErrors, type AgentWorkflowsPublishResponse, type AgentWorkflowsPublishResponses, type AgentWorkflowsValidateData, type AgentWorkflowsValidateError, type AgentWorkflowsValidateErrors, type AgentWorkflowsValidateResponse, type AgentWorkflowsValidateResponses, type AgentsAgentAgentDuplicateRequest, type AgentsAgentAgentDuplicateResponse, type AgentsAgentAvailableTool, type AgentsAgentAvailableToolsResponse, type AgentsAgentBase, type AgentsAgentCreateResponse, type AgentsAgentExecuteAgentRequest, type AgentsAgentExecuteAgentResponse, type AgentsAgentExecutionOptions, type AgentsAgentExecutionStats, type AgentsAgentExecutionSummary, type AgentsAgentExternalCreateRequest, type AgentsAgentExternalDetail, type AgentsAgentOnCapacityLimit, type AgentsAgentSearch, type AgentsAgentSortField, type AgentsAgentTimeSeriesDataPoint, type AgentsAgentUpdateRequest, type AgentsAgentWorkflowVersionMetadata, type AgentsContextUserContextResponse, type AgentsContextUserOrganization, type AgentsCustomerActivityCustomerActivityList, type AgentsCustomerActivityCustomerActivityRow, type AgentsCustomerActivityCustomerWindowStatsList, type AgentsCustomerActivityCustomerWindowStatsRow, type AgentsCustomerActivityNotableActivityKind, type AgentsCustomerActivityNotableActivityList, type AgentsCustomerActivityNotableActivityRow, type AgentsCustomerActivityOrgWindowStat, type AgentsCustomerActivityRiskLevel, type AgentsDocsSearchDocsRequest, type AgentsDocsSearchDocsResponse, type AgentsDocsSearchResult, type AgentsEnvironmentAstroEnvironmentOwner, type AgentsEnvironmentEnvironment, type AgentsEnvironmentEnvironmentConnection, type AgentsEnvironmentEnvironmentLifecycle, type AgentsEnvironmentEnvironmentOwner, type AgentsEnvironmentEnvironmentSource, type AgentsEnvironmentEnvironmentStatus, type AgentsEnvironmentEnvironmentSummary, type AgentsEnvironmentExecutionEnvironmentOwner, type AgentsEnvironmentExplicitEnvironmentSource, type AgentsEnvironmentExternalEnvironmentOwner, type AgentsEnvironmentListEnvironmentsResponse, type AgentsEnvironmentOrganizationEnvironmentOwner, type AgentsEnvironmentSpecBrowserTemplate, type AgentsEnvironmentSpecEnvironmentTemplate, type AgentsEnvironmentSpecOsTemplate, type AgentsEnvironmentStartEnvironmentRequest, type AgentsEnvironmentWarmPoolEnvironmentOwner, type AgentsEnvironmentWorkflowEnvironmentSource, type AgentsExecutionActionName, type AgentsExecutionActivity, type AgentsExecutionActivityActionCompletedInfo, type AgentsExecutionActivityActionCompletedPayload, type AgentsExecutionActivityActionFailedPayload, type AgentsExecutionActivityActionStartedInfo, type AgentsExecutionActivityActionStartedPayload, type AgentsExecutionActivityCompactionPerformedPayload, type AgentsExecutionActivityCompactionStartedPayload, type AgentsExecutionActivityDisplay, type AgentsExecutionActivityFileAddedPayload, type AgentsExecutionActivityGenericPayload, type AgentsExecutionActivityInputSchemaResolvedPayload, type AgentsExecutionActivityOutputSchemaResolvedPayload, type AgentsExecutionActivityPayloadUnion, type AgentsExecutionActivityPlaywrightScriptGeneratedPayload, type AgentsExecutionActivityPresentationLevel, type AgentsExecutionActivityReasoningPayload, type AgentsExecutionActivityScriptVariablesSubstitutedPayload, type AgentsExecutionActivityStatusChangedPayload, type AgentsExecutionActivityStepCompletedPayload, type AgentsExecutionActivityStepStartedPayload, type AgentsExecutionActivityTodosUpdatedPayload, type AgentsExecutionActivityTransitionedNodePayload, type AgentsExecutionActivityUserMessageReceivedPayload, type AgentsExecutionAgentQueryContextCompletedDetails, type AgentsExecutionAgentQueryContextStartedDetails, type AgentsExecutionAnchorProviderConfig, type AgentsExecutionApiKeyRef, type AgentsExecutionApiTriggerContext, type AgentsExecutionAskUserQuestion, type AgentsExecutionAwaitingConfirmationPayload, type AgentsExecutionBatchBase, type AgentsExecutionBatchBatchConfig, type AgentsExecutionBatchBatchItem, type AgentsExecutionBatchCreateRequest, type AgentsExecutionBatchListFilterAgentId, type AgentsExecutionBatchListFilterStatus, type AgentsExecutionBatchMaxConcurrentConfig, type AgentsExecutionBatchStatus, type AgentsExecutionBatchTimeBatchingConfig, type AgentsExecutionBrowserProviderConfig, type AgentsExecutionBrowserRunCodeCompletedDetails, type AgentsExecutionBrowserRunCodeStartedDetails, type AgentsExecutionBrowserState, type AgentsExecutionCancelReason, type AgentsExecutionCancelledPayload, type AgentsExecutionComment, type AgentsExecutionCompletedPayload, type AgentsExecutionDaytonaProviderConfig, type AgentsExecutionElementFileUploadCompletedDetails, type AgentsExecutionEnvironmentState, type AgentsExecutionExecutionAggregates, type AgentsExecutionExecutionOutcomeCounts, type AgentsExecutionExecutionResult, type AgentsExecutionExtApiCallCompletedDetails, type AgentsExecutionExtGetMailCompletedDetails, type AgentsExecutionExtSendMailCompletedDetails, type AgentsExecutionExtSendMailStartedDetails, type AgentsExecutionFailedPayload, type AgentsExecutionFileListCompletedDetails, type AgentsExecutionFileReadCompletedDetails, type AgentsExecutionFileStageCompletedDetails, type AgentsExecutionHandoffPrepareCompletedDetails, type AgentsExecutionHandoffPrepareStartedDetails, type AgentsExecutionHandoffPrepareVariable, type AgentsExecutionHumanLabel, type AgentsExecutionInputResolutionSource, type AgentsExecutionListItem, type AgentsExecutionLlmCallPurpose, type AgentsExecutionLlmCallStartedDetails, type AgentsExecutionNavToCompletedDetails, type AgentsExecutionNavToStartedDetails, type AgentsExecutionNodeOutputItem, type AgentsExecutionObsSnapshotWithSelectorsCompletedDetails, type AgentsExecutionOsState, type AgentsExecutionOutcomeCount, type AgentsExecutionPausedPayload, type AgentsExecutionPhase, type AgentsExecutionQuestionItem, type AgentsExecutionQuestionOption, type AgentsExecutionReadFileCompletedDetails, type AgentsExecutionReadFileStartedDetails, type AgentsExecutionScheduleRef, type AgentsExecutionScheduleTriggerContext, type AgentsExecutionScratchpadReadCompletedDetails, type AgentsExecutionScratchpadReadStartedDetails, type AgentsExecutionScratchpadWriteCompletedDetails, type AgentsExecutionScratchpadWriteStartedDetails, type AgentsExecutionScriptEvalCompletedDetails, type AgentsExecutionScriptEvalStartedDetails, type AgentsExecutionScriptFailure, type AgentsExecutionScriptHybridPlaywrightCompletedDetails, type AgentsExecutionScriptHybridPlaywrightStartedDetails, type AgentsExecutionScriptPadRunFunctionCompletedDetails, type AgentsExecutionScriptPlaywrightCompletedDetails, type AgentsExecutionScriptPlaywrightStartedDetails, type AgentsExecutionScriptpadReadCompletedDetails, type AgentsExecutionScriptpadReadStartedDetails, type AgentsExecutionScriptpadRunFunctionStartedDetails, type AgentsExecutionScriptpadSearchReplaceCompletedDetails, type AgentsExecutionScriptpadSearchReplaceStartedDetails, type AgentsExecutionScriptpadWriteCompletedDetails, type AgentsExecutionSdkBashCompletedDetails, type AgentsExecutionSdkBashStartedDetails, type AgentsExecutionSdkEditCompletedDetails, type AgentsExecutionSdkEditStartedDetails, type AgentsExecutionSdkGlobCompletedDetails, type AgentsExecutionSdkGlobStartedDetails, type AgentsExecutionSdkGrepCompletedDetails, type AgentsExecutionSdkGrepStartedDetails, type AgentsExecutionSdkReadCompletedDetails, type AgentsExecutionSdkReadStartedDetails, type AgentsExecutionSdkSkillCompletedDetails, type AgentsExecutionSdkSkillStartedDetails, type AgentsExecutionSdkWriteCompletedDetails, type AgentsExecutionSdkWriteStartedDetails, type AgentsExecutionSearchAgentId, type AgentsExecutionSearchAgentProfileIds, type AgentsExecutionSearchCreatedAfter, type AgentsExecutionSearchCreatedBefore, type AgentsExecutionSearchExecutionId, type AgentsExecutionSearchHasScriptFailures, type AgentsExecutionSearchHumanLabels, type AgentsExecutionSearchInputsKey, type AgentsExecutionSearchInputsValue, type AgentsExecutionSearchMetadataKey, type AgentsExecutionSearchMetadataValue, type AgentsExecutionSearchOutcomeLabel, type AgentsExecutionSearchPhase, type AgentsExecutionSearchStatus, type AgentsExecutionSearchTriggerSource, type AgentsExecutionSearchWorkflowVersion, type AgentsExecutionSortField, type AgentsExecutionStatus, type AgentsExecutionStatusCounts, type AgentsExecutionSteelProviderConfig, type AgentsExecutionTerminalPayload, type AgentsExecutionTodo, type AgentsExecutionTodoStatus, type AgentsExecutionTriggerContext, type AgentsExecutionTriggerRunner, type AgentsExecutionUiTriggerContext, type AgentsExecutionUpdateExecutionStatusRequest, type AgentsExecutionUpdateableStatus, type AgentsExecutionUserMessagesAddTextBody, type AgentsExecutionUtilGetDatetimeCompletedDetails, type AgentsExecutionUtilGetDatetimeStartedDetails, type AgentsExecutionWarmupTriggerContext, type AgentsFilesAgentFile, type AgentsFilesAgentFileCreatedBy, type AgentsFilesAgentFileDirectory, type AgentsFilesAgentFilesDirectoryListing, type AgentsFilesAgentFilesResponse, type AgentsFilesFile, type AgentsFilesFilePart, type AgentsFilesSignedUrlResponse, type AgentsFilesTempFile, type AgentsFilesTempFilesResponse, type AgentsGraphModelsAgentGraph, type AgentsGraphModelsExternalSettings, type AgentsGraphModelsNodesNode, type AgentsGraphModelsNodesNodePropertiesUnion, type AgentsGraphModelsNodesNodeType, type AgentsGraphModelsNodesPosition, type AgentsGraphModelsNodesPropertiesApiMethod, type AgentsGraphModelsNodesPropertiesApiProperties, type AgentsGraphModelsNodesPropertiesIrisPlaywrightScriptProperties, type AgentsGraphModelsNodesPropertiesIrisProperties, type AgentsGraphModelsNodesPropertiesNodeCapabilities, type AgentsGraphModelsNodesPropertiesOutcomeString, type AgentsGraphModelsNodesPropertiesOutputProperties, type AgentsGraphModelsNodesPropertiesPlaywrightScriptLlmVar, type AgentsGraphModelsNodesPropertiesPlaywrightScriptLlmVarType, type AgentsGraphModelsNodesPropertiesPlaywrightScriptProperties, type AgentsGraphModelsNodesPropertiesStartProperties, type AgentsGraphModelsNodesPropertiesUrlProperties, type AgentsGraphModelsNodesSize, type AgentsGraphModelsStickyNote, type AgentsGraphModelsTransitionsPropertiesIrisProperties, type AgentsGraphModelsTransitionsPropertiesOutcomeSuccessProperties, type AgentsGraphModelsTransitionsPropertiesSelectorProperties, type AgentsGraphModelsTransitionsTransition, type AgentsGraphModelsTransitionsTransitionPropertiesUnion, type AgentsGraphModelsTransitionsTransitionType, type AgentsModelsModelMetadata, type AgentsModelsModelProvider, type AgentsModelsModelsResponse, type AgentsProfileAddProfilesToPoolRequest, type AgentsProfileAgentProfile, type AgentsProfileAgentProfileInboxEmailsResponse, type AgentsProfileAgentProfilePool, type AgentsProfileAgentProfilePoolMember, type AgentsProfileAgentProfileVaultItemFieldRef, type AgentsProfileAgentProfileVaultItemRef, type AgentsProfileCookie, type AgentsProfileCountryCode, type AgentsProfileCreateAgentProfilePoolRequest, type AgentsProfileCreateAgentProfileRequest, type AgentsProfileCredential, type AgentsProfileCredentialUpdate, type AgentsProfileCustomProxyConfigInput, type AgentsProfileCustomProxyConfigOutput, type AgentsProfileDuplicateAgentProfileRequest, type AgentsProfileFeature, type AgentsProfileFingerprintIdInput, type AgentsProfileOperatingSystem, type AgentsProfilePoolSearch, type AgentsProfilePoolSortField, type AgentsProfileProfileInboxEmail, type AgentsProfileProfileInboxEmailDetail, type AgentsProfileProxyMode, type AgentsProfileProxyType, type AgentsProfileRemoveProfilesFromPoolRequest, type AgentsProfileSameSite, type AgentsProfileSearchFeature, type AgentsProfileSearchOperatingSystem, type AgentsProfileSearchProxyMode, type AgentsProfileSearchSearchName, type AgentsProfileSelectionStrategy, type AgentsProfileSortField, type AgentsProfileUpdateAgentProfilePoolRequest, type AgentsProfileUpdateAgentProfileRequest, type AgentsScheduleBase, type AgentsScheduleBatchSource, type AgentsScheduleCreateRequest, type AgentsScheduleUpdateRequest, type AgentsScheduledExecutionBase, type AgentsScheduledExecutionCreateRequest, type AgentsScheduledExecutionListFilterAgentId, type AgentsScheduledExecutionListFilterBatchId, type AgentsScheduledExecutionListFilterOrder, type AgentsScheduledExecutionListFilterStatus, type AgentsScheduledExecutionListFilterWorkflowId, type AgentsScheduledExecutionRescheduleRequest, type AgentsScheduledExecutionStatus, type AgentsSchemaValidateSchemaRequest, type AgentsSchemaValidateSchemaResponse, type AgentsTagAgentWorkflowTagName, type AgentsTagCreateWorkflowTagRequest, type AgentsTagPatchAgentWorkflowTagsRequest, type AgentsTagSetAgentWorkflowTagsRequest, type AgentsTagUpdateWorkflowTagGroupRequest, type AgentsTagUpdateWorkflowTagRequest, type AgentsTagWorkflowTag, type AgentsTagWorkflowTagGroup, type AgentsTagWorkflowTagProtectedGroupKey, type AgentsVaultFieldKey, type AgentsVaultFieldType, type AgentsVaultItemKey, type AgentsVaultItemKind, type AgentsWorkflowBrowserProvider, type AgentsWorkflowBrowserTemplateConfig, type AgentsWorkflowCreateWorkflowResponse, type AgentsWorkflowEnvironmentType, type AgentsWorkflowExecuteWorkflowRequest, type AgentsWorkflowExecuteWorkflowResponse, type AgentsWorkflowExternalCreateWorkflowRequest, type AgentsWorkflowExternalEnvironmentTemplate, type AgentsWorkflowExternalOsTemplateConfig, type AgentsWorkflowExternalWorkflowSnapshot, type AgentsWorkflowInput, type AgentsWorkflowOsProvider, type AgentsWorkflowOsRegion, type AgentsWorkflowOsType, type AgentsWorkflowPublishWorkflowResponse, type AgentsWorkflowRevertWorkflowHeadRequest, type AgentsWorkflowWorkflowFile, type AgentsWorkflowWorkflowFileContentsMode, type AgentsWorkflowWorkflowFileEntry, type AgentsWorkflowWorkflowFileKind, type AgentsWorkflowWorkflowFileTree, type AgentsWorkflowWorkflowFileWrite, type AgentsWorkflowWorkflowFilesPatchRequest, type AgentsWorkflowWorkflowInputs, type AgentsWorkflowWorkflowOutputSchemas, type AgentsWorkflowWorkflowRef, type AgentsWorkflowWorkflowValidationIssue, type AgentsWorkflowWorkflowValidationResponse, type AgentsWorkflowWorkflowValidationSeverity, type AvailableToolsListData, type AvailableToolsListError, type AvailableToolsListErrors, type AvailableToolsListResponse, type AvailableToolsListResponses, type ClientOptions, type CommonBadRequestErrorBody, type CommonConflictErrorBody, type CommonError, type CommonForbiddenErrorBody, type CommonInternalServerErrorBody, type CommonNotFoundErrorBody, type CommonOsError, type CommonPaginationPage, type CommonPaginationPageSize, type CommonPaymentRequiredErrorBody, type CommonSortDirection, type CommonTooManyRequestsErrorBody, type CommonUnauthorizedErrorBody, type CommonUuid, type ContextGetData, type ContextGetError, type ContextGetErrors, type ContextGetResponse, type ContextGetResponses, type CreateClientConfig, type DocsSearchSearchData, type DocsSearchSearchError, type DocsSearchSearchErrors, type DocsSearchSearchResponse, type DocsSearchSearchResponses, type ExecutionActivitiesGetData, type ExecutionActivitiesGetError, type ExecutionActivitiesGetErrors, type ExecutionActivitiesGetResponse, type ExecutionActivitiesGetResponses, type ExecutionAgentFileDownloadRedirectData, type ExecutionAgentFileDownloadRedirectError, type ExecutionAgentFileDownloadRedirectErrors, type ExecutionAgentFilesGetData, type ExecutionAgentFilesGetError, type ExecutionAgentFilesGetErrors, type ExecutionAgentFilesGetResponse, type ExecutionAgentFilesGetResponses, type ExecutionContextFileDownloadRedirectData, type ExecutionContextFileDownloadRedirectError, type ExecutionContextFileDownloadRedirectErrors, type ExecutionContextFilesGetData, type ExecutionContextFilesGetError, type ExecutionContextFilesGetErrors, type ExecutionContextFilesGetResponse, type ExecutionContextFilesGetResponses, type ExecutionContextFilesUploadData, type ExecutionContextFilesUploadError, type ExecutionContextFilesUploadErrors, type ExecutionContextFilesUploadResponse, type ExecutionContextFilesUploadResponses, type ExecutionDebugFileDownloadRedirectData, type ExecutionDebugFileDownloadRedirectError, type ExecutionDebugFileDownloadRedirectErrors, type ExecutionFileDownloadRedirectData, type ExecutionFileDownloadRedirectError, type ExecutionFileDownloadRedirectErrors, type ExecutionFilesGetData, type ExecutionFilesGetError, type ExecutionFilesGetErrors, type ExecutionFilesGetResponse, type ExecutionFilesGetResponses, type ExecutionGetData, type ExecutionGetError, type ExecutionGetErrors, type ExecutionGetResponse, type ExecutionGetResponses, type ExecutionRecordingRedirectData, type ExecutionRecordingRedirectError, type ExecutionRecordingRedirectErrors, type ExecutionStatusUpdateData, type ExecutionStatusUpdateError, type ExecutionStatusUpdateErrors, type ExecutionStatusUpdateResponse, type ExecutionStatusUpdateResponses, type ExecutionUserMessagesAddData, type ExecutionUserMessagesAddError, type ExecutionUserMessagesAddErrors, type ExecutionUserMessagesAddResponse, type ExecutionUserMessagesAddResponses, type ExecutionsListData, type ExecutionsListError, type ExecutionsListErrors, type ExecutionsListResponse, type ExecutionsListResponses, type Options, type SchemaValidationValidateData, type SchemaValidationValidateError, type SchemaValidationValidateErrors, type SchemaValidationValidateResponse, type SchemaValidationValidateResponses, type TempFilesStageData, type TempFilesStageError, type TempFilesStageErrors, type TempFilesStageResponse, type TempFilesStageResponses, type Version, type WorkflowSpecValidationValidateData, type WorkflowSpecValidationValidateError, type WorkflowSpecValidationValidateErrors, type WorkflowSpecValidationValidateResponse, type WorkflowSpecValidationValidateResponses, adminCustomerActivityList, adminCustomerActivityNotableList, adminCustomerActivityWindowStatsList, agentByIdDelete, agentByIdUpdate, agentCreate, agentExecutePost, agentList, agentProfileClearBrowserCache, agentProfileDelete, agentProfileDuplicate, agentProfileGet, agentProfileGetInboxEmail, agentProfileGetInboxEmails, agentProfilePoolDelete, agentProfilePoolGet, agentProfilePoolMembersAdd, agentProfilePoolMembersList, agentProfilePoolMembersRemove, agentProfilePoolUpdate, agentProfilePoolsCreate, agentProfilePoolsList, agentProfileUpdate, agentProfilesCreate, agentProfilesList, agentWorkflowHeadGetFiles, agentWorkflowHeadPatchFiles, agentWorkflowHeadPublishHead, agentWorkflowsCreate, agentWorkflowsDeleteWorkflow, agentWorkflowsExecute, agentWorkflowsGet, agentWorkflowsGetFilesByVersion, agentWorkflowsGetInputs, agentWorkflowsGetOutputSchemas, agentWorkflowsList, agentWorkflowsPublish, agentWorkflowsValidate, availableToolsList, client, contextGet, docsSearchSearch, executionActivitiesGet, executionAgentFileDownloadRedirect, executionAgentFilesGet, executionContextFileDownloadRedirect, executionContextFilesGet, executionContextFilesUpload, executionDebugFileDownloadRedirect, executionFileDownloadRedirect, executionFilesGet, executionGet, executionRecordingRedirect, executionStatusUpdate, executionUserMessagesAdd, executionsList, schemaValidationValidate, tempFilesStage, workflowSpecValidationValidate };