// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

import { APIResource } from '../../resource';
import { isRequestOptions } from '../../core';
import * as Core from '../../core';
import * as FlowRunsAPI from './flow-runs';
import * as Shared from '../shared';
import * as GraphAPI from './graph';
import * as GraphV2API from './graph-v2';
import * as InputAPI from './input';
import * as LogsAPI from './logs';

export class FlowRuns extends APIResource {
  graph: GraphAPI.Graph = new GraphAPI.Graph(this._client);
  graphV2: GraphV2API.GraphV2 = new GraphV2API.GraphV2(this._client);
  input: InputAPI.Input = new InputAPI.Input(this._client);
  logs: LogsAPI.Logs = new LogsAPI.Logs(this._client);

  /**
   * Create a flow run. If a flow run with the same flow_id and idempotency key
   * already exists, the existing flow run will be returned.
   *
   * If no state is provided, the flow run will be created in a PENDING state.
   */
  create(
    params: FlowRunCreateParams,
    options?: Core.RequestOptions,
  ): Core.APIPromise<Shared.FlowRunResponse> {
    const { 'x-prefect-api-version': xPrefectAPIVersion, ...body } = params;
    return this._client.post('/api/flow_runs/', {
      body,
      ...options,
      headers: {
        ...(xPrefectAPIVersion != null ? { 'x-prefect-api-version': xPrefectAPIVersion } : undefined),
        ...options?.headers,
      },
    });
  }

  /**
   * Get a flow run by id.
   */
  retrieve(
    id: string,
    params?: FlowRunRetrieveParams,
    options?: Core.RequestOptions,
  ): Core.APIPromise<Shared.FlowRunResponse>;
  retrieve(id: string, options?: Core.RequestOptions): Core.APIPromise<Shared.FlowRunResponse>;
  retrieve(
    id: string,
    params: FlowRunRetrieveParams | Core.RequestOptions = {},
    options?: Core.RequestOptions,
  ): Core.APIPromise<Shared.FlowRunResponse> {
    if (isRequestOptions(params)) {
      return this.retrieve(id, {}, params);
    }
    const { 'x-prefect-api-version': xPrefectAPIVersion } = params;
    return this._client.get(`/api/flow_runs/${id}`, {
      ...options,
      headers: {
        ...(xPrefectAPIVersion != null ? { 'x-prefect-api-version': xPrefectAPIVersion } : undefined),
        ...options?.headers,
      },
    });
  }

  /**
   * Updates a flow run.
   */
  update(id: string, params: FlowRunUpdateParams, options?: Core.RequestOptions): Core.APIPromise<void> {
    const { 'x-prefect-api-version': xPrefectAPIVersion, ...body } = params;
    return this._client.patch(`/api/flow_runs/${id}`, {
      body,
      ...options,
      headers: {
        Accept: '*/*',
        ...(xPrefectAPIVersion != null ? { 'x-prefect-api-version': xPrefectAPIVersion } : undefined),
        ...options?.headers,
      },
    });
  }

  /**
   * Delete a flow run by id.
   */
  delete(id: string, params?: FlowRunDeleteParams, options?: Core.RequestOptions): Core.APIPromise<void>;
  delete(id: string, options?: Core.RequestOptions): Core.APIPromise<void>;
  delete(
    id: string,
    params: FlowRunDeleteParams | Core.RequestOptions = {},
    options?: Core.RequestOptions,
  ): Core.APIPromise<void> {
    if (isRequestOptions(params)) {
      return this.delete(id, {}, params);
    }
    const { 'x-prefect-api-version': xPrefectAPIVersion } = params;
    return this._client.delete(`/api/flow_runs/${id}`, {
      ...options,
      headers: {
        Accept: '*/*',
        ...(xPrefectAPIVersion != null ? { 'x-prefect-api-version': xPrefectAPIVersion } : undefined),
        ...options?.headers,
      },
    });
  }

  /**
   * Query for flow runs.
   */
  count(params?: FlowRunCountParams, options?: Core.RequestOptions): Core.APIPromise<FlowRunCountResponse>;
  count(options?: Core.RequestOptions): Core.APIPromise<FlowRunCountResponse>;
  count(
    params: FlowRunCountParams | Core.RequestOptions = {},
    options?: Core.RequestOptions,
  ): Core.APIPromise<FlowRunCountResponse> {
    if (isRequestOptions(params)) {
      return this.count({}, params);
    }
    const { 'x-prefect-api-version': xPrefectAPIVersion, ...body } = params;
    return this._client.post('/api/flow_runs/count', {
      body,
      ...options,
      headers: {
        ...(xPrefectAPIVersion != null ? { 'x-prefect-api-version': xPrefectAPIVersion } : undefined),
        ...options?.headers,
      },
    });
  }

  /**
   * Query for flow runs.
   */
  filter(params?: FlowRunFilterParams, options?: Core.RequestOptions): Core.APIPromise<FlowRunFilterResponse>;
  filter(options?: Core.RequestOptions): Core.APIPromise<FlowRunFilterResponse>;
  filter(
    params: FlowRunFilterParams | Core.RequestOptions = {},
    options?: Core.RequestOptions,
  ): Core.APIPromise<FlowRunFilterResponse> {
    if (isRequestOptions(params)) {
      return this.filter({}, params);
    }
    const { 'x-prefect-api-version': xPrefectAPIVersion, ...body } = params;
    return this._client.post('/api/flow_runs/filter', {
      body,
      ...options,
      headers: {
        ...(xPrefectAPIVersion != null ? { 'x-prefect-api-version': xPrefectAPIVersion } : undefined),
        ...options?.headers,
      },
    });
  }

