import { APIResource } from "../core/resource.js";
import * as Shared from "./shared.js";
import * as CompletionsAPI from "./chat/completions.js";
import { APIPromise } from "../core/api-promise.js";
import { CursorPage, type CursorPageParams, PagePromise } from "../core/pagination.js";
import { RequestOptions } from "../internal/request-options.js";
export declare class Deploy extends APIResource {
    /**
     * Deploy a successfully built agent image to Kubernetes as a Helm release.
     *
     * Takes a completed build (referenced by `build_id`, or by `image_name` +
     * `image_tag`) together with the agent manifest and environment config, then
     * starts an asynchronous Temporal workflow that provisions the agent as a Helm
     * release. The call returns immediately with the deployment record in `PENDING`
     * status — it does not wait for the release to become healthy; poll
     * `GET /v5/agentex/deployments/{deployment_id}` for status and Kubernetes events
     * and `GET /v5/agentex/deployments/{deployment_id}/logs` for progress. This is the
     * deploy counterpart to `POST /v5/agentex/builds`: a build produces the container
     * image, a deployment runs that image. The referenced build must have finished
     * successfully, and the manifest's agent name must match the build's agent.
     *
     * Set `preview=True` for an ephemeral deployment: it gets a globally unique Helm
     * release name (so concurrent redeploys never collide), an optional
     * `preview_label` for grouping, and an expiry (`expires_at`, defaulting to 8 hours
     * from now); `preview_label` and `expires_at` are rejected on non-preview deploys.
     * A non-preview (production) deploy instead supersedes any prior active deployment
     * that shares its Helm release name. Fails with a client error if the build is
     * missing or not in a successful state, if the manifest or environment YAML is
     * invalid or their agent names disagree, or if a secret referenced by the manifest
     * does not exist.
     */
    create(body: DeployCreateParams, options?: RequestOptions): APIPromise<AgentexCloudDeploy>;
    /**
     * Get a single agent deployment by ID, including its current status and Kubernetes
     * events.
     *
     * Returns the deployment record with its latest status and the associated
     * Kubernetes events (`deploy_events`) observed for the release, which are useful
     * for diagnosing why a deployment is still pending or unhealthy. Poll this after
     * `POST /v5/agentex/deployments` to track the asynchronous deploy to completion.
     * For the incremental log output rather than status and events, use
     * `GET /v5/agentex/deployments/{deployment_id}/logs`. Returns 404 if no deployment
     * with this ID exists for the caller's account.
     */
    retrieve(deploymentID: string, options?: RequestOptions): APIPromise<AgentexCloudDeploy>;
    /**
     * List the account's agent deployments, with pagination and optional filters.
     *
     * Returns the deployments the caller is authorized to read. Optionally filter by
     * `build_id`, by `agent_name` (matched through each deployment's associated
     * build), or by `preview_label`. A `preview_label` is non-unique — many
     * deployments can share one (for example every deploy for a branch) — so combine
     * it with `limit=1` to fetch the latest deployment for that label. This lists
     * deployments (the running or attempted agent instances); to list the image builds
     * they run, use the agentex builds API.
     */
    list(query?: DeployListParams | null | undefined, options?: RequestOptions): PagePromise<AgentexCloudDeploysCursorPage, AgentexCloudDeploy>;
    /**
     * Delete an agent deployment and tear down its Kubernetes resources.
     *
     * Deletes the deployment's Kubernetes resources first, then marks the record as
     * `DELETED`; the underlying Helm release is subsequently uninstalled
     * asynchronously by FluxCD once the resource is removed. If the Kubernetes
     * teardown fails, the record is left unchanged and the call errors, so the delete
     * can be safely retried. Rejects the call with a client error if the deployment is
     * already in a terminal state (`DELETED`, `CANCELLED`, or `SUPERSEDED`) — a
     * `SUPERSEDED` record shares its Helm release with the deployment that replaced
     * it, so deleting it would tear down the live release. Returns 404 if no
     * deployment with this ID exists for the caller's account. This removes a running
     * deployment, not the image build behind it, which is managed separately through
     * the agentex builds API.
     */
    delete(deploymentID: string, options?: RequestOptions): APIPromise<AgentexCloudDeploy>;
    /**
     * Get structured deployment log lines, with cursor-based pagination.
     *
     * Returns the deployment's log lines in time order together with a `next_cursor`
     * and a `has_more` flag. Poll to stream logs incrementally: make the first call
     * without a cursor, then pass the previous response's `next_cursor` as `cursor` on
     * each subsequent call, stopping once the deployment reaches a terminal status.
     * Unlike `GET /v5/agentex/deployments/{deployment_id}`, which returns the
     * deployment's status and Kubernetes events, this returns the raw log output from
     * the deploy process. Returns 404 if no deployment with this ID exists for the
     * caller's account.
     */
    logs(deploymentID: string, query?: DeployLogsParams | null | undefined, options?: RequestOptions): APIPromise<DeployLogsResponse>;
}
export type AgentexCloudDeploysCursorPage = CursorPage<AgentexCloudDeploy>;
export interface AgentexCloudDeploy {
    /**
     * The unique identifier of the deployment.
     */
    id: string;
    /**
     * The ID of the account that owns the given entity.
     */
    account_id: string;
    /**
     * The date and time when the entity was created in ISO format.
     */
    created_at: string;
    /**
     * The identity that created the entity.
     */
    created_by: Shared.Identity;
    /**
     * YAML content of environment configuration from the environment config file.
     */
    environment_config: string;
    /**
     * YAML content of manifest configuration.
     */
    manifest_file: string;
    /**
     * Kubernetes namespace where the deployment is deployed.
     */
    namespace: string;
    /**
     * Deployment status: pending, running, completed, failed, or cancelled.
     */
    status: string;
    /**
     * The build_id of the cloud build that produced the deployed image.
     */
    build_id?: string;
    /**
     * Kubernetes events for this deployment.
     */
    deploy_events?: Array<AgentexCloudDeployEvent>;
    /**
     * When this deployment will be cleaned up. Always set on preview deployments
     * (defaults to 8 hours from creation if the request omits it). Null on non-preview
     * deployments — they have no TTL.
     */
    expires_at?: string;
    /**
     * Helm release name after successful deployment.
     */
    helm_release_name?: string;
    object?: 'agentex_cloud_deploy';
    /**
     * Non-unique grouping label for preview deployments. Filter
     * `?preview_label=X&limit=1` returns the latest deploy for the label. Sanitized
     * (lowercase alphanumeric + hyphens) and capped at 30 characters.
     */
    preview_label?: string;
}
/**
 * Slim event representation for the API response.
 */
