client

type APIToken struct {
	CreatedAt time.Time `json:"created_at"`
	ExpiresAt time.Time `json:"expires_at"`
	Id        string    `json:"id"`

	// LastUsedAt When the token last authenticated a request, recorded at most once every five minutes; null when it was never used.
	LastUsedAt *time.Time `json:"last_used_at,omitempty"`
	Name       string     `json:"name"`

	// OwnerEmail Email of the token's owner (in lists).
	OwnerEmail *string  `json:"owner_email,omitempty"`
	Scopes     []string `json:"scopes"`
}

type APITokenCollection struct {
	ApiTokens    *[]APIToken `json:"api_tokens,omitempty"`
	TotalEntries *int        `json:"total_entries,omitempty"`
}

type AuthMethods struct {
	// Password is whether a password login can succeed for someone.
	Password bool `json:"password"`
	// SSO is whether the OIDC single sign-on flow is served.
	SSO bool `json:"sso"`
	// Device is whether the device sign-in for machines with no browser is
	// served (POST /api/v2/auth/cli/device). Servers from before it omit it.
	Device bool `json:"device"`
}

type BuildInfo struct {
	// BaseImage The base image the DAG image was built from; it carries the task agent.
	BaseImage *string `json:"base_image,omitempty"`

	// Builder The builder that produced the image.
	Builder *string `json:"builder,omitempty"`

	// CliVersion The version of the CLI that built and registered the version.
	CliVersion *string `json:"cli_version,omitempty"`

	// Commit The git commit of the sources.
	Commit *string `json:"commit,omitempty"`

	// PipelineUrl The CI pipeline run that built the version (http or https URL).
	PipelineUrl *string `json:"pipeline_url,omitempty"`

	// Repo The repository of the sources (http or https URL).
	Repo *string `json:"repo,omitempty"`
}

type CITokenRequest struct {
	Token string `json:"token"`
}

type CITokenResponse struct {
	AccessToken string    `json:"access_token"`
	TokenType   string    `json:"token_type"`
	ExpiresIn   int       `json:"expires_in"`
	ExpiresAt   time.Time `json:"expires_at"`
	Issuer      string    `json:"issuer"`
	Tenant      string    `json:"tenant"`
	Role        string    `json:"role"`
	Scopes      []string  `json:"scopes"`
}

type CLIDeviceAuthorization struct {
	// DeviceCode is the secret the CLI polls with. Never print it.
	DeviceCode string `json:"device_code"`
	// UserCode is the short code the person enters and confirms.
	UserCode string `json:"user_code"`
	// VerificationURI is the page the person enters the code on.
	VerificationURI string `json:"verification_uri"`
	// VerificationURIComplete is that page with the code filled in.
	VerificationURIComplete string `json:"verification_uri_complete"`
	// ExpiresIn is the sign-in's lifetime in seconds.
	ExpiresIn int `json:"expires_in"`
	// Interval is the minimum number of seconds between polls.
	Interval int `json:"interval"`
}

type CLITokenRequest struct {
	// Code is the one-time code the CLI's loopback received.
	Code string `json:"code"`
	// CodeVerifier is the PKCE verifier of the login's code_challenge.
	CodeVerifier string `json:"code_verifier"`
	// RedirectURI is the redirect_uri the login was started with.
	RedirectURI string `json:"redirect_uri"`
}

type ClearDagRun200JSONResponseBody struct {
	// contains filtered or unexported fields
}

type ClearDagRunJSONRequestBody = DAGRunClearRequest

type ClearDagRunResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *ClearDagRun200JSONResponseBody
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *Error
	// JSON403 the response for an HTTP 403 `application/json` response
	JSON403 *Error
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
	// JSON409 the response for an HTTP 409 `application/json` response
	JSON409 *Error
}

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. Only a finished run (success or failed, with no task instance queued or running) moves: the clear creates the task instances of the tasks the version adds and marks removed the ones of the tasks it dropped. A run that has not finished keeps its version, as in Airflow, and the response lists it in run_on_latest_version_not_applied with the reason (ADR 0086).
	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
	// JSON409 the response for an HTTP 409 `application/json` response
	JSON409 *Error
}