  /**
   * Query for flow run history data across a given range and interval.
   */
  history(
    params: FlowRunHistoryParams,
    options?: Core.RequestOptions,
  ): Core.APIPromise<FlowRunHistoryResponse> {
    const { 'x-prefect-api-version': xPrefectAPIVersion, ...body } = params;
    return this._client.post('/api/flow_runs/history', {
      body,
      ...options,
      headers: {
        ...(xPrefectAPIVersion != null ? { 'x-prefect-api-version': xPrefectAPIVersion } : undefined),
        ...options?.headers,
      },
    });
  }

  /**
   * Query for average flow-run lateness in seconds.
   */
  lateness(
    params?: FlowRunLatenessParams,
    options?: Core.RequestOptions,
  ): Core.APIPromise<FlowRunLatenessResponse | null>;
  lateness(options?: Core.RequestOptions): Core.APIPromise<FlowRunLatenessResponse | null>;
  lateness(
    params: FlowRunLatenessParams | Core.RequestOptions = {},
    options?: Core.RequestOptions,
  ): Core.APIPromise<FlowRunLatenessResponse | null> {
    if (isRequestOptions(params)) {
      return this.lateness({}, params);
    }
    const { 'x-prefect-api-version': xPrefectAPIVersion, ...body } = params;
    return this._client.post('/api/flow_runs/lateness', {
      body,
      ...options,
      headers: {
        ...(xPrefectAPIVersion != null ? { 'x-prefect-api-version': xPrefectAPIVersion } : undefined),
        ...options?.headers,
      },
    });
  }

  /**
   * Pagination query for flow runs.
   */
  paginate(
    params?: FlowRunPaginateParams,
    options?: Core.RequestOptions,
  ): Core.APIPromise<FlowRunPaginationResponse>;
  paginate(options?: Core.RequestOptions): Core.APIPromise<FlowRunPaginationResponse>;
  paginate(
    params: FlowRunPaginateParams | Core.RequestOptions = {},
    options?: Core.RequestOptions,
  ): Core.APIPromise<FlowRunPaginationResponse> {
    if (isRequestOptions(params)) {
      return this.paginate({}, params);
    }
    const { 'x-prefect-api-version': xPrefectAPIVersion, ...body } = params;
    return this._client.post('/api/flow_runs/paginate', {
      body,
      ...options,
      headers: {
        ...(xPrefectAPIVersion != null ? { 'x-prefect-api-version': xPrefectAPIVersion } : undefined),
        ...options?.headers,
      },
    });
  }

  /**
   * Resume a paused flow run.
   */
  resume(
    id: string,
    params?: FlowRunResumeParams,
    options?: Core.RequestOptions,
  ): Core.APIPromise<Shared.OrchestrationResult>;
  resume(id: string, options?: Core.RequestOptions): Core.APIPromise<Shared.OrchestrationResult>;
  resume(
    id: string,
    params: FlowRunResumeParams | Core.RequestOptions = {},
    options?: Core.RequestOptions,
  ): Core.APIPromise<Shared.OrchestrationResult> {
    if (isRequestOptions(params)) {
      return this.resume(id, {}, params);
    }
    const { 'x-prefect-api-version': xPrefectAPIVersion, ...body } = params;
    return this._client.post(`/api/flow_runs/${id}/resume`, {
      body,
      ...options,
      headers: {
        ...(xPrefectAPIVersion != null ? { 'x-prefect-api-version': xPrefectAPIVersion } : undefined),
        ...options?.headers,
      },
    });
  }

  /**
   * Set a flow run state, invoking any orchestration rules.
   */
  setState(
    id: string,
    params: FlowRunSetStateParams,
    options?: Core.RequestOptions,
  ): Core.APIPromise<Shared.OrchestrationResult> {
    const { 'x-prefect-api-version': xPrefectAPIVersion, ...body } = params;
    return this._client.post(`/api/flow_runs/${id}/set_state`, {
      body,
      ...options,
      headers: {
        ...(xPrefectAPIVersion != null ? { 'x-prefect-api-version': xPrefectAPIVersion } : undefined),
        ...options?.headers,
      },
    });
  }
}

export interface DependencyResult {
  id: string;

  end_time: string | null;

  estimated_run_time: number | null;

  expected_start_time: string | null;

  name: string;

  start_time: string | null;

  /**
   * Represents the state of a run.
   */
  state: Shared.State;

  total_run_time: number | null;

  untrackable_result: boolean;

  upstream_dependencies: Array<DependencyResult.UpstreamDependency>;
}

export namespace DependencyResult {
  /**
   * Represents a task run result input to another task run.
   */
  export interface UpstreamDependency {
    id: string;

    input_type?: 'task_run';
  }
}

export interface FlowRunInput {
  /**
   * The flow run ID associated with the input.
   */
  flow_run_id: string;

  /**
   * The key of the input.
   */
  key: string;

  /**
   * The value of the input.
   */
  value: string;

  id?: string;

  created?: string | null;

