import { APIResource } from "../../resource.js";
import * as Core from "../../core.js";
import * as DeploymentsAPI from "./deployments.js";
import * as Shared from "../shared.js";
import * as FlowRunsAPI from "./flow-runs.js";
import * as NamesAPI from "./names.js";
import * as SchedulesAPI from "./schedules.js";
import * as WorkQueueCheckAPI from "./work-queue-check.js";
export declare class Deployments extends APIResource {
    names: NamesAPI.Names;
    flowRuns: FlowRunsAPI.FlowRuns;
    schedules: SchedulesAPI.Schedules;
    workQueueCheck: WorkQueueCheckAPI.WorkQueueCheck;
    /**
     * Gracefully creates a new deployment from the provided schema. If a deployment
     * with the same name and flow_id already exists, the deployment is updated.
     *
     * If the deployment has an active schedule, flow runs will be scheduled. When
     * upserting, any scheduled runs from the existing deployment will be deleted.
     */
    create(params: DeploymentCreateParams, options?: Core.RequestOptions): Core.APIPromise<DeploymentResponse>;
    /**
     * Get a deployment by id.
     */
    retrieve(id: string, params?: DeploymentRetrieveParams, options?: Core.RequestOptions): Core.APIPromise<DeploymentResponse>;
    retrieve(id: string, options?: Core.RequestOptions): Core.APIPromise<DeploymentResponse>;
    /**
     * Update Deployment
     */
    update(id: string, params: DeploymentUpdateParams, options?: Core.RequestOptions): Core.APIPromise<void>;
    /**
     * Delete a deployment by id.
     */
    delete(id: string, params?: DeploymentDeleteParams, options?: Core.RequestOptions): Core.APIPromise<void>;
    delete(id: string, options?: Core.RequestOptions): Core.APIPromise<void>;
    /**
     * Count deployments.
     */
    count(params?: DeploymentCountParams, options?: Core.RequestOptions): Core.APIPromise<DeploymentCountResponse>;
    count(options?: Core.RequestOptions): Core.APIPromise<DeploymentCountResponse>;
    /**
     * Query for deployments.
     */
    filter(params?: DeploymentFilterParams, options?: Core.RequestOptions): Core.APIPromise<DeploymentFilterResponse>;
    filter(options?: Core.RequestOptions): Core.APIPromise<DeploymentFilterResponse>;
    /**
     * Get scheduled runs for a set of deployments. Used by a runner to poll for work.
     */
    getScheduledFlowRuns(params: DeploymentGetScheduledFlowRunsParams, options?: Core.RequestOptions): Core.APIPromise<DeploymentGetScheduledFlowRunsResponse>;
    /**
     * Pagination query for flow runs.
     */
    paginateQuery(params?: DeploymentPaginateQueryParams, options?: Core.RequestOptions): Core.APIPromise<DeploymentPaginationResponse>;
    paginateQuery(options?: Core.RequestOptions): Core.APIPromise<DeploymentPaginationResponse>;
    /**
     * Set a deployment schedule to inactive. Any auto-scheduled runs still in a
     * Scheduled state will be deleted.
     */
    pauseDeployment(id: string, params?: DeploymentPauseDeploymentParams, options?: Core.RequestOptions): Core.APIPromise<unknown>;
    pauseDeployment(id: string, options?: Core.RequestOptions): Core.APIPromise<unknown>;
    /**
     * Set a deployment schedule to active. Runs will be scheduled immediately.
     */
    resumeDeployment(id: string, params?: DeploymentResumeDeploymentParams, options?: Core.RequestOptions): Core.APIPromise<unknown>;
    resumeDeployment(id: string, options?: Core.RequestOptions): Core.APIPromise<unknown>;
}
export interface DeploymentPaginationResponse {
    count: number;
    limit: number;
    page: number;
    pages: number;
    results: Array<DeploymentResponse>;
}
export interface DeploymentResponse {
    /**
     * The flow id associated with the deployment.
     */
    flow_id: string;
    /**
     * The name of the deployment.
     */
    name: string;
    id?: string;
    /**
     * The maximum number of flow runs that can be active at once.
     */
    concurrency_limit?: number | null;
    created?: string | null;
    /**
     * Optional information about the creator of this deployment.
     */
    created_by?: DeploymentResponse.CreatedBy | null;
    /**
     * A description for the deployment.
     */
    description?: string | null;
    /**
     * Whether or not the deployment should enforce the parameter schema.
     */
    enforce_parameter_schema?: boolean;
    /**
     * The path to the entrypoint for the workflow, relative to the `path`.
     */
    entrypoint?: string | null;
    /**
     * The block document defining infrastructure to use for flow runs.
     */
    infrastructure_document_id?: string | null;
    /**
     * Overrides to apply to the base infrastructure block at runtime.
     */
    job_variables?: unknown;
    /**
     * The last time the deployment was polled for status updates.
     */
    last_polled?: string | null;
    /**
     * The parameter schema of the flow, including defaults.
     */
    parameter_openapi_schema?: unknown | null;
    /**
     * Parameters for flow runs scheduled by the deployment.
     */
    parameters?: unknown;
    /**
     * The path to the working directory for the workflow, relative to remote storage
     * or an absolute path.
     */
    path?: string | null;
    /**
     * Whether or not the deployment is paused.
     */
    paused?: boolean;
    /**
     * Pull steps for cloning and running this deployment.
     */
    pull_steps?: Array<unknown> | null;
    /**
     * A list of schedules for the deployment.
     */
    schedules?: Array<DeploymentSchedule>;
    /**
     * Enumeration of deployment statuses.
     */
    status?: 'READY' | 'NOT_READY' | null;
    /**
     * The block document defining storage used for this flow.
     */
    storage_document_id?: string | null;
    /**
     * A list of tags for the deployment
     */
    tags?: Array<string>;
    updated?: string | null;
    /**
     * Optional information about the updater of this deployment.
     */
    updated_by?: DeploymentResponse.UpdatedBy | null;
    /**
     * An optional version for the deployment.
     */
    version?: string | null;
    /**
     * The name of the deployment's work pool.
     */
    work_pool_name?: string | null;
    /**
     * The work queue for the deployment. If no work queue is set, work will not be
     * scheduled.
     */
    work_queue_name?: string | null;
}
export declare namespace DeploymentResponse {
    /**
     * Optional information about the creator of this deployment.
     */
    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;
    }
    /**
     * Optional information about the updater of this deployment.
     */
    interface UpdatedBy {
        /**
         * The id of the updater of the object.
         */
        id?: string | null;
        /**
         * The display value for the updater.
         */
        display_value?: string | null;
        /**
         * The type of the updater of the object.
         */
        type?: string | null;
    }
}
export interface DeploymentSchedule {
    /**
     * The schedule for the deployment.
     */
    schedule: DeploymentSchedule.IntervalSchedule | DeploymentSchedule.CronSchedule | DeploymentSchedule.RRuleSchedule;
    id?: string;
    /**
     * Whether or not the schedule is active.
     */
    active?: boolean;
    /**
     * Whether or not a worker should catch up on Late runs for the schedule.
     */
    catchup?: boolean;
    created?: string | null;
    /**
     * The deployment id associated with this schedule.
     */
    deployment_id?: string | null;
    /**
     * The maximum number of active runs for the schedule.
     */
    max_active_runs?: number | null;
    /**
     * The maximum number of scheduled runs for the schedule.
     */
    max_scheduled_runs?: number | null;
    updated?: string | null;
}
export declare namespace DeploymentSchedule {
    /**
     * A schedule formed by adding `interval` increments to an `anchor_date`. If no
     * `anchor_date` is supplied, the current UTC time is used. If a timezone-naive
     * datetime is provided for `anchor_date`, it is assumed to be in the schedule's
     * timezone (or UTC). Even if supplied with an IANA timezone, anchor dates are
     * always stored as UTC offsets, so a `timezone` can be provided to determine
     * localization behaviors like DST boundary handling. If none is provided it will
     * be inferred from the anchor date.
     *
     * NOTE: If the `IntervalSchedule` `anchor_date` or `timezone` is provided in a
     * DST-observing timezone, then the schedule will adjust itself appropriately.
     * Intervals greater than 24 hours will follow DST conventions, while intervals of
     * less than 24 hours will follow UTC intervals. For example, an hourly schedule
     * will fire every UTC hour, even across DST boundaries. When clocks are set back,
     * this will result in two runs that _appear_ to both be scheduled for 1am local
     * time, even though they are an hour apart in UTC time. For longer intervals, like
     * a daily schedule, the interval schedule will adjust for DST boundaries so that
     * the clock-hour remains constant. This means that a daily schedule that always
     * fires at 9am will observe DST and continue to fire at 9am in the local time
     * zone.
     *
     * Args: interval (datetime.timedelta): an interval to schedule on. anchor_date
     * (DateTime, optional): an anchor date to schedule increments against; if not
     * provided, the current timestamp will be used. timezone (str, optional): a valid
     * timezone string.
     */
    interface IntervalSchedule {
        interval: number;
        anchor_date?: string;
        timezone?: string | null;
    }
    /**
     * Cron schedule
     *
     * NOTE: If the timezone is a DST-observing one, then the schedule will adjust
     * itself appropriately. Cron's rules for DST are based on schedule times, not
     * intervals. This means that an hourly cron schedule will fire on every new
     * schedule hour, not every elapsed hour; for example, when clocks are set back
     * this will result in a two-hour pause as the schedule will fire _the first time_
     * 1am is reached and _the first time_ 2am is reached, 120 minutes later. Longer
     * schedules, such as one that fires at 9am every morning, will automatically
     * adjust for DST.
     *
     * Args: cron (str): a valid cron string timezone (str): a valid timezone string in
     * IANA tzdata format (for example, America/New_York). day_or (bool, optional):
     * Control how croniter handles `day` and `day_of_week` entries. Defaults to True,
     * matching cron which connects those values using OR. If the switch is set to
     * False, the values are connected using AND. This behaves like fcron and enables
     * you to e.g. define a job that executes each 2nd friday of a month by setting the
     * days of month and the weekday.
     */
    interface CronSchedule {
        cron: string;
        /**
         * Control croniter behavior for handling day and day_of_week entries.
         */
        day_or?: boolean;
        timezone?: string | null;
    }
    /**
     * RRule schedule, based on the iCalendar standard
     * ([RFC 5545](https://datatracker.ietf.org/doc/html/rfc5545)) as implemented in
     * `dateutils.rrule`.
     *
     * RRules are appropriate for any kind of calendar-date manipulation, including
     * irregular intervals, repetition, exclusions, week day or day-of-month
     * adjustments, and more.
     *
     * Note that as a calendar-oriented standard, `RRuleSchedules` are sensitive to to
     * the initial timezone provided. A 9am daily schedule with a daylight saving
     * time-aware start date will maintain a local 9am time through DST boundaries; a
     * 9am daily schedule with a UTC start date will maintain a 9am UTC time.
     *
     * Args: rrule (str): a valid RRule string timezone (str, optional): a valid
     * timezone string
     */
    interface RRuleSchedule {
        rrule: string;
        timezone?: string | null;
    }
}
/**
 * An ORM representation of a work queue
 */
