gen

type CheckZone200JSONResponse ZoneCheck

type CheckZoneParams struct {
	// Reverse Also report the reverse entries this zone's records imply and it
	// does not have. Off by default: working that out means planning the
	// write that would fix it, which holds the zone's write lock while it
	// runs, and a check is otherwise a read that blocks nothing.
	Reverse *bool `form:"reverse,omitempty" json:"reverse,omitempty"`
}

type CheckZoneRequestObject struct {
	ZoneId ZoneID `json:"zoneId"`
	Params CheckZoneParams
}

type CheckZoneResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *ZoneCheck
	// ApplicationproblemJSONDefault the response for an HTTP default `application/problem+json` response
	ApplicationproblemJSONDefault *Problem
}

type CheckZoneResponseObject interface {
	VisitCheckZoneResponse(w http.ResponseWriter) error
}

type CheckZonedefaultApplicationProblemPlusJSONResponse struct {
	Body       Problem
	StatusCode int
}

type ChiServerOptions struct {
	BaseURL          string
	BaseRouter       chi.Router
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

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 {

	// DeleteSession End the session
	//
	// The cookies are cleared and the session is forgotten here, so a copy of
	// the cookie taken beforehand stops working too. The token it was opened
	// with is untouched.
	//
	// Corresponds with DELETE /auth/session (the `DeleteSession` operationId).
	DeleteSession(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSession Report who this request is authenticated as
	//
	// What an interface asks when it loads, to find out whether it has to
	// show a login at all, and what to grey out if it does not.
	//
	// Corresponds with GET /auth/session (the `GetSession` operationId).
	GetSession(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateSessionWithBody Exchange a token for a browser session
	//
	// The web interface does not hold a long-lived token. It posts one here
	// once and receives an `httpOnly` session cookie, which no script that
	// gets injected into the page can read, which is the whole point.
	//
	// A second, readable cookie carries a CSRF value. Every state-changing
	// request authenticated by the session cookie has to repeat it in the
	// `X-Wegweiser-CSRF` header. `SameSite=Strict` already blocks a
	// cross-site form post; this is the second layer. A request that
	// authenticates with a bearer token skips the check, because CSRF needs
	// ambient credentials and a bearer token is not ambient.
	//
	// Unauthenticated, because a request that could authenticate would not
	// need this. The token inside is checked the same way and is rate-limited
	// the same way.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /auth/session (the `CreateSession` operationId).
	CreateSessionWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateSession Exchange a token for a browser session
	//
	// The web interface does not hold a long-lived token. It posts one here
	// once and receives an `httpOnly` session cookie, which no script that
	// gets injected into the page can read, which is the whole point.
	//
	// A second, readable cookie carries a CSRF value. Every state-changing
	// request authenticated by the session cookie has to repeat it in the
	// `X-Wegweiser-CSRF` header. `SameSite=Strict` already blocks a
	// cross-site form post; this is the second layer. A request that
	// authenticates with a bearer token skips the check, because CSRF needs
	// ambient credentials and a bearer token is not ambient.
	//
	// Unauthenticated, because a request that could authenticate would not
	// need this. The token inside is checked the same way and is rate-limited
	// the same way.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /auth/session (the `CreateSession` operationId).
	CreateSession(ctx context.Context, body CreateSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetCluster Say who the members are, and how far this one has got
	//
	// The members as this node's copy of the cluster's configuration lists
	// them, which of them leads, and how far each has got through the log.
	// This node asks every other member for that as it answers, and one
	// that does not answer within a couple of seconds is listed as not
	// reached (docs/decisions/d47-status-asks-every-member.md). Asked over
	// the cluster port, a member answers for itself only.
	//
	// A node that has left the cluster over an entry it could not apply says
	// where it stopped and why, and goes on answering queries with what it
	// holds (docs/decisions/d29-a-node-that-cannot-apply.md).
	//
	// A node whose configuration file has no cluster section answers 404.
	//
	// Corresponds with GET /cluster (the `GetCluster` operationId).
	GetCluster(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// InitCluster Start a cluster with this node as its first member
	//
	// This node becomes the only member of a new cluster, and brings
	// everything it holds into it: zones, tokens, keys and settings. Every
	// other node joins by asking a member, with `weg serve --join`
	// (docs/decisions/d44-starting-and-joining.md).
	//
	// It is done once. A node that is a member already is refused, and so is
	// one whose configuration file has no cluster section, since it has no
	// address to be reached at and no secret to prove it belongs.
	//
	// Writes wait while the cluster is started, and go through its log from
	// then on.
	//
	// Corresponds with POST /cluster/init (the `InitCluster` operationId).
	InitCluster(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RemoveClusterMember Take a member out of the cluster
	//
	// The member stops being one once the change is committed. Naming the
	// member asked is how it leaves, and naming another is how a member that
	// is off, or has stopped, is taken out
	// (docs/decisions/d44-starting-and-joining.md). Any member can be
	// asked; one that does not lead hands the request to the one that does.
	//
	// A member taken out goes on answering queries with what it held, and
	// refuses writes until it is joined again or run on its own
	// (docs/decisions/d46-a-member-that-has-left.md).
	//
	// A member the cluster does not have is 404. The cluster's only voter
	// cannot be removed, and is 409.
	//
	// Corresponds with DELETE /cluster/members/{memberId} (the `RemoveClusterMember` operationId).
	RemoveClusterMember(ctx context.Context, memberId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListCommits List commits, newest first
	//
	// Every write is a commit, so this is the whole history of the server.
	// Commits are listed without their events, which is what makes a page of
	// history cheap on a zone that has been edited for years; read one commit
	// to get the changes it made.
	//
	// A commit outlives the zone it describes, so the history of a deleted
	// zone is still here, under the name it had.
	//
	// Corresponds with GET /commits (the `ListCommits` operationId).
	ListCommits(ctx context.Context, params *ListCommitsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetCommit Read one commit and everything it changed
	//
	// The events are the diff: every record that was removed and every record
	// that was added, both carrying their full data. That is what RFC 1995 §2
	// asks of an incremental transfer, and it is also what an interface needs
	// to render the change and what restoring an earlier state needs to undo
	// it.
	//
	// Corresponds with GET /commits/{commitId} (the `GetCommit` operationId).
	GetCommit(ctx context.Context, commitId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetHealth Report whether the server is fit to answer queries
	//
	// Unauthenticated on purpose: a health check that needs a credential is
	// one more thing that can fail for a reason unrelated to health.
	//
	// Corresponds with GET /healthz (the `GetHealth` operationId).
	GetHealth(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetMetrics Export the current metrics
	//
	// The Prometheus text exposition format: queries by transport, type and
	// response code, latency, response sizes, drops, truncations, what the
	// snapshot being answered from holds, and the Go runtime and process
	// collectors that come with any Go exporter.
	//
	// Authenticated like everything else here. What a server is asked, how
	// often and by how many zones is operational detail, and a scraper can
	// carry a bearer token: Prometheus has had `authorization` in its scrape
	// configuration for years. `/healthz` is the one endpoint that needs no
	// credential, because a load balancer cannot be given one.
	//
	// The response carries the exposition format's version in its
	// `Content-Type`, which is where a scraper reads it.
	//
	// Corresponds with GET /metrics (the `GetMetrics` operationId).
	GetMetrics(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// StreamQueries Watch queries as they are answered
	//
	// A live tail of the exchanges matching the filter, as Server-Sent
	// Events. Two kinds of message arrive:
	//
	// - `query`, one per exchange, carrying a `QueryEvent`.
	// - `status`, whenever what the stream is leaving out changes and every
	//   few seconds regardless, carrying a `StreamStatus`. It says what the
	//   stream is sampling at and how much it has dropped, because a stream
	//   that quietly leaves things out while looking complete is worse than
	//   one that admits to showing every fiftieth query
	//   (docs/decisions/ D9).
	//
	// The filter is applied before anything is buffered, so watching one zone
	// stays complete however busy the rest of the server is. A watcher that
	// stops reading loses its oldest exchanges, never its newest: this is a
	// live view, and it is never allowed to slow a query down.
	//
	// How many watchers may be open at once is bounded, because each one
	// costs the query path a filter evaluation per query. A request past the
	// bound is refused with 503.
	//
	// Corresponds with GET /queries/stream (the `StreamQueries` operationId).
	StreamQueries(ctx context.Context, params *StreamQueriesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteRecord Delete a record
	//
	// Corresponds with DELETE /records/{recordId} (the `DeleteRecord` operationId).
	DeleteRecord(ctx context.Context, recordId RecordID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetRecord Read one record
	//
	// Corresponds with GET /records/{recordId} (the `GetRecord` operationId).
	GetRecord(ctx context.Context, recordId RecordID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateRecordWithBody Change a record
	//
	// Only the fields that are present are changed. The record keeps its
	// identity, and with it its comment, its provenance and the history
	// pointing at it, which is what tells an edit apart from a delete and an
	// add.
	//
	// A record the server generated is refused, naming the record it came
	// from; detach it first to take it over (docs/decisions/ D4).
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /records/{recordId} (the `UpdateRecord` operationId).
	UpdateRecordWithBody(ctx context.Context, recordId RecordID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateRecord Change a record
	//
	// Only the fields that are present are changed. The record keeps its
	// identity, and with it its comment, its provenance and the history
	// pointing at it, which is what tells an edit apart from a delete and an
	// add.
	//
	// A record the server generated is refused, naming the record it came
	// from; detach it first to take it over (docs/decisions/ D4).
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /records/{recordId} (the `UpdateRecord` operationId).
	UpdateRecord(ctx context.Context, recordId RecordID, body UpdateRecordJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MakeRecordCanonical Make this the name an address reverses to
	//
	// Several names on one address is ordinary, and only one of them can be
	// the answer to a reverse lookup. Where the address record named here is
	// not that one, this hands it the entry and takes it from whatever
	// generated one holds it.
	//
	// The record itself does not change. What changes is the reverse zone,
	// in a commit of its own like any other change the automation makes.
	//
	// An entry somebody wrote by hand is left alone: detaching a generated
	// record is how a person says to stop maintaining it, and taking it back
	// would make detaching mean nothing (docs/decisions/ D4). A record that
	// already holds the entry is answered without anything being written.
	//
	// Corresponds with POST /records/{recordId}/canonical (the `MakeRecordCanonical` operationId).
	MakeRecordCanonical(ctx context.Context, recordId RecordID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DetachRecord Take over a generated record
	//
	// The record keeps its data and its identity, loses its link to the
	// record it was generated from, and the automation stops maintaining it
	// (docs/decisions/ D4). A record that was already authored is returned
	// unchanged: asking for it to be nobody's derivative has got what it
	// asked for.
	//
	// Corresponds with POST /records/{recordId}/detach (the `DetachRecord` operationId).
	DetachRecord(ctx context.Context, recordId RecordID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSecondaryConfig Write the configuration a secondary needs
	//
	// The zones this server holds, rendered as a configuration file for the
	// software running at the other end. It carries the transfer key's secret
	// in clear, which is what it is for, so it needs the `admin` scope for the
	// same reason reading that secret does.
	//
	// The output is deterministic. Regenerating it produces the same bytes
	// when nothing has changed, so it can live under configuration management
	// without a diff on every run.
	//
	// What is reported beside it is the arrangement rather than the syntax: a
	// transfer list nobody is on, a key that grants nothing, a secondary the
	// notifications do not reach. Each of those renders a file that is
	// perfectly formed and does not work.
	//
	// Corresponds with GET /secondary-config (the `GetSecondaryConfig` operationId).
	GetSecondaryConfig(ctx context.Context, params *GetSecondaryConfigParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSecondaryStatus Say what each secondary holds
	//
	// One entry per zone per secondary on the notify list, saying what that
	// secondary last said its serial was and how that compares with what this
	// server publishes now.
	//
	// A secondary is asked once a notification to it has been answered or
	// given up on, and at least hourly whether anything changed or not. Until
	// the first question about a pair has finished it is reported as unasked,
	// which is a state of its own: reporting it as in step would be the one
	// thing this is here to stop.
	//
	// Nothing is reported while a notification is outstanding. A secondary
	// that has just been told and has not fetched yet is in flight rather than
	// behind, and a report that cannot tell those apart is one nobody reads.
	//
	// Corresponds with GET /secondary-status (the `GetSecondaryStatus` operationId).
	GetSecondaryStatus(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSettings Read the server-wide settings
	//
	// These are the defaults a zone that says nothing about itself inherits.
	// They live in the database, so changing one takes effect on the next
	// write without a restart (docs/decisions/ D11).
	//
	// Corresponds with GET /settings (the `GetSettings` operationId).
	GetSettings(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateSettingsWithBody Change the server-wide settings
	//
	// A field that is absent is left alone, so a client may send only what it
	// means to change.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /settings (the `UpdateSettings` operationId).
	UpdateSettingsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateSettings Change the server-wide settings
	//
	// A field that is absent is left alone, so a client may send only what it
	// means to change.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /settings (the `UpdateSettings` operationId).
	UpdateSettings(ctx context.Context, body UpdateSettingsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListTokens List the tokens that may use this API
	//
	// Revoked and expired tokens are listed too, so that a name in the
	// history can still be looked up. No response ever carries a secret: what
	// is stored is its SHA-256, and the leading characters kept in the clear
	// are there to tell two tokens apart, not to authenticate with.
	//
	// Corresponds with GET /tokens (the `ListTokens` operationId).
	ListTokens(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateTokenWithBody Mint a token
	//
	// The secret comes back in this response and never again. It is 256 bits
	// from a cryptographic source; what the server keeps is its SHA-256, so a
	// copy of the database is not a copy of the credentials.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /tokens (the `CreateToken` operationId).
	CreateTokenWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateToken Mint a token
	//
	// The secret comes back in this response and never again. It is 256 bits
	// from a cryptographic source; what the server keeps is its SHA-256, so a
	// copy of the database is not a copy of the credentials.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /tokens (the `CreateToken` operationId).
	CreateToken(ctx context.Context, body CreateTokenJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RevokeToken Withdraw a token
	//
	// The token is marked unusable rather than removed, so that the history
	// it appears in still names something. Revoking a token that is already
	// revoked changes nothing and is not an error.
	//
	// The last token that can still administer the server is refused: a
	// server nobody can reach is not a state this API will put itself in.
	//
	// Corresponds with DELETE /tokens/{tokenId} (the `RevokeToken` operationId).
	RevokeToken(ctx context.Context, tokenId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListTSIGKeys List the keys a secondary may sign a transfer with
	//
	// Revoked keys are listed too, so that a name a secondary still has
	// configured can be looked up. No listing carries a secret; reading one
	// back is a request of its own.
	//
	// Corresponds with GET /tsig-keys (the `ListTSIGKeys` operationId).
	ListTSIGKeys(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateTSIGKeyWithBody Create a key
	//
	// The secret comes back in this response. Unlike an API token it can be
	// read again, because verifying a signature means recomputing the MAC and
	// this server therefore has to keep it.
	//
	// Leave the secret out and one is generated, at least as long as the hash
	// output of the algorithm (RFC 8945 section 8). Send one to match a
	// secondary that already has a key, base64 as every other implementation
	// writes it.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /tsig-keys (the `CreateTSIGKey` operationId).
	CreateTSIGKeyWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateTSIGKey Create a key
	//
	// The secret comes back in this response. Unlike an API token it can be
	// read again, because verifying a signature means recomputing the MAC and
	// this server therefore has to keep it.
	//
	// Leave the secret out and one is generated, at least as long as the hash
	// output of the algorithm (RFC 8945 section 8). Send one to match a
	// secondary that already has a key, base64 as every other implementation
	// writes it.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /tsig-keys (the `CreateTSIGKey` operationId).
	CreateTSIGKey(ctx context.Context, body CreateTSIGKeyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RevokeTSIGKey Withdraw a key
	//
	// The key stops signing and its secret is cleared, which is the one thing
	// revoking a token does not do: a token leaves only a hash behind, and a
	// key would leave material nothing will read again. The row stays so the
	// name and the dates still read, and the name is then free for a
	// replacement.
	//
	// Revoking a key that is already revoked changes nothing and is not an
	// error.
	//
	// Corresponds with DELETE /tsig-keys/{keyId} (the `RevokeTSIGKey` operationId).
	RevokeTSIGKey(ctx context.Context, keyId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ReadTSIGKeySecret Read a key's secret
	//
	// Separate from the listing so that a secret is shown when somebody asked
	// for it and not when they were looking at something else. It is not a
	// boundary: the database holds the secret either way.
	//
	// A revoked key has none, and this is then a refusal rather than an empty
	// answer.
	//
	// Corresponds with GET /tsig-keys/{keyId}/secret (the `ReadTSIGKeySecret` operationId).
	ReadTSIGKeySecret(ctx context.Context, keyId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListZones List zones
	//
	// Corresponds with GET /zones (the `ListZones` operationId).
	ListZones(ctx context.Context, params *ListZonesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateZoneWithBody Create a zone
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /zones (the `CreateZone` operationId).
	CreateZoneWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateZone Create a zone
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /zones (the `CreateZone` operationId).
	CreateZone(ctx context.Context, body CreateZoneJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ImportZoneWithBody Bring a whole zone in from a zonefile
	//
	// The body is the file itself, in the presentation format of RFC 1035 §5.
	// The zone it describes is wherever its SOA sits, so the name is not sent
	// separately and cannot be sent inconsistently.
	//
	// The serial in the file is the serial the zone starts at. A migrated
	// zone that restarted at 1 would look older than itself to every
	// secondary that has already seen it (RFC 1982 §3.2), which is the single
	// most common way to break a migration (docs/decisions/ D2).
	//
	// `$INCLUDE` is refused: a file arriving here that could pull in a path
	// would read this server's filesystem out loud.
	//
	// Records that a delegation in the same file makes unanswerable are left
	// out rather than failing the whole file, and come back in `skipped`.
	// Real zones carry them, and a migration that stops on one is a migration
	// nobody finishes.
	//
	// The zone must not already exist. A file is the complete contents of a
	// zone, so bringing one into a zone that holds records is a replacement
	// rather than an import.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /zones/import (the `ImportZone` operationId).
	ImportZoneWithBody(ctx context.Context, params *ImportZoneParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteZone Delete a zone and everything in it
	//
	// Corresponds with DELETE /zones/{zoneId} (the `DeleteZone` operationId).
	DeleteZone(ctx context.Context, zoneId ZoneID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetZone Read one zone
	//
	// Everything a listing carries, and the one diagnosis a zone can carry
	// that nothing about it looks wrong for. It is computed here rather than
	// left to `/check` because somebody who has to know to run a check in
	// order to be told their delegation is broken has been told nothing. It
	// costs the zone's NS records and one lookup per name server, not a walk
	// of the zone, which is what makes that affordable.
	//
	// Corresponds with GET /zones/{zoneId} (the `GetZone` operationId).
	GetZone(ctx context.Context, zoneId ZoneID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateZoneWithBody Change a zone's own settings
	//
	// Only the fields that are present are changed. The zone's records are
	// not touched, and the zone cannot be renamed: every owner name, every
	// sort key and the whole journal belong to the name it has.
	//
	// Changing anything that is served advances the serial, like any other
	// change. Changing nothing writes nothing.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /zones/{zoneId} (the `UpdateZone` operationId).
	UpdateZoneWithBody(ctx context.Context, zoneId ZoneID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateZone Change a zone's own settings
	//
	// Only the fields that are present are changed. The zone's records are
	// not touched, and the zone cannot be renamed: every owner name, every
	// sort key and the whole journal belong to the name it has.
	//
	// Changing anything that is served advances the serial, like any other
	// change. Changing nothing writes nothing.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /zones/{zoneId} (the `UpdateZone` operationId).
	UpdateZone(ctx context.Context, zoneId ZoneID, body UpdateZoneJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CheckZone Report what is wrong with a zone as it stands
	//
	// Every rule the write path enforces, applied to the zone as it is
	// stored.
	//
	// A write is checked against the names it touches, and against the names
	// a new delegation would put out of reach, so a zone edited only through
	// this API stays sound. What this finds is what did not arrive that way:
	// data written before a rule existed, or a hand on the database file.
	//
	// It reports rather than refuses. A name with more than one problem
	// yields the first of them, and the list stops at a thousand findings:
	// a zone past that has one systematic fault rather than a thousand
	// separate ones.
	//
	// Nothing is written. Repairing what this names is ordinary editing.
	//
	// Corresponds with GET /zones/{zoneId}/check (the `CheckZone` operationId).
	CheckZone(ctx context.Context, zoneId ZoneID, params *CheckZoneParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ExportZone Write a zone out as a zonefile
	//
	// The presentation format of RFC 1035 §5, which any other authoritative
	// server reads. Every name is absolute and every record carries its own
	// TTL and class, so no line means something different when it is copied
	// out; records come out in the canonical order of RFC 4034 §6.1, so
	// exporting the same zone twice is the same bytes and a diff of two
	// exports is a diff of two zones.
	//
	// A disabled record is left out. It is not part of the zone as it
	// answers, and a file has nowhere to say "present but switched off".
	//
	// Corresponds with GET /zones/{zoneId}/export (the `ExportZone` operationId).
	ExportZone(ctx context.Context, zoneId ZoneID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ReconcileZone Write the reverse entries this zone's records imply and does not have
	//
	// Reverse automation reacts to changes, so a zone that arrives after the
	// records it should hold has nothing to react to. A reverse zone created
	// for a network already in use starts empty, however many addresses are
	// already named in it, and this is what fills it: one commit for
	// everything missing.
	//
	// It only adds. An entry that became obsolete was taken away by the
	// change that obsoleted it, and one somebody detached is theirs to keep,
	// so nothing here removes anything.
	//
	// A zone that needs nothing is left alone and answers with no commit.
	//
	// Corresponds with POST /zones/{zoneId}/reconcile (the `ReconcileZone` operationId).
	ReconcileZone(ctx context.Context, zoneId ZoneID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListRecords List the records of a zone
	//
	// Corresponds with GET /zones/{zoneId}/records (the `ListRecords` operationId).
	ListRecords(ctx context.Context, zoneId ZoneID, params *ListRecordsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateRecordWithBody Add a record to a zone
	//
	// An address record may generate a PTR in the reverse zone answering for
	// it. What that produced, and what it could not produce, comes back in
	// the response rather than in a log line (docs/decisions/ D3 and D6).
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /zones/{zoneId}/records (the `CreateRecord` operationId).
	CreateRecordWithBody(ctx context.Context, zoneId ZoneID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateRecord Add a record to a zone
	//
	// An address record may generate a PTR in the reverse zone answering for
	// it. What that produced, and what it could not produce, comes back in
	// the response rather than in a log line (docs/decisions/ D3 and D6).
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /zones/{zoneId}/records (the `CreateRecord` operationId).
	CreateRecord(ctx context.Context, zoneId ZoneID, body CreateRecordJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RollbackZoneWithBody Restore a zone to the state it had at a serial
	//
	// The difference between the zone as it stands and the zone as it stood
	// is written as a **new** commit that moves forward to that state. It is
	// not a rewind: a secondary that has already seen serial 90 will never
	// accept a jump back to 42, because RFC 1982 arithmetic makes 42 older
	// and RFC 1995 has no way to express going backwards.
	//
	// Records that did not change in between are not touched, so they keep
	// their identity, their comments and the history pointing at them.
	// Records the server generated are not restored directly: they follow
	// from the records they were generated from, so restoring those is what
	// moves them.
	//
	// A rollback to the serial the zone is already at changes nothing and
	// answers with no commit.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /zones/{zoneId}/rollback (the `RollbackZone` operationId).
	RollbackZoneWithBody(ctx context.Context, zoneId ZoneID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RollbackZone Restore a zone to the state it had at a serial
	//
	// The difference between the zone as it stands and the zone as it stood
	// is written as a **new** commit that moves forward to that state. It is
	// not a rewind: a secondary that has already seen serial 90 will never
	// accept a jump back to 42, because RFC 1982 arithmetic makes 42 older
	// and RFC 1995 has no way to express going backwards.
	//
	// Records that did not change in between are not touched, so they keep
	// their identity, their comments and the history pointing at them.
	// Records the server generated are not restored directly: they follow
	// from the records they were generated from, so restoring those is what
	// moves them.
	//
	// A rollback to the serial the zone is already at changes nothing and
	// answers with no commit.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /zones/{zoneId}/rollback (the `RollbackZone` operationId).
	RollbackZone(ctx context.Context, zoneId ZoneID, body RollbackZoneJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ReplaceRRsetsWithBody Make the named RRsets exactly what is given
	//
	// An RRset (everything sharing an owner name, class and type) is the
	// unit DNS answers with (RFC 2181 §5), and therefore the unit a record
	// editor edits. Sending the set rather than a list of additions and
	// removals means the client says what it wants to be true, and the server
	// works out the difference; a record whose data did not change keeps its
	// identity, and with it its comment, its provenance and the history
	// pointing at it.
	//
	// Only the RRsets named here are touched. An empty `records` removes one.
	//
	// Everything in one request becomes one commit, so a page of edits saved
	// together is one line in the history and one point to roll back to.
	//
	// The RRsets are named in the body rather than in the path because a DNS
	// label may hold any octet, `/` among them, so there is no path form that
	// is safe for every name.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PUT /zones/{zoneId}/rrsets (the `ReplaceRRsets` operationId).
	ReplaceRRsetsWithBody(ctx context.Context, zoneId ZoneID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ReplaceRRsets Make the named RRsets exactly what is given
	//
	// An RRset (everything sharing an owner name, class and type) is the
	// unit DNS answers with (RFC 2181 §5), and therefore the unit a record
	// editor edits. Sending the set rather than a list of additions and
	// removals means the client says what it wants to be true, and the server
	// works out the difference; a record whose data did not change keeps its
	// identity, and with it its comment, its provenance and the history
	// pointing at it.
	//
	// Only the RRsets named here are touched. An empty `records` removes one.
	//
	// Everything in one request becomes one commit, so a page of edits saved
	// together is one line in the history and one point to roll back to.
	//
	// The RRsets are named in the body rather than in the path because a DNS
	// label may hold any octet, `/` among them, so there is no path form that
	// is safe for every name.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PUT /zones/{zoneId}/rrsets (the `ReplaceRRsets` operationId).
	ReplaceRRsets(ctx context.Context, zoneId ZoneID, body ReplaceRRsetsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
}

type ClientOption func(*Client) error

type ClientWithResponses struct {
	ClientInterface
}

type ClientWithResponsesInterface interface {

	// DeleteSessionWithResponse End the session
	//
	// The cookies are cleared and the session is forgotten here, so a copy of
	// the cookie taken beforehand stops working too. The token it was opened
	// with is untouched.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /auth/session (the `DeleteSession` operationId).
	DeleteSessionWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DeleteSessionResponse, error)

	// GetSessionWithResponse Report who this request is authenticated as
	//
	// What an interface asks when it loads, to find out whether it has to
	// show a login at all, and what to grey out if it does not.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /auth/session (the `GetSession` operationId).
	GetSessionWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetSessionResponse, error)

	// CreateSessionWithBodyWithResponse Exchange a token for a browser session
	//
	// The web interface does not hold a long-lived token. It posts one here
	// once and receives an `httpOnly` session cookie, which no script that
	// gets injected into the page can read, which is the whole point.
	//
	// A second, readable cookie carries a CSRF value. Every state-changing
	// request authenticated by the session cookie has to repeat it in the
	// `X-Wegweiser-CSRF` header. `SameSite=Strict` already blocks a
	// cross-site form post; this is the second layer. A request that
	// authenticates with a bearer token skips the check, because CSRF needs
	// ambient credentials and a bearer token is not ambient.
	//
	// Unauthenticated, because a request that could authenticate would not
	// need this. The token inside is checked the same way and is rate-limited
	// the same way.
	//
	// 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/session (the `CreateSession` operationId).
	CreateSessionWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateSessionResponse, error)

	// CreateSessionWithResponse Exchange a token for a browser session
	//
	// The web interface does not hold a long-lived token. It posts one here
	// once and receives an `httpOnly` session cookie, which no script that
	// gets injected into the page can read, which is the whole point.
	//
	// A second, readable cookie carries a CSRF value. Every state-changing
	// request authenticated by the session cookie has to repeat it in the
	// `X-Wegweiser-CSRF` header. `SameSite=Strict` already blocks a
	// cross-site form post; this is the second layer. A request that
	// authenticates with a bearer token skips the check, because CSRF needs
	// ambient credentials and a bearer token is not ambient.
	//
	// Unauthenticated, because a request that could authenticate would not
	// need this. The token inside is checked the same way and is rate-limited
	// the same way.
	//
	// 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/session (the `CreateSession` operationId).
	CreateSessionWithResponse(ctx context.Context, body CreateSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateSessionResponse, error)

	// GetClusterWithResponse Say who the members are, and how far this one has got
	//
	// The members as this node's copy of the cluster's configuration lists
	// them, which of them leads, and how far each has got through the log.
	// This node asks every other member for that as it answers, and one
	// that does not answer within a couple of seconds is listed as not
	// reached (docs/decisions/d47-status-asks-every-member.md). Asked over
	// the cluster port, a member answers for itself only.
	//
	// A node that has left the cluster over an entry it could not apply says
	// where it stopped and why, and goes on answering queries with what it
	// holds (docs/decisions/d29-a-node-that-cannot-apply.md).
	//
	// A node whose configuration file has no cluster section answers 404.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /cluster (the `GetCluster` operationId).
	GetClusterWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetClusterResponse, error)

	// InitClusterWithResponse Start a cluster with this node as its first member
	//
	// This node becomes the only member of a new cluster, and brings
	// everything it holds into it: zones, tokens, keys and settings. Every
	// other node joins by asking a member, with `weg serve --join`
	// (docs/decisions/d44-starting-and-joining.md).
	//
	// It is done once. A node that is a member already is refused, and so is
	// one whose configuration file has no cluster section, since it has no
	// address to be reached at and no secret to prove it belongs.
	//
	// Writes wait while the cluster is started, and go through its log from
	// then on.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /cluster/init (the `InitCluster` operationId).
	InitClusterWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*InitClusterResponse, error)

	// RemoveClusterMemberWithResponse Take a member out of the cluster
	//
	// The member stops being one once the change is committed. Naming the
	// member asked is how it leaves, and naming another is how a member that
	// is off, or has stopped, is taken out
	// (docs/decisions/d44-starting-and-joining.md). Any member can be
	// asked; one that does not lead hands the request to the one that does.
	//
	// A member taken out goes on answering queries with what it held, and
	// refuses writes until it is joined again or run on its own
	// (docs/decisions/d46-a-member-that-has-left.md).
	//
	// A member the cluster does not have is 404. The cluster's only voter
	// cannot be removed, and is 409.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /cluster/members/{memberId} (the `RemoveClusterMember` operationId).
	RemoveClusterMemberWithResponse(ctx context.Context, memberId string, reqEditors ...RequestEditorFn) (*RemoveClusterMemberResponse, error)

	// ListCommitsWithResponse List commits, newest first
	//
	// Every write is a commit, so this is the whole history of the server.
	// Commits are listed without their events, which is what makes a page of
	// history cheap on a zone that has been edited for years; read one commit
	// to get the changes it made.
	//
	// A commit outlives the zone it describes, so the history of a deleted
	// zone is still here, under the name it had.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /commits (the `ListCommits` operationId).
	ListCommitsWithResponse(ctx context.Context, params *ListCommitsParams, reqEditors ...RequestEditorFn) (*ListCommitsResponse, error)

	// GetCommitWithResponse Read one commit and everything it changed
	//
	// The events are the diff: every record that was removed and every record
	// that was added, both carrying their full data. That is what RFC 1995 §2
	// asks of an incremental transfer, and it is also what an interface needs
	// to render the change and what restoring an earlier state needs to undo
	// it.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /commits/{commitId} (the `GetCommit` operationId).
	GetCommitWithResponse(ctx context.Context, commitId string, reqEditors ...RequestEditorFn) (*GetCommitResponse, error)

	// GetHealthWithResponse Report whether the server is fit to answer queries
	//
	// Unauthenticated on purpose: a health check that needs a credential is
	// one more thing that can fail for a reason unrelated to health.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /healthz (the `GetHealth` operationId).
	GetHealthWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetHealthResponse, error)

	// GetMetricsWithResponse Export the current metrics
	//
	// The Prometheus text exposition format: queries by transport, type and
	// response code, latency, response sizes, drops, truncations, what the
	// snapshot being answered from holds, and the Go runtime and process
	// collectors that come with any Go exporter.
	//
	// Authenticated like everything else here. What a server is asked, how
	// often and by how many zones is operational detail, and a scraper can
	// carry a bearer token: Prometheus has had `authorization` in its scrape
	// configuration for years. `/healthz` is the one endpoint that needs no
	// credential, because a load balancer cannot be given one.
	//
	// The response carries the exposition format's version in its
	// `Content-Type`, which is where a scraper reads it.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /metrics (the `GetMetrics` operationId).
	GetMetricsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetMetricsResponse, error)

	// StreamQueriesWithResponse Watch queries as they are answered
	//
	// A live tail of the exchanges matching the filter, as Server-Sent
	// Events. Two kinds of message arrive:
	//
	// - `query`, one per exchange, carrying a `QueryEvent`.
	// - `status`, whenever what the stream is leaving out changes and every
	//   few seconds regardless, carrying a `StreamStatus`. It says what the
	//   stream is sampling at and how much it has dropped, because a stream
	//   that quietly leaves things out while looking complete is worse than
	//   one that admits to showing every fiftieth query
	//   (docs/decisions/ D9).
	//
	// The filter is applied before anything is buffered, so watching one zone
	// stays complete however busy the rest of the server is. A watcher that
	// stops reading loses its oldest exchanges, never its newest: this is a
	// live view, and it is never allowed to slow a query down.
	//
	// How many watchers may be open at once is bounded, because each one
	// costs the query path a filter evaluation per query. A request past the
	// bound is refused with 503.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /queries/stream (the `StreamQueries` operationId).
	StreamQueriesWithResponse(ctx context.Context, params *StreamQueriesParams, reqEditors ...RequestEditorFn) (*StreamQueriesResponse, error)

	// DeleteRecordWithResponse Delete a record
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /records/{recordId} (the `DeleteRecord` operationId).
	DeleteRecordWithResponse(ctx context.Context, recordId RecordID, reqEditors ...RequestEditorFn) (*DeleteRecordResponse, error)

	// GetRecordWithResponse Read one record
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /records/{recordId} (the `GetRecord` operationId).
	GetRecordWithResponse(ctx context.Context, recordId RecordID, reqEditors ...RequestEditorFn) (*GetRecordResponse, error)

	// UpdateRecordWithBodyWithResponse Change a record
	//
	// Only the fields that are present are changed. The record keeps its
	// identity, and with it its comment, its provenance and the history
	// pointing at it, which is what tells an edit apart from a delete and an
	// add.
	//
	// A record the server generated is refused, naming the record it came
	// from; detach it first to take it over (docs/decisions/ D4).
	//
	// 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 /records/{recordId} (the `UpdateRecord` operationId).
	UpdateRecordWithBodyWithResponse(ctx context.Context, recordId RecordID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateRecordResponse, error)

	// UpdateRecordWithResponse Change a record
	//
	// Only the fields that are present are changed. The record keeps its
	// identity, and with it its comment, its provenance and the history
	// pointing at it, which is what tells an edit apart from a delete and an
	// add.
	//
	// A record the server generated is refused, naming the record it came
	// from; detach it first to take it over (docs/decisions/ D4).
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /records/{recordId} (the `UpdateRecord` operationId).
	UpdateRecordWithResponse(ctx context.Context, recordId RecordID, body UpdateRecordJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateRecordResponse, error)

	// MakeRecordCanonicalWithResponse Make this the name an address reverses to
	//
	// Several names on one address is ordinary, and only one of them can be
	// the answer to a reverse lookup. Where the address record named here is
	// not that one, this hands it the entry and takes it from whatever
	// generated one holds it.
	//
	// The record itself does not change. What changes is the reverse zone,
	// in a commit of its own like any other change the automation makes.
	//
	// An entry somebody wrote by hand is left alone: detaching a generated
	// record is how a person says to stop maintaining it, and taking it back
	// would make detaching mean nothing (docs/decisions/ D4). A record that
	// already holds the entry is answered without anything being written.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /records/{recordId}/canonical (the `MakeRecordCanonical` operationId).
	MakeRecordCanonicalWithResponse(ctx context.Context, recordId RecordID, reqEditors ...RequestEditorFn) (*MakeRecordCanonicalResponse, error)

	// DetachRecordWithResponse Take over a generated record
	//
	// The record keeps its data and its identity, loses its link to the
	// record it was generated from, and the automation stops maintaining it
	// (docs/decisions/ D4). A record that was already authored is returned
	// unchanged: asking for it to be nobody's derivative has got what it
	// asked for.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /records/{recordId}/detach (the `DetachRecord` operationId).
	DetachRecordWithResponse(ctx context.Context, recordId RecordID, reqEditors ...RequestEditorFn) (*DetachRecordResponse, error)

	// GetSecondaryConfigWithResponse Write the configuration a secondary needs
	//
	// The zones this server holds, rendered as a configuration file for the
	// software running at the other end. It carries the transfer key's secret
	// in clear, which is what it is for, so it needs the `admin` scope for the
	// same reason reading that secret does.
	//
	// The output is deterministic. Regenerating it produces the same bytes
	// when nothing has changed, so it can live under configuration management
	// without a diff on every run.
	//
	// What is reported beside it is the arrangement rather than the syntax: a
	// transfer list nobody is on, a key that grants nothing, a secondary the
	// notifications do not reach. Each of those renders a file that is
	// perfectly formed and does not work.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /secondary-config (the `GetSecondaryConfig` operationId).
	GetSecondaryConfigWithResponse(ctx context.Context, params *GetSecondaryConfigParams, reqEditors ...RequestEditorFn) (*GetSecondaryConfigResponse, error)

	// GetSecondaryStatusWithResponse Say what each secondary holds
	//
	// One entry per zone per secondary on the notify list, saying what that
	// secondary last said its serial was and how that compares with what this
	// server publishes now.
	//
	// A secondary is asked once a notification to it has been answered or
	// given up on, and at least hourly whether anything changed or not. Until
	// the first question about a pair has finished it is reported as unasked,
	// which is a state of its own: reporting it as in step would be the one
	// thing this is here to stop.
	//
	// Nothing is reported while a notification is outstanding. A secondary
	// that has just been told and has not fetched yet is in flight rather than
	// behind, and a report that cannot tell those apart is one nobody reads.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /secondary-status (the `GetSecondaryStatus` operationId).
	GetSecondaryStatusWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetSecondaryStatusResponse, error)

	// GetSettingsWithResponse Read the server-wide settings
	//
	// These are the defaults a zone that says nothing about itself inherits.
	// They live in the database, so changing one takes effect on the next
	// write without a restart (docs/decisions/ D11).
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /settings (the `GetSettings` operationId).
	GetSettingsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetSettingsResponse, error)

	// UpdateSettingsWithBodyWithResponse Change the server-wide settings
	//
	// A field that is absent is left alone, so a client may send only what it
	// means to change.
	//
	// 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 /settings (the `UpdateSettings` operationId).
	UpdateSettingsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateSettingsResponse, error)

	// UpdateSettingsWithResponse Change the server-wide settings
	//
	// A field that is absent is left alone, so a client may send only what it
	// means to change.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /settings (the `UpdateSettings` operationId).
	UpdateSettingsWithResponse(ctx context.Context, body UpdateSettingsJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateSettingsResponse, error)

	// ListTokensWithResponse List the tokens that may use this API
	//
	// Revoked and expired tokens are listed too, so that a name in the
	// history can still be looked up. No response ever carries a secret: what
	// is stored is its SHA-256, and the leading characters kept in the clear
	// are there to tell two tokens apart, not to authenticate with.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /tokens (the `ListTokens` operationId).
	ListTokensWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListTokensResponse, error)

	// CreateTokenWithBodyWithResponse Mint a token
	//
	// The secret comes back in this response and never again. It is 256 bits
	// from a cryptographic source; what the server keeps is its SHA-256, so a
	// copy of the database is not a copy of the 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 /tokens (the `CreateToken` operationId).
	CreateTokenWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateTokenResponse, error)

	// CreateTokenWithResponse Mint a token
	//
	// The secret comes back in this response and never again. It is 256 bits
	// from a cryptographic source; what the server keeps is its SHA-256, so a
	// copy of the database is not a copy of the 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 /tokens (the `CreateToken` operationId).
	CreateTokenWithResponse(ctx context.Context, body CreateTokenJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateTokenResponse, error)

	// RevokeTokenWithResponse Withdraw a token
	//
	// The token is marked unusable rather than removed, so that the history
	// it appears in still names something. Revoking a token that is already
	// revoked changes nothing and is not an error.
	//
	// The last token that can still administer the server is refused: a
	// server nobody can reach is not a state this API will put itself in.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /tokens/{tokenId} (the `RevokeToken` operationId).
	RevokeTokenWithResponse(ctx context.Context, tokenId string, reqEditors ...RequestEditorFn) (*RevokeTokenResponse, error)

	// ListTSIGKeysWithResponse List the keys a secondary may sign a transfer with
	//
	// Revoked keys are listed too, so that a name a secondary still has
	// configured can be looked up. No listing carries a secret; reading one
	// back is a request of its own.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /tsig-keys (the `ListTSIGKeys` operationId).
	ListTSIGKeysWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListTSIGKeysResponse, error)

	// CreateTSIGKeyWithBodyWithResponse Create a key
	//
	// The secret comes back in this response. Unlike an API token it can be
	// read again, because verifying a signature means recomputing the MAC and
	// this server therefore has to keep it.
	//
	// Leave the secret out and one is generated, at least as long as the hash
	// output of the algorithm (RFC 8945 section 8). Send one to match a
	// secondary that already has a key, base64 as every other implementation
	// writes 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 POST /tsig-keys (the `CreateTSIGKey` operationId).
	CreateTSIGKeyWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateTSIGKeyResponse, error)

	// CreateTSIGKeyWithResponse Create a key
	//
	// The secret comes back in this response. Unlike an API token it can be
	// read again, because verifying a signature means recomputing the MAC and
	// this server therefore has to keep it.
	//
	// Leave the secret out and one is generated, at least as long as the hash
	// output of the algorithm (RFC 8945 section 8). Send one to match a
	// secondary that already has a key, base64 as every other implementation
	// writes it.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /tsig-keys (the `CreateTSIGKey` operationId).
	CreateTSIGKeyWithResponse(ctx context.Context, body CreateTSIGKeyJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateTSIGKeyResponse, error)

	// RevokeTSIGKeyWithResponse Withdraw a key
	//
	// The key stops signing and its secret is cleared, which is the one thing
	// revoking a token does not do: a token leaves only a hash behind, and a
	// key would leave material nothing will read again. The row stays so the
	// name and the dates still read, and the name is then free for a
	// replacement.
	//
	// Revoking a key that is already revoked changes nothing and is not an
	// error.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /tsig-keys/{keyId} (the `RevokeTSIGKey` operationId).
	RevokeTSIGKeyWithResponse(ctx context.Context, keyId string, reqEditors ...RequestEditorFn) (*RevokeTSIGKeyResponse, error)

	// ReadTSIGKeySecretWithResponse Read a key's secret
	//
	// Separate from the listing so that a secret is shown when somebody asked
	// for it and not when they were looking at something else. It is not a
	// boundary: the database holds the secret either way.
	//
	// A revoked key has none, and this is then a refusal rather than an empty
	// answer.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /tsig-keys/{keyId}/secret (the `ReadTSIGKeySecret` operationId).
	ReadTSIGKeySecretWithResponse(ctx context.Context, keyId string, reqEditors ...RequestEditorFn) (*ReadTSIGKeySecretResponse, error)

	// ListZonesWithResponse List zones
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /zones (the `ListZones` operationId).
	ListZonesWithResponse(ctx context.Context, params *ListZonesParams, reqEditors ...RequestEditorFn) (*ListZonesResponse, error)

	// CreateZoneWithBodyWithResponse Create a zone
	//
	// 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 /zones (the `CreateZone` operationId).
	CreateZoneWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateZoneResponse, error)

	// CreateZoneWithResponse Create a zone
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /zones (the `CreateZone` operationId).
	CreateZoneWithResponse(ctx context.Context, body CreateZoneJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateZoneResponse, error)

	// ImportZoneWithBodyWithResponse Bring a whole zone in from a zonefile
	//
	// The body is the file itself, in the presentation format of RFC 1035 §5.
	// The zone it describes is wherever its SOA sits, so the name is not sent
	// separately and cannot be sent inconsistently.
	//
	// The serial in the file is the serial the zone starts at. A migrated
	// zone that restarted at 1 would look older than itself to every
	// secondary that has already seen it (RFC 1982 §3.2), which is the single
	// most common way to break a migration (docs/decisions/ D2).
	//
	// `$INCLUDE` is refused: a file arriving here that could pull in a path
	// would read this server's filesystem out loud.
	//
	// Records that a delegation in the same file makes unanswerable are left
	// out rather than failing the whole file, and come back in `skipped`.
	// Real zones carry them, and a migration that stops on one is a migration
	// nobody finishes.
	//
	// The zone must not already exist. A file is the complete contents of a
	// zone, so bringing one into a zone that holds records is a replacement
	// rather than an import.
	//
	// 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 /zones/import (the `ImportZone` operationId).
	ImportZoneWithBodyWithResponse(ctx context.Context, params *ImportZoneParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ImportZoneResponse, error)

	// DeleteZoneWithResponse Delete a zone and everything in it
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /zones/{zoneId} (the `DeleteZone` operationId).
	DeleteZoneWithResponse(ctx context.Context, zoneId ZoneID, reqEditors ...RequestEditorFn) (*DeleteZoneResponse, error)

	// GetZoneWithResponse Read one zone
	//
	// Everything a listing carries, and the one diagnosis a zone can carry
	// that nothing about it looks wrong for. It is computed here rather than
	// left to `/check` because somebody who has to know to run a check in
	// order to be told their delegation is broken has been told nothing. It
	// costs the zone's NS records and one lookup per name server, not a walk
	// of the zone, which is what makes that affordable.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /zones/{zoneId} (the `GetZone` operationId).
	GetZoneWithResponse(ctx context.Context, zoneId ZoneID, reqEditors ...RequestEditorFn) (*GetZoneResponse, error)

	// UpdateZoneWithBodyWithResponse Change a zone's own settings
	//
	// Only the fields that are present are changed. The zone's records are
	// not touched, and the zone cannot be renamed: every owner name, every
	// sort key and the whole journal belong to the name it has.
	//
	// Changing anything that is served advances the serial, like any other
	// change. Changing nothing 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 PATCH /zones/{zoneId} (the `UpdateZone` operationId).
	UpdateZoneWithBodyWithResponse(ctx context.Context, zoneId ZoneID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateZoneResponse, error)

	// UpdateZoneWithResponse Change a zone's own settings
	//
	// Only the fields that are present are changed. The zone's records are
	// not touched, and the zone cannot be renamed: every owner name, every
	// sort key and the whole journal belong to the name it has.
	//
	// Changing anything that is served advances the serial, like any other
	// change. Changing nothing 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 PATCH /zones/{zoneId} (the `UpdateZone` operationId).
	UpdateZoneWithResponse(ctx context.Context, zoneId ZoneID, body UpdateZoneJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateZoneResponse, error)

	// CheckZoneWithResponse Report what is wrong with a zone as it stands
	//
	// Every rule the write path enforces, applied to the zone as it is
	// stored.
	//
	// A write is checked against the names it touches, and against the names
	// a new delegation would put out of reach, so a zone edited only through
	// this API stays sound. What this finds is what did not arrive that way:
	// data written before a rule existed, or a hand on the database file.
	//
	// It reports rather than refuses. A name with more than one problem
	// yields the first of them, and the list stops at a thousand findings:
	// a zone past that has one systematic fault rather than a thousand
	// separate ones.
	//
	// Nothing is written. Repairing what this names is ordinary editing.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /zones/{zoneId}/check (the `CheckZone` operationId).
	CheckZoneWithResponse(ctx context.Context, zoneId ZoneID, params *CheckZoneParams, reqEditors ...RequestEditorFn) (*CheckZoneResponse, error)

	// ExportZoneWithResponse Write a zone out as a zonefile
	//
	// The presentation format of RFC 1035 §5, which any other authoritative
	// server reads. Every name is absolute and every record carries its own
	// TTL and class, so no line means something different when it is copied
	// out; records come out in the canonical order of RFC 4034 §6.1, so
	// exporting the same zone twice is the same bytes and a diff of two
	// exports is a diff of two zones.
	//
	// A disabled record is left out. It is not part of the zone as it
	// answers, and a file has nowhere to say "present but switched off".
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /zones/{zoneId}/export (the `ExportZone` operationId).
	ExportZoneWithResponse(ctx context.Context, zoneId ZoneID, reqEditors ...RequestEditorFn) (*ExportZoneResponse, error)

	// ReconcileZoneWithResponse Write the reverse entries this zone's records imply and does not have
	//
	// Reverse automation reacts to changes, so a zone that arrives after the
	// records it should hold has nothing to react to. A reverse zone created
	// for a network already in use starts empty, however many addresses are
	// already named in it, and this is what fills it: one commit for
	// everything missing.
	//
	// It only adds. An entry that became obsolete was taken away by the
	// change that obsoleted it, and one somebody detached is theirs to keep,
	// so nothing here removes anything.
	//
	// A zone that needs nothing is left alone and answers with no commit.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /zones/{zoneId}/reconcile (the `ReconcileZone` operationId).
	ReconcileZoneWithResponse(ctx context.Context, zoneId ZoneID, reqEditors ...RequestEditorFn) (*ReconcileZoneResponse, error)

	// ListRecordsWithResponse List the records of a zone
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /zones/{zoneId}/records (the `ListRecords` operationId).
	ListRecordsWithResponse(ctx context.Context, zoneId ZoneID, params *ListRecordsParams, reqEditors ...RequestEditorFn) (*ListRecordsResponse, error)

	// CreateRecordWithBodyWithResponse Add a record to a zone
	//
	// An address record may generate a PTR in the reverse zone answering for
	// it. What that produced, and what it could not produce, comes back in
	// the response rather than in a log line (docs/decisions/ D3 and D6).
	//
	// 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 /zones/{zoneId}/records (the `CreateRecord` operationId).
	CreateRecordWithBodyWithResponse(ctx context.Context, zoneId ZoneID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateRecordResponse, error)

	// CreateRecordWithResponse Add a record to a zone
	//
	// An address record may generate a PTR in the reverse zone answering for
	// it. What that produced, and what it could not produce, comes back in
	// the response rather than in a log line (docs/decisions/ D3 and D6).
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /zones/{zoneId}/records (the `CreateRecord` operationId).
	CreateRecordWithResponse(ctx context.Context, zoneId ZoneID, body CreateRecordJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateRecordResponse, error)

	// RollbackZoneWithBodyWithResponse Restore a zone to the state it had at a serial
	//
	// The difference between the zone as it stands and the zone as it stood
	// is written as a **new** commit that moves forward to that state. It is
	// not a rewind: a secondary that has already seen serial 90 will never
	// accept a jump back to 42, because RFC 1982 arithmetic makes 42 older
	// and RFC 1995 has no way to express going backwards.
	//
	// Records that did not change in between are not touched, so they keep
	// their identity, their comments and the history pointing at them.
	// Records the server generated are not restored directly: they follow
	// from the records they were generated from, so restoring those is what
	// moves them.
	//
	// A rollback to the serial the zone is already at changes nothing and
	// answers with no commit.
	//
	// 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 /zones/{zoneId}/rollback (the `RollbackZone` operationId).
	RollbackZoneWithBodyWithResponse(ctx context.Context, zoneId ZoneID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RollbackZoneResponse, error)

	// RollbackZoneWithResponse Restore a zone to the state it had at a serial
	//
	// The difference between the zone as it stands and the zone as it stood
	// is written as a **new** commit that moves forward to that state. It is
	// not a rewind: a secondary that has already seen serial 90 will never
	// accept a jump back to 42, because RFC 1982 arithmetic makes 42 older
	// and RFC 1995 has no way to express going backwards.
	//
	// Records that did not change in between are not touched, so they keep
	// their identity, their comments and the history pointing at them.
	// Records the server generated are not restored directly: they follow
	// from the records they were generated from, so restoring those is what
	// moves them.
	//
	// A rollback to the serial the zone is already at changes nothing and
	// answers with no commit.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /zones/{zoneId}/rollback (the `RollbackZone` operationId).
	RollbackZoneWithResponse(ctx context.Context, zoneId ZoneID, body RollbackZoneJSONRequestBody, reqEditors ...RequestEditorFn) (*RollbackZoneResponse, error)

	// ReplaceRRsetsWithBodyWithResponse Make the named RRsets exactly what is given
	//
	// An RRset (everything sharing an owner name, class and type) is the
	// unit DNS answers with (RFC 2181 §5), and therefore the unit a record
	// editor edits. Sending the set rather than a list of additions and
	// removals means the client says what it wants to be true, and the server
	// works out the difference; a record whose data did not change keeps its
	// identity, and with it its comment, its provenance and the history
	// pointing at it.
	//
	// Only the RRsets named here are touched. An empty `records` removes one.
	//
	// Everything in one request becomes one commit, so a page of edits saved
	// together is one line in the history and one point to roll back to.
	//
	// The RRsets are named in the body rather than in the path because a DNS
	// label may hold any octet, `/` among them, so there is no path form that
	// is safe for every name.
	//
	// 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 /zones/{zoneId}/rrsets (the `ReplaceRRsets` operationId).
	ReplaceRRsetsWithBodyWithResponse(ctx context.Context, zoneId ZoneID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ReplaceRRsetsResponse, error)

	// ReplaceRRsetsWithResponse Make the named RRsets exactly what is given
	//
	// An RRset (everything sharing an owner name, class and type) is the
	// unit DNS answers with (RFC 2181 §5), and therefore the unit a record
	// editor edits. Sending the set rather than a list of additions and
	// removals means the client says what it wants to be true, and the server
	// works out the difference; a record whose data did not change keeps its
	// identity, and with it its comment, its provenance and the history
	// pointing at it.
	//
	// Only the RRsets named here are touched. An empty `records` removes one.
	//
	// Everything in one request becomes one commit, so a page of edits saved
	// together is one line in the history and one point to roll back to.
	//
	// The RRsets are named in the body rather than in the path because a DNS
	// label may hold any octet, `/` among them, so there is no path form that
	// is safe for every name.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PUT /zones/{zoneId}/rrsets (the `ReplaceRRsets` operationId).
	ReplaceRRsetsWithResponse(ctx context.Context, zoneId ZoneID, body ReplaceRRsetsJSONRequestBody, reqEditors ...RequestEditorFn) (*ReplaceRRsetsResponse, error)
}

type ClusterMember struct {
	// Address Where the other members reach it, and where a new node asks to join.
	Address string `json:"address"`

	// Id The identifier the member is known by. It never changes
	// (docs/decisions/d42-membership-lives-in-the-log.md).
	Id string `json:"id"`
}

type ClusterMemberState struct {
	Address string `json:"address"`
	Id      string `json:"id"`
	Leader  bool   `json:"leader"`

	// Progress How far one member has got, as it said itself just now.
	Progress *ClusterProgress `json:"progress,omitempty"`

	// Role A voter counts towards quorum and can lead. A non-voter receives
	// the whole log and answers queries like any member, and is neither
	// counted nor waited for (docs/decisions/d25-cluster-shape.md). A
	// witness votes and keeps the log, answers no queries, and hands
	// leadership on when it wins an election
	// (docs/decisions/d39-the-witness.md).
	Role ClusterMemberStateRole `json:"role"`

	// Trouble Why the member could not be asked, or what it answered instead.
	Trouble *string `json:"trouble,omitempty"`
}

type ClusterMemberStateRole string

type ClusterProgress struct {
	// Applied The last entry of the log the member has carried out.
	Applied int64 `json:"applied"`

	// Behind Where this node stopped applying the log, present only when it has.
	// It has left the cluster, refuses writes, and answers queries with what
	// it held at that entry.
	Behind *ClusterStall `json:"behind,omitempty"`

	// Committed The last entry the member knows to be committed.
	Committed int64 `json:"committed"`

	// Removed True once the member has been taken out of the cluster.
	Removed bool `json:"removed"`
}

type ClusterStall struct {
	// Entry The entry it could not get past; 0 for a log snapshot it could not read.
	Entry  int64     `json:"entry"`
	Reason string    `json:"reason"`
	Since  time.Time `json:"since"`
}

type ClusterStatus struct {
	// Applied The last entry of the log this node has carried out.
	Applied int64 `json:"applied"`

	// Behind Where this node stopped applying the log, present only when it has.
	// It has left the cluster, refuses writes, and answers queries with what
	// it held at that entry.
	Behind *ClusterStall `json:"behind,omitempty"`

	// Committed The last entry this node knows to be committed. A member that
	// keeps up has this equal to `applied`, or nearly.
	Committed int64 `json:"committed"`

	// Members Every member, as this node's copy of the configuration lists them.
	// Empty on a node in no cluster, and on one that has stopped over
	// an entry it could not apply, which no longer has a copy to read.
	Members []ClusterMemberState `json:"members"`

	// Removed True once this node has been taken out of the cluster, by leaving
	// or by being removed. It answers queries with what it held and
	// refuses writes, and `members` is who it last knew to be in the
	// cluster (docs/decisions/d46-a-member-that-has-left.md).
	Removed bool `json:"removed"`

	// Replicating False for a node that has a cluster section and has not started or
	// joined a cluster. It is an ordinary server until it does.
	Replicating bool `json:"replicating"`

	// Self One member of a cluster.
	Self ClusterMember `json:"self"`
}

type Commit struct {
	// Actor Who caused it, as far as the interface it arrived through could tell.
	Actor     *string   `json:"actor,omitempty"`
	Comment   *string   `json:"comment,omitempty"`
	CreatedAt time.Time `json:"createdAt"`

	// Events The records this commit removed and added, in order. Absent in a
	// listing, which is what keeps a page of history cheap.
	Events *[]Event `json:"events,omitempty"`
	Id     string   `json:"id"`

	// Kind What a commit did, for an interface that would rather say it than recite the events.
	Kind CommitKind `json:"kind"`

	// RevertsTo The serial a rollback restored the zone to. Absent on every other
	// kind of commit, which is what the schema enforces.
	RevertsTo *int64 `json:"revertsTo,omitempty"`

	// SerialFrom The serial this commit was applied to.
	SerialFrom int64 `json:"serialFrom"`

	// SerialTo The serial it produced. Exactly one step on (docs/decisions/ D2).
	SerialTo int64 `json:"serialTo"`

	// Source The interface a change arrived through.
	Source CommitSource `json:"source"`
	ZoneId string       `json:"zoneId"`

	// ZoneName Carried on the commit rather than joined from the zone, because a
	// commit outlives the zone: the last thing that happens to a zone is
	// that someone deletes it.
	ZoneName string `json:"zoneName"`
}

type CommitKind string