  /**
   * The sender of the input.
   */
  sender?: string | null;

  updated?: string | null;
}

export interface FlowRunPaginationResponse {
  count: number;

  limit: number;

  page: number;

  pages: number;

  results: Array<Shared.FlowRunResponse>;
}

export interface Graph {
  artifacts: Array<FlowRunGraph.Artifact>;

  end_time: string | null;

  nodes: Array<Array<unknown>>;

  root_node_ids: Array<string>;

  start_time: string;

  states: Array<FlowRunGraph.State>;
}

export namespace FlowRunGraph {
  export interface Artifact {
    id: string;

    created: string;

    data: unknown | null;

    is_latest: boolean;

    key: string | null;

    type: string;
  }

  export interface State {
    id: string;

    name: string;

    timestamp: string;

    /**
     * Enumeration of state types.
     */
    type:
      | 'SCHEDULED'
      | 'PENDING'
      | 'RUNNING'
      | 'COMPLETED'
      | 'FAILED'
      | 'CANCELLED'
      | 'CRASHED'
      | 'PAUSED'
      | 'CANCELLING';
  }
}

export type FlowRunCountResponse = number;

export type FlowRunFilterResponse = Array<Shared.FlowRunResponse>;

export type FlowRunHistoryResponse = Array<Shared.HistoryResponse>;

export type FlowRunLatenessResponse = number | null;

export interface FlowRunCreateParams {
  /**
   * Body param: The id of the flow being run.
   */
  flow_id: string;

  /**
   * Body param: The context of the flow run.
   */
  context?: unknown;

  /**
   * Body param: DEPRECATED: The id of the deployment associated with this flow run,
   * if available.
   */
  deployment_id?: string | null;

  /**
   * Body param: The empirical policy for the flow run.
   */
  empirical_policy?: FlowRunCreateParams.EmpiricalPolicy;

  /**
   * Body param: The version of the flow being run.
   */
  flow_version?: string | null;

  /**
   * Body param: An optional idempotency key. If a flow run with the same idempotency
   * key has already been created, the existing flow run will be returned.
   */
  idempotency_key?: string | null;

  /**
   * Body param:
   */
  infrastructure_document_id?: string | null;

  /**
   * Body param: The name of the flow run. Defaults to a random slug if not
   * specified.
   */
  name?: string;

  /**
   * Body param:
   */
  parameters?: unknown;

  /**
   * Body param:
   */
  parent_task_run_id?: string | null;

  /**
   * Body param: Data used by the Prefect REST API to create a new state.
   */
  state?: FlowRunCreateParams.State | null;

  /**
   * Body param: A list of tags for the flow run.
   */
  tags?: Array<string>;

  /**
   * Header param:
   */
  'x-prefect-api-version'?: string;
}

export namespace FlowRunCreateParams {
  /**
   * The empirical policy for the flow run.
   */
  export interface EmpiricalPolicy {
    /**
     * @deprecated: The maximum number of retries. Field is not used. Please use
     * `retries` instead.
     */
    max_retries?: number;

    /**
     * Tracks pauses this run has observed.
     */
    pause_keys?: Array<unknown> | null;

    /**
     * Indicates if this run is resuming from a pause.
     */
    resuming?: boolean | null;

    /**
     * The number of retries.
     */
    retries?: number | null;

    /**
     * The delay time between retries, in seconds.
     */
    retry_delay?: number | null;

    /**
     * @deprecated: The delay between retries. Field is not used. Please use
     * `retry_delay` instead.
     */
    retry_delay_seconds?: number;
  }

  /**
   * Data used by the Prefect REST API to create a new state.
   */
  export interface State {
    /**
     * The type of the state to create
     */
    type:
      | 'SCHEDULED'
      | 'PENDING'
      | 'RUNNING'
      | 'COMPLETED'
      | 'FAILED'
      | 'CANCELLED'
      | 'CRASHED'
      | 'PAUSED'
      | 'CANCELLING';

    /**
     * The data of the state to create
     */
    data?: unknown | null;

    /**
     * The message of the state to create
     */
    message?: string | null;

    /**
     * The name of the state to create
     */
    name?: string | null;

    /**
     * The details of the state to create
     */
    state_details?: State.StateDetails;
  }

  export namespace State {
    /**
     * The details of the state to create
     */
    export interface StateDetails {
      cache_expiration?: string | null;

      cache_key?: string | null;

      child_flow_run_id?: string | null;

      deferred?: boolean | null;

      flow_run_id?: string | null;

      pause_key?: string | null;

      pause_reschedule?: boolean;

      pause_timeout?: string | null;

      refresh_cache?: boolean | null;

      retriable?: boolean | null;

      run_input_keyset?: Record<string, string> | null;

      scheduled_time?: string | null;

      task_parameters_id?: string | null;

      task_run_id?: string | null;

      transition_id?: string | null;

      untrackable_result?: boolean;
    }
  }
}

export interface FlowRunRetrieveParams {
  'x-prefect-api-version'?: string;
}

export interface FlowRunUpdateParams {
  /**
   * Body param: Defines of how a flow run should retry.
   */
  empirical_policy?: FlowRunUpdateParams.EmpiricalPolicy;

  /**
   * Body param:
   */
  flow_version?: string | null;

  /**
   * Body param:
   */
  infrastructure_pid?: string | null;

