gen

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)

	// 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.md 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.md 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.md 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)

	// 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.md 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)

	// 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.md 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)

	// 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.md 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
	//
	// 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)

	// 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)

	// 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.md 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.md 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)

	// 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.md 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.md 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.md 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)

	// 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.md 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)

	// 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.md 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)

	// 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.md 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
	//
	// 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)

	// 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)

	// 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.md 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.md 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 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.md 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

type CommitPage struct {
	Items      []Commit `json:"items"`
	NextCursor *string  `json:"nextCursor,omitempty"`
}

type CommitSource string

type Conflict struct {
	Address          string  `json:"address"`
	ExistingName     string  `json:"existingName"`
	ExistingRecordId *string `json:"existingRecordId,omitempty"`

	// Policy The policy that decided what happened here, so a client can say
	// whether the existing name was kept, replaced or joined rather than
	// leaving the reader to guess from the records.
	Policy        ReverseConflictPolicy `json:"policy"`
	RequestedName string                `json:"requestedName"`
}

type CreateRecord struct {
	// Class Defaults to IN, which is the only class this server answers.
	Class   *string `json:"class,omitempty"`
	Comment *string `json:"comment,omitempty"`
	Data    string  `json:"data"`

	// Name The owner name, absolute. A trailing dot is optional and changes
	// nothing: `www.example.com` and `www.example.com.` are the same
	// name. A name is never completed with the zone apex; that is what
	// turns `www.example.com` into `www.example.com.example.com.` in a
	// zonefile, and an interface that offers a relative field completes
	// it before it gets here.
	Name string `json:"name"`

	// Ttl Defaults to the zone's own default TTL.
	Ttl  *int64 `json:"ttl,omitempty"`
	Type string `json:"type"`
}

type CreateRecord201JSONResponse struct {
	Body    RecordWritten
	Headers CreateRecord201ResponseHeaders
}

type CreateRecord201ResponseHeaders struct {
	Location *string
}

type CreateRecordJSONRequestBody = CreateRecord

type CreateRecordRequestObject struct {
	ZoneId ZoneID `json:"zoneId"`
	Body   *CreateRecordJSONRequestBody
}

type CreateRecordResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *RecordWritten
	// ApplicationproblemJSONDefault the response for an HTTP default `application/problem+json` response
	ApplicationproblemJSONDefault *Problem
	// Headers201 the parsed response headers for an HTTP 201 response
	Headers201 *CreateRecordResponse201Headers
}

type CreateRecordResponse201Headers struct {
	Location *string
}

type CreateRecordResponseObject interface {
	VisitCreateRecordResponse(w http.ResponseWriter) error
}

type CreateRecorddefaultApplicationProblemPlusJSONResponse struct {
	Body       Problem
	StatusCode int
}

type CreateSession struct {
	// Token The API token to open the session with.
	Token string `json:"token"`
}

type CreateSession201JSONResponse struct {
	Body    Session
	Headers CreateSession201ResponseHeaders
}

type CreateSession201ResponseHeaders struct {
	SetCookie *string
}

type CreateSessionJSONRequestBody = CreateSession

type CreateSessionRequestObject struct {
	Body *CreateSessionJSONRequestBody
}

type CreateSessionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *Session
	// ApplicationproblemJSONDefault the response for an HTTP default `application/problem+json` response
	ApplicationproblemJSONDefault *Problem
	// Headers201 the parsed response headers for an HTTP 201 response
	Headers201 *CreateSessionResponse201Headers
}

type CreateSessionResponse201Headers struct {
	SetCookie *string
}

type CreateSessionResponseObject interface {
	VisitCreateSessionResponse(w http.ResponseWriter) error
}

type CreateSessiondefaultApplicationProblemPlusJSONResponse struct {
	Body       Problem
	StatusCode int
}

type CreateToken struct {
	// ExpiresAt When the token stops working. Absent means it does not.
	ExpiresAt *time.Time `json:"expiresAt,omitempty"`
	Name      string     `json:"name"`
	Scopes    []Scope    `json:"scopes"`
}

type CreateToken201JSONResponse TokenCreated

type CreateTokenJSONRequestBody = CreateToken

type CreateTokenRequestObject struct {
	Body *CreateTokenJSONRequestBody
}

type CreateTokenResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *TokenCreated
	// ApplicationproblemJSONDefault the response for an HTTP default `application/problem+json` response
	ApplicationproblemJSONDefault *Problem
}

type CreateTokenResponseObject interface {
	VisitCreateTokenResponse(w http.ResponseWriter) error
}

type CreateTokendefaultApplicationProblemPlusJSONResponse struct {
	Body       Problem
	StatusCode int
}