type ClearVersionNotApplied = []struct {
	DagRunId string `json:"dag_run_id"`

	// Reason Why the run keeps its version, for example "the run is running: only a finished run moves to the current version".
	Reason string `json:"reason"`
}

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 {

	// ListAPITokens List API tokens (Dexaflow)
	//
	// Lists the caller's unrevoked API tokens, newest first, expired ones included. A caller who may manage accounts (write:user) sees every token of the tenant. The token itself and its hash are never returned. Not callable with an API token or any other scoped token (ADR 0074).
	//
	// Corresponds with GET /api/v2/apiTokens (the `ListAPITokens` operationId).
	ListAPITokens(ctx context.Context, params *ListAPITokensParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateAPITokenWithBody Create an API token (Dexaflow)
	//
	// Creates a long-lived, named API token owned by the caller (ADR 0074). The response carries the token once; the server keeps only its SHA-256 hash. The token authenticates as its owner, with the owner's current roles narrowed to the token's scopes: deploy carries dexaflow:deploy alone (it registers versions, sets the current version, and reads the DAG list, DAGs, their details and versions, and nothing else), read carries dexaflow:read. The caller's roles must allow what the scope does (deploy needs deploy or write on dags, read needs read on dags). An account holds at most 50 live tokens. Audited as api_token.create. Reusing the name of an expired token retires that token, audited as api_token.retire_expired. Not callable with an API token or any other scoped token.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /api/v2/apiTokens (the `CreateAPIToken` operationId).
	CreateAPITokenWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateAPIToken Create an API token (Dexaflow)
	//
	// Creates a long-lived, named API token owned by the caller (ADR 0074). The response carries the token once; the server keeps only its SHA-256 hash. The token authenticates as its owner, with the owner's current roles narrowed to the token's scopes: deploy carries dexaflow:deploy alone (it registers versions, sets the current version, and reads the DAG list, DAGs, their details and versions, and nothing else), read carries dexaflow:read. The caller's roles must allow what the scope does (deploy needs deploy or write on dags, read needs read on dags). An account holds at most 50 live tokens. Audited as api_token.create. Reusing the name of an expired token retires that token, audited as api_token.retire_expired. Not callable with an API token or any other scoped token.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /api/v2/apiTokens (the `CreateAPIToken` operationId).
	CreateAPIToken(ctx context.Context, body CreateAPITokenJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RevokeAPIToken Revoke an API token (Dexaflow)
	//
	// Revokes one of the caller's API tokens, or any token of the tenant for a caller who may manage accounts (write:user). The token stops working on its next request. Revoking a revoked token succeeds. Audited as api_token.revoke. Not callable with an API token or any other scoped token.
	//
	// Corresponds with DELETE /api/v2/apiTokens/{token_id} (the `RevokeAPIToken` operationId).
	RevokeAPIToken(ctx context.Context, tokenId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// 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)
	//
	// The source registered with one version of the DAG, as in Airflow 3.2: version_number selects the version, and without it (or with 0) the newest version is served. After a rollback the newest version is not the current one. A version the DAG does not have is a 404, and a version_number that is not an integer is a 400.
	//
	// 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)
	//
	// Sets is_paused. A change is audited as dag.pause or dag.unpause with the acting user; asking for the state the DAG is already in records nothing.
	//
	// 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)
	//
	// Sets is_paused. A change is audited as dag.pause or dag.unpause with the acting user; asking for the state the DAG is already in records nothing.
	//
	// 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)

	// SetDagCurrentVersionWithBody Make a registered version current (Dexaflow)
	//
	// Makes a registered version of the DAG the one new runs are created with, by label or by version_number: a rollback, or a roll forward. The DAG's schedule and metadata become that version's, in the same transaction. Runs that already exist keep their version, and is_paused is never changed. The version must pass the checks a register of it would pass today. Naming the current version changes nothing (changed false). Audited as dag.version.set_current. Needs deploy or write on dags (scope dexaflow:deploy). Under the server setting deploy.require_digest, a version whose image is not pinned by a full sha256 digest is made current with a warning in warnings (warn), or refused with 400 (enforce).
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PUT /api/v2/dags/{dag_id}/currentVersion (the `SetDagCurrentVersion` operationId).
	SetDagCurrentVersionWithBody(ctx context.Context, dagId DagID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SetDagCurrentVersion Make a registered version current (Dexaflow)
	//
	// Makes a registered version of the DAG the one new runs are created with, by label or by version_number: a rollback, or a roll forward. The DAG's schedule and metadata become that version's, in the same transaction. Runs that already exist keep their version, and is_paused is never changed. The version must pass the checks a register of it would pass today. Naming the current version changes nothing (changed false). Audited as dag.version.set_current. Needs deploy or write on dags (scope dexaflow:deploy). Under the server setting deploy.require_digest, a version whose image is not pinned by a full sha256 digest is made current with a warning in warnings (warn), or refused with 400 (enforce).
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PUT /api/v2/dags/{dag_id}/currentVersion (the `SetDagCurrentVersion` operationId).
	SetDagCurrentVersion(ctx context.Context, dagId DagID, body SetDagCurrentVersionJSONRequestBody, 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)

	// ClearDagRunWithBody Clear a whole DAG run (queue its task instances for re-run)
	//
	// The run page's Clear action. A dry run (the default) answers the task instances the clear would reset. The clear itself resets them, re-queues the run and answers the run.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/clear (the `ClearDagRun` operationId).
	ClearDagRunWithBody(ctx context.Context, dagId DagID, dagRunId DagRunID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ClearDagRun Clear a whole DAG run (queue its task instances for re-run)
	//
	// The run page's Clear action. A dry run (the default) answers the task instances the clear would reset. The clear itself resets them, re-queues the run and answers the run.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/clear (the `ClearDagRun` operationId).
	ClearDagRun(ctx context.Context, dagId DagID, dagRunId DagRunID, body ClearDagRunJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListTaskInstances List task instances of a DAG run
	//
	// Pages with the same limit, offset and cursor query parameters as the DAG run list (they are not declared on this operation so the generated client keeps its signature). A request that carries cursor gets next_cursor and previous_cursor in the body; only the offset cursors this list issues are accepted, any other is refused with 400.
	//
	// 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)

	// PatchTaskInstanceWithBody Mark a task instance as success, failed or skipped
	//
	// Sets the task instance's state, as the UI's Mark as action does. The answer is the affected set, a collection holding the updated task instance, as Apache Airflow declares it.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id} (the `PatchTaskInstance` operationId).
	PatchTaskInstanceWithBody(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PatchTaskInstance Mark a task instance as success, failed or skipped
	//
	// Sets the task instance's state, as the UI's Mark as action does. The answer is the affected set, a collection holding the updated task instance, as Apache Airflow declares it.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id} (the `PatchTaskInstance` operationId).
	PatchTaskInstance(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, body PatchTaskInstanceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PatchTaskInstanceDryRunWithBody Preview marking a task instance
	//
	// Answers the task instance with the state the PATCH would set, without changing anything.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id}/dry_run (the `PatchTaskInstanceDryRun` operationId).
	PatchTaskInstanceDryRunWithBody(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PatchTaskInstanceDryRun Preview marking a task instance
	//
	// Answers the task instance with the state the PATCH would set, without changing anything.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id}/dry_run (the `PatchTaskInstanceDryRun` operationId).
	PatchTaskInstanceDryRun(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, body PatchTaskInstanceDryRunJSONRequestBody, 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)

	// RegisterDagVersionWithBody Register a compiled DAG version (Dexaflow)
	//
	// Registers a compiled dag.json as a new version of the DAG and makes it current. Re-registering content that is already registered (same spec hash) is a no-op answered with 200 and created false, and leaves the current version as it is. The same label with other content is refused with 409. Needs deploy or write on dags (scope dexaflow:deploy).
	// Without is_paused, a DAG the register creates starts paused per its is_paused_upon_creation, else the server's dags_are_paused_at_creation, and an existing DAG keeps its state. With is_paused, the DAG ends the register in that state whether it is created, gets a new version or already had this content; a change to an existing DAG is audited as dag.pause or dag.unpause in the same transaction. Pausing is a run-state write: sending is_paused also needs write on dags, and a scoped token needs dexaflow:run as well as dexaflow:deploy, else the register is refused with 403.
	// Under the server setting deploy.require_digest, an image that is not pinned by a full digest (repository@sha256: and 64 hex characters) is registered with a warning in warnings (warn), or refused with 400 (enforce). Off, the default, accepts any image.
	// POST /api/v2/dags/{dag_id}/versions/dry_run runs the same checks and writes nothing.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /api/v2/dags/{dag_id}/versions (the `RegisterDagVersion` operationId).
	RegisterDagVersionWithBody(ctx context.Context, dagId DagID, params *RegisterDagVersionParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RegisterDagVersion Register a compiled DAG version (Dexaflow)
	//
	// Registers a compiled dag.json as a new version of the DAG and makes it current. Re-registering content that is already registered (same spec hash) is a no-op answered with 200 and created false, and leaves the current version as it is. The same label with other content is refused with 409. Needs deploy or write on dags (scope dexaflow:deploy).
	// Without is_paused, a DAG the register creates starts paused per its is_paused_upon_creation, else the server's dags_are_paused_at_creation, and an existing DAG keeps its state. With is_paused, the DAG ends the register in that state whether it is created, gets a new version or already had this content; a change to an existing DAG is audited as dag.pause or dag.unpause in the same transaction. Pausing is a run-state write: sending is_paused also needs write on dags, and a scoped token needs dexaflow:run as well as dexaflow:deploy, else the register is refused with 403.
	// Under the server setting deploy.require_digest, an image that is not pinned by a full digest (repository@sha256: and 64 hex characters) is registered with a warning in warnings (warn), or refused with 400 (enforce). Off, the default, accepts any image.
	// POST /api/v2/dags/{dag_id}/versions/dry_run runs the same checks and writes nothing.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /api/v2/dags/{dag_id}/versions (the `RegisterDagVersion` operationId).
	RegisterDagVersion(ctx context.Context, dagId DagID, params *RegisterDagVersionParams, body RegisterDagVersionJSONRequestBody, 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 {

	// ListAPITokensWithResponse List API tokens (Dexaflow)
	//
	// Lists the caller's unrevoked API tokens, newest first, expired ones included. A caller who may manage accounts (write:user) sees every token of the tenant. The token itself and its hash are never returned. Not callable with an API token or any other scoped token (ADR 0074).
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /api/v2/apiTokens (the `ListAPITokens` operationId).
	ListAPITokensWithResponse(ctx context.Context, params *ListAPITokensParams, reqEditors ...RequestEditorFn) (*ListAPITokensResponse, error)

	// CreateAPITokenWithBodyWithResponse Create an API token (Dexaflow)
	//
	// Creates a long-lived, named API token owned by the caller (ADR 0074). The response carries the token once; the server keeps only its SHA-256 hash. The token authenticates as its owner, with the owner's current roles narrowed to the token's scopes: deploy carries dexaflow:deploy alone (it registers versions, sets the current version, and reads the DAG list, DAGs, their details and versions, and nothing else), read carries dexaflow:read. The caller's roles must allow what the scope does (deploy needs deploy or write on dags, read needs read on dags). An account holds at most 50 live tokens. Audited as api_token.create. Reusing the name of an expired token retires that token, audited as api_token.retire_expired. Not callable with an API token or any other scoped token.
	//
	// 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/apiTokens (the `CreateAPIToken` operationId).
	CreateAPITokenWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateAPITokenResponse, error)

	// CreateAPITokenWithResponse Create an API token (Dexaflow)
	//
	// Creates a long-lived, named API token owned by the caller (ADR 0074). The response carries the token once; the server keeps only its SHA-256 hash. The token authenticates as its owner, with the owner's current roles narrowed to the token's scopes: deploy carries dexaflow:deploy alone (it registers versions, sets the current version, and reads the DAG list, DAGs, their details and versions, and nothing else), read carries dexaflow:read. The caller's roles must allow what the scope does (deploy needs deploy or write on dags, read needs read on dags). An account holds at most 50 live tokens. Audited as api_token.create. Reusing the name of an expired token retires that token, audited as api_token.retire_expired. Not callable with an API token or any other scoped token.
	//
	// 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/apiTokens (the `CreateAPIToken` operationId).
	CreateAPITokenWithResponse(ctx context.Context, body CreateAPITokenJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateAPITokenResponse, error)

	// RevokeAPITokenWithResponse Revoke an API token (Dexaflow)
	//
	// Revokes one of the caller's API tokens, or any token of the tenant for a caller who may manage accounts (write:user). The token stops working on its next request. Revoking a revoked token succeeds. Audited as api_token.revoke. Not callable with an API token or any other scoped token.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /api/v2/apiTokens/{token_id} (the `RevokeAPIToken` operationId).
	RevokeAPITokenWithResponse(ctx context.Context, tokenId string, reqEditors ...RequestEditorFn) (*RevokeAPITokenResponse, error)

	// 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)
	//
	// The source registered with one version of the DAG, as in Airflow 3.2: version_number selects the version, and without it (or with 0) the newest version is served. After a rollback the newest version is not the current one. A version the DAG does not have is a 404, and a version_number that is not an integer is a 400.
	//
	// 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)
	//
	// Sets is_paused. A change is audited as dag.pause or dag.unpause with the acting user; asking for the state the DAG is already in records nothing.
	//
	// 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)
	//
	// Sets is_paused. A change is audited as dag.pause or dag.unpause with the acting user; asking for the state the DAG is already in records nothing.
	//
	// 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)

	// SetDagCurrentVersionWithBodyWithResponse Make a registered version current (Dexaflow)
	//
	// Makes a registered version of the DAG the one new runs are created with, by label or by version_number: a rollback, or a roll forward. The DAG's schedule and metadata become that version's, in the same transaction. Runs that already exist keep their version, and is_paused is never changed. The version must pass the checks a register of it would pass today. Naming the current version changes nothing (changed false). Audited as dag.version.set_current. Needs deploy or write on dags (scope dexaflow:deploy). Under the server setting deploy.require_digest, a version whose image is not pinned by a full sha256 digest is made current with a warning in warnings (warn), or refused with 400 (enforce).
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PUT /api/v2/dags/{dag_id}/currentVersion (the `SetDagCurrentVersion` operationId).
	SetDagCurrentVersionWithBodyWithResponse(ctx context.Context, dagId DagID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SetDagCurrentVersionResponse, error)

	// SetDagCurrentVersionWithResponse Make a registered version current (Dexaflow)
	//
	// Makes a registered version of the DAG the one new runs are created with, by label or by version_number: a rollback, or a roll forward. The DAG's schedule and metadata become that version's, in the same transaction. Runs that already exist keep their version, and is_paused is never changed. The version must pass the checks a register of it would pass today. Naming the current version changes nothing (changed false). Audited as dag.version.set_current. Needs deploy or write on dags (scope dexaflow:deploy). Under the server setting deploy.require_digest, a version whose image is not pinned by a full sha256 digest is made current with a warning in warnings (warn), or refused with 400 (enforce).
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PUT /api/v2/dags/{dag_id}/currentVersion (the `SetDagCurrentVersion` operationId).
	SetDagCurrentVersionWithResponse(ctx context.Context, dagId DagID, body SetDagCurrentVersionJSONRequestBody, reqEditors ...RequestEditorFn) (*SetDagCurrentVersionResponse, 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)

	// ClearDagRunWithBodyWithResponse Clear a whole DAG run (queue its task instances for re-run)
	//
	// The run page's Clear action. A dry run (the default) answers the task instances the clear would reset. The clear itself resets them, re-queues the run and answers the 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/{dag_run_id}/clear (the `ClearDagRun` operationId).
	ClearDagRunWithBodyWithResponse(ctx context.Context, dagId DagID, dagRunId DagRunID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ClearDagRunResponse, error)

	// ClearDagRunWithResponse Clear a whole DAG run (queue its task instances for re-run)
	//
	// The run page's Clear action. A dry run (the default) answers the task instances the clear would reset. The clear itself resets them, re-queues the run and answers the 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/{dag_run_id}/clear (the `ClearDagRun` operationId).
	ClearDagRunWithResponse(ctx context.Context, dagId DagID, dagRunId DagRunID, body ClearDagRunJSONRequestBody, reqEditors ...RequestEditorFn) (*ClearDagRunResponse, error)

	// ListTaskInstancesWithResponse List task instances of a DAG run
	//
	// Pages with the same limit, offset and cursor query parameters as the DAG run list (they are not declared on this operation so the generated client keeps its signature). A request that carries cursor gets next_cursor and previous_cursor in the body; only the offset cursors this list issues are accepted, any other is refused with 400.
	//
	// 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)

	// PatchTaskInstanceWithBodyWithResponse Mark a task instance as success, failed or skipped
	//
	// Sets the task instance's state, as the UI's Mark as action does. The answer is the affected set, a collection holding the updated task instance, as Apache Airflow declares it.
	//
	// 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}/dagRuns/{dag_run_id}/taskInstances/{task_id} (the `PatchTaskInstance` operationId).
	PatchTaskInstanceWithBodyWithResponse(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PatchTaskInstanceResponse, error)

	// PatchTaskInstanceWithResponse Mark a task instance as success, failed or skipped
	//
	// Sets the task instance's state, as the UI's Mark as action does. The answer is the affected set, a collection holding the updated task instance, as Apache Airflow declares it.
	//
	// 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}/dagRuns/{dag_run_id}/taskInstances/{task_id} (the `PatchTaskInstance` operationId).
	PatchTaskInstanceWithResponse(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, body PatchTaskInstanceJSONRequestBody, reqEditors ...RequestEditorFn) (*PatchTaskInstanceResponse, error)

	// PatchTaskInstanceDryRunWithBodyWithResponse Preview marking a task instance
	//
	// Answers the task instance with the state the PATCH would set, without changing anything.
	//
	// 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}/dagRuns/{dag_run_id}/taskInstances/{task_id}/dry_run (the `PatchTaskInstanceDryRun` operationId).
	PatchTaskInstanceDryRunWithBodyWithResponse(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PatchTaskInstanceDryRunResponse, error)

	// PatchTaskInstanceDryRunWithResponse Preview marking a task instance
	//
	// Answers the task instance with the state the PATCH would set, without changing anything.
	//
	// 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}/dagRuns/{dag_run_id}/taskInstances/{task_id}/dry_run (the `PatchTaskInstanceDryRun` operationId).
	PatchTaskInstanceDryRunWithResponse(ctx context.Context, dagId DagID, dagRunId DagRunID, taskId TaskID, body PatchTaskInstanceDryRunJSONRequestBody, reqEditors ...RequestEditorFn) (*PatchTaskInstanceDryRunResponse, 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)

	// RegisterDagVersionWithBodyWithResponse Register a compiled DAG version (Dexaflow)
	//
	// Registers a compiled dag.json as a new version of the DAG and makes it current. Re-registering content that is already registered (same spec hash) is a no-op answered with 200 and created false, and leaves the current version as it is. The same label with other content is refused with 409. Needs deploy or write on dags (scope dexaflow:deploy).
	// Without is_paused, a DAG the register creates starts paused per its is_paused_upon_creation, else the server's dags_are_paused_at_creation, and an existing DAG keeps its state. With is_paused, the DAG ends the register in that state whether it is created, gets a new version or already had this content; a change to an existing DAG is audited as dag.pause or dag.unpause in the same transaction. Pausing is a run-state write: sending is_paused also needs write on dags, and a scoped token needs dexaflow:run as well as dexaflow:deploy, else the register is refused with 403.
	// Under the server setting deploy.require_digest, an image that is not pinned by a full digest (repository@sha256: and 64 hex characters) is registered with a warning in warnings (warn), or refused with 400 (enforce). Off, the default, accepts any image.
	// POST /api/v2/dags/{dag_id}/versions/dry_run runs the same checks and writes nothing.
	//
	// 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}/versions (the `RegisterDagVersion` operationId).
	RegisterDagVersionWithBodyWithResponse(ctx context.Context, dagId DagID, params *RegisterDagVersionParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RegisterDagVersionResponse, error)

	// RegisterDagVersionWithResponse Register a compiled DAG version (Dexaflow)
	//
	// Registers a compiled dag.json as a new version of the DAG and makes it current. Re-registering content that is already registered (same spec hash) is a no-op answered with 200 and created false, and leaves the current version as it is. The same label with other content is refused with 409. Needs deploy or write on dags (scope dexaflow:deploy).
	// Without is_paused, a DAG the register creates starts paused per its is_paused_upon_creation, else the server's dags_are_paused_at_creation, and an existing DAG keeps its state. With is_paused, the DAG ends the register in that state whether it is created, gets a new version or already had this content; a change to an existing DAG is audited as dag.pause or dag.unpause in the same transaction. Pausing is a run-state write: sending is_paused also needs write on dags, and a scoped token needs dexaflow:run as well as dexaflow:deploy, else the register is refused with 403.
	// Under the server setting deploy.require_digest, an image that is not pinned by a full digest (repository@sha256: and 64 hex characters) is registered with a warning in warnings (warn), or refused with 400 (enforce). Off, the default, accepts any image.
	// POST /api/v2/dags/{dag_id}/versions/dry_run runs the same checks and writes nothing.
	//
	// 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}/versions (the `RegisterDagVersion` operationId).
	RegisterDagVersionWithResponse(ctx context.Context, dagId DagID, params *RegisterDagVersionParams, body RegisterDagVersionJSONRequestBody, reqEditors ...RequestEditorFn) (*RegisterDagVersionResponse, 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"`

	// ExtraUnreadable Present and true in a listing when the extra is encrypted with a secret key the server does not have (for example after a key rotation that dropped the old key). The extra is then null, so a client that parses it as JSON still can. Reading the connection alone, or updating it, answers 500 with a message naming it, and the stored extra is kept.
	ExtraUnreadable *bool   `json:"extra_unreadable,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 CreateAPITokenJSONRequestBody = CreateAPITokenRequest

type CreateAPITokenRequest struct {
	// ExpiresInSeconds Lifetime of the token. Defaults to 7776000 (90 days).
	ExpiresInSeconds *int64 `json:"expires_in_seconds,omitempty"`

	// Name A name for the token, unique among the caller's live tokens: 1 to 64 letters, digits, dots, dashes or underscores, starting with a letter or digit.
	Name string `json:"name"`

	// Scope deploy registers versions, sets the current version and reads DAGs; read only reads.
	Scope CreateAPITokenRequestScope `json:"scope"`
}

type CreateAPITokenRequestScope string

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

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
}