  /**
   * Body param:
   */
  job_variables?: unknown | null;

  /**
   * Body param:
   */
  name?: string | null;

  /**
   * Body param:
   */
  parameters?: unknown;

  /**
   * Body param:
   */
  tags?: Array<string>;

  /**
   * Header param:
   */
  'x-prefect-api-version'?: string;
}

export namespace FlowRunUpdateParams {
  /**
   * Defines of how a flow run should retry.
   */
  export interface EmpiricalPolicy {
    /**
     * @deprecated: The maximum number of retries. Field is not used. Please use
     * `retries` instead.
     */
    max_retries?: number;

    /**
     * Tracks pauses this run has observed.
     */
    pause_keys?: Array<unknown> | null;

    /**
     * Indicates if this run is resuming from a pause.
     */
    resuming?: boolean | null;

    /**
     * The number of retries.
     */
    retries?: number | null;

    /**
     * The delay time between retries, in seconds.
     */
    retry_delay?: number | null;

    /**
     * @deprecated: The delay between retries. Field is not used. Please use
     * `retry_delay` instead.
     */
    retry_delay_seconds?: number;
  }
}

export interface FlowRunDeleteParams {
  'x-prefect-api-version'?: string;
}

export interface FlowRunCountParams {
  /**
   * Body param: Filter for deployments. Only deployments matching all criteria will
   * be returned.
   */
  deployments?: FlowRunCountParams.Deployments;

  /**
   * Body param: Filter flow runs. Only flow runs matching all criteria will be
   * returned
   */
  flow_runs?: FlowRunCountParams.FlowRuns;

  /**
   * Body param: Filter for flows. Only flows matching all criteria will be returned.
   */
  flows?: FlowRunCountParams.Flows;

  /**
   * Body param: Filter task runs. Only task runs matching all criteria will be
   * returned
   */
  task_runs?: FlowRunCountParams.TaskRuns;

  /**
   * Body param: Filter work queues. Only work queues matching all criteria will be
   * returned
   */
  work_pool_queues?: FlowRunCountParams.WorkPoolQueues;

  /**
   * Body param: Filter work pools. Only work pools matching all criteria will be
   * returned
   */
  work_pools?: FlowRunCountParams.WorkPools;

  /**
   * Header param:
   */
  'x-prefect-api-version'?: string;
}

