client

type ClearTaskInstancesJSONRequestBody = ClearTaskInstancesRequest

type ClearTaskInstancesRequest struct {
	DagRunId *string `json:"dag_run_id,omitempty"`

	// DryRun Return the task instances that WOULD be cleared, without clearing them. Defaults to true, matching Apache Airflow, so a request that names no flags never destroys state. Send false to execute.
	DryRun            *bool `json:"dry_run,omitempty"`
	IncludeDownstream *bool `json:"include_downstream,omitempty"`
	IncludeFuture     *bool `json:"include_future,omitempty"`
	IncludePast       *bool `json:"include_past,omitempty"`
	IncludeUpstream   *bool `json:"include_upstream,omitempty"`

	// OnlyFailed Restrict the clear to task instances in a failed state, matching Apache Airflow. false widens it to every task instance named by the request, including ones that succeeded.
	OnlyFailed *bool `json:"only_failed,omitempty"`

	// OnlyRunning Not supported. Sending true is refused with 400. leoflow has no path that clears a running task instance (Apache Airflow sets it to RESTARTING and kills it), and honoring the only_failed=false that Airflow requires alongside it would widen the clear to every task instance named by the request, including ones that succeeded.
	OnlyRunning *bool `json:"only_running,omitempty"`

	// ResetDagRuns Re-open the run so the scheduler looks at it again. Without it a terminal run stays terminal and the cleared task instance is never scheduled.
	ResetDagRuns *bool `json:"reset_dag_runs,omitempty"`

	// RunOnLatestVersion Which version the re-run executes. false (the default, matching Apache Airflow) keeps the version the run was created with, so the re-run executes the image that produced the original attempt. true re-binds the run to the DAG's current registered version, so the re-run picks up the newest image and config — use it to re-run a failed task against a fix without creating a new run.
	RunOnLatestVersion *bool     `json:"run_on_latest_version,omitempty"`
	TaskIds            *[]string `json:"task_ids,omitempty"`
}

type ClearTaskInstancesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *TaskInstanceCollection
}

type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}