type CreateZone struct {
	Comment    *string `json:"comment,omitempty"`
	DefaultTtl *int64  `json:"defaultTtl,omitempty"`

	// Name The apex. A trailing dot is optional; the name is absolute either
	// way.
	//
	// A network in CIDR notation is accepted here instead, and becomes
	// the reverse zone that answers for it: `192.168.0.0/16` is
	// `168.192.in-addr.arpa.`, `192.0.2.0/25` is the classless
	// `0/25.2.0.192.in-addr.arpa.` of RFC 2317, and `2001:db8::/32` is
	// eight nibbles written backwards. Working that out by hand is the
	// first thing that sends somebody to a manual.
	//
	// A prefix and a name cannot be confused for one another, so nothing
	// is guessed. A bare address is refused with the network it probably
	// meant.
	Name string `json:"name"`

	// Soa The start-of-authority fields a client may set, on a zone it is
	// creating and on one it is changing. Every field is optional in both
	// cases: creating a zone fills what is not given from this server's
	// defaults, and changing one leaves it as it was. A client that only
	// cares about the name server should not have to send five timers it has
	// no opinion about.
	//
	// The serial is not among them: one commit advances it by exactly one,
	// and that is what lets the journal be replayed (docs/decisions.md D2).
	Soa *SOAInput `json:"soa,omitempty"`
}

type CreateZone201JSONResponse struct {
	Body    Zone
	Headers CreateZone201ResponseHeaders
}

type CreateZone201ResponseHeaders struct {
	Location *string
}

type CreateZoneJSONRequestBody = CreateZone

type CreateZoneRequestObject struct {
	Body *CreateZoneJSONRequestBody
}

type CreateZoneResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *Zone
	// ApplicationproblemJSONDefault the response for an HTTP default `application/problem+json` response
	ApplicationproblemJSONDefault *Problem
	// Headers201 the parsed response headers for an HTTP 201 response
	Headers201 *CreateZoneResponse201Headers
}

type CreateZoneResponse201Headers struct {
	Location *string
}

type CreateZoneResponseObject interface {
	VisitCreateZoneResponse(w http.ResponseWriter) error
}

type CreateZonedefaultApplicationProblemPlusJSONResponse struct {
	Body       Problem
	StatusCode int
}

type Cursor = string

type DeleteRecord204Response struct {
}

type DeleteRecordRequestObject struct {
	RecordId RecordID `json:"recordId"`
}

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

type DeleteRecordResponseObject interface {
	VisitDeleteRecordResponse(w http.ResponseWriter) error
}

type DeleteRecorddefaultApplicationProblemPlusJSONResponse struct {
	Body       Problem
	StatusCode int
}

type DeleteSession204Response struct {
}

type DeleteSessionRequestObject struct {
}

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

type DeleteSessionResponseObject interface {
	VisitDeleteSessionResponse(w http.ResponseWriter) error
}

type DeleteSessiondefaultApplicationProblemPlusJSONResponse struct {
	Body       Problem
	StatusCode int
}

type DeleteZone204Response struct {
}

type DeleteZoneRequestObject struct {
	ZoneId ZoneID `json:"zoneId"`
}

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

type DeleteZoneResponseObject interface {
	VisitDeleteZoneResponse(w http.ResponseWriter) error
}

type DeleteZonedefaultApplicationProblemPlusJSONResponse struct {
	Body       Problem
	StatusCode int
}

type DetachRecord200JSONResponse RecordWritten

type DetachRecordRequestObject struct {
	RecordId RecordID `json:"recordId"`
}

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

type DetachRecordResponseObject interface {
	VisitDetachRecordResponse(w http.ResponseWriter) error
}

type DetachRecorddefaultApplicationProblemPlusJSONResponse struct {
	Body       Problem
	StatusCode int
}

type Event struct {
	Class string  `json:"class"`
	Data  string  `json:"data"`
	Name  string  `json:"name"`
	Op    EventOp `json:"op"`

	// Seq Orders the events within the commit, counting from zero.
	Seq  int    `json:"seq"`
	Ttl  int64  `json:"ttl"`
	Type string `json:"type"`
}

type EventOp string

type ExportZone200TextdnsResponse struct {
	Body          io.Reader
	ContentLength int64
}

type ExportZoneRequestObject struct {
	ZoneId ZoneID `json:"zoneId"`
}

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

type ExportZoneResponseObject interface {
	VisitExportZoneResponse(w http.ResponseWriter) error
}

type ExportZonedefaultApplicationProblemPlusJSONResponse struct {
	Body       Problem
	StatusCode int
}

type GetCommit200JSONResponse Commit

type GetCommitRequestObject struct {
	CommitId string `json:"commitId"`
}

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

type GetCommitResponseObject interface {
	VisitGetCommitResponse(w http.ResponseWriter) error
}

type GetCommitdefaultApplicationProblemPlusJSONResponse struct {
	Body       Problem
	StatusCode int
}

type GetHealth200JSONResponse Health

type GetHealth503ApplicationProblemPlusJSONResponse Problem

type GetHealthRequestObject struct {
}

type GetHealthResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *Health
	// ApplicationproblemJSON503 the response for an HTTP 503 `application/problem+json` response
	ApplicationproblemJSON503 *Problem
}

type GetHealthResponseObject interface {
	VisitGetHealthResponse(w http.ResponseWriter) error
}

type GetMetrics200TextResponse string

type GetMetricsRequestObject struct {
}

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

type GetMetricsResponseObject interface {
	VisitGetMetricsResponse(w http.ResponseWriter) error
}

type GetMetricsdefaultApplicationProblemPlusJSONResponse struct {
	Body       Problem
	StatusCode int
}

type GetRecord200JSONResponse Record

type GetRecordRequestObject struct {
	RecordId RecordID `json:"recordId"`
}

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

type GetRecordResponseObject interface {
	VisitGetRecordResponse(w http.ResponseWriter) error
}