export namespace FlowRunCountParams {
  /**
   * Filter for deployments. Only deployments matching all criteria will be returned.
   */
  export 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;
  }

  export namespace Deployments {
    /**
     * Filter by `Deployment.id`.
     */
    export interface ID {
      /**
       * A list of deployment ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `Deployment.concurrency_limit`.
     */
    export 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.
     */
    export 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`.
     */
    export 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`.
     */
    export interface Paused {
      /**
       * Only returns where deployment is/is not paused
       */
      eq_?: boolean | null;
    }

    /**
     * Filter by `Deployment.tags`.
     */
    export 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`.
     */
    export 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
   */
  export 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;
  }

  export namespace FlowRuns {
    /**
     * Filter by `FlowRun.id`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export interface FlowVersion {
      /**
       * A list of flow run flow_versions to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by FlowRun.idempotency_key.
     */
    export 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`.
     */
    export 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`.
     */
    export 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
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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;
    }

    export namespace State {
      /**
       * Filter by `FlowRun.state_name`.
       */
      export 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`.
       */
      export 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`.
     */
    export 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`.
     */
    export 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.
   */
  export 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;
  }

  export namespace Flows {
    /**
     * Filter by `Flow.id`.
     */
    export interface ID {
      /**
       * A list of flow ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by flows by deployment
     */
    export 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`.
     */
    export 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`.
     */
    export 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
   */
  export 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;
  }

  export namespace TaskRuns {
    /**
     * Filter by `TaskRun.id`.
     */
    export interface ID {
      /**
       * A list of task run ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `TaskRun.expected_start_time`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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;
    }

    export namespace State {
      /**
       * Filter by `TaskRun.state_name`.
       */
      export interface Name {
        /**
         * A list of task run state names to include
         */
        any_?: Array<string> | null;
      }

      /**
       * Filter by `TaskRun.state_type`.
       */
      export 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`.
     */
    export 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`.
     */
    export 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
   */
  export 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_';
  }

  export namespace WorkPoolQueues {
    /**
     * Filter by `WorkQueue.id`.
     */
    export interface ID {
      /**
       * A list of work queue ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkQueue.name`.
     */
    export 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
   */
  export 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;
  }

  export namespace WorkPools {
    /**
     * Filter by `WorkPool.id`.
     */
    export interface ID {
      /**
       * A list of work pool ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkPool.name`.
     */
    export interface Name {
      /**
       * A list of work pool names to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkPool.type`.
     */
    export interface Type {
      /**
       * A list of work pool types to include
       */
      any_?: Array<string> | null;
    }
  }
}

export interface FlowRunFilterParams {
  /**
   * Body param: Filter for deployments. Only deployments matching all criteria will
   * be returned.
   */
  deployments?: FlowRunFilterParams.Deployments | null;

  /**
   * Body param: Filter flow runs. Only flow runs matching all criteria will be
   * returned
   */
  flow_runs?: FlowRunFilterParams.FlowRuns | null;

  /**
   * Body param: Filter for flows. Only flows matching all criteria will be returned.
   */
  flows?: FlowRunFilterParams.Flows | null;

  /**
   * Body param: Defaults to PREFECT_API_DEFAULT_LIMIT if not provided.
   */
  limit?: number;

  /**
   * Body param:
   */
  offset?: number;

  /**
   * Body param: Defines flow run sorting options.
   */
  sort?:
    | 'ID_DESC'
    | 'START_TIME_ASC'
    | 'START_TIME_DESC'
    | 'EXPECTED_START_TIME_ASC'
    | 'EXPECTED_START_TIME_DESC'
    | 'NAME_ASC'
    | 'NAME_DESC'
    | 'NEXT_SCHEDULED_START_TIME_ASC'
    | 'END_TIME_DESC';

  /**
   * Body param: Filter task runs. Only task runs matching all criteria will be
   * returned
   */
  task_runs?: FlowRunFilterParams.TaskRuns | null;

  /**
   * Body param: Filter work queues. Only work queues matching all criteria will be
   * returned
   */
  work_pool_queues?: FlowRunFilterParams.WorkPoolQueues | null;

  /**
   * Body param: Filter work pools. Only work pools matching all criteria will be
   * returned
   */
  work_pools?: FlowRunFilterParams.WorkPools | null;

  /**
   * Header param:
   */
  'x-prefect-api-version'?: string;
}

export namespace FlowRunFilterParams {
  /**
   * Filter for deployments. Only deployments matching all criteria will be returned.
   */
  export 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;
  }

  export namespace Deployments {
    /**
     * Filter by `Deployment.id`.
     */
    export interface ID {
      /**
       * A list of deployment ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `Deployment.concurrency_limit`.
     */
    export 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.
     */
    export 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`.
     */
    export 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`.
     */
    export interface Paused {
      /**
       * Only returns where deployment is/is not paused
       */
      eq_?: boolean | null;
    }

    /**
     * Filter by `Deployment.tags`.
     */
    export 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`.
     */
    export 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
   */
  export 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;
  }

  export namespace FlowRuns {
    /**
     * Filter by `FlowRun.id`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export interface FlowVersion {
      /**
       * A list of flow run flow_versions to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by FlowRun.idempotency_key.
     */
    export 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`.
     */
    export 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`.
     */
    export 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
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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;
    }

    export namespace State {
      /**
       * Filter by `FlowRun.state_name`.
       */
      export 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`.
       */
      export 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`.
     */
    export 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`.
     */
    export 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.
   */
  export 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;
  }

  export namespace Flows {
    /**
     * Filter by `Flow.id`.
     */
    export interface ID {
      /**
       * A list of flow ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by flows by deployment
     */
    export 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`.
     */
    export 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`.
     */
    export 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
   */
  export 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;
  }

  export namespace TaskRuns {
    /**
     * Filter by `TaskRun.id`.
     */
    export interface ID {
      /**
       * A list of task run ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `TaskRun.expected_start_time`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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;
    }

    export namespace State {
      /**
       * Filter by `TaskRun.state_name`.
       */
      export interface Name {
        /**
         * A list of task run state names to include
         */
        any_?: Array<string> | null;
      }

      /**
       * Filter by `TaskRun.state_type`.
       */
      export 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`.
     */
    export 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`.
     */
    export 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
   */
  export 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_';
  }

  export namespace WorkPoolQueues {
    /**
     * Filter by `WorkQueue.id`.
     */
    export interface ID {
      /**
       * A list of work queue ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkQueue.name`.
     */
    export 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
   */
  export 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;
  }

  export namespace WorkPools {
    /**
     * Filter by `WorkPool.id`.
     */
    export interface ID {
      /**
       * A list of work pool ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkPool.name`.
     */
    export interface Name {
      /**
       * A list of work pool names to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkPool.type`.
     */
    export interface Type {
      /**
       * A list of work pool types to include
       */
      any_?: Array<string> | null;
    }
  }
}

export interface FlowRunHistoryParams {
  /**
   * Body param: The history's end time.
   */
  history_end: string;

  /**
   * Body param: The size of each history interval, in seconds. Must be at least 1
   * second.
   */
  history_interval: number;

  /**
   * Body param: The history's start time.
   */
  history_start: string;

  /**
   * Body param: Filter for deployments. Only deployments matching all criteria will
   * be returned.
   */
  deployments?: FlowRunHistoryParams.Deployments;

  /**
   * Body param: Filter flow runs. Only flow runs matching all criteria will be
   * returned
   */
  flow_runs?: FlowRunHistoryParams.FlowRuns;

  /**
   * Body param: Filter for flows. Only flows matching all criteria will be returned.
   */
  flows?: FlowRunHistoryParams.Flows;

  /**
   * Body param: Filter task runs. Only task runs matching all criteria will be
   * returned
   */
  task_runs?: FlowRunHistoryParams.TaskRuns;

  /**
   * Body param: Filter work pools. Only work pools matching all criteria will be
   * returned
   */
  work_pools?: FlowRunHistoryParams.WorkPools;

  /**
   * Body param: Filter work queues. Only work queues matching all criteria will be
   * returned
   */
  work_queues?: FlowRunHistoryParams.WorkQueues;

  /**
   * Header param:
   */
  'x-prefect-api-version'?: string;
}

export namespace FlowRunHistoryParams {
  /**
   * Filter for deployments. Only deployments matching all criteria will be returned.
   */
  export 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;
  }

  export namespace Deployments {
    /**
     * Filter by `Deployment.id`.
     */
    export interface ID {
      /**
       * A list of deployment ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `Deployment.concurrency_limit`.
     */
    export 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.
     */
    export 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`.
     */
    export 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`.
     */
    export interface Paused {
      /**
       * Only returns where deployment is/is not paused
       */
      eq_?: boolean | null;
    }

    /**
     * Filter by `Deployment.tags`.
     */
    export 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`.
     */
    export 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
   */
  export 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;
  }

  export namespace FlowRuns {
    /**
     * Filter by `FlowRun.id`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export interface FlowVersion {
      /**
       * A list of flow run flow_versions to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by FlowRun.idempotency_key.
     */
    export 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`.
     */
    export 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`.
     */
    export 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
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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;
    }

    export namespace State {
      /**
       * Filter by `FlowRun.state_name`.
       */
      export 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`.
       */
      export 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`.
     */
    export 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`.
     */
    export 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.
   */
  export 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;
  }

  export namespace Flows {
    /**
     * Filter by `Flow.id`.
     */
    export interface ID {
      /**
       * A list of flow ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by flows by deployment
     */
    export 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`.
     */
    export 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`.
     */
    export 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
   */
  export 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;
  }

  export namespace TaskRuns {
    /**
     * Filter by `TaskRun.id`.
     */
    export interface ID {
      /**
       * A list of task run ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `TaskRun.expected_start_time`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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;
    }

    export namespace State {
      /**
       * Filter by `TaskRun.state_name`.
       */
      export interface Name {
        /**
         * A list of task run state names to include
         */
        any_?: Array<string> | null;
      }

      /**
       * Filter by `TaskRun.state_type`.
       */
      export 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`.
     */
    export 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`.
     */
    export 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 pools. Only work pools matching all criteria will be returned
   */
  export 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;
  }

  export namespace WorkPools {
    /**
     * Filter by `WorkPool.id`.
     */
    export interface ID {
      /**
       * A list of work pool ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkPool.name`.
     */
    export interface Name {
      /**
       * A list of work pool names to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkPool.type`.
     */
    export interface Type {
      /**
       * A list of work pool types to include
       */
      any_?: Array<string> | null;
    }
  }

  /**
   * Filter work queues. Only work queues matching all criteria will be returned
   */
  export interface WorkQueues {
    /**
     * Filter by `WorkQueue.id`.
     */
    id?: WorkQueues.ID | null;

    /**
     * Filter by `WorkQueue.name`.
     */
    name?: WorkQueues.Name | null;

    /**
     * Operator for combining filter criteria. Defaults to 'and\_'.
     */
    operator?: 'and_' | 'or_';
  }

  export namespace WorkQueues {
    /**
     * Filter by `WorkQueue.id`.
     */
    export interface ID {
      /**
       * A list of work queue ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkQueue.name`.
     */
    export 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;
    }
  }
}

export interface FlowRunLatenessParams {
  /**
   * Body param: Filter for deployments. Only deployments matching all criteria will
   * be returned.
   */
  deployments?: FlowRunLatenessParams.Deployments | null;

  /**
   * Body param: Filter flow runs. Only flow runs matching all criteria will be
   * returned
   */
  flow_runs?: FlowRunLatenessParams.FlowRuns | null;

  /**
   * Body param: Filter for flows. Only flows matching all criteria will be returned.
   */
  flows?: FlowRunLatenessParams.Flows | null;

  /**
   * Body param: Filter task runs. Only task runs matching all criteria will be
   * returned
   */
  task_runs?: FlowRunLatenessParams.TaskRuns | null;

  /**
   * Body param: Filter work queues. Only work queues matching all criteria will be
   * returned
   */
  work_pool_queues?: FlowRunLatenessParams.WorkPoolQueues | null;

  /**
   * Body param: Filter work pools. Only work pools matching all criteria will be
   * returned
   */
  work_pools?: FlowRunLatenessParams.WorkPools | null;

  /**
   * Header param:
   */
  'x-prefect-api-version'?: string;
}

export namespace FlowRunLatenessParams {
  /**
   * Filter for deployments. Only deployments matching all criteria will be returned.
   */
  export 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;
  }

  export namespace Deployments {
    /**
     * Filter by `Deployment.id`.
     */
    export interface ID {
      /**
       * A list of deployment ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `Deployment.concurrency_limit`.
     */
    export 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.
     */
    export 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`.
     */
    export 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`.
     */
    export interface Paused {
      /**
       * Only returns where deployment is/is not paused
       */
      eq_?: boolean | null;
    }

    /**
     * Filter by `Deployment.tags`.
     */
    export 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`.
     */
    export 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
   */
  export 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;
  }

  export namespace FlowRuns {
    /**
     * Filter by `FlowRun.id`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export interface FlowVersion {
      /**
       * A list of flow run flow_versions to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by FlowRun.idempotency_key.
     */
    export 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`.
     */
    export 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`.
     */
    export 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
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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;
    }

    export namespace State {
      /**
       * Filter by `FlowRun.state_name`.
       */
      export 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`.
       */
      export 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`.
     */
    export 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`.
     */
    export 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.
   */
  export 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;
  }

  export namespace Flows {
    /**
     * Filter by `Flow.id`.
     */
    export interface ID {
      /**
       * A list of flow ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by flows by deployment
     */
    export 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`.
     */
    export 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`.
     */
    export 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
   */
  export 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;
  }

  export namespace TaskRuns {
    /**
     * Filter by `TaskRun.id`.
     */
    export interface ID {
      /**
       * A list of task run ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `TaskRun.expected_start_time`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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;
    }

    export namespace State {
      /**
       * Filter by `TaskRun.state_name`.
       */
      export interface Name {
        /**
         * A list of task run state names to include
         */
        any_?: Array<string> | null;
      }

      /**
       * Filter by `TaskRun.state_type`.
       */
      export 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`.
     */
    export 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`.
     */
    export 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
   */
  export 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_';
  }

  export namespace WorkPoolQueues {
    /**
     * Filter by `WorkQueue.id`.
     */
    export interface ID {
      /**
       * A list of work queue ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkQueue.name`.
     */
    export 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
   */
  export 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;
  }

  export namespace WorkPools {
    /**
     * Filter by `WorkPool.id`.
     */
    export interface ID {
      /**
       * A list of work pool ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkPool.name`.
     */
    export interface Name {
      /**
       * A list of work pool names to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkPool.type`.
     */
    export interface Type {
      /**
       * A list of work pool types to include
       */
      any_?: Array<string> | null;
    }
  }
}

export interface FlowRunPaginateParams {
  /**
   * Body param: Filter for deployments. Only deployments matching all criteria will
   * be returned.
   */
  deployments?: FlowRunPaginateParams.Deployments | null;

  /**
   * Body param: Filter flow runs. Only flow runs matching all criteria will be
   * returned
   */
  flow_runs?: FlowRunPaginateParams.FlowRuns | null;

  /**
   * Body param: Filter for flows. Only flows matching all criteria will be returned.
   */
  flows?: FlowRunPaginateParams.Flows | null;

  /**
   * Body param: Defaults to PREFECT_API_DEFAULT_LIMIT if not provided.
   */
  limit?: number;

  /**
   * Body param:
   */
  page?: number;

  /**
   * Body param: Defines flow run sorting options.
   */
  sort?:
    | 'ID_DESC'
    | 'START_TIME_ASC'
    | 'START_TIME_DESC'
    | 'EXPECTED_START_TIME_ASC'
    | 'EXPECTED_START_TIME_DESC'
    | 'NAME_ASC'
    | 'NAME_DESC'
    | 'NEXT_SCHEDULED_START_TIME_ASC'
    | 'END_TIME_DESC';

  /**
   * Body param: Filter task runs. Only task runs matching all criteria will be
   * returned
   */
  task_runs?: FlowRunPaginateParams.TaskRuns | null;

  /**
   * Body param: Filter work queues. Only work queues matching all criteria will be
   * returned
   */
  work_pool_queues?: FlowRunPaginateParams.WorkPoolQueues | null;

  /**
   * Body param: Filter work pools. Only work pools matching all criteria will be
   * returned
   */
  work_pools?: FlowRunPaginateParams.WorkPools | null;

  /**
   * Header param:
   */
  'x-prefect-api-version'?: string;
}

export namespace FlowRunPaginateParams {
  /**
   * Filter for deployments. Only deployments matching all criteria will be returned.
   */
  export 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;
  }

  export namespace Deployments {
    /**
     * Filter by `Deployment.id`.
     */
    export interface ID {
      /**
       * A list of deployment ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `Deployment.concurrency_limit`.
     */
    export 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.
     */
    export 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`.
     */
    export 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`.
     */
    export interface Paused {
      /**
       * Only returns where deployment is/is not paused
       */
      eq_?: boolean | null;
    }

    /**
     * Filter by `Deployment.tags`.
     */
    export 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`.
     */
    export 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
   */
  export 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;
  }

  export namespace FlowRuns {
    /**
     * Filter by `FlowRun.id`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export interface FlowVersion {
      /**
       * A list of flow run flow_versions to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by FlowRun.idempotency_key.
     */
    export 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`.
     */
    export 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`.
     */
    export 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
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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;
    }

    export namespace State {
      /**
       * Filter by `FlowRun.state_name`.
       */
      export 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`.
       */
      export 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`.
     */
    export 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`.
     */
    export 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.
   */
  export 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;
  }

  export namespace Flows {
    /**
     * Filter by `Flow.id`.
     */
    export interface ID {
      /**
       * A list of flow ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by flows by deployment
     */
    export 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`.
     */
    export 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`.
     */
    export 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
   */
  export 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;
  }

  export namespace TaskRuns {
    /**
     * Filter by `TaskRun.id`.
     */
    export interface ID {
      /**
       * A list of task run ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `TaskRun.expected_start_time`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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`.
     */
    export 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;
    }

    export namespace State {
      /**
       * Filter by `TaskRun.state_name`.
       */
      export interface Name {
        /**
         * A list of task run state names to include
         */
        any_?: Array<string> | null;
      }

      /**
       * Filter by `TaskRun.state_type`.
       */
      export 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`.
     */
    export 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`.
     */
    export 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
   */
  export 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_';
  }

  export namespace WorkPoolQueues {
    /**
     * Filter by `WorkQueue.id`.
     */
    export interface ID {
      /**
       * A list of work queue ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkQueue.name`.
     */
    export 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
   */
  export 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;
  }

  export namespace WorkPools {
    /**
     * Filter by `WorkPool.id`.
     */
    export interface ID {
      /**
       * A list of work pool ids to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkPool.name`.
     */
    export interface Name {
      /**
       * A list of work pool names to include
       */
      any_?: Array<string> | null;
    }

    /**
     * Filter by `WorkPool.type`.
     */
    export interface Type {
      /**
       * A list of work pool types to include
       */
      any_?: Array<string> | null;
    }
  }
}

export interface FlowRunResumeParams {
  /**
   * Body param:
   */
  run_input?: unknown | null;

  /**
   * Header param:
   */
  'x-prefect-api-version'?: string;
}

export interface FlowRunSetStateParams {
  /**
   * Body param: The intended state.
   */
  state: FlowRunSetStateParams.State;

  /**
   * Body param: If false, orchestration rules will be applied that may alter or
   * prevent the state transition. If True, orchestration rules are not applied.
   */
  force?: boolean;

  /**
   * Header param:
   */
  'x-prefect-api-version'?: string;
}

export namespace FlowRunSetStateParams {
  /**
   * The intended state.
   */
  export interface State {
    /**
     * The type of the state to create
     */
    type:
      | 'SCHEDULED'
      | 'PENDING'
      | 'RUNNING'
      | 'COMPLETED'
      | 'FAILED'
      | 'CANCELLED'
      | 'CRASHED'
      | 'PAUSED'
      | 'CANCELLING';

    /**
     * The data of the state to create
     */
    data?: unknown | null;

    /**
     * The message of the state to create
     */
    message?: string | null;

    /**
     * The name of the state to create
     */
    name?: string | null;

    /**
     * The details of the state to create
     */
    state_details?: State.StateDetails;
  }

  export namespace State {
    /**
     * The details of the state to create
     */
    export interface StateDetails {
      cache_expiration?: string | null;

      cache_key?: string | null;

      child_flow_run_id?: string | null;

      deferred?: boolean | null;

      flow_run_id?: string | null;

      pause_key?: string | null;

      pause_reschedule?: boolean;

      pause_timeout?: string | null;

      refresh_cache?: boolean | null;

      retriable?: boolean | null;

      run_input_keyset?: Record<string, string> | null;

      scheduled_time?: string | null;

      task_parameters_id?: string | null;

      task_run_id?: string | null;

      transition_id?: string | null;

      untrackable_result?: boolean;
    }
  }
}

export namespace FlowRuns {
  export import DependencyResult = FlowRunsAPI.DependencyResult;
  export import FlowRunInput = FlowRunsAPI.FlowRunInput;
  export import FlowRunPaginationResponse = FlowRunsAPI.FlowRunPaginationResponse;
  export import FlowRunGraph = FlowRunsAPI.FlowRunGraph;
  export import FlowRunCountResponse = FlowRunsAPI.FlowRunCountResponse;
  export import FlowRunFilterResponse = FlowRunsAPI.FlowRunFilterResponse;
  export import FlowRunHistoryResponse = FlowRunsAPI.FlowRunHistoryResponse;
  export import FlowRunLatenessResponse = FlowRunsAPI.FlowRunLatenessResponse;
  export import FlowRunCreateParams = FlowRunsAPI.FlowRunCreateParams;
  export import FlowRunRetrieveParams = FlowRunsAPI.FlowRunRetrieveParams;
  export import FlowRunUpdateParams = FlowRunsAPI.FlowRunUpdateParams;
  export import FlowRunDeleteParams = FlowRunsAPI.FlowRunDeleteParams;
  export import FlowRunCountParams = FlowRunsAPI.FlowRunCountParams;
  export import FlowRunFilterParams = FlowRunsAPI.FlowRunFilterParams;
  export import FlowRunHistoryParams = FlowRunsAPI.FlowRunHistoryParams;
  export import FlowRunLatenessParams = FlowRunsAPI.FlowRunLatenessParams;
  export import FlowRunPaginateParams = FlowRunsAPI.FlowRunPaginateParams;
  export import FlowRunResumeParams = FlowRunsAPI.FlowRunResumeParams;
  export import FlowRunSetStateParams = FlowRunsAPI.FlowRunSetStateParams;
  export import GraphRetrieveResponse = GraphAPI.GraphRetrieveResponse;
  export import GraphRetrieveParams = GraphAPI.GraphRetrieveParams;
  export import GraphV2 = GraphV2API.GraphV2;
  export import GraphV2RetrieveParams = GraphV2API.GraphV2RetrieveParams;
  export import Input = InputAPI.Input;
  export import InputCreateResponse = InputAPI.InputCreateResponse;
  export import InputRetrieveResponse = InputAPI.InputRetrieveResponse;
  export import InputFilterResponse = InputAPI.InputFilterResponse;
  export import InputCreateParams = InputAPI.InputCreateParams;
  export import InputRetrieveParams = InputAPI.InputRetrieveParams;
  export import InputDeleteParams = InputAPI.InputDeleteParams;
  export import InputFilterParams = InputAPI.InputFilterParams;
  export import Logs = LogsAPI.Logs;
  export import LogDownloadResponse = LogsAPI.LogDownloadResponse;
  export import LogDownloadParams = LogsAPI.LogDownloadParams;
}