import * as BlockSchemasAPI from "./block-schemas/block-schemas.js";
import * as BlockTypesAPI from "./block-types/block-types.js";
/**
 * An ORM representation of a block document.
 */
export interface BlockDocument {
    /**
     * A block schema ID
     */
    block_schema_id: string;
    /**
     * A block type ID
     */
    block_type_id: string;
    id?: string;
    /**
     * Record of the block document's references
     */
    block_document_references?: Record<string, unknown>;
    /**
     * An ORM representation of a block schema.
     */
    block_schema?: BlockSchemasAPI.BlockSchema | null;
    /**
     * An ORM representation of a block type
     */
    block_type?: BlockTypesAPI.BlockType | null;
    /**
     * The associated block type's name
     */
    block_type_name?: string | null;
    created?: string | null;
    /**
     * The block document's data
     */
    data?: unknown;
    /**
     * Whether the block is anonymous (anonymous blocks are usually created by Prefect
     * automatically)
     */
    is_anonymous?: boolean;
    /**
     * The block document's name. Not required for anonymous block documents.
     */
    name?: string | null;
    updated?: string | null;
}
/**
 * An ORM representation of a concurrency limit.
 */
export interface ConcurrencyLimit {
    /**
     * The concurrency limit.
     */
    concurrency_limit: number;
    /**
     * A tag the concurrency limit is applied to.
     */
    tag: string;
    id?: string;
    /**
     * A list of active run ids using a concurrency slot
     */
    active_slots?: Array<string>;
    created?: string | null;
    updated?: string | null;
}
export interface FlowRunResponse {
    /**
     * The id of the flow being run.
     */
    flow_id: string;
    id?: string;
    /**
     * Whether or not the flow run was automatically scheduled.
     */
    auto_scheduled?: boolean;
    /**
     * Additional context for the flow run.
     */
    context?: unknown;
    created?: string | null;
    /**
     * Optional information about the creator of this flow run.
     */
    created_by?: FlowRunResponse.CreatedBy | null;
    /**
     * The id of the deployment associated with this flow run, if available.
     */
    deployment_id?: string | null;
    /**
     * The version of the deployment associated with this flow run.
     */
    deployment_version?: string | null;
    /**
     * Defines of how a flow run should retry.
     */
    empirical_policy?: FlowRunResponse.EmpiricalPolicy;
    /**
     * The actual end time.
     */
    end_time?: string | null;
    /**
     * A real-time estimate of the total run time.
     */
    estimated_run_time?: number;
    /**
     * The difference between actual and expected start time.
     */
    estimated_start_time_delta?: number;
    /**
     * The flow run's expected start time.
     */
    expected_start_time?: string | null;
    /**
     * The version of the flow executed in this flow run.
     */
    flow_version?: string | null;
    /**
     * An optional idempotency key for the flow run. Used to ensure the same flow run
     * is not created multiple times.
     */
    idempotency_key?: string | null;
    /**
     * The block document defining infrastructure to use this flow run.
     */
    infrastructure_document_id?: string | null;
    /**
     * The id of the flow run as returned by an infrastructure block.
     */
    infrastructure_pid?: string | null;
    /**
     * Variables used as overrides in the base job template
     */
    job_variables?: unknown | null;
    /**
     * The name of the flow run. Defaults to a random slug if not specified.
     */
    name?: string;
    /**
     * The next time the flow run is scheduled to start.
     */
    next_scheduled_start_time?: string | null;
    /**
     * Parameters for the flow run.
     */
    parameters?: unknown;
    /**
     * If the flow run is a subflow, the id of the 'dummy' task in the parent flow used
     * to track subflow state.
     */
    parent_task_run_id?: string | null;
    /**
     * The number of times the flow run was executed.
     */
    run_count?: number;
    /**
     * The actual start time.
     */
    start_time?: string | null;
    /**
     * Represents the state of a run.
     */
    state?: State | null;
    /**
     * The id of the flow run's current state.
     */
    state_id?: string | null;
    /**
     * The name of the current flow run state.
     */
    state_name?: string | null;
    /**
     * Enumeration of state types.
     */
    state_type?: 'SCHEDULED' | 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'CRASHED' | 'PAUSED' | 'CANCELLING' | null;
    /**
     * A list of tags on the flow run
     */
    tags?: Array<string>;
    /**
     * Total run time. If the flow run was executed multiple times, the time of each
     * run will be summed.
     */
    total_run_time?: number;
    updated?: string | null;
    /**
     * The id of the flow run's work pool.
     */
    work_pool_id?: string | null;
    /**
     * The name of the flow run's work pool.
     */
    work_pool_name?: string | null;
    /**
     * The id of the run's work pool queue.
     */
    work_queue_id?: string | null;
    /**
     * The work queue that handled this flow run.
     */
    work_queue_name?: string | null;
}
export declare namespace FlowRunResponse {
    /**
     * Optional information about the creator of this flow run.
     */
    interface CreatedBy {
        /**
         * The id of the creator of the object.
         */
        id?: string | null;
        /**
         * The display value for the creator.
         */
        display_value?: string | null;
        /**
         * The type of the creator of the object.
         */
        type?: string | null;
    }
    /**
     * Defines of how a flow run should retry.
     */
    interface EmpiricalPolicy {
        /**
         * @deprecated: The maximum number of retries. Field is not used. Please use
         * `retries` instead.
         */
        max_retries?: number;
        /**
         * Tracks pauses this run has observed.
         */
        pause_keys?: Array<unknown> | null;
        /**
         * Indicates if this run is resuming from a pause.
         */
        resuming?: boolean | null;
        /**
         * The number of retries.
         */
        retries?: number | null;
        /**
         * The delay time between retries, in seconds.
         */
        retry_delay?: number | null;
        /**
         * @deprecated: The delay between retries. Field is not used. Please use
         * `retry_delay` instead.
         */
        retry_delay_seconds?: number;
    }
}
/**
 * Represents a history of aggregation states over an interval
 */