export interface WorkQueue {
    /**
     * 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?: WorkQueue.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;
    updated?: string | null;
    /**
     * The work pool with which the queue is associated.
     */
    work_pool_id?: string | null;
}
export declare namespace WorkQueue {
    /**
     * @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;
    }
}
export type DeploymentCountResponse = number;
export type DeploymentFilterResponse = Array<DeploymentResponse>;
export type DeploymentGetScheduledFlowRunsResponse = Array<Shared.FlowRunResponse>;
export type DeploymentPauseDeploymentResponse = unknown;
export type DeploymentResumeDeploymentResponse = unknown;
export interface DeploymentCreateParams {
    /**
     * Body param: The ID of the flow associated with the deployment.
     */
    flow_id: string;
    /**
     * Body param: The name of the deployment.
     */
    name: string;
    /**
     * Body param: The deployment's concurrency limit.
     */
    concurrency_limit?: number | null;
    /**
     * Body param:
     */
    description?: string | null;
    /**
     * Body param: Whether or not the deployment should enforce the parameter schema.
     */
    enforce_parameter_schema?: boolean;
    /**
     * Body param:
     */
    entrypoint?: string | null;
    /**
     * Body param:
     */
    infrastructure_document_id?: string | null;
    /**
     * Body param: Overrides for the flow's infrastructure configuration.
     */
    job_variables?: unknown;
    /**
     * Body param: The parameter schema of the flow, including defaults.
     */
    parameter_openapi_schema?: unknown | null;
    /**
     * Body param: Parameters for flow runs scheduled by the deployment.
     */
    parameters?: unknown;
    /**
     * Body param:
     */
    path?: string | null;
    /**
     * Body param: Whether or not the deployment is paused.
     */
    paused?: boolean;
    /**
     * Body param:
     */
    pull_steps?: Array<unknown> | null;
    /**
     * Body param: A list of schedules for the deployment.
     */
    schedules?: Array<DeploymentCreateParams.Schedule>;
    /**
     * Body param:
     */
    storage_document_id?: string | null;
    /**
     * Body param: A list of deployment tags.
     */
    tags?: Array<string>;
    /**
     * Body param:
     */
    version?: string | null;
    /**
     * Body param: The name of the deployment's work pool.
     */
    work_pool_name?: string | null;
    /**
     * Body param:
     */
    work_queue_name?: string | null;
    /**
     * Header param:
     */
    'x-prefect-api-version'?: string;
}
export declare namespace DeploymentCreateParams {
    interface Schedule {
        /**
         * The schedule for the deployment.
         */
        schedule: Schedule.IntervalSchedule | Schedule.CronSchedule | Schedule.RRuleSchedule;
        /**
         * Whether or not the schedule is active.
         */
        active?: boolean;
        /**
         * Whether or not a worker should catch up on Late runs for the schedule.
         */
        catchup?: boolean;
        /**
         * The maximum number of active runs for the schedule.
         */
        max_active_runs?: number | null;
        /**
         * The maximum number of scheduled runs for the schedule.
         */
        max_scheduled_runs?: number | null;
    }
    namespace Schedule {
        /**
         * A schedule formed by adding `interval` increments to an `anchor_date`. If no
         * `anchor_date` is supplied, the current UTC time is used. If a timezone-naive
         * datetime is provided for `anchor_date`, it is assumed to be in the schedule's
         * timezone (or UTC). Even if supplied with an IANA timezone, anchor dates are
         * always stored as UTC offsets, so a `timezone` can be provided to determine
         * localization behaviors like DST boundary handling. If none is provided it will
         * be inferred from the anchor date.
         *
         * NOTE: If the `IntervalSchedule` `anchor_date` or `timezone` is provided in a
         * DST-observing timezone, then the schedule will adjust itself appropriately.
         * Intervals greater than 24 hours will follow DST conventions, while intervals of
         * less than 24 hours will follow UTC intervals. For example, an hourly schedule
         * will fire every UTC hour, even across DST boundaries. When clocks are set back,
         * this will result in two runs that _appear_ to both be scheduled for 1am local
         * time, even though they are an hour apart in UTC time. For longer intervals, like
         * a daily schedule, the interval schedule will adjust for DST boundaries so that
         * the clock-hour remains constant. This means that a daily schedule that always
         * fires at 9am will observe DST and continue to fire at 9am in the local time
         * zone.
         *
         * Args: interval (datetime.timedelta): an interval to schedule on. anchor_date
         * (DateTime, optional): an anchor date to schedule increments against; if not
         * provided, the current timestamp will be used. timezone (str, optional): a valid
         * timezone string.
         */
        interface IntervalSchedule {
            interval: number;
            anchor_date?: string;
            timezone?: string | null;
        }
        /**
         * Cron schedule
         *
         * NOTE: If the timezone is a DST-observing one, then the schedule will adjust
         * itself appropriately. Cron's rules for DST are based on schedule times, not
         * intervals. This means that an hourly cron schedule will fire on every new
         * schedule hour, not every elapsed hour; for example, when clocks are set back
         * this will result in a two-hour pause as the schedule will fire _the first time_
         * 1am is reached and _the first time_ 2am is reached, 120 minutes later. Longer
         * schedules, such as one that fires at 9am every morning, will automatically
         * adjust for DST.
         *
         * Args: cron (str): a valid cron string timezone (str): a valid timezone string in
         * IANA tzdata format (for example, America/New_York). day_or (bool, optional):
         * Control how croniter handles `day` and `day_of_week` entries. Defaults to True,
         * matching cron which connects those values using OR. If the switch is set to
         * False, the values are connected using AND. This behaves like fcron and enables
         * you to e.g. define a job that executes each 2nd friday of a month by setting the
         * days of month and the weekday.
         */
        interface CronSchedule {
            cron: string;
            /**
             * Control croniter behavior for handling day and day_of_week entries.
             */
            day_or?: boolean;
            timezone?: string | null;
        }
        /**
         * RRule schedule, based on the iCalendar standard
         * ([RFC 5545](https://datatracker.ietf.org/doc/html/rfc5545)) as implemented in
         * `dateutils.rrule`.
         *
         * RRules are appropriate for any kind of calendar-date manipulation, including
         * irregular intervals, repetition, exclusions, week day or day-of-month
         * adjustments, and more.
         *
         * Note that as a calendar-oriented standard, `RRuleSchedules` are sensitive to to
         * the initial timezone provided. A 9am daily schedule with a daylight saving
         * time-aware start date will maintain a local 9am time through DST boundaries; a
         * 9am daily schedule with a UTC start date will maintain a 9am UTC time.
         *
         * Args: rrule (str): a valid RRule string timezone (str, optional): a valid
         * timezone string
         */
        interface RRuleSchedule {
            rrule: string;
            timezone?: string | null;
        }
    }
}
export interface DeploymentRetrieveParams {
    'x-prefect-api-version'?: string;
}
export interface DeploymentUpdateParams {
    /**
     * Body param: The deployment's concurrency limit.
     */
    concurrency_limit?: number | null;
    /**
     * Body param:
     */
    description?: string | null;
    /**
     * Body param: Whether or not the deployment should enforce the parameter schema.
     */
    enforce_parameter_schema?: boolean | null;
    /**
     * Body param:
     */
    entrypoint?: string | null;
    /**
     * Body param:
     */
    infrastructure_document_id?: string | null;
    /**
     * Body param: Overrides for the flow's infrastructure configuration.
     */
    job_variables?: unknown | null;
    /**
     * Body param: Parameters for flow runs scheduled by the deployment.
     */
    parameters?: unknown | null;
    /**
     * Body param:
     */
    path?: string | null;
    /**
     * Body param: Whether or not the deployment is paused.
     */
    paused?: boolean;
    /**
     * Body param: A list of schedules for the deployment.
     */
    schedules?: Array<DeploymentUpdateParams.Schedule>;
    /**
     * Body param:
     */
    storage_document_id?: string | null;
    /**
     * Body param: A list of deployment tags.
     */
    tags?: Array<string>;
    /**
     * Body param:
     */
    version?: string | null;
    /**
     * Body param: The name of the deployment's work pool.
     */
    work_pool_name?: string | null;
    /**
     * Body param:
     */
    work_queue_name?: string | null;
    /**
     * Header param:
     */
    'x-prefect-api-version'?: string;
}
export declare namespace DeploymentUpdateParams {
    interface Schedule {
        /**
         * The schedule for the deployment.
         */
        schedule: Schedule.IntervalSchedule | Schedule.CronSchedule | Schedule.RRuleSchedule;
        /**
         * Whether or not the schedule is active.
         */
        active?: boolean;
        /**
         * Whether or not a worker should catch up on Late runs for the schedule.
         */
        catchup?: boolean;
        /**
         * The maximum number of active runs for the schedule.
         */
        max_active_runs?: number | null;
        /**
         * The maximum number of scheduled runs for the schedule.
         */
        max_scheduled_runs?: number | null;
    }
    namespace Schedule {
        /**
         * A schedule formed by adding `interval` increments to an `anchor_date`. If no
         * `anchor_date` is supplied, the current UTC time is used. If a timezone-naive
         * datetime is provided for `anchor_date`, it is assumed to be in the schedule's
         * timezone (or UTC). Even if supplied with an IANA timezone, anchor dates are
         * always stored as UTC offsets, so a `timezone` can be provided to determine
         * localization behaviors like DST boundary handling. If none is provided it will
         * be inferred from the anchor date.
         *
         * NOTE: If the `IntervalSchedule` `anchor_date` or `timezone` is provided in a
         * DST-observing timezone, then the schedule will adjust itself appropriately.
         * Intervals greater than 24 hours will follow DST conventions, while intervals of
         * less than 24 hours will follow UTC intervals. For example, an hourly schedule
         * will fire every UTC hour, even across DST boundaries. When clocks are set back,
         * this will result in two runs that _appear_ to both be scheduled for 1am local
         * time, even though they are an hour apart in UTC time. For longer intervals, like
         * a daily schedule, the interval schedule will adjust for DST boundaries so that
         * the clock-hour remains constant. This means that a daily schedule that always
         * fires at 9am will observe DST and continue to fire at 9am in the local time
         * zone.
         *
         * Args: interval (datetime.timedelta): an interval to schedule on. anchor_date
         * (DateTime, optional): an anchor date to schedule increments against; if not
         * provided, the current timestamp will be used. timezone (str, optional): a valid
         * timezone string.
         */
        interface IntervalSchedule {
            interval: number;
            anchor_date?: string;
            timezone?: string | null;
        }
        /**
         * Cron schedule
         *
         * NOTE: If the timezone is a DST-observing one, then the schedule will adjust
         * itself appropriately. Cron's rules for DST are based on schedule times, not
         * intervals. This means that an hourly cron schedule will fire on every new
         * schedule hour, not every elapsed hour; for example, when clocks are set back
         * this will result in a two-hour pause as the schedule will fire _the first time_
         * 1am is reached and _the first time_ 2am is reached, 120 minutes later. Longer
         * schedules, such as one that fires at 9am every morning, will automatically
         * adjust for DST.
         *
         * Args: cron (str): a valid cron string timezone (str): a valid timezone string in
         * IANA tzdata format (for example, America/New_York). day_or (bool, optional):
         * Control how croniter handles `day` and `day_of_week` entries. Defaults to True,
         * matching cron which connects those values using OR. If the switch is set to
         * False, the values are connected using AND. This behaves like fcron and enables
         * you to e.g. define a job that executes each 2nd friday of a month by setting the
         * days of month and the weekday.
         */
        interface CronSchedule {
            cron: string;
            /**
             * Control croniter behavior for handling day and day_of_week entries.
             */
            day_or?: boolean;
            timezone?: string | null;
        }
        /**
         * RRule schedule, based on the iCalendar standard
         * ([RFC 5545](https://datatracker.ietf.org/doc/html/rfc5545)) as implemented in
         * `dateutils.rrule`.
         *
         * RRules are appropriate for any kind of calendar-date manipulation, including
         * irregular intervals, repetition, exclusions, week day or day-of-month
         * adjustments, and more.
         *
         * Note that as a calendar-oriented standard, `RRuleSchedules` are sensitive to to
         * the initial timezone provided. A 9am daily schedule with a daylight saving
         * time-aware start date will maintain a local 9am time through DST boundaries; a
         * 9am daily schedule with a UTC start date will maintain a 9am UTC time.
         *
         * Args: rrule (str): a valid RRule string timezone (str, optional): a valid
         * timezone string
         */
        interface RRuleSchedule {
            rrule: string;
            timezone?: string | null;
        }
    }
}
export interface DeploymentDeleteParams {
    'x-prefect-api-version'?: string;
}
export interface DeploymentCountParams {
    /**
     * Body param: Filter for deployments. Only deployments matching all criteria will
     * be returned.
     */
    deployments?: DeploymentCountParams.Deployments;
    /**
     * Body param: Filter flow runs. Only flow runs matching all criteria will be
     * returned
     */
    flow_runs?: DeploymentCountParams.FlowRuns;
    /**
     * Body param: Filter for flows. Only flows matching all criteria will be returned.
     */
    flows?: DeploymentCountParams.Flows;
    /**
     * Body param: Filter task runs. Only task runs matching all criteria will be
     * returned
     */
    task_runs?: DeploymentCountParams.TaskRuns;
    /**
     * Body param: Filter work queues. Only work queues matching all criteria will be
     * returned
     */
    work_pool_queues?: DeploymentCountParams.WorkPoolQueues;
    /**
     * Body param: Filter work pools. Only work pools matching all criteria will be
     * returned
     */
    work_pools?: DeploymentCountParams.WorkPools;
    /**
     * Header param:
     */
    'x-prefect-api-version'?: string;
}
export declare namespace DeploymentCountParams {
    /**
     * Filter for deployments. Only deployments matching all criteria will be returned.
     */
    interface Deployments {
        /**
         * Filter by `Deployment.id`.
         */
        id?: Deployments.ID | null;
        /**
         * Filter by `Deployment.concurrency_limit`.
         */
        concurrency_limit?: Deployments.ConcurrencyLimit | null;
        /**
         * Filter by `Deployment.name` or `Flow.name` with a single input string for ilike
         * filtering.
         */
        flow_or_deployment_name?: Deployments.FlowOrDeploymentName | null;
        /**
         * Filter by `Deployment.name`.
         */
        name?: Deployments.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `Deployment.paused`.
         */
        paused?: Deployments.Paused | null;
        /**
         * Filter by `Deployment.tags`.
         */
        tags?: Deployments.Tags | null;
        /**
         * Filter by `Deployment.work_queue_name`.
         */
        work_queue_name?: Deployments.WorkQueueName | null;
    }
    namespace Deployments {
        /**
         * Filter by `Deployment.id`.
         */
        interface ID {
            /**
             * A list of deployment ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `Deployment.concurrency_limit`.
         */
        interface ConcurrencyLimit {
            /**
             * Only include deployments with a concurrency limit greater than or equal to this
             * value
             */
            ge_?: number | null;
            /**
             * If true, only include deployments without a concurrency limit
             */
            is_null_?: boolean | null;
            /**
             * Only include deployments with a concurrency limit less than or equal to this
             * value
             */
            le_?: number | null;
        }
        /**
         * Filter by `Deployment.name` or `Flow.name` with a single input string for ilike
         * filtering.
         */
        interface FlowOrDeploymentName {
            /**
             * A case-insensitive partial match on deployment or flow names. For example,
             * passing 'example' might match deployments or flows with 'example' in their
             * names.
             */
            like_?: string | null;
        }
        /**
         * Filter by `Deployment.name`.
         */
        interface Name {
            /**
             * A list of deployment names to include
             */
            any_?: Array<string> | null;
            /**
             * A case-insensitive partial match. For example, passing 'marvin' will match
             * 'marvin', 'sad-Marvin', and 'marvin-robot'.
             */
            like_?: string | null;
        }
        /**
         * Filter by `Deployment.paused`.
         */
        interface Paused {
            /**
             * Only returns where deployment is/is not paused
             */
            eq_?: boolean | null;
        }
        /**
         * Filter by `Deployment.tags`.
         */
        interface Tags {
            /**
             * A list of tags. Deployments will be returned only if their tags are a superset
             * of the list
             */
            all_?: Array<string> | null;
            /**
             * If true, only include deployments without tags
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `Deployment.work_queue_name`.
         */
        interface WorkQueueName {
            /**
             * A list of work queue names to include
             */
            any_?: Array<string> | null;
        }
    }
    /**
     * Filter flow runs. Only flow runs matching all criteria will be returned
     */
    interface FlowRuns {
        /**
         * Filter by `FlowRun.id`.
         */
        id?: FlowRuns.ID | null;
        /**
         * Filter by `FlowRun.deployment_id`.
         */
        deployment_id?: FlowRuns.DeploymentID | null;
        /**
         * Filter by `FlowRun.expected_start_time`.
         */
        expected_start_time?: FlowRuns.ExpectedStartTime | null;
        /**
         * Filter by `FlowRun.flow_version`.
         */
        flow_version?: FlowRuns.FlowVersion | null;
        /**
         * Filter by FlowRun.idempotency_key.
         */
        idempotency_key?: FlowRuns.IdempotencyKey | null;
        /**
         * Filter by `FlowRun.name`.
         */
        name?: FlowRuns.Name | null;
        /**
         * Filter by `FlowRun.next_scheduled_start_time`.
         */
        next_scheduled_start_time?: FlowRuns.NextScheduledStartTime | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter for subflows of a given flow run
         */
        parent_flow_run_id?: FlowRuns.ParentFlowRunID | null;
        /**
         * Filter by `FlowRun.parent_task_run_id`.
         */
        parent_task_run_id?: FlowRuns.ParentTaskRunID | null;
        /**
         * Filter by `FlowRun.start_time`.
         */
        start_time?: FlowRuns.StartTime | null;
        /**
         * Filter by `FlowRun.state_type` and `FlowRun.state_name`.
         */
        state?: FlowRuns.State | null;
        /**
         * Filter by `FlowRun.tags`.
         */
        tags?: FlowRuns.Tags | null;
        /**
         * Filter by `FlowRun.work_queue_name`.
         */
        work_queue_name?: FlowRuns.WorkQueueName | null;
    }
    namespace FlowRuns {
        /**
         * Filter by `FlowRun.id`.
         */
        interface ID {
            /**
             * A list of flow run ids to include
             */
            any_?: Array<string> | null;
            /**
             * A list of flow run ids to exclude
             */
            not_any_?: Array<string> | null;
        }
        /**
         * Filter by `FlowRun.deployment_id`.
         */
        interface DeploymentID {
            /**
             * A list of flow run deployment ids to include
             */
            any_?: Array<string> | null;
            /**
             * If true, only include flow runs without deployment ids
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `FlowRun.expected_start_time`.
         */
        interface ExpectedStartTime {
            /**
             * Only include flow runs scheduled to start at or after this time
             */
            after_?: string | null;
            /**
             * Only include flow runs scheduled to start at or before this time
             */
            before_?: string | null;
        }
        /**
         * Filter by `FlowRun.flow_version`.
         */
        interface FlowVersion {
            /**
             * A list of flow run flow_versions to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by FlowRun.idempotency_key.
         */
        interface IdempotencyKey {
            /**
             * A list of flow run idempotency keys to include
             */
            any_?: Array<string> | null;
            /**
             * A list of flow run idempotency keys to exclude
             */
            not_any_?: Array<string> | null;
        }
        /**
         * Filter by `FlowRun.name`.
         */
        interface Name {
            /**
             * A list of flow run names to include
             */
            any_?: Array<string> | null;
            /**
             * A case-insensitive partial match. For example, passing 'marvin' will match
             * 'marvin', 'sad-Marvin', and 'marvin-robot'.
             */
            like_?: string | null;
        }
        /**
         * Filter by `FlowRun.next_scheduled_start_time`.
         */
        interface NextScheduledStartTime {
            /**
             * Only include flow runs with a next_scheduled_start_time at or after this time
             */
            after_?: string | null;
            /**
             * Only include flow runs with a next_scheduled_start_time or before this time
             */
            before_?: string | null;
        }
        /**
         * Filter for subflows of a given flow run
         */
        interface ParentFlowRunID {
            /**
             * A list of parent flow run ids to include
             */
            any_?: Array<string> | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `FlowRun.parent_task_run_id`.
         */
        interface ParentTaskRunID {
            /**
             * A list of flow run parent_task_run_ids to include
             */
            any_?: Array<string> | null;
            /**
             * If true, only include flow runs without parent_task_run_id
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `FlowRun.start_time`.
         */
        interface StartTime {
            /**
             * Only include flow runs starting at or after this time
             */
            after_?: string | null;
            /**
             * Only include flow runs starting at or before this time
             */
            before_?: string | null;
            /**
             * If true, only return flow runs without a start time
             */
            is_null_?: boolean | null;
        }
        /**
         * Filter by `FlowRun.state_type` and `FlowRun.state_name`.
         */
        interface State {
            /**
             * Filter by `FlowRun.state_name`.
             */
            name?: State.Name | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
            /**
             * Filter by `FlowRun.state_type`.
             */
            type?: State.Type | null;
        }
        namespace State {
            /**
             * Filter by `FlowRun.state_name`.
             */
            interface Name {
                /**
                 * A list of flow run state names to include
                 */
                any_?: Array<string> | null;
                /**
                 * A list of flow run state names to exclude
                 */
                not_any_?: Array<string> | null;
            }
            /**
             * Filter by `FlowRun.state_type`.
             */
            interface Type {
                /**
                 * A list of flow run state types to include
                 */
                any_?: Array<'SCHEDULED' | 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'CRASHED' | 'PAUSED' | 'CANCELLING'> | null;
                /**
                 * A list of flow run state types to exclude
                 */
                not_any_?: Array<'SCHEDULED' | 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'CRASHED' | 'PAUSED' | 'CANCELLING'> | null;
            }
        }
        /**
         * Filter by `FlowRun.tags`.
         */
        interface Tags {
            /**
             * A list of tags. Flow runs will be returned only if their tags are a superset of
             * the list
             */
            all_?: Array<string> | null;
            /**
             * If true, only include flow runs without tags
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `FlowRun.work_queue_name`.
         */
        interface WorkQueueName {
            /**
             * A list of work queue names to include
             */
            any_?: Array<string> | null;
            /**
             * If true, only include flow runs without work queue names
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
    }
    /**
     * Filter for flows. Only flows matching all criteria will be returned.
     */
    interface Flows {
        /**
         * Filter by `Flow.id`.
         */
        id?: Flows.ID | null;
        /**
         * Filter by flows by deployment
         */
        deployment?: Flows.Deployment | null;
        /**
         * Filter by `Flow.name`.
         */
        name?: Flows.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `Flow.tags`.
         */
        tags?: Flows.Tags | null;
    }
    namespace Flows {
        /**
         * Filter by `Flow.id`.
         */
        interface ID {
            /**
             * A list of flow ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by flows by deployment
         */
        interface Deployment {
            /**
             * If true, only include flows without deployments
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `Flow.name`.
         */
        interface Name {
            /**
             * A list of flow names to include
             */
            any_?: Array<string> | null;
            /**
             * A case-insensitive partial match. For example, passing 'marvin' will match
             * 'marvin', 'sad-Marvin', and 'marvin-robot'.
             */
            like_?: string | null;
        }
        /**
         * Filter by `Flow.tags`.
         */
        interface Tags {
            /**
             * A list of tags. Flows will be returned only if their tags are a superset of the
             * list
             */
            all_?: Array<string> | null;
            /**
             * If true, only include flows without tags
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
    }
    /**
     * Filter task runs. Only task runs matching all criteria will be returned
     */
    interface TaskRuns {
        /**
         * Filter by `TaskRun.id`.
         */
        id?: TaskRuns.ID | null;
        /**
         * Filter by `TaskRun.expected_start_time`.
         */
        expected_start_time?: TaskRuns.ExpectedStartTime | null;
        /**
         * Filter by `TaskRun.flow_run_id`.
         */
        flow_run_id?: TaskRuns.FlowRunID | null;
        /**
         * Filter by `TaskRun.name`.
         */
        name?: TaskRuns.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `TaskRun.start_time`.
         */
        start_time?: TaskRuns.StartTime | null;
        /**
         * Filter by `TaskRun.type` and `TaskRun.name`.
         */
        state?: TaskRuns.State | null;
        /**
         * Filter by `TaskRun.subflow_run`.
         */
        subflow_runs?: TaskRuns.SubflowRuns | null;
        /**
         * Filter by `TaskRun.tags`.
         */
        tags?: TaskRuns.Tags | null;
    }
    namespace TaskRuns {
        /**
         * Filter by `TaskRun.id`.
         */
        interface ID {
            /**
             * A list of task run ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `TaskRun.expected_start_time`.
         */
        interface ExpectedStartTime {
            /**
             * Only include task runs expected to start at or after this time
             */
            after_?: string | null;
            /**
             * Only include task runs expected to start at or before this time
             */
            before_?: string | null;
        }
        /**
         * Filter by `TaskRun.flow_run_id`.
         */
        interface FlowRunID {
            /**
             * A list of task run flow run ids to include
             */
            any_?: Array<string> | null;
            /**
             * Filter for task runs with None as their flow run id
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `TaskRun.name`.
         */
        interface Name {
            /**
             * A list of task run names to include
             */
            any_?: Array<string> | null;
            /**
             * A case-insensitive partial match. For example, passing 'marvin' will match
             * 'marvin', 'sad-Marvin', and 'marvin-robot'.
             */
            like_?: string | null;
        }
        /**
         * Filter by `TaskRun.start_time`.
         */
        interface StartTime {
            /**
             * Only include task runs starting at or after this time
             */
            after_?: string | null;
            /**
             * Only include task runs starting at or before this time
             */
            before_?: string | null;
            /**
             * If true, only return task runs without a start time
             */
            is_null_?: boolean | null;
        }
        /**
         * Filter by `TaskRun.type` and `TaskRun.name`.
         */
        interface State {
            /**
             * Filter by `TaskRun.state_name`.
             */
            name?: State.Name | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
            /**
             * Filter by `TaskRun.state_type`.
             */
            type?: State.Type | null;
        }
        namespace State {
            /**
             * Filter by `TaskRun.state_name`.
             */
            interface Name {
                /**
                 * A list of task run state names to include
                 */
                any_?: Array<string> | null;
            }
            /**
             * Filter by `TaskRun.state_type`.
             */
            interface Type {
                /**
                 * A list of task run state types to include
                 */
                any_?: Array<'SCHEDULED' | 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'CRASHED' | 'PAUSED' | 'CANCELLING'> | null;
            }
        }
        /**
         * Filter by `TaskRun.subflow_run`.
         */
        interface SubflowRuns {
            /**
             * If true, only include task runs that are subflow run parents; if false, exclude
             * parent task runs
             */
            exists_?: boolean | null;
        }
        /**
         * Filter by `TaskRun.tags`.
         */
        interface Tags {
            /**
             * A list of tags. Task runs will be returned only if their tags are a superset of
             * the list
             */
            all_?: Array<string> | null;
            /**
             * If true, only include task runs without tags
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
    }
    /**
     * Filter work queues. Only work queues matching all criteria will be returned
     */
    interface WorkPoolQueues {
        /**
         * Filter by `WorkQueue.id`.
         */
        id?: WorkPoolQueues.ID | null;
        /**
         * Filter by `WorkQueue.name`.
         */
        name?: WorkPoolQueues.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
    }
    namespace WorkPoolQueues {
        /**
         * Filter by `WorkQueue.id`.
         */
        interface ID {
            /**
             * A list of work queue ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `WorkQueue.name`.
         */
        interface Name {
            /**
             * A list of work queue names to include
             */
            any_?: Array<string> | null;
            /**
             * A list of case-insensitive starts-with matches. For example, passing 'marvin'
             * will match 'marvin', and 'Marvin-robot', but not 'sad-marvin'.
             */
            startswith_?: Array<string> | null;
        }
    }
    /**
     * Filter work pools. Only work pools matching all criteria will be returned
     */
    interface WorkPools {
        /**
         * Filter by `WorkPool.id`.
         */
        id?: WorkPools.ID | null;
        /**
         * Filter by `WorkPool.name`.
         */
        name?: WorkPools.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `WorkPool.type`.
         */
        type?: WorkPools.Type | null;
    }
    namespace WorkPools {
        /**
         * Filter by `WorkPool.id`.
         */
        interface ID {
            /**
             * A list of work pool ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `WorkPool.name`.
         */
        interface Name {
            /**
             * A list of work pool names to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `WorkPool.type`.
         */
        interface Type {
            /**
             * A list of work pool types to include
             */
            any_?: Array<string> | null;
        }
    }
}
export interface DeploymentFilterParams {
    /**
     * Body param: Filter for deployments. Only deployments matching all criteria will
     * be returned.
     */
    deployments?: DeploymentFilterParams.Deployments;
    /**
     * Body param: Filter flow runs. Only flow runs matching all criteria will be
     * returned
     */
    flow_runs?: DeploymentFilterParams.FlowRuns;
    /**
     * Body param: Filter for flows. Only flows matching all criteria will be returned.
     */
    flows?: DeploymentFilterParams.Flows;
    /**
     * Body param: Defaults to PREFECT_API_DEFAULT_LIMIT if not provided.
     */
    limit?: number;
    /**
     * Body param:
     */
    offset?: number;
    /**
     * Body param: Defines deployment sorting options.
     */
    sort?: 'CREATED_DESC' | 'UPDATED_DESC' | 'NAME_ASC' | 'NAME_DESC';
    /**
     * Body param: Filter task runs. Only task runs matching all criteria will be
     * returned
     */
    task_runs?: DeploymentFilterParams.TaskRuns;
    /**
     * Body param: Filter work queues. Only work queues matching all criteria will be
     * returned
     */
    work_pool_queues?: DeploymentFilterParams.WorkPoolQueues;
    /**
     * Body param: Filter work pools. Only work pools matching all criteria will be
     * returned
     */
    work_pools?: DeploymentFilterParams.WorkPools;
    /**
     * Header param:
     */
    'x-prefect-api-version'?: string;
}
export declare namespace DeploymentFilterParams {
    /**
     * Filter for deployments. Only deployments matching all criteria will be returned.
     */
    interface Deployments {
        /**
         * Filter by `Deployment.id`.
         */
        id?: Deployments.ID | null;
        /**
         * Filter by `Deployment.concurrency_limit`.
         */
        concurrency_limit?: Deployments.ConcurrencyLimit | null;
        /**
         * Filter by `Deployment.name` or `Flow.name` with a single input string for ilike
         * filtering.
         */
        flow_or_deployment_name?: Deployments.FlowOrDeploymentName | null;
        /**
         * Filter by `Deployment.name`.
         */
        name?: Deployments.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `Deployment.paused`.
         */
        paused?: Deployments.Paused | null;
        /**
         * Filter by `Deployment.tags`.
         */
        tags?: Deployments.Tags | null;
        /**
         * Filter by `Deployment.work_queue_name`.
         */
        work_queue_name?: Deployments.WorkQueueName | null;
    }
    namespace Deployments {
        /**
         * Filter by `Deployment.id`.
         */
        interface ID {
            /**
             * A list of deployment ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `Deployment.concurrency_limit`.
         */
        interface ConcurrencyLimit {
            /**
             * Only include deployments with a concurrency limit greater than or equal to this
             * value
             */
            ge_?: number | null;
            /**
             * If true, only include deployments without a concurrency limit
             */
            is_null_?: boolean | null;
            /**
             * Only include deployments with a concurrency limit less than or equal to this
             * value
             */
            le_?: number | null;
        }
        /**
         * Filter by `Deployment.name` or `Flow.name` with a single input string for ilike
         * filtering.
         */
        interface FlowOrDeploymentName {
            /**
             * A case-insensitive partial match on deployment or flow names. For example,
             * passing 'example' might match deployments or flows with 'example' in their
             * names.
             */
            like_?: string | null;
        }
        /**
         * Filter by `Deployment.name`.
         */
        interface Name {
            /**
             * A list of deployment names to include
             */
            any_?: Array<string> | null;
            /**
             * A case-insensitive partial match. For example, passing 'marvin' will match
             * 'marvin', 'sad-Marvin', and 'marvin-robot'.
             */
            like_?: string | null;
        }
        /**
         * Filter by `Deployment.paused`.
         */
        interface Paused {
            /**
             * Only returns where deployment is/is not paused
             */
            eq_?: boolean | null;
        }
        /**
         * Filter by `Deployment.tags`.
         */
        interface Tags {
            /**
             * A list of tags. Deployments will be returned only if their tags are a superset
             * of the list
             */
            all_?: Array<string> | null;
            /**
             * If true, only include deployments without tags
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `Deployment.work_queue_name`.
         */
        interface WorkQueueName {
            /**
             * A list of work queue names to include
             */
            any_?: Array<string> | null;
        }
    }
    /**
     * Filter flow runs. Only flow runs matching all criteria will be returned
     */
    interface FlowRuns {
        /**
         * Filter by `FlowRun.id`.
         */
        id?: FlowRuns.ID | null;
        /**
         * Filter by `FlowRun.deployment_id`.
         */
        deployment_id?: FlowRuns.DeploymentID | null;
        /**
         * Filter by `FlowRun.expected_start_time`.
         */
        expected_start_time?: FlowRuns.ExpectedStartTime | null;
        /**
         * Filter by `FlowRun.flow_version`.
         */
        flow_version?: FlowRuns.FlowVersion | null;
        /**
         * Filter by FlowRun.idempotency_key.
         */
        idempotency_key?: FlowRuns.IdempotencyKey | null;
        /**
         * Filter by `FlowRun.name`.
         */
        name?: FlowRuns.Name | null;
        /**
         * Filter by `FlowRun.next_scheduled_start_time`.
         */
        next_scheduled_start_time?: FlowRuns.NextScheduledStartTime | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter for subflows of a given flow run
         */
        parent_flow_run_id?: FlowRuns.ParentFlowRunID | null;
        /**
         * Filter by `FlowRun.parent_task_run_id`.
         */
        parent_task_run_id?: FlowRuns.ParentTaskRunID | null;
        /**
         * Filter by `FlowRun.start_time`.
         */
        start_time?: FlowRuns.StartTime | null;
        /**
         * Filter by `FlowRun.state_type` and `FlowRun.state_name`.
         */
        state?: FlowRuns.State | null;
        /**
         * Filter by `FlowRun.tags`.
         */
        tags?: FlowRuns.Tags | null;
        /**
         * Filter by `FlowRun.work_queue_name`.
         */
        work_queue_name?: FlowRuns.WorkQueueName | null;
    }
    namespace FlowRuns {
        /**
         * Filter by `FlowRun.id`.
         */
        interface ID {
            /**
             * A list of flow run ids to include
             */
            any_?: Array<string> | null;
            /**
             * A list of flow run ids to exclude
             */
            not_any_?: Array<string> | null;
        }
        /**
         * Filter by `FlowRun.deployment_id`.
         */
        interface DeploymentID {
            /**
             * A list of flow run deployment ids to include
             */
            any_?: Array<string> | null;
            /**
             * If true, only include flow runs without deployment ids
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `FlowRun.expected_start_time`.
         */
        interface ExpectedStartTime {
            /**
             * Only include flow runs scheduled to start at or after this time
             */
            after_?: string | null;
            /**
             * Only include flow runs scheduled to start at or before this time
             */
            before_?: string | null;
        }
        /**
         * Filter by `FlowRun.flow_version`.
         */
        interface FlowVersion {
            /**
             * A list of flow run flow_versions to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by FlowRun.idempotency_key.
         */
        interface IdempotencyKey {
            /**
             * A list of flow run idempotency keys to include
             */
            any_?: Array<string> | null;
            /**
             * A list of flow run idempotency keys to exclude
             */
            not_any_?: Array<string> | null;
        }
        /**
         * Filter by `FlowRun.name`.
         */
        interface Name {
            /**
             * A list of flow run names to include
             */
            any_?: Array<string> | null;
            /**
             * A case-insensitive partial match. For example, passing 'marvin' will match
             * 'marvin', 'sad-Marvin', and 'marvin-robot'.
             */
            like_?: string | null;
        }
        /**
         * Filter by `FlowRun.next_scheduled_start_time`.
         */
        interface NextScheduledStartTime {
            /**
             * Only include flow runs with a next_scheduled_start_time at or after this time
             */
            after_?: string | null;
            /**
             * Only include flow runs with a next_scheduled_start_time or before this time
             */
            before_?: string | null;
        }
        /**
         * Filter for subflows of a given flow run
         */
        interface ParentFlowRunID {
            /**
             * A list of parent flow run ids to include
             */
            any_?: Array<string> | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `FlowRun.parent_task_run_id`.
         */
        interface ParentTaskRunID {
            /**
             * A list of flow run parent_task_run_ids to include
             */
            any_?: Array<string> | null;
            /**
             * If true, only include flow runs without parent_task_run_id
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `FlowRun.start_time`.
         */
        interface StartTime {
            /**
             * Only include flow runs starting at or after this time
             */
            after_?: string | null;
            /**
             * Only include flow runs starting at or before this time
             */
            before_?: string | null;
            /**
             * If true, only return flow runs without a start time
             */
            is_null_?: boolean | null;
        }
        /**
         * Filter by `FlowRun.state_type` and `FlowRun.state_name`.
         */
        interface State {
            /**
             * Filter by `FlowRun.state_name`.
             */
            name?: State.Name | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
            /**
             * Filter by `FlowRun.state_type`.
             */
            type?: State.Type | null;
        }
        namespace State {
            /**
             * Filter by `FlowRun.state_name`.
             */
            interface Name {
                /**
                 * A list of flow run state names to include
                 */
                any_?: Array<string> | null;
                /**
                 * A list of flow run state names to exclude
                 */
                not_any_?: Array<string> | null;
            }
            /**
             * Filter by `FlowRun.state_type`.
             */
            interface Type {
                /**
                 * A list of flow run state types to include
                 */
                any_?: Array<'SCHEDULED' | 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'CRASHED' | 'PAUSED' | 'CANCELLING'> | null;
                /**
                 * A list of flow run state types to exclude
                 */
                not_any_?: Array<'SCHEDULED' | 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'CRASHED' | 'PAUSED' | 'CANCELLING'> | null;
            }
        }
        /**
         * Filter by `FlowRun.tags`.
         */
        interface Tags {
            /**
             * A list of tags. Flow runs will be returned only if their tags are a superset of
             * the list
             */
            all_?: Array<string> | null;
            /**
             * If true, only include flow runs without tags
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `FlowRun.work_queue_name`.
         */
        interface WorkQueueName {
            /**
             * A list of work queue names to include
             */
            any_?: Array<string> | null;
            /**
             * If true, only include flow runs without work queue names
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
    }
    /**
     * Filter for flows. Only flows matching all criteria will be returned.
     */
    interface Flows {
        /**
         * Filter by `Flow.id`.
         */
        id?: Flows.ID | null;
        /**
         * Filter by flows by deployment
         */
        deployment?: Flows.Deployment | null;
        /**
         * Filter by `Flow.name`.
         */
        name?: Flows.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `Flow.tags`.
         */
        tags?: Flows.Tags | null;
    }
    namespace Flows {
        /**
         * Filter by `Flow.id`.
         */
        interface ID {
            /**
             * A list of flow ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by flows by deployment
         */
        interface Deployment {
            /**
             * If true, only include flows without deployments
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `Flow.name`.
         */
        interface Name {
            /**
             * A list of flow names to include
             */
            any_?: Array<string> | null;
            /**
             * A case-insensitive partial match. For example, passing 'marvin' will match
             * 'marvin', 'sad-Marvin', and 'marvin-robot'.
             */
            like_?: string | null;
        }
        /**
         * Filter by `Flow.tags`.
         */
        interface Tags {
            /**
             * A list of tags. Flows will be returned only if their tags are a superset of the
             * list
             */
            all_?: Array<string> | null;
            /**
             * If true, only include flows without tags
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
    }
    /**
     * Filter task runs. Only task runs matching all criteria will be returned
     */
    interface TaskRuns {
        /**
         * Filter by `TaskRun.id`.
         */
        id?: TaskRuns.ID | null;
        /**
         * Filter by `TaskRun.expected_start_time`.
         */
        expected_start_time?: TaskRuns.ExpectedStartTime | null;
        /**
         * Filter by `TaskRun.flow_run_id`.
         */
        flow_run_id?: TaskRuns.FlowRunID | null;
        /**
         * Filter by `TaskRun.name`.
         */
        name?: TaskRuns.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `TaskRun.start_time`.
         */
        start_time?: TaskRuns.StartTime | null;
        /**
         * Filter by `TaskRun.type` and `TaskRun.name`.
         */
        state?: TaskRuns.State | null;
        /**
         * Filter by `TaskRun.subflow_run`.
         */
        subflow_runs?: TaskRuns.SubflowRuns | null;
        /**
         * Filter by `TaskRun.tags`.
         */
        tags?: TaskRuns.Tags | null;
    }
    namespace TaskRuns {
        /**
         * Filter by `TaskRun.id`.
         */
        interface ID {
            /**
             * A list of task run ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `TaskRun.expected_start_time`.
         */
        interface ExpectedStartTime {
            /**
             * Only include task runs expected to start at or after this time
             */
            after_?: string | null;
            /**
             * Only include task runs expected to start at or before this time
             */
            before_?: string | null;
        }
        /**
         * Filter by `TaskRun.flow_run_id`.
         */
        interface FlowRunID {
            /**
             * A list of task run flow run ids to include
             */
            any_?: Array<string> | null;
            /**
             * Filter for task runs with None as their flow run id
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `TaskRun.name`.
         */
        interface Name {
            /**
             * A list of task run names to include
             */
            any_?: Array<string> | null;
            /**
             * A case-insensitive partial match. For example, passing 'marvin' will match
             * 'marvin', 'sad-Marvin', and 'marvin-robot'.
             */
            like_?: string | null;
        }
        /**
         * Filter by `TaskRun.start_time`.
         */
        interface StartTime {
            /**
             * Only include task runs starting at or after this time
             */
            after_?: string | null;
            /**
             * Only include task runs starting at or before this time
             */
            before_?: string | null;
            /**
             * If true, only return task runs without a start time
             */
            is_null_?: boolean | null;
        }
        /**
         * Filter by `TaskRun.type` and `TaskRun.name`.
         */
        interface State {
            /**
             * Filter by `TaskRun.state_name`.
             */
            name?: State.Name | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
            /**
             * Filter by `TaskRun.state_type`.
             */
            type?: State.Type | null;
        }
        namespace State {
            /**
             * Filter by `TaskRun.state_name`.
             */
            interface Name {
                /**
                 * A list of task run state names to include
                 */
                any_?: Array<string> | null;
            }
            /**
             * Filter by `TaskRun.state_type`.
             */
            interface Type {
                /**
                 * A list of task run state types to include
                 */
                any_?: Array<'SCHEDULED' | 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'CRASHED' | 'PAUSED' | 'CANCELLING'> | null;
            }
        }
        /**
         * Filter by `TaskRun.subflow_run`.
         */
        interface SubflowRuns {
            /**
             * If true, only include task runs that are subflow run parents; if false, exclude
             * parent task runs
             */
            exists_?: boolean | null;
        }
        /**
         * Filter by `TaskRun.tags`.
         */
        interface Tags {
            /**
             * A list of tags. Task runs will be returned only if their tags are a superset of
             * the list
             */
            all_?: Array<string> | null;
            /**
             * If true, only include task runs without tags
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
    }
    /**
     * Filter work queues. Only work queues matching all criteria will be returned
     */
    interface WorkPoolQueues {
        /**
         * Filter by `WorkQueue.id`.
         */
        id?: WorkPoolQueues.ID | null;
        /**
         * Filter by `WorkQueue.name`.
         */
        name?: WorkPoolQueues.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
    }
    namespace WorkPoolQueues {
        /**
         * Filter by `WorkQueue.id`.
         */
        interface ID {
            /**
             * A list of work queue ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `WorkQueue.name`.
         */
        interface Name {
            /**
             * A list of work queue names to include
             */
            any_?: Array<string> | null;
            /**
             * A list of case-insensitive starts-with matches. For example, passing 'marvin'
             * will match 'marvin', and 'Marvin-robot', but not 'sad-marvin'.
             */
            startswith_?: Array<string> | null;
        }
    }
    /**
     * Filter work pools. Only work pools matching all criteria will be returned
     */
    interface WorkPools {
        /**
         * Filter by `WorkPool.id`.
         */
        id?: WorkPools.ID | null;
        /**
         * Filter by `WorkPool.name`.
         */
        name?: WorkPools.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `WorkPool.type`.
         */
        type?: WorkPools.Type | null;
    }
    namespace WorkPools {
        /**
         * Filter by `WorkPool.id`.
         */
        interface ID {
            /**
             * A list of work pool ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `WorkPool.name`.
         */
        interface Name {
            /**
             * A list of work pool names to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `WorkPool.type`.
         */
        interface Type {
            /**
             * A list of work pool types to include
             */
            any_?: Array<string> | null;
        }
    }
}
export interface DeploymentGetScheduledFlowRunsParams {
    /**
     * Body param: The deployment IDs to get scheduled runs for
     */
    deployment_ids: Array<string>;
    /**
     * Body param: Defaults to PREFECT_API_DEFAULT_LIMIT if not provided.
     */
    limit?: number;
    /**
     * Body param: The maximum time to look for scheduled flow runs
     */
    scheduled_before?: string;
    /**
     * Header param:
     */
    'x-prefect-api-version'?: string;
}
export interface DeploymentPaginateQueryParams {
    /**
     * Body param: Filter for deployments. Only deployments matching all criteria will
     * be returned.
     */
    deployments?: DeploymentPaginateQueryParams.Deployments;
    /**
     * Body param: Filter flow runs. Only flow runs matching all criteria will be
     * returned
     */
    flow_runs?: DeploymentPaginateQueryParams.FlowRuns;
    /**
     * Body param: Filter for flows. Only flows matching all criteria will be returned.
     */
    flows?: DeploymentPaginateQueryParams.Flows;
    /**
     * Body param: Defaults to PREFECT_API_DEFAULT_LIMIT if not provided.
     */
    limit?: number;
    /**
     * Body param:
     */
    page?: number;
    /**
     * Body param: Defines deployment sorting options.
     */
    sort?: 'CREATED_DESC' | 'UPDATED_DESC' | 'NAME_ASC' | 'NAME_DESC';
    /**
     * Body param: Filter task runs. Only task runs matching all criteria will be
     * returned
     */
    task_runs?: DeploymentPaginateQueryParams.TaskRuns;
    /**
     * Body param: Filter work queues. Only work queues matching all criteria will be
     * returned
     */
    work_pool_queues?: DeploymentPaginateQueryParams.WorkPoolQueues;
    /**
     * Body param: Filter work pools. Only work pools matching all criteria will be
     * returned
     */
    work_pools?: DeploymentPaginateQueryParams.WorkPools;
    /**
     * Header param:
     */
    'x-prefect-api-version'?: string;
}
export declare namespace DeploymentPaginateQueryParams {
    /**
     * Filter for deployments. Only deployments matching all criteria will be returned.
     */
    interface Deployments {
        /**
         * Filter by `Deployment.id`.
         */
        id?: Deployments.ID | null;
        /**
         * Filter by `Deployment.concurrency_limit`.
         */
        concurrency_limit?: Deployments.ConcurrencyLimit | null;
        /**
         * Filter by `Deployment.name` or `Flow.name` with a single input string for ilike
         * filtering.
         */
        flow_or_deployment_name?: Deployments.FlowOrDeploymentName | null;
        /**
         * Filter by `Deployment.name`.
         */
        name?: Deployments.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `Deployment.paused`.
         */
        paused?: Deployments.Paused | null;
        /**
         * Filter by `Deployment.tags`.
         */
        tags?: Deployments.Tags | null;
        /**
         * Filter by `Deployment.work_queue_name`.
         */
        work_queue_name?: Deployments.WorkQueueName | null;
    }
    namespace Deployments {
        /**
         * Filter by `Deployment.id`.
         */
        interface ID {
            /**
             * A list of deployment ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `Deployment.concurrency_limit`.
         */
        interface ConcurrencyLimit {
            /**
             * Only include deployments with a concurrency limit greater than or equal to this
             * value
             */
            ge_?: number | null;
            /**
             * If true, only include deployments without a concurrency limit
             */
            is_null_?: boolean | null;
            /**
             * Only include deployments with a concurrency limit less than or equal to this
             * value
             */
            le_?: number | null;
        }
        /**
         * Filter by `Deployment.name` or `Flow.name` with a single input string for ilike
         * filtering.
         */
        interface FlowOrDeploymentName {
            /**
             * A case-insensitive partial match on deployment or flow names. For example,
             * passing 'example' might match deployments or flows with 'example' in their
             * names.
             */
            like_?: string | null;
        }
        /**
         * Filter by `Deployment.name`.
         */
        interface Name {
            /**
             * A list of deployment names to include
             */
            any_?: Array<string> | null;
            /**
             * A case-insensitive partial match. For example, passing 'marvin' will match
             * 'marvin', 'sad-Marvin', and 'marvin-robot'.
             */
            like_?: string | null;
        }
        /**
         * Filter by `Deployment.paused`.
         */
        interface Paused {
            /**
             * Only returns where deployment is/is not paused
             */
            eq_?: boolean | null;
        }
        /**
         * Filter by `Deployment.tags`.
         */
        interface Tags {
            /**
             * A list of tags. Deployments will be returned only if their tags are a superset
             * of the list
             */
            all_?: Array<string> | null;
            /**
             * If true, only include deployments without tags
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `Deployment.work_queue_name`.
         */
        interface WorkQueueName {
            /**
             * A list of work queue names to include
             */
            any_?: Array<string> | null;
        }
    }
    /**
     * Filter flow runs. Only flow runs matching all criteria will be returned
     */
    interface FlowRuns {
        /**
         * Filter by `FlowRun.id`.
         */
        id?: FlowRuns.ID | null;
        /**
         * Filter by `FlowRun.deployment_id`.
         */
        deployment_id?: FlowRuns.DeploymentID | null;
        /**
         * Filter by `FlowRun.expected_start_time`.
         */
        expected_start_time?: FlowRuns.ExpectedStartTime | null;
        /**
         * Filter by `FlowRun.flow_version`.
         */
        flow_version?: FlowRuns.FlowVersion | null;
        /**
         * Filter by FlowRun.idempotency_key.
         */
        idempotency_key?: FlowRuns.IdempotencyKey | null;
        /**
         * Filter by `FlowRun.name`.
         */
        name?: FlowRuns.Name | null;
        /**
         * Filter by `FlowRun.next_scheduled_start_time`.
         */
        next_scheduled_start_time?: FlowRuns.NextScheduledStartTime | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter for subflows of a given flow run
         */
        parent_flow_run_id?: FlowRuns.ParentFlowRunID | null;
        /**
         * Filter by `FlowRun.parent_task_run_id`.
         */
        parent_task_run_id?: FlowRuns.ParentTaskRunID | null;
        /**
         * Filter by `FlowRun.start_time`.
         */
        start_time?: FlowRuns.StartTime | null;
        /**
         * Filter by `FlowRun.state_type` and `FlowRun.state_name`.
         */
        state?: FlowRuns.State | null;
        /**
         * Filter by `FlowRun.tags`.
         */
        tags?: FlowRuns.Tags | null;
        /**
         * Filter by `FlowRun.work_queue_name`.
         */
        work_queue_name?: FlowRuns.WorkQueueName | null;
    }
    namespace FlowRuns {
        /**
         * Filter by `FlowRun.id`.
         */
        interface ID {
            /**
             * A list of flow run ids to include
             */
            any_?: Array<string> | null;
            /**
             * A list of flow run ids to exclude
             */
            not_any_?: Array<string> | null;
        }
        /**
         * Filter by `FlowRun.deployment_id`.
         */
        interface DeploymentID {
            /**
             * A list of flow run deployment ids to include
             */
            any_?: Array<string> | null;
            /**
             * If true, only include flow runs without deployment ids
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `FlowRun.expected_start_time`.
         */
        interface ExpectedStartTime {
            /**
             * Only include flow runs scheduled to start at or after this time
             */
            after_?: string | null;
            /**
             * Only include flow runs scheduled to start at or before this time
             */
            before_?: string | null;
        }
        /**
         * Filter by `FlowRun.flow_version`.
         */
        interface FlowVersion {
            /**
             * A list of flow run flow_versions to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by FlowRun.idempotency_key.
         */
        interface IdempotencyKey {
            /**
             * A list of flow run idempotency keys to include
             */
            any_?: Array<string> | null;
            /**
             * A list of flow run idempotency keys to exclude
             */
            not_any_?: Array<string> | null;
        }
        /**
         * Filter by `FlowRun.name`.
         */
        interface Name {
            /**
             * A list of flow run names to include
             */
            any_?: Array<string> | null;
            /**
             * A case-insensitive partial match. For example, passing 'marvin' will match
             * 'marvin', 'sad-Marvin', and 'marvin-robot'.
             */
            like_?: string | null;
        }
        /**
         * Filter by `FlowRun.next_scheduled_start_time`.
         */
        interface NextScheduledStartTime {
            /**
             * Only include flow runs with a next_scheduled_start_time at or after this time
             */
            after_?: string | null;
            /**
             * Only include flow runs with a next_scheduled_start_time or before this time
             */
            before_?: string | null;
        }
        /**
         * Filter for subflows of a given flow run
         */
        interface ParentFlowRunID {
            /**
             * A list of parent flow run ids to include
             */
            any_?: Array<string> | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `FlowRun.parent_task_run_id`.
         */
        interface ParentTaskRunID {
            /**
             * A list of flow run parent_task_run_ids to include
             */
            any_?: Array<string> | null;
            /**
             * If true, only include flow runs without parent_task_run_id
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `FlowRun.start_time`.
         */
        interface StartTime {
            /**
             * Only include flow runs starting at or after this time
             */
            after_?: string | null;
            /**
             * Only include flow runs starting at or before this time
             */
            before_?: string | null;
            /**
             * If true, only return flow runs without a start time
             */
            is_null_?: boolean | null;
        }
        /**
         * Filter by `FlowRun.state_type` and `FlowRun.state_name`.
         */
        interface State {
            /**
             * Filter by `FlowRun.state_name`.
             */
            name?: State.Name | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
            /**
             * Filter by `FlowRun.state_type`.
             */
            type?: State.Type | null;
        }
        namespace State {
            /**
             * Filter by `FlowRun.state_name`.
             */
            interface Name {
                /**
                 * A list of flow run state names to include
                 */
                any_?: Array<string> | null;
                /**
                 * A list of flow run state names to exclude
                 */
                not_any_?: Array<string> | null;
            }
            /**
             * Filter by `FlowRun.state_type`.
             */
            interface Type {
                /**
                 * A list of flow run state types to include
                 */
                any_?: Array<'SCHEDULED' | 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'CRASHED' | 'PAUSED' | 'CANCELLING'> | null;
                /**
                 * A list of flow run state types to exclude
                 */
                not_any_?: Array<'SCHEDULED' | 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'CRASHED' | 'PAUSED' | 'CANCELLING'> | null;
            }
        }
        /**
         * Filter by `FlowRun.tags`.
         */
        interface Tags {
            /**
             * A list of tags. Flow runs will be returned only if their tags are a superset of
             * the list
             */
            all_?: Array<string> | null;
            /**
             * If true, only include flow runs without tags
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `FlowRun.work_queue_name`.
         */
        interface WorkQueueName {
            /**
             * A list of work queue names to include
             */
            any_?: Array<string> | null;
            /**
             * If true, only include flow runs without work queue names
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
    }
    /**
     * Filter for flows. Only flows matching all criteria will be returned.
     */
    interface Flows {
        /**
         * Filter by `Flow.id`.
         */
        id?: Flows.ID | null;
        /**
         * Filter by flows by deployment
         */
        deployment?: Flows.Deployment | null;
        /**
         * Filter by `Flow.name`.
         */
        name?: Flows.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `Flow.tags`.
         */
        tags?: Flows.Tags | null;
    }
    namespace Flows {
        /**
         * Filter by `Flow.id`.
         */
        interface ID {
            /**
             * A list of flow ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by flows by deployment
         */
        interface Deployment {
            /**
             * If true, only include flows without deployments
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `Flow.name`.
         */
        interface Name {
            /**
             * A list of flow names to include
             */
            any_?: Array<string> | null;
            /**
             * A case-insensitive partial match. For example, passing 'marvin' will match
             * 'marvin', 'sad-Marvin', and 'marvin-robot'.
             */
            like_?: string | null;
        }
        /**
         * Filter by `Flow.tags`.
         */
        interface Tags {
            /**
             * A list of tags. Flows will be returned only if their tags are a superset of the
             * list
             */
            all_?: Array<string> | null;
            /**
             * If true, only include flows without tags
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
    }
    /**
     * Filter task runs. Only task runs matching all criteria will be returned
     */
    interface TaskRuns {
        /**
         * Filter by `TaskRun.id`.
         */
        id?: TaskRuns.ID | null;
        /**
         * Filter by `TaskRun.expected_start_time`.
         */
        expected_start_time?: TaskRuns.ExpectedStartTime | null;
        /**
         * Filter by `TaskRun.flow_run_id`.
         */
        flow_run_id?: TaskRuns.FlowRunID | null;
        /**
         * Filter by `TaskRun.name`.
         */
        name?: TaskRuns.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `TaskRun.start_time`.
         */
        start_time?: TaskRuns.StartTime | null;
        /**
         * Filter by `TaskRun.type` and `TaskRun.name`.
         */
        state?: TaskRuns.State | null;
        /**
         * Filter by `TaskRun.subflow_run`.
         */
        subflow_runs?: TaskRuns.SubflowRuns | null;
        /**
         * Filter by `TaskRun.tags`.
         */
        tags?: TaskRuns.Tags | null;
    }
    namespace TaskRuns {
        /**
         * Filter by `TaskRun.id`.
         */
        interface ID {
            /**
             * A list of task run ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `TaskRun.expected_start_time`.
         */
        interface ExpectedStartTime {
            /**
             * Only include task runs expected to start at or after this time
             */
            after_?: string | null;
            /**
             * Only include task runs expected to start at or before this time
             */
            before_?: string | null;
        }
        /**
         * Filter by `TaskRun.flow_run_id`.
         */
        interface FlowRunID {
            /**
             * A list of task run flow run ids to include
             */
            any_?: Array<string> | null;
            /**
             * Filter for task runs with None as their flow run id
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
        /**
         * Filter by `TaskRun.name`.
         */
        interface Name {
            /**
             * A list of task run names to include
             */
            any_?: Array<string> | null;
            /**
             * A case-insensitive partial match. For example, passing 'marvin' will match
             * 'marvin', 'sad-Marvin', and 'marvin-robot'.
             */
            like_?: string | null;
        }
        /**
         * Filter by `TaskRun.start_time`.
         */
        interface StartTime {
            /**
             * Only include task runs starting at or after this time
             */
            after_?: string | null;
            /**
             * Only include task runs starting at or before this time
             */
            before_?: string | null;
            /**
             * If true, only return task runs without a start time
             */
            is_null_?: boolean | null;
        }
        /**
         * Filter by `TaskRun.type` and `TaskRun.name`.
         */
        interface State {
            /**
             * Filter by `TaskRun.state_name`.
             */
            name?: State.Name | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
            /**
             * Filter by `TaskRun.state_type`.
             */
            type?: State.Type | null;
        }
        namespace State {
            /**
             * Filter by `TaskRun.state_name`.
             */
            interface Name {
                /**
                 * A list of task run state names to include
                 */
                any_?: Array<string> | null;
            }
            /**
             * Filter by `TaskRun.state_type`.
             */
            interface Type {
                /**
                 * A list of task run state types to include
                 */
                any_?: Array<'SCHEDULED' | 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'CRASHED' | 'PAUSED' | 'CANCELLING'> | null;
            }
        }
        /**
         * Filter by `TaskRun.subflow_run`.
         */
        interface SubflowRuns {
            /**
             * If true, only include task runs that are subflow run parents; if false, exclude
             * parent task runs
             */
            exists_?: boolean | null;
        }
        /**
         * Filter by `TaskRun.tags`.
         */
        interface Tags {
            /**
             * A list of tags. Task runs will be returned only if their tags are a superset of
             * the list
             */
            all_?: Array<string> | null;
            /**
             * If true, only include task runs without tags
             */
            is_null_?: boolean | null;
            /**
             * Operator for combining filter criteria. Defaults to 'and\_'.
             */
            operator?: 'and_' | 'or_';
        }
    }
    /**
     * Filter work queues. Only work queues matching all criteria will be returned
     */
    interface WorkPoolQueues {
        /**
         * Filter by `WorkQueue.id`.
         */
        id?: WorkPoolQueues.ID | null;
        /**
         * Filter by `WorkQueue.name`.
         */
        name?: WorkPoolQueues.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
    }
    namespace WorkPoolQueues {
        /**
         * Filter by `WorkQueue.id`.
         */
        interface ID {
            /**
             * A list of work queue ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `WorkQueue.name`.
         */
        interface Name {
            /**
             * A list of work queue names to include
             */
            any_?: Array<string> | null;
            /**
             * A list of case-insensitive starts-with matches. For example, passing 'marvin'
             * will match 'marvin', and 'Marvin-robot', but not 'sad-marvin'.
             */
            startswith_?: Array<string> | null;
        }
    }
    /**
     * Filter work pools. Only work pools matching all criteria will be returned
     */
    interface WorkPools {
        /**
         * Filter by `WorkPool.id`.
         */
        id?: WorkPools.ID | null;
        /**
         * Filter by `WorkPool.name`.
         */
        name?: WorkPools.Name | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `WorkPool.type`.
         */
        type?: WorkPools.Type | null;
    }
    namespace WorkPools {
        /**
         * Filter by `WorkPool.id`.
         */
        interface ID {
            /**
             * A list of work pool ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `WorkPool.name`.
         */
        interface Name {
            /**
             * A list of work pool names to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `WorkPool.type`.
         */
        interface Type {
            /**
             * A list of work pool types to include
             */
            any_?: Array<string> | null;
        }
    }
}
export interface DeploymentPauseDeploymentParams {
    'x-prefect-api-version'?: string;
}
export interface DeploymentResumeDeploymentParams {
    'x-prefect-api-version'?: string;
}
export declare namespace Deployments {
    export import DeploymentPaginationResponse = DeploymentsAPI.DeploymentPaginationResponse;
    export import DeploymentResponse = DeploymentsAPI.DeploymentResponse;
    export import DeploymentSchedule = DeploymentsAPI.DeploymentSchedule;
    export import WorkQueue = DeploymentsAPI.WorkQueue;
    export import DeploymentCountResponse = DeploymentsAPI.DeploymentCountResponse;
    export import DeploymentFilterResponse = DeploymentsAPI.DeploymentFilterResponse;
    export import DeploymentGetScheduledFlowRunsResponse = DeploymentsAPI.DeploymentGetScheduledFlowRunsResponse;
    export import DeploymentPauseDeploymentResponse = DeploymentsAPI.DeploymentPauseDeploymentResponse;
    export import DeploymentResumeDeploymentResponse = DeploymentsAPI.DeploymentResumeDeploymentResponse;
    export import DeploymentCreateParams = DeploymentsAPI.DeploymentCreateParams;
    export import DeploymentRetrieveParams = DeploymentsAPI.DeploymentRetrieveParams;
    export import DeploymentUpdateParams = DeploymentsAPI.DeploymentUpdateParams;
    export import DeploymentDeleteParams = DeploymentsAPI.DeploymentDeleteParams;
    export import DeploymentCountParams = DeploymentsAPI.DeploymentCountParams;
    export import DeploymentFilterParams = DeploymentsAPI.DeploymentFilterParams;
    export import DeploymentGetScheduledFlowRunsParams = DeploymentsAPI.DeploymentGetScheduledFlowRunsParams;
    export import DeploymentPaginateQueryParams = DeploymentsAPI.DeploymentPaginateQueryParams;
    export import DeploymentPauseDeploymentParams = DeploymentsAPI.DeploymentPauseDeploymentParams;
    export import DeploymentResumeDeploymentParams = DeploymentsAPI.DeploymentResumeDeploymentParams;
    export import Names = NamesAPI.Names;
    export import NameRetrieveParams = NamesAPI.NameRetrieveParams;
    export import FlowRuns = FlowRunsAPI.FlowRuns;
    export import FlowRunCreateFlowRunParams = FlowRunsAPI.FlowRunCreateFlowRunParams;
    export import Schedules = SchedulesAPI.Schedules;
    export import ScheduleCreateResponse = SchedulesAPI.ScheduleCreateResponse;
    export import ScheduleListResponse = SchedulesAPI.ScheduleListResponse;
    export import ScheduleScheduleRunsResponse = SchedulesAPI.ScheduleScheduleRunsResponse;
    export import ScheduleCreateParams = SchedulesAPI.ScheduleCreateParams;
    export import ScheduleUpdateParams = SchedulesAPI.ScheduleUpdateParams;
    export import ScheduleListParams = SchedulesAPI.ScheduleListParams;
    export import ScheduleDeleteParams = SchedulesAPI.ScheduleDeleteParams;
    export import ScheduleScheduleRunsParams = SchedulesAPI.ScheduleScheduleRunsParams;
    export import WorkQueueCheck = WorkQueueCheckAPI.WorkQueueCheck;
    export import WorkQueueCheckListResponse = WorkQueueCheckAPI.WorkQueueCheckListResponse;
    export import WorkQueueCheckListParams = WorkQueueCheckAPI.WorkQueueCheckListParams;
}
//# sourceMappingURL=deployments.d.ts.map