export interface AgentexCloudDeployEvent {
    /**
     * Full event message.
     */
    message?: string;
    /**
     * Short reason, e.g. 'Pulling', 'Scheduled'.
     */
    reason?: string;
    /**
     * When the event was observed.
     */
    timestamp?: string;
    /**
     * Event type, e.g. 'Normal' or 'Warning'.
     */
    type?: string;
}
/**
 * Response containing structured deployment log lines with cursor-based
 * pagination.
 *
 * The CLI can poll this endpoint to stream logs incrementally:
 *
 * 1. First call: no after_id
 * 2. Subsequent calls: after_id=next_cursor from previous response
 * 3. Stop polling when has_more is False and the deployment reaches a terminal
 *    status
 */
export interface DeployLogsResponse {
    /**
     * The deployment ID
     */
    deployment_id: string;
    /**
     * True if there may be more lines beyond this page (len(lines) == limit).
     */
    has_more: boolean;
    /**
     * Structured log lines
     */
    lines?: Array<DeployLogsResponse.Line>;
    /**
     * Cursor for the next page. Pass this as the after_id query parameter to get
     * subsequent logs.
     */
    next_cursor?: string;
}
export declare namespace DeployLogsResponse {
    /**
     * A single structured log line from the deployment process.
     */
    interface Line {
        /**
         * Unique log line identifier (time-ordered)
         */
        id: string;
        /**
         * Log line content after the K8s timestamp
         */
        message: string;
        /**
         * Parsed log level (INFO, ERROR, WARN, DEBUG, FATAL)
         */
        log_level?: string;
        /**
         * Parsed K8s log timestamp
         */
        timestamp?: string;
    }
}
export interface DeployCreateParams {
    /**
     * YAML content of environment configuration from the environment config file.
     */
    environment_config: string;
    /**
     * YAML content of manifest configuration.
     */
    manifest_file: string;
    /**
     * The build_id of the cloud build. Required if image_name and image_tag are not
     * provided.
     */
    build_id?: string;
    /**
     * ISO 8601 expiry timestamp. Only valid for preview deployments. If omitted on a
     * preview deployment, defaults to 8 hours from now. Previews are always ephemeral
     * and always have an expires_at.
     */
    expires_at?: string;
    /**
     * Name of the image to deploy. Required if build_id is not provided.
     */
    image_name?: string;
    /**
     * Tag of the image to deploy. Required if build_id is not provided.
     */
    image_tag?: string;
    /**
     * When True, creates a preview deployment with a unique deployment-id suffix
     * appended to the helm release name.
     */
    preview?: boolean;
    /**
     * Non-unique grouping label for the preview (e.g. branch name, PR number).
     * Persisted on the deployment record so callers can list all deploys for a given
     * label via `GET /v5/agentex/deployments?preview_label=X&limit=1` (get the
     * latest). Sanitized to lowercase alphanumeric + hyphens for K8s DNS-label
     * compatibility (max 30 characters after sanitization). Each deploy still gets a
     * unique helm release name regardless of label, so concurrent redeploys never
     * share K8s resources. Only valid when preview=True.
     */
    preview_label?: string;
}
export interface DeployListParams extends CursorPageParams {
    /**
     * Filter deployments by agent name (via associated build)
     */
    agent_name?: string;
    /**
     * Filter deployments by build ID
     */
    build_id?: string;
    /**
     * Filter deployments by preview label (e.g. branch name). The label is non-unique
     * — many deployments can share it. Combine with limit=1 to get the latest deploy
     * for that label.
     */
    preview_label?: string;
    sort_by?: string;
    sort_order?: CompletionsAPI.SortOrder;
}
export interface DeployLogsParams {
    /**
     * Cursor from previous response's next_cursor field
     */
    cursor?: string;
    /**
     * Maximum number of log lines to return
     */
    limit?: number;
}
export declare namespace Deploy {
    export { type AgentexCloudDeploy as AgentexCloudDeploy, type AgentexCloudDeployEvent as AgentexCloudDeployEvent, type DeployLogsResponse as DeployLogsResponse, type AgentexCloudDeploysCursorPage as AgentexCloudDeploysCursorPage, type DeployCreateParams as DeployCreateParams, type DeployListParams as DeployListParams, type DeployLogsParams as DeployLogsParams, };
}
//# sourceMappingURL=deploy.d.ts.map