export interface HistoryResponse {
    /**
     * The end date of the interval.
     */
    interval_end: string;
    /**
     * The start date of the interval.
     */
    interval_start: string;
    /**
     * A list of state histories during the interval.
     */
    states: Array<HistoryResponse.State>;
}
export declare namespace HistoryResponse {
    /**
     * Represents a single state's history over an interval.
     */
    interface State {
        /**
         * The number of runs in the specified state during the interval.
         */
        count_runs: number;
        /**
         * The state name.
         */
        state_name: string;
        /**
         * The state type.
         */
        state_type: 'SCHEDULED' | 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'CRASHED' | 'PAUSED' | 'CANCELLING';
        /**
         * The sum of differences between actual and expected start time during the
         * interval.
         */
        sum_estimated_lateness: number;
        /**
         * The total estimated run time of all runs during the interval.
         */
        sum_estimated_run_time: number;
    }
}
export interface MinimalConcurrencyLimitResponse {
    id: string;
    limit: number;
    name: string;
}
/**
 * A container for the output of state orchestration.
 */
export interface OrchestrationResult {
    /**
     * Details associated with an ACCEPT state transition.
     */
    details: OrchestrationResult.StateAcceptDetails | OrchestrationResult.StateWaitDetails | OrchestrationResult.StateRejectDetails | OrchestrationResult.StateAbortDetails;
    /**
     * Represents the state of a run.
     */
    state: State | null;
    /**
     * Enumerates return statuses for setting run states.
     */
    status: 'ACCEPT' | 'REJECT' | 'ABORT' | 'WAIT';
}
export declare namespace OrchestrationResult {
    /**
     * Details associated with an ACCEPT state transition.
     */
    interface StateAcceptDetails {
        /**
         * The type of state transition detail. Used to ensure pydantic does not coerce
         * into a different type.
         */
        type?: 'accept_details';
    }
    /**
     * Details associated with a WAIT state transition.
     */
    interface StateWaitDetails {
        /**
         * The length of time in seconds the client should wait before transitioning
         * states.
         */
        delay_seconds: number;
        /**
         * The reason why the state transition should wait.
         */
        reason?: string | null;
        /**
         * The type of state transition detail. Used to ensure pydantic does not coerce
         * into a different type.
         */
        type?: 'wait_details';
    }
    /**
     * Details associated with a REJECT state transition.
     */
    interface StateRejectDetails {
        /**
         * The reason why the state transition was rejected.
         */
        reason?: string | null;
        /**
         * The type of state transition detail. Used to ensure pydantic does not coerce
         * into a different type.
         */
        type?: 'reject_details';
    }
    /**
     * Details associated with an ABORT state transition.
     */
    interface StateAbortDetails {
        /**
         * The reason why the state transition was aborted.
         */
        reason?: string | null;
        /**
         * The type of state transition detail. Used to ensure pydantic does not coerce
         * into a different type.
         */
        type?: 'abort_details';
    }
}
/**
 * Represents the state of a run.
 */