type ClientInterface interface {

	// RenewToken Renew a still-valid JWT into a fresh short-lived token
	//
	// Transparent renewal: given a still-valid user bearer, re-mints the same identity with a fresh short TTL, bounded by a server-side max_lifetime measured from first login. Lets a long CLI/dev session avoid re-logging in every token TTL while keeping the access token short-lived. Returns 401 when the presented token is invalid, expired, or past max_lifetime, in which case the client must log in again.
	//
	// Corresponds with POST /api/v2/auth/token/renew (the `RenewToken` operationId).
	RenewToken(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListConnections List connections
	//
	// Lists the tenant's Airflow-style connections. Passwords are write-only and
	// never returned; secret-bearing keys inside `extra` are masked server-side.
	// Requires the read:connection permission.
	//
	// Corresponds with GET /api/v2/connections (the `ListConnections` operationId).
	ListConnections(ctx context.Context, params *ListConnectionsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateConnectionWithBody Create or replace a connection (upsert)
	//
	// Upserts a connection: creates it, or replaces an existing one with the same
	// connection_id. The password is write-only and never returned. Requires the
	// write:connection permission and a configured encryption key.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /api/v2/connections (the `CreateConnection` operationId).
	CreateConnectionWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateConnection Create or replace a connection (upsert)
	//
	// Upserts a connection: creates it, or replaces an existing one with the same
	// connection_id. The password is write-only and never returned. Requires the
	// write:connection permission and a configured encryption key.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /api/v2/connections (the `CreateConnection` operationId).
	CreateConnection(ctx context.Context, body CreateConnectionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteConnection Delete a connection
	//
	// Corresponds with DELETE /api/v2/connections/{connection_id} (the `DeleteConnection` operationId).
	DeleteConnection(ctx context.Context, connectionId ConnectionID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetConnection Get a connection
	//
	// Corresponds with GET /api/v2/connections/{connection_id} (the `GetConnection` operationId).
	GetConnection(ctx context.Context, connectionId ConnectionID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateConnectionWithBody Update a connection
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /api/v2/connections/{connection_id} (the `UpdateConnection` operationId).
	UpdateConnectionWithBody(ctx context.Context, connectionId ConnectionID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateConnection Update a connection
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /api/v2/connections/{connection_id} (the `UpdateConnection` operationId).
	UpdateConnection(ctx context.Context, connectionId ConnectionID, body UpdateConnectionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDagSource Get a DAG's source (the dag.py text)
	//
	// Corresponds with GET /api/v2/dagSources/{dag_id} (the `GetDagSource` operationId).
	GetDagSource(ctx context.Context, dagId DagID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListDags List DAGs
	//
	// Corresponds with GET /api/v2/dags (the `ListDags` operationId).
	ListDags(ctx context.Context, params *ListDagsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDag Get a DAG
	//
	// Corresponds with GET /api/v2/dags/{dag_id} (the `GetDag` operationId).
	GetDag(ctx context.Context, dagId DagID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateDagWithBody Update DAG (typically pause/unpause)
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /api/v2/dags/{dag_id} (the `UpdateDag` operationId).
	UpdateDagWithBody(ctx context.Context, dagId DagID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateDag Update DAG (typically pause/unpause)
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /api/v2/dags/{dag_id} (the `UpdateDag` operationId).
	UpdateDag(ctx context.Context, dagId DagID, body UpdateDagJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ClearTaskInstancesWithBody Clear task instances (queue them for re-run)
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /api/v2/dags/{dag_id}/clearTaskInstances (the `ClearTaskInstances` operationId).
	ClearTaskInstancesWithBody(ctx context.Context, dagId DagID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ClearTaskInstances Clear task instances (queue them for re-run)
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /api/v2/dags/{dag_id}/clearTaskInstances (the `ClearTaskInstances` operationId).
	ClearTaskInstances(ctx context.Context, dagId DagID, body ClearTaskInstancesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListDagRuns List DAG runs
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagRuns (the `ListDagRuns` operationId).
	ListDagRuns(ctx context.Context, dagId DagID, params *ListDagRunsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TriggerDagRunWithBody Trigger a DAG run
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /api/v2/dags/{dag_id}/dagRuns (the `TriggerDagRun` operationId).
	TriggerDagRunWithBody(ctx context.Context, dagId DagID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TriggerDagRun Trigger a DAG run
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /api/v2/dags/{dag_id}/dagRuns (the `TriggerDagRun` operationId).
	TriggerDagRun(ctx context.Context, dagId DagID, body TriggerDagRunJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDagRun Get a DAG run
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagRuns/{dag_run_id} (the `GetDagRun` operationId).
	GetDagRun(ctx context.Context, dagId DagID, dagRunId DagRunID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListTaskInstances List task instances of a DAG run
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances (the `ListTaskInstances` operationId).
	ListTaskInstances(ctx context.Context, dagId DagID, dagRunId DagRunID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetTaskInstance Get a task instance
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id} (the `GetTaskInstance` operationId).
	GetTaskInstance(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetTaskLogs Get task logs
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id}/logs/{try_number} (the `GetTaskLogs` operationId).
	GetTaskLogs(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, tryNumber int, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListDagVersions List a DAG's registered versions
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagVersions (the `ListDagVersions` operationId).
	ListDagVersions(ctx context.Context, dagId DagID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDagVersion Get a specific registered DAG version
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagVersions/{version_number} (the `GetDagVersion` operationId).
	GetDagVersion(ctx context.Context, dagId DagID, versionNumber int, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDagSpec Get a DAG's compiled spec (the dag.json artifact)
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/spec (the `GetDagSpec` operationId).
	GetDagSpec(ctx context.Context, dagId DagID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetMonitorExecutor Executor capability and configuration
	//
	// Corresponds with GET /api/v2/monitor/executor (the `GetMonitorExecutor` operationId).
	GetMonitorExecutor(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetMonitorHealth Control-plane health (Airflow HealthInfoResponse shape)
	//
	// Corresponds with GET /api/v2/monitor/health (the `GetMonitorHealth` operationId).
	GetMonitorHealth(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListUsers List users
	//
	// Lists the tenant's control-plane accounts, newest first. Each entry
	// carries the full set of roles the user holds; the password and its hash
	// are write-only and never returned. Requires the read:user permission.
	//
	// Corresponds with GET /api/v2/users (the `ListUsers` operationId).
	ListUsers(ctx context.Context, params *ListUsersParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateUserWithBody Create a user
	//
	// Admin-only. Creates a control-plane account with the given email and
	// password and grants the requested roles. The password is write-only and
	// is never returned. Requires the write:user permission.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /api/v2/users (the `CreateUser` operationId).
	CreateUserWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateUser Create a user
	//
	// Admin-only. Creates a control-plane account with the given email and
	// password and grants the requested roles. The password is write-only and
	// is never returned. Requires the write:user permission.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /api/v2/users (the `CreateUser` operationId).
	CreateUser(ctx context.Context, body CreateUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListVariables List variables
	//
	// Lists the tenant's Airflow-style variables. Values of secret-ish keys are
	// masked server-side. Requires the read:variable permission.
	//
	// Corresponds with GET /api/v2/variables (the `ListVariables` operationId).
	ListVariables(ctx context.Context, params *ListVariablesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateVariableWithBody Create or replace a variable (upsert)
	//
	// Upserts a variable: creates it, or replaces an existing one with the same
	// key. Requires the write:variable permission.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /api/v2/variables (the `CreateVariable` operationId).
	CreateVariableWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateVariable Create or replace a variable (upsert)
	//
	// Upserts a variable: creates it, or replaces an existing one with the same
	// key. Requires the write:variable permission.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /api/v2/variables (the `CreateVariable` operationId).
	CreateVariable(ctx context.Context, body CreateVariableJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteVariable Delete a variable
	//
	// Corresponds with DELETE /api/v2/variables/{variable_key} (the `DeleteVariable` operationId).
	DeleteVariable(ctx context.Context, variableKey VariableKey, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetVariable Get a variable
	//
	// Corresponds with GET /api/v2/variables/{variable_key} (the `GetVariable` operationId).
	GetVariable(ctx context.Context, variableKey VariableKey, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetVersion Control-plane version (Airflow VersionInfo shape)
	//
	// Corresponds with GET /api/v2/version (the `GetVersion` operationId).
	GetVersion(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetXcomEntry Read XCom value (read-only proxy for the Redis backend)
	//
	// Corresponds with GET /api/v2/xcoms/{dag_id}/{dag_run_id}/{task_id}/{key} (the `GetXcomEntry` operationId).
	GetXcomEntry(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, key string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// IssueTokenWithBody Issue a JWT for username/password credentials
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /auth/token (the `IssueToken` operationId).
	IssueTokenWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// IssueToken Issue a JWT for username/password credentials
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /auth/token (the `IssueToken` operationId).
	IssueToken(ctx context.Context, body IssueTokenJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetHealthz Liveness probe
	//
	// Corresponds with GET /healthz (the `GetHealthz` operationId).
	GetHealthz(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetReadyz Readiness probe
	//
	// Corresponds with GET /readyz (the `GetReadyz` operationId).
	GetReadyz(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)
}

type ClientOption func(*Client) error

type ClientWithResponses struct {
	ClientInterface
}

type ClientWithResponsesInterface interface {

	// RenewTokenWithResponse Renew a still-valid JWT into a fresh short-lived token
	//
	// Transparent renewal: given a still-valid user bearer, re-mints the same identity with a fresh short TTL, bounded by a server-side max_lifetime measured from first login. Lets a long CLI/dev session avoid re-logging in every token TTL while keeping the access token short-lived. Returns 401 when the presented token is invalid, expired, or past max_lifetime, in which case the client must log in again.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /api/v2/auth/token/renew (the `RenewToken` operationId).
	RenewTokenWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RenewTokenResponse, error)

	// ListConnectionsWithResponse List connections
	//
	// Lists the tenant's Airflow-style connections. Passwords are write-only and
	// never returned; secret-bearing keys inside `extra` are masked server-side.
	// Requires the read:connection permission.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/connections (the `ListConnections` operationId).
	ListConnectionsWithResponse(ctx context.Context, params *ListConnectionsParams, reqEditors ...RequestEditorFn) (*ListConnectionsResponse, error)

	// CreateConnectionWithBodyWithResponse Create or replace a connection (upsert)
	//
	// Upserts a connection: creates it, or replaces an existing one with the same
	// connection_id. The password is write-only and never returned. Requires the
	// write:connection permission and a configured encryption key.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /api/v2/connections (the `CreateConnection` operationId).
	CreateConnectionWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateConnectionResponse, error)

	// CreateConnectionWithResponse Create or replace a connection (upsert)
	//
	// Upserts a connection: creates it, or replaces an existing one with the same
	// connection_id. The password is write-only and never returned. Requires the
	// write:connection permission and a configured encryption key.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /api/v2/connections (the `CreateConnection` operationId).
	CreateConnectionWithResponse(ctx context.Context, body CreateConnectionJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateConnectionResponse, error)

	// DeleteConnectionWithResponse Delete a connection
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /api/v2/connections/{connection_id} (the `DeleteConnection` operationId).
	DeleteConnectionWithResponse(ctx context.Context, connectionId ConnectionID, reqEditors ...RequestEditorFn) (*DeleteConnectionResponse, error)

	// GetConnectionWithResponse Get a connection
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/connections/{connection_id} (the `GetConnection` operationId).
	GetConnectionWithResponse(ctx context.Context, connectionId ConnectionID, reqEditors ...RequestEditorFn) (*GetConnectionResponse, error)

	// UpdateConnectionWithBodyWithResponse Update a connection
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /api/v2/connections/{connection_id} (the `UpdateConnection` operationId).
	UpdateConnectionWithBodyWithResponse(ctx context.Context, connectionId ConnectionID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateConnectionResponse, error)

	// UpdateConnectionWithResponse Update a connection
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /api/v2/connections/{connection_id} (the `UpdateConnection` operationId).
	UpdateConnectionWithResponse(ctx context.Context, connectionId ConnectionID, body UpdateConnectionJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateConnectionResponse, error)

	// GetDagSourceWithResponse Get a DAG's source (the dag.py text)
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/dagSources/{dag_id} (the `GetDagSource` operationId).
	GetDagSourceWithResponse(ctx context.Context, dagId DagID, reqEditors ...RequestEditorFn) (*GetDagSourceResponse, error)

	// ListDagsWithResponse List DAGs
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/dags (the `ListDags` operationId).
	ListDagsWithResponse(ctx context.Context, params *ListDagsParams, reqEditors ...RequestEditorFn) (*ListDagsResponse, error)

	// GetDagWithResponse Get a DAG
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/dags/{dag_id} (the `GetDag` operationId).
	GetDagWithResponse(ctx context.Context, dagId DagID, reqEditors ...RequestEditorFn) (*GetDagResponse, error)

	// UpdateDagWithBodyWithResponse Update DAG (typically pause/unpause)
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /api/v2/dags/{dag_id} (the `UpdateDag` operationId).
	UpdateDagWithBodyWithResponse(ctx context.Context, dagId DagID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateDagResponse, error)

	// UpdateDagWithResponse Update DAG (typically pause/unpause)
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /api/v2/dags/{dag_id} (the `UpdateDag` operationId).
	UpdateDagWithResponse(ctx context.Context, dagId DagID, body UpdateDagJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateDagResponse, error)

	// ClearTaskInstancesWithBodyWithResponse Clear task instances (queue them for re-run)
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /api/v2/dags/{dag_id}/clearTaskInstances (the `ClearTaskInstances` operationId).
	ClearTaskInstancesWithBodyWithResponse(ctx context.Context, dagId DagID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ClearTaskInstancesResponse, error)

	// ClearTaskInstancesWithResponse Clear task instances (queue them for re-run)
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /api/v2/dags/{dag_id}/clearTaskInstances (the `ClearTaskInstances` operationId).
	ClearTaskInstancesWithResponse(ctx context.Context, dagId DagID, body ClearTaskInstancesJSONRequestBody, reqEditors ...RequestEditorFn) (*ClearTaskInstancesResponse, error)

	// ListDagRunsWithResponse List DAG runs
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagRuns (the `ListDagRuns` operationId).
	ListDagRunsWithResponse(ctx context.Context, dagId DagID, params *ListDagRunsParams, reqEditors ...RequestEditorFn) (*ListDagRunsResponse, error)

	// TriggerDagRunWithBodyWithResponse Trigger a DAG run
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /api/v2/dags/{dag_id}/dagRuns (the `TriggerDagRun` operationId).
	TriggerDagRunWithBodyWithResponse(ctx context.Context, dagId DagID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TriggerDagRunResponse, error)

	// TriggerDagRunWithResponse Trigger a DAG run
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /api/v2/dags/{dag_id}/dagRuns (the `TriggerDagRun` operationId).
	TriggerDagRunWithResponse(ctx context.Context, dagId DagID, body TriggerDagRunJSONRequestBody, reqEditors ...RequestEditorFn) (*TriggerDagRunResponse, error)

	// GetDagRunWithResponse Get a DAG run
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagRuns/{dag_run_id} (the `GetDagRun` operationId).
	GetDagRunWithResponse(ctx context.Context, dagId DagID, dagRunId DagRunID, reqEditors ...RequestEditorFn) (*GetDagRunResponse, error)

	// ListTaskInstancesWithResponse List task instances of a DAG run
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances (the `ListTaskInstances` operationId).
	ListTaskInstancesWithResponse(ctx context.Context, dagId DagID, dagRunId DagRunID, reqEditors ...RequestEditorFn) (*ListTaskInstancesResponse, error)

	// GetTaskInstanceWithResponse Get a task instance
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id} (the `GetTaskInstance` operationId).
	GetTaskInstanceWithResponse(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, reqEditors ...RequestEditorFn) (*GetTaskInstanceResponse, error)

	// GetTaskLogsWithResponse Get task logs
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id}/logs/{try_number} (the `GetTaskLogs` operationId).
	GetTaskLogsWithResponse(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, tryNumber int, reqEditors ...RequestEditorFn) (*GetTaskLogsResponse, error)

	// ListDagVersionsWithResponse List a DAG's registered versions
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagVersions (the `ListDagVersions` operationId).
	ListDagVersionsWithResponse(ctx context.Context, dagId DagID, reqEditors ...RequestEditorFn) (*ListDagVersionsResponse, error)

	// GetDagVersionWithResponse Get a specific registered DAG version
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/dagVersions/{version_number} (the `GetDagVersion` operationId).
	GetDagVersionWithResponse(ctx context.Context, dagId DagID, versionNumber int, reqEditors ...RequestEditorFn) (*GetDagVersionResponse, error)

	// GetDagSpecWithResponse Get a DAG's compiled spec (the dag.json artifact)
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/dags/{dag_id}/spec (the `GetDagSpec` operationId).
	GetDagSpecWithResponse(ctx context.Context, dagId DagID, reqEditors ...RequestEditorFn) (*GetDagSpecResponse, error)

	// GetMonitorExecutorWithResponse Executor capability and configuration
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/monitor/executor (the `GetMonitorExecutor` operationId).
	GetMonitorExecutorWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetMonitorExecutorResponse, error)

	// GetMonitorHealthWithResponse Control-plane health (Airflow HealthInfoResponse shape)
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/monitor/health (the `GetMonitorHealth` operationId).
	GetMonitorHealthWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetMonitorHealthResponse, error)

	// ListUsersWithResponse List users
	//
	// Lists the tenant's control-plane accounts, newest first. Each entry
	// carries the full set of roles the user holds; the password and its hash
	// are write-only and never returned. Requires the read:user permission.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/users (the `ListUsers` operationId).
	ListUsersWithResponse(ctx context.Context, params *ListUsersParams, reqEditors ...RequestEditorFn) (*ListUsersResponse, error)

	// CreateUserWithBodyWithResponse Create a user
	//
	// Admin-only. Creates a control-plane account with the given email and
	// password and grants the requested roles. The password is write-only and
	// is never returned. Requires the write:user permission.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /api/v2/users (the `CreateUser` operationId).
	CreateUserWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateUserResponse, error)

	// CreateUserWithResponse Create a user
	//
	// Admin-only. Creates a control-plane account with the given email and
	// password and grants the requested roles. The password is write-only and
	// is never returned. Requires the write:user permission.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /api/v2/users (the `CreateUser` operationId).
	CreateUserWithResponse(ctx context.Context, body CreateUserJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateUserResponse, error)

	// ListVariablesWithResponse List variables
	//
	// Lists the tenant's Airflow-style variables. Values of secret-ish keys are
	// masked server-side. Requires the read:variable permission.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/variables (the `ListVariables` operationId).
	ListVariablesWithResponse(ctx context.Context, params *ListVariablesParams, reqEditors ...RequestEditorFn) (*ListVariablesResponse, error)

	// CreateVariableWithBodyWithResponse Create or replace a variable (upsert)
	//
	// Upserts a variable: creates it, or replaces an existing one with the same
	// key. Requires the write:variable permission.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /api/v2/variables (the `CreateVariable` operationId).
	CreateVariableWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateVariableResponse, error)

	// CreateVariableWithResponse Create or replace a variable (upsert)
	//
	// Upserts a variable: creates it, or replaces an existing one with the same
	// key. Requires the write:variable permission.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /api/v2/variables (the `CreateVariable` operationId).
	CreateVariableWithResponse(ctx context.Context, body CreateVariableJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateVariableResponse, error)

	// DeleteVariableWithResponse Delete a variable
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /api/v2/variables/{variable_key} (the `DeleteVariable` operationId).
	DeleteVariableWithResponse(ctx context.Context, variableKey VariableKey, reqEditors ...RequestEditorFn) (*DeleteVariableResponse, error)

	// GetVariableWithResponse Get a variable
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/variables/{variable_key} (the `GetVariable` operationId).
	GetVariableWithResponse(ctx context.Context, variableKey VariableKey, reqEditors ...RequestEditorFn) (*GetVariableResponse, error)

	// GetVersionWithResponse Control-plane version (Airflow VersionInfo shape)
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/version (the `GetVersion` operationId).
	GetVersionWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetVersionResponse, error)

	// GetXcomEntryWithResponse Read XCom value (read-only proxy for the Redis backend)
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/xcoms/{dag_id}/{dag_run_id}/{task_id}/{key} (the `GetXcomEntry` operationId).
	GetXcomEntryWithResponse(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, key string, reqEditors ...RequestEditorFn) (*GetXcomEntryResponse, error)

	// IssueTokenWithBodyWithResponse Issue a JWT for username/password credentials
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /auth/token (the `IssueToken` operationId).
	IssueTokenWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*IssueTokenResponse, error)

	// IssueTokenWithResponse Issue a JWT for username/password credentials
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /auth/token (the `IssueToken` operationId).
	IssueTokenWithResponse(ctx context.Context, body IssueTokenJSONRequestBody, reqEditors ...RequestEditorFn) (*IssueTokenResponse, error)

	// GetHealthzWithResponse Liveness probe
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /healthz (the `GetHealthz` operationId).
	GetHealthzWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetHealthzResponse, error)

	// GetReadyzWithResponse Readiness probe
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /readyz (the `GetReadyz` operationId).
	GetReadyzWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetReadyzResponse, error)
}

type ComponentHealth struct {
	LatestDagProcessorHeartbeat *string `json:"latest_dag_processor_heartbeat,omitempty"`
	LatestSchedulerHeartbeat    *string `json:"latest_scheduler_heartbeat,omitempty"`
	LatestTriggererHeartbeat    *string `json:"latest_triggerer_heartbeat,omitempty"`
	Status                      *string `json:"status,omitempty"`
}

type Connection struct {
	ConnType     string  `json:"conn_type"`
	ConnectionId string  `json:"connection_id"`
	Description  *string `json:"description,omitempty"`
	Extra        *string `json:"extra,omitempty"`
	Host         *string `json:"host,omitempty"`
	Login        *string `json:"login,omitempty"`
	Port         *int    `json:"port,omitempty"`
	Schema       *string `json:"schema,omitempty"`
}

type ConnectionBody struct {
	ConnType     string  `json:"conn_type"`
	ConnectionId *string `json:"connection_id,omitempty"`
	Description  *string `json:"description,omitempty"`
	Extra        *string `json:"extra,omitempty"`
	Host         *string `json:"host,omitempty"`
	Login        *string `json:"login,omitempty"`
	Password     *string `json:"password,omitempty"`
	Port         *int    `json:"port,omitempty"`
	Schema       *string `json:"schema,omitempty"`
}

type ConnectionCollection struct {
	Connections  *[]Connection `json:"connections,omitempty"`
	TotalEntries *int          `json:"total_entries,omitempty"`
}

type ConnectionID = string

type CreateConnectionJSONRequestBody = ConnectionBody

type CreateConnectionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *Connection
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *Error
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON503 the response for an HTTP 503 `application/json` response
	JSON503 *EncryptionUnavailable
}

type CreateUserJSONRequestBody = CreateUserRequest

type CreateUserRequest struct {
	// Email Login email. Normalized to lowercase, so it is unique case-insensitively within the tenant.
	Email string `json:"email"`

	// Password Plaintext password (write-only; never returned). Must be at least 8 characters — the server rejects anything shorter with 400.
	Password *string `json:"password,omitempty"`

	// Roles Names of existing roles to grant; omit or empty to grant none.
	Roles *[]string `json:"roles,omitempty"`
}

type CreateUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *User
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *Error
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON409 the response for an HTTP 409 `application/json` response
	JSON409 *Error
}

type CreateVariableJSONRequestBody = VariableBody

type CreateVariableResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *Variable
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *Error
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
}

type DAG struct {
	Catchup                  *bool                   `json:"catchup,omitempty"`
	DagDisplayName           *string                 `json:"dag_display_name,omitempty"`
	DagId                    *string                 `json:"dag_id,omitempty"`
	Description              *string                 `json:"description,omitempty"`
	Fileloc                  *string                 `json:"fileloc,omitempty"`
	HasTaskConcurrencyLimits *bool                   `json:"has_task_concurrency_limits,omitempty"`
	IsActive                 *bool                   `json:"is_active,omitempty"`
	IsPaused                 *bool                   `json:"is_paused,omitempty"`
	LastParsedTime           *time.Time              `json:"last_parsed_time,omitempty"`
	MaxActiveRuns            *int                    `json:"max_active_runs,omitempty"`
	NextDagrun               *time.Time              `json:"next_dagrun,omitempty"`
	Owners                   *[]string               `json:"owners,omitempty"`
	ScheduleInterval         *map[string]interface{} `json:"schedule_interval,omitempty"`
	Tags                     *[]struct {
		Name *string `json:"name,omitempty"`
	} `json:"tags,omitempty"`
	TimetableDescription *string `json:"timetable_description,omitempty"`
}

type DAGCollection struct {
	Dags         *[]DAG `json:"dags,omitempty"`
	TotalEntries *int   `json:"total_entries,omitempty"`
}

type DAGRun struct {
	Conf              *map[string]interface{} `json:"conf,omitempty"`
	DagId             *string                 `json:"dag_id,omitempty"`
	DagRunId          *string                 `json:"dag_run_id,omitempty"`
	DataIntervalEnd   *time.Time              `json:"data_interval_end,omitempty"`
	DataIntervalStart *time.Time              `json:"data_interval_start,omitempty"`
	EndDate           *time.Time              `json:"end_date,omitempty"`
	LogicalDate       *time.Time              `json:"logical_date,omitempty"`
	Note              *string                 `json:"note,omitempty"`
	QueuedAt          *time.Time              `json:"queued_at,omitempty"`
	RunType           *DAGRunRunType          `json:"run_type,omitempty"`
	StartDate         *time.Time              `json:"start_date,omitempty"`
	State             *DAGRunState            `json:"state,omitempty"`
}

type DAGRunCollection struct {
	DagRuns      *[]DAGRun `json:"dag_runs,omitempty"`
	TotalEntries *int      `json:"total_entries,omitempty"`
}

type DAGRunCreate struct {
	Conf        *map[string]interface{} `json:"conf,omitempty"`
	DagRunId    *string                 `json:"dag_run_id,omitempty"`
	LogicalDate *time.Time              `json:"logical_date,omitempty"`
	Note        *string                 `json:"note,omitempty"`
}

type DAGRunRunType string

type DAGRunState string

type DAGUpdate struct {
	IsPaused *bool `json:"is_paused,omitempty"`
}

type DagID = string

type DagRunID = string

type DagSource struct {
	// Content The dag.py source text (compiled-spec JSON fallback for pre-source-capture versions).
	Content        *string `json:"content,omitempty"`
	DagDisplayName *string `json:"dag_display_name,omitempty"`
	DagId          *string `json:"dag_id,omitempty"`
	VersionNumber  *int    `json:"version_number,omitempty"`
}

type DagVersion struct {
	BundleName     *string    `json:"bundle_name,omitempty"`
	BundleUrl      *string    `json:"bundle_url,omitempty"`
	BundleVersion  *string    `json:"bundle_version,omitempty"`
	CreatedAt      *time.Time `json:"created_at,omitempty"`
	DagDisplayName *string    `json:"dag_display_name,omitempty"`
	DagId          *string    `json:"dag_id,omitempty"`
	Id             *string    `json:"id,omitempty"`
	VersionNumber  *int       `json:"version_number,omitempty"`
}

type DagVersionCollection struct {
	DagVersions  *[]DagVersion `json:"dag_versions,omitempty"`
	TotalEntries *int          `json:"total_entries,omitempty"`
}

type DeleteConnectionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type DeleteVariableResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type EncryptionUnavailable = Error

type Error struct {
	Detail   *string `json:"detail,omitempty"`
	Instance *string `json:"instance,omitempty"`
	Status   *int    `json:"status,omitempty"`
	Title    *string `json:"title,omitempty"`
	Type     *string `json:"type,omitempty"`
}

type ExecutorInfo struct {
	AgentControlPlaneAddr *string   `json:"agent_control_plane_addr,omitempty"`
	ExecutionModes        *[]string `json:"execution_modes,omitempty"`
	PodDispatchEnabled    *bool     `json:"pod_dispatch_enabled,omitempty"`
	TaskNamespace         *string   `json:"task_namespace,omitempty"`
}

type GetConnectionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *Connection
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type GetDagResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *DAG
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type GetDagRunResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *DAGRun
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type GetDagSourceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *DagSource
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type GetDagSpecResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *map[string]interface{}
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type GetDagVersionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *DagVersion
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type GetHealthzResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

type GetMonitorExecutorResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *ExecutorInfo
}

type GetMonitorHealthResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *HealthInfo
}

type GetReadyzResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

type GetTaskInstanceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *TaskInstance
}

type GetTaskLogsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

type GetVariableResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *Variable
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type GetVersionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *VersionInfo
}

type GetXcomEntryResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *XComEntry
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type HealthInfo struct {
	DagProcessor *ComponentHealth `json:"dag_processor,omitempty"`
	Metadatabase *ComponentHealth `json:"metadatabase,omitempty"`
	Scheduler    *ComponentHealth `json:"scheduler,omitempty"`
	Triggerer    *ComponentHealth `json:"triggerer,omitempty"`
}

type HttpRequestDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

type IssueTokenJSONRequestBody = TokenRequest

type IssueTokenResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *TokenResponse
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *IssueTokenResponse200Headers
}

type IssueTokenResponse200Headers struct {
	SetCookie *string
}

type Limit = int

type ListConnectionsParams struct {
	Limit  *Limit  `form:"limit,omitempty" json:"limit,omitempty"`
	Offset *Offset `form:"offset,omitempty" json:"offset,omitempty"`
}

type ListConnectionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *ConnectionCollection
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
}

type ListDagRunsParams struct {
	Limit  *Limit                    `form:"limit,omitempty" json:"limit,omitempty"`
	Offset *Offset                   `form:"offset,omitempty" json:"offset,omitempty"`
	State  *[]ListDagRunsParamsState `form:"state,omitempty" json:"state,omitempty"`
}

type ListDagRunsParamsState string

type ListDagRunsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *DAGRunCollection
}

type ListDagVersionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *DagVersionCollection
}

type ListDagsParams struct {
	Limit      *Limit    `form:"limit,omitempty" json:"limit,omitempty"`
	Offset     *Offset   `form:"offset,omitempty" json:"offset,omitempty"`
	Tags       *[]string `form:"tags,omitempty" json:"tags,omitempty"`
	OnlyActive *bool     `form:"only_active,omitempty" json:"only_active,omitempty"`
	Paused     *bool     `form:"paused,omitempty" json:"paused,omitempty"`
}

type ListDagsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *DAGCollection
}

type ListTaskInstancesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *TaskInstanceCollection
}

type ListUsersParams struct {
	Limit  *Limit  `form:"limit,omitempty" json:"limit,omitempty"`
	Offset *Offset `form:"offset,omitempty" json:"offset,omitempty"`
}

type ListUsersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *UserCollection
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
}

type ListVariablesParams struct {
	Limit  *Limit  `form:"limit,omitempty" json:"limit,omitempty"`
	Offset *Offset `form:"offset,omitempty" json:"offset,omitempty"`
}

type ListVariablesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *VariableCollection
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
}

type NotFound = Error

type Offset = int