export interface State {
    /**
     * Enumeration of state types.
     */
    type: 'SCHEDULED' | 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'CRASHED' | 'PAUSED' | 'CANCELLING';
    id?: string;
    /**
     * Data associated with the state, e.g. a result. Content must be storable as JSON.
     */
    data?: unknown | null;
    message?: string | null;
    name?: string | null;
    state_details?: State.StateDetails;
    timestamp?: string;
}
export declare namespace State {
    interface StateDetails {
        cache_expiration?: string | null;
        cache_key?: string | null;
        child_flow_run_id?: string | null;
        deferred?: boolean | null;
        flow_run_id?: string | null;
        pause_key?: string | null;
        pause_reschedule?: boolean;
        pause_timeout?: string | null;
        refresh_cache?: boolean | null;
        retriable?: boolean | null;
        run_input_keyset?: Record<string, string> | null;
        scheduled_time?: string | null;
        task_parameters_id?: string | null;
        task_run_id?: string | null;
        transition_id?: string | null;
        untrackable_result?: boolean;
    }
}
export interface Variable {
    /**
     * The name of the variable
     */
    name: string;
    /**
     * The value of the variable
     */
    value: string | boolean | number | unknown | Array<unknown> | null;
    id?: string;
    created?: string | null;
    /**
     * A list of variable tags
     */
    tags?: Array<string>;
    updated?: string | null;
}
export interface WorkQueueResponse {
    /**
     * The name of the work queue.
     */
    name: string;
    id?: string;
    /**
     * An optional concurrency limit for the work queue.
     */
    concurrency_limit?: number | null;
    created?: string | null;
    /**
     * An optional description for the work queue.
     */
    description?: string | null;
    /**
     * @deprecated: Filter criteria definition for a work queue.
     */
    filter?: WorkQueueResponse.Filter | null;
    /**
     * Whether or not the work queue is paused.
     */
    is_paused?: boolean;
    /**
     * The last time an agent polled this queue for work.
     */
    last_polled?: string | null;
    /**
     * The queue's priority. Lower values are higher priority (1 is the highest).
     */
    priority?: number;
    /**
     * Enumeration of work queue statuses.
     */
    status?: 'READY' | 'NOT_READY' | 'PAUSED' | null;
    updated?: string | null;
    /**
     * The work pool with which the queue is associated.
     */
    work_pool_id?: string | null;
    /**
     * The name of the work pool the work pool resides within.
     */
    work_pool_name?: string | null;
}
export declare namespace WorkQueueResponse {
    /**
     * @deprecated: Filter criteria definition for a work queue.
     */
    interface Filter {
        /**
         * Only include flow runs from these deployments in the work queue.
         */
        deployment_ids?: Array<string> | null;
        /**
         * Only include flow runs with these tags in the work queue.
         */
        tags?: Array<string> | null;
    }
}
//# sourceMappingURL=shared.d.ts.map