controlv1

type AdminDrainRelayRequest struct {
	Deadline           time.Time  `json:"deadline"`
	RelayLeaseRevision int64      `json:"relay_lease_revision"`
	RelayRunId         ResourceID `json:"relay_run_id"`
}

type AdminRelayLease struct {
	ConnectionCapacity   int64             `json:"connection_capacity"`
	DrainDeadline        *time.Time        `json:"drain_deadline,omitempty"`
	Draining             bool              `json:"draining"`
	InternalRelayAddress string            `json:"internal_relay_address"`
	LeaseExpiresAt       time.Time         `json:"lease_expires_at"`
	ProtocolVersion      int64             `json:"protocol_version"`
	RelayAddress         string            `json:"relay_address"`
	RelayId              RelayID           `json:"relay_id"`
	RelayLeaseRevision   int64             `json:"relay_lease_revision"`
	RelayRunId           ResourceID        `json:"relay_run_id"`
	RelayServiceId       RelayServiceID    `json:"relay_service_id"`
	RenewedAt            time.Time         `json:"renewed_at"`
	ReportedConnections  int64             `json:"reported_connections"`
	ReportedStreams      int64             `json:"reported_streams"`
	StreamCapacity       int64             `json:"stream_capacity"`
	TlsServerName        CanonicalHostname `json:"tls_server_name"`
}

type AdminRelayPage struct {
	NextCursor *RelayID          `json:"next_cursor,omitempty"`
	Relays     []AdminRelayLease `json:"relays"`
}

type AdminServerStatus struct {
	CurrentTime           time.Time             `json:"current_time"`
	EnabledRoutes         int                   `json:"enabled_routes"`
	IngressLeases         int                   `json:"ingress_leases"`
	ReadyRouteSessions    int                   `json:"ready_route_sessions"`
	RelayLeases           int                   `json:"relay_leases"`
	Role                  AdminServerStatusRole `json:"role"`
	StartedAt             time.Time             `json:"started_at"`
	StartingRouteSessions int                   `json:"starting_route_sessions"`
	SuspendedRoutes       int                   `json:"suspended_routes"`
}

type AdminServerStatusRole string

type AuthenticationFacts struct {
	Methods []AuthenticationFactsMethods `json:"methods"`
	Oidc    *OIDCAuthenticationFacts     `json:"oidc,omitempty"`
}

type AuthenticationFactsMethods string

type CanonicalHostname = string

type CanonicalHostnameQuery = CanonicalHostname

type CertificateChallenge struct {
	Digest     string                     `json:"digest"`
	ExpiresAt  time.Time                  `json:"expires_at"`
	Identifier CanonicalHostname          `json:"identifier"`
	Method     CertificateChallengeMethod `json:"method"`
	Token      string                     `json:"token"`
}

type CertificateChallengeMethod string

type CertificateInstalledRequest struct {
	IssuanceId   IssuanceID `json:"issuance_id"`
	NotAfter     time.Time  `json:"not_after"`
	RouteVersion int64      `json:"route_version"`
}

type CertificateIssuance struct {
	CertificatePem  *string                  `json:"certificate_pem,omitempty"`
	CertificatePlan CertificatePlan          `json:"certificate_plan"`
	Challenges      *[]CertificateChallenge  `json:"challenges,omitempty"`
	CreatedAt       time.Time                `json:"created_at"`
	Id              IssuanceID               `json:"id"`
	NotAfter        *time.Time               `json:"not_after,omitempty"`
	NotBefore       *time.Time               `json:"not_before,omitempty"`
	RetryAt         *time.Time               `json:"retry_at,omitempty"`
	RouteId         RouteID                  `json:"route_id"`
	RouteSessionId  RouteSessionID           `json:"route_session_id"`
	RouteVersion    int64                    `json:"route_version"`
	State           CertificateIssuanceState `json:"state"`
	UpdatedAt       time.Time                `json:"updated_at"`
}

type CertificateIssuanceState string

type CertificatePlan struct {
	CacheKey        string                     `json:"cache_key"`
	ChallengeMethod CertificateChallengeMethod `json:"challenge_method"`
	Identifiers     []string                   `json:"identifiers"`
	Scope           string                     `json:"scope"`
}

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 ClientIPResponse struct {
	Ip string `json:"ip"`
}

type ClientInterface interface {

	// ListMaintenanceControls List maintenance controls
	//
	// Corresponds with GET /v1/admin/maintenance-controls (the `ListMaintenanceControls` operationId).
	ListMaintenanceControls(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SetMaintenanceControlWithBody Set one maintenance control
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PUT /v1/admin/maintenance-controls/{control_name} (the `SetMaintenanceControl` operationId).
	SetMaintenanceControlWithBody(ctx context.Context, controlName MaintenanceControlName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SetMaintenanceControl Set one maintenance control
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PUT /v1/admin/maintenance-controls/{control_name} (the `SetMaintenanceControl` operationId).
	SetMaintenanceControl(ctx context.Context, controlName MaintenanceControlName, body SetMaintenanceControlJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListAdminRelays List relay leases
	//
	// Corresponds with GET /v1/admin/relays (the `ListAdminRelays` operationId).
	ListAdminRelays(ctx context.Context, params *ListAdminRelaysParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DrainAdminRelayWithBody Remove a matching relay lease from placement and begin draining
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/admin/relays/{relay_id}/drain (the `DrainAdminRelay` operationId).
	DrainAdminRelayWithBody(ctx context.Context, relayId RelayID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DrainAdminRelay Remove a matching relay lease from placement and begin draining
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/admin/relays/{relay_id}/drain (the `DrainAdminRelay` operationId).
	DrainAdminRelay(ctx context.Context, relayId RelayID, body DrainAdminRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetAdminServerStatus Read control, ingress, and relay status
	//
	// Corresponds with GET /v1/admin/status (the `GetAdminServerStatus` operationId).
	GetAdminServerStatus(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetCertificateIssuance Read one route-session certificate issuance
	//
	// Corresponds with GET /v1/certificate-issuances/{issuance_id} (the `GetCertificateIssuance` operationId).
	GetCertificateIssuance(ctx context.Context, issuanceId IssuanceID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MarkCertificateChallengeReady Confirm a TLS-ALPN-01 challenge is installed
	//
	// Corresponds with POST /v1/certificate-issuances/{issuance_id}/challenge-ready (the `MarkCertificateChallengeReady` operationId).
	MarkCertificateChallengeReady(ctx context.Context, issuanceId IssuanceID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MarkCertificateChallengeRemoved Confirm a TLS-ALPN-01 challenge is removed
	//
	// Corresponds with POST /v1/certificate-issuances/{issuance_id}/challenge-removed (the `MarkCertificateChallengeRemoved` operationId).
	MarkCertificateChallengeRemoved(ctx context.Context, issuanceId IssuanceID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetClientIP Return the requesting client's public IP address
	//
	// Corresponds with GET /v1/client-ip (the `GetClientIP` operationId).
	GetClientIP(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetControlDiscovery Describe control and its authentication methods
	//
	// Corresponds with GET /v1/discovery (the `GetControlDiscovery` operationId).
	GetControlDiscovery(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetHealth Confirm that the control HTTP server is serving
	//
	// Corresponds with GET /v1/health (the `GetHealth` operationId).
	GetHealth(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetReadiness Confirm that control and its database are ready
	//
	// Corresponds with GET /v1/ready (the `GetReadiness` operationId).
	GetReadiness(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CloseRouteSession Close and drain a route session without deleting its route
	//
	// Corresponds with DELETE /v1/route-sessions/{route_session_id} (the `CloseRouteSession` operationId).
	CloseRouteSession(ctx context.Context, routeSessionId RouteSessionID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MarkRouteSessionCertificateInstalledWithBody Record installation of the current route certificate
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/route-sessions/{route_session_id}/certificate-installed (the `MarkRouteSessionCertificateInstalled` operationId).
	MarkRouteSessionCertificateInstalledWithBody(ctx context.Context, routeSessionId RouteSessionID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MarkRouteSessionCertificateInstalled Record installation of the current route certificate
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/route-sessions/{route_session_id}/certificate-installed (the `MarkRouteSessionCertificateInstalled` operationId).
	MarkRouteSessionCertificateInstalled(ctx context.Context, routeSessionId RouteSessionID, body MarkRouteSessionCertificateInstalledJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateCertificateIssuanceWithBody Begin issuance for the route session's certificate plan
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/route-sessions/{route_session_id}/certificate-issuances (the `CreateCertificateIssuance` operationId).
	CreateCertificateIssuanceWithBody(ctx context.Context, routeSessionId RouteSessionID, params *CreateCertificateIssuanceParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateCertificateIssuance Begin issuance for the route session's certificate plan
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/route-sessions/{route_session_id}/certificate-issuances (the `CreateCertificateIssuance` operationId).
	CreateCertificateIssuance(ctx context.Context, routeSessionId RouteSessionID, params *CreateCertificateIssuanceParams, body CreateCertificateIssuanceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// HeartbeatRouteSessionWithBody Renew a route session and replace missing publisher connections
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/route-sessions/{route_session_id}/heartbeat (the `HeartbeatRouteSession` operationId).
	HeartbeatRouteSessionWithBody(ctx context.Context, routeSessionId RouteSessionID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// HeartbeatRouteSession Renew a route session and replace missing publisher connections
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/route-sessions/{route_session_id}/heartbeat (the `HeartbeatRouteSession` operationId).
	HeartbeatRouteSession(ctx context.Context, routeSessionId RouteSessionID, body HeartbeatRouteSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MarkRouteSessionReadyWithBody Mark a route session ready after its certificate and two publisher connections are ready
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/route-sessions/{route_session_id}/ready (the `MarkRouteSessionReady` operationId).
	MarkRouteSessionReadyWithBody(ctx context.Context, routeSessionId RouteSessionID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MarkRouteSessionReady Mark a route session ready after its certificate and two publisher connections are ready
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/route-sessions/{route_session_id}/ready (the `MarkRouteSessionReady` operationId).
	MarkRouteSessionReady(ctx context.Context, routeSessionId RouteSessionID, body MarkRouteSessionReadyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListRoutes List routes for one team
	//
	// Corresponds with GET /v1/routes (the `ListRoutes` operationId).
	ListRoutes(ctx context.Context, params *ListRoutesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateRouteWithBody Create one team route
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/routes (the `CreateRoute` operationId).
	CreateRouteWithBody(ctx context.Context, params *CreateRouteParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateRoute Create one team route
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/routes (the `CreateRoute` operationId).
	CreateRoute(ctx context.Context, params *CreateRouteParams, body CreateRouteJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteRoute Delete one route and close its route session
	//
	// Corresponds with DELETE /v1/routes/{route_id} (the `DeleteRoute` operationId).
	DeleteRoute(ctx context.Context, routeId RouteID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetRoute Read one route
	//
	// Corresponds with GET /v1/routes/{route_id} (the `GetRoute` operationId).
	GetRoute(ctx context.Context, routeId RouteID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateRouteWithBody Update a route's target and IP policy
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /v1/routes/{route_id} (the `UpdateRoute` operationId).
	UpdateRouteWithBody(ctx context.Context, routeId RouteID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateRoute Update a route's target and IP policy
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /v1/routes/{route_id} (the `UpdateRoute` operationId).
	UpdateRoute(ctx context.Context, routeId RouteID, body UpdateRouteJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateRouteSession Create a route session and allocate its route version
	//
	// Corresponds with POST /v1/routes/{route_id}/sessions (the `CreateRouteSession` operationId).
	CreateRouteSession(ctx context.Context, routeId RouteID, params *CreateRouteSessionParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateDNSAuthorityWithBody Create a DNS authority for one claimed domain
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/service/dns-authorities (the `CreateDNSAuthority` operationId).
	CreateDNSAuthorityWithBody(ctx context.Context, params *CreateDNSAuthorityParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateDNSAuthority Create a DNS authority for one claimed domain
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/service/dns-authorities (the `CreateDNSAuthority` operationId).
	CreateDNSAuthority(ctx context.Context, params *CreateDNSAuthorityParams, body CreateDNSAuthorityJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ReleaseDNSAuthority Begin releasing a claimed domain's DNS authority
	//
	// Corresponds with DELETE /v1/service/dns-authorities/{dns_authority_reference} (the `ReleaseDNSAuthority` operationId).
	ReleaseDNSAuthority(ctx context.Context, dnsAuthorityReference DNSAuthorityReference, params *ReleaseDNSAuthorityParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDNSAuthority Read a claimed domain's DNS authority
	//
	// Corresponds with GET /v1/service/dns-authorities/{dns_authority_reference} (the `GetDNSAuthority` operationId).
	GetDNSAuthority(ctx context.Context, dnsAuthorityReference DNSAuthorityReference, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RevokeHostedPolicyWithBody Apply a policy revision from the external authority and close affected route sessions
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/service/revoke (the `RevokeHostedPolicy` operationId).
	RevokeHostedPolicyWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RevokeHostedPolicy Apply a policy revision from the external authority and close affected route sessions
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/service/revoke (the `RevokeHostedPolicy` operationId).
	RevokeHostedPolicy(ctx context.Context, body RevokeHostedPolicyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
}

type ClientOption func(*Client) error

type ClientWithResponses struct {
	ClientInterface
}

type ClientWithResponsesInterface interface {

	// ListMaintenanceControlsWithResponse List maintenance controls
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/admin/maintenance-controls (the `ListMaintenanceControls` operationId).
	ListMaintenanceControlsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListMaintenanceControlsResponse, error)

	// SetMaintenanceControlWithBodyWithResponse Set one maintenance control
	//
	// 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 /v1/admin/maintenance-controls/{control_name} (the `SetMaintenanceControl` operationId).
	SetMaintenanceControlWithBodyWithResponse(ctx context.Context, controlName MaintenanceControlName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SetMaintenanceControlResponse, error)

	// SetMaintenanceControlWithResponse Set one maintenance control
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PUT /v1/admin/maintenance-controls/{control_name} (the `SetMaintenanceControl` operationId).
	SetMaintenanceControlWithResponse(ctx context.Context, controlName MaintenanceControlName, body SetMaintenanceControlJSONRequestBody, reqEditors ...RequestEditorFn) (*SetMaintenanceControlResponse, error)

	// ListAdminRelaysWithResponse List relay leases
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/admin/relays (the `ListAdminRelays` operationId).
	ListAdminRelaysWithResponse(ctx context.Context, params *ListAdminRelaysParams, reqEditors ...RequestEditorFn) (*ListAdminRelaysResponse, error)

	// DrainAdminRelayWithBodyWithResponse Remove a matching relay lease from placement and begin draining
	//
	// 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 /v1/admin/relays/{relay_id}/drain (the `DrainAdminRelay` operationId).
	DrainAdminRelayWithBodyWithResponse(ctx context.Context, relayId RelayID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DrainAdminRelayResponse, error)

	// DrainAdminRelayWithResponse Remove a matching relay lease from placement and begin draining
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/admin/relays/{relay_id}/drain (the `DrainAdminRelay` operationId).
	DrainAdminRelayWithResponse(ctx context.Context, relayId RelayID, body DrainAdminRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*DrainAdminRelayResponse, error)

	// GetAdminServerStatusWithResponse Read control, ingress, and relay status
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/admin/status (the `GetAdminServerStatus` operationId).
	GetAdminServerStatusWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetAdminServerStatusResponse, error)

	// GetCertificateIssuanceWithResponse Read one route-session certificate issuance
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/certificate-issuances/{issuance_id} (the `GetCertificateIssuance` operationId).
	GetCertificateIssuanceWithResponse(ctx context.Context, issuanceId IssuanceID, reqEditors ...RequestEditorFn) (*GetCertificateIssuanceResponse, error)

	// MarkCertificateChallengeReadyWithResponse Confirm a TLS-ALPN-01 challenge is installed
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/certificate-issuances/{issuance_id}/challenge-ready (the `MarkCertificateChallengeReady` operationId).
	MarkCertificateChallengeReadyWithResponse(ctx context.Context, issuanceId IssuanceID, reqEditors ...RequestEditorFn) (*MarkCertificateChallengeReadyResponse, error)

	// MarkCertificateChallengeRemovedWithResponse Confirm a TLS-ALPN-01 challenge is removed
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/certificate-issuances/{issuance_id}/challenge-removed (the `MarkCertificateChallengeRemoved` operationId).
	MarkCertificateChallengeRemovedWithResponse(ctx context.Context, issuanceId IssuanceID, reqEditors ...RequestEditorFn) (*MarkCertificateChallengeRemovedResponse, error)

	// GetClientIPWithResponse Return the requesting client's public IP address
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/client-ip (the `GetClientIP` operationId).
	GetClientIPWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetClientIPResponse, error)

	// GetControlDiscoveryWithResponse Describe control and its authentication methods
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/discovery (the `GetControlDiscovery` operationId).
	GetControlDiscoveryWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetControlDiscoveryResponse, error)

	// GetHealthWithResponse Confirm that the control HTTP server is serving
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/health (the `GetHealth` operationId).
	GetHealthWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetHealthResponse, error)

	// GetReadinessWithResponse Confirm that control and its database are ready
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/ready (the `GetReadiness` operationId).
	GetReadinessWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetReadinessResponse, error)

	// CloseRouteSessionWithResponse Close and drain a route session without deleting its route
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/route-sessions/{route_session_id} (the `CloseRouteSession` operationId).
	CloseRouteSessionWithResponse(ctx context.Context, routeSessionId RouteSessionID, reqEditors ...RequestEditorFn) (*CloseRouteSessionResponse, error)

	// MarkRouteSessionCertificateInstalledWithBodyWithResponse Record installation of the current route certificate
	//
	// 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 /v1/route-sessions/{route_session_id}/certificate-installed (the `MarkRouteSessionCertificateInstalled` operationId).
	MarkRouteSessionCertificateInstalledWithBodyWithResponse(ctx context.Context, routeSessionId RouteSessionID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MarkRouteSessionCertificateInstalledResponse, error)

	// MarkRouteSessionCertificateInstalledWithResponse Record installation of the current route certificate
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/route-sessions/{route_session_id}/certificate-installed (the `MarkRouteSessionCertificateInstalled` operationId).
	MarkRouteSessionCertificateInstalledWithResponse(ctx context.Context, routeSessionId RouteSessionID, body MarkRouteSessionCertificateInstalledJSONRequestBody, reqEditors ...RequestEditorFn) (*MarkRouteSessionCertificateInstalledResponse, error)

	// CreateCertificateIssuanceWithBodyWithResponse Begin issuance for the route session's certificate plan
	//
	// 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 /v1/route-sessions/{route_session_id}/certificate-issuances (the `CreateCertificateIssuance` operationId).
	CreateCertificateIssuanceWithBodyWithResponse(ctx context.Context, routeSessionId RouteSessionID, params *CreateCertificateIssuanceParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateCertificateIssuanceResponse, error)

	// CreateCertificateIssuanceWithResponse Begin issuance for the route session's certificate plan
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/route-sessions/{route_session_id}/certificate-issuances (the `CreateCertificateIssuance` operationId).
	CreateCertificateIssuanceWithResponse(ctx context.Context, routeSessionId RouteSessionID, params *CreateCertificateIssuanceParams, body CreateCertificateIssuanceJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateCertificateIssuanceResponse, error)

	// HeartbeatRouteSessionWithBodyWithResponse Renew a route session and replace missing publisher connections
	//
	// 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 /v1/route-sessions/{route_session_id}/heartbeat (the `HeartbeatRouteSession` operationId).
	HeartbeatRouteSessionWithBodyWithResponse(ctx context.Context, routeSessionId RouteSessionID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*HeartbeatRouteSessionResponse, error)

	// HeartbeatRouteSessionWithResponse Renew a route session and replace missing publisher connections
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/route-sessions/{route_session_id}/heartbeat (the `HeartbeatRouteSession` operationId).
	HeartbeatRouteSessionWithResponse(ctx context.Context, routeSessionId RouteSessionID, body HeartbeatRouteSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*HeartbeatRouteSessionResponse, error)

	// MarkRouteSessionReadyWithBodyWithResponse Mark a route session ready after its certificate and two publisher connections are ready
	//
	// 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 /v1/route-sessions/{route_session_id}/ready (the `MarkRouteSessionReady` operationId).
	MarkRouteSessionReadyWithBodyWithResponse(ctx context.Context, routeSessionId RouteSessionID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MarkRouteSessionReadyResponse, error)

	// MarkRouteSessionReadyWithResponse Mark a route session ready after its certificate and two publisher connections are ready
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/route-sessions/{route_session_id}/ready (the `MarkRouteSessionReady` operationId).
	MarkRouteSessionReadyWithResponse(ctx context.Context, routeSessionId RouteSessionID, body MarkRouteSessionReadyJSONRequestBody, reqEditors ...RequestEditorFn) (*MarkRouteSessionReadyResponse, error)

	// ListRoutesWithResponse List routes for one team
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/routes (the `ListRoutes` operationId).
	ListRoutesWithResponse(ctx context.Context, params *ListRoutesParams, reqEditors ...RequestEditorFn) (*ListRoutesResponse, error)

	// CreateRouteWithBodyWithResponse Create one team route
	//
	// 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 /v1/routes (the `CreateRoute` operationId).
	CreateRouteWithBodyWithResponse(ctx context.Context, params *CreateRouteParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateRouteResponse, error)

	// CreateRouteWithResponse Create one team route
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/routes (the `CreateRoute` operationId).
	CreateRouteWithResponse(ctx context.Context, params *CreateRouteParams, body CreateRouteJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateRouteResponse, error)

	// DeleteRouteWithResponse Delete one route and close its route session
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/routes/{route_id} (the `DeleteRoute` operationId).
	DeleteRouteWithResponse(ctx context.Context, routeId RouteID, reqEditors ...RequestEditorFn) (*DeleteRouteResponse, error)

	// GetRouteWithResponse Read one route
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/routes/{route_id} (the `GetRoute` operationId).
	GetRouteWithResponse(ctx context.Context, routeId RouteID, reqEditors ...RequestEditorFn) (*GetRouteResponse, error)

	// UpdateRouteWithBodyWithResponse Update a route's target and IP policy
	//
	// 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 /v1/routes/{route_id} (the `UpdateRoute` operationId).
	UpdateRouteWithBodyWithResponse(ctx context.Context, routeId RouteID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateRouteResponse, error)

	// UpdateRouteWithResponse Update a route's target and IP policy
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /v1/routes/{route_id} (the `UpdateRoute` operationId).
	UpdateRouteWithResponse(ctx context.Context, routeId RouteID, body UpdateRouteJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateRouteResponse, error)

	// CreateRouteSessionWithResponse Create a route session and allocate its route version
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/routes/{route_id}/sessions (the `CreateRouteSession` operationId).
	CreateRouteSessionWithResponse(ctx context.Context, routeId RouteID, params *CreateRouteSessionParams, reqEditors ...RequestEditorFn) (*CreateRouteSessionResponse, error)

	// CreateDNSAuthorityWithBodyWithResponse Create a DNS authority for one claimed domain
	//
	// 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 /v1/service/dns-authorities (the `CreateDNSAuthority` operationId).
	CreateDNSAuthorityWithBodyWithResponse(ctx context.Context, params *CreateDNSAuthorityParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateDNSAuthorityResponse, error)

	// CreateDNSAuthorityWithResponse Create a DNS authority for one claimed domain
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/service/dns-authorities (the `CreateDNSAuthority` operationId).
	CreateDNSAuthorityWithResponse(ctx context.Context, params *CreateDNSAuthorityParams, body CreateDNSAuthorityJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateDNSAuthorityResponse, error)

	// ReleaseDNSAuthorityWithResponse Begin releasing a claimed domain's DNS authority
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/service/dns-authorities/{dns_authority_reference} (the `ReleaseDNSAuthority` operationId).
	ReleaseDNSAuthorityWithResponse(ctx context.Context, dnsAuthorityReference DNSAuthorityReference, params *ReleaseDNSAuthorityParams, reqEditors ...RequestEditorFn) (*ReleaseDNSAuthorityResponse, error)

	// GetDNSAuthorityWithResponse Read a claimed domain's DNS authority
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/service/dns-authorities/{dns_authority_reference} (the `GetDNSAuthority` operationId).
	GetDNSAuthorityWithResponse(ctx context.Context, dnsAuthorityReference DNSAuthorityReference, reqEditors ...RequestEditorFn) (*GetDNSAuthorityResponse, error)

	// RevokeHostedPolicyWithBodyWithResponse Apply a policy revision from the external authority and close affected route sessions
	//
	// 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 /v1/service/revoke (the `RevokeHostedPolicy` operationId).
	RevokeHostedPolicyWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RevokeHostedPolicyResponse, error)

	// RevokeHostedPolicyWithResponse Apply a policy revision from the external authority and close affected route sessions
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/service/revoke (the `RevokeHostedPolicy` operationId).
	RevokeHostedPolicyWithResponse(ctx context.Context, body RevokeHostedPolicyJSONRequestBody, reqEditors ...RequestEditorFn) (*RevokeHostedPolicyResponse, error)
}

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

type ConnectionAssignment struct {
	ConnectionAssignmentRevision           int64                    `json:"connection_assignment_revision"`
	ConnectionSlot                         int                      `json:"connection_slot"`
	PublisherConnectionCredential          string                   `json:"publisher_connection_credential"`
	PublisherConnectionCredentialExpiresAt time.Time                `json:"publisher_connection_credential_expires_at"`
	PublisherConnectionId                  PublisherConnectionID    `json:"publisher_connection_id"`
	RelayAddress                           string                   `json:"relay_address"`
	RelayServiceId                         RelayServiceID           `json:"relay_service_id"`
	State                                  PublisherConnectionState `json:"state"`
	TlsServerName                          CanonicalHostname        `json:"tls_server_name"`
}

type ControlDiscovery struct {
	Authentication          AuthenticationFacts `json:"authentication"`
	AuthorityEndpoint       string              `json:"authority_endpoint"`
	DnsAutomation           bool                `json:"dns_automation"`
	ManagedDeploymentDomain CanonicalHostname   `json:"managed_deployment_domain"`
}

type CreateCertificateIssuanceJSONRequestBody = CreateCertificateIssuanceRequest

type CreateCertificateIssuanceParams struct {
	IdempotencyKey IdempotencyKey `json:"Idempotency-Key"`
}

type CreateCertificateIssuanceRequest struct {
	Csr          []byte `json:"csr"`
	RouteVersion int64  `json:"route_version"`
}

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

type CreateDNSAuthorityJSONRequestBody = CreateDNSAuthorityRequest

type CreateDNSAuthorityParams struct {
	IdempotencyKey IdempotencyKey `json:"Idempotency-Key"`
}

type CreateDNSAuthorityRequest struct {
	CanonicalDomain CanonicalHostname `json:"canonical_domain"`
	DomainId        DomainID          `json:"domain_id"`
	TeamId          TeamID            `json:"team_id"`
}

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

type CreateRouteJSONRequestBody = CreateRouteRequest

type CreateRouteParams struct {
	IdempotencyKey IdempotencyKey `json:"Idempotency-Key"`
}

type CreateRouteRequest struct {
	AllowedIpPrefixes *[]string         `json:"allowed_ip_prefixes,omitempty"`
	CanonicalHostname CanonicalHostname `json:"canonical_hostname"`
	DomainId          DomainID          `json:"domain_id"`
	Ephemeral         *bool             `json:"ephemeral,omitempty"`
	MembershipId      *MembershipID     `json:"membership_id,omitempty"`
	RouteScope        RouteScope        `json:"route_scope"`
	Target            string            `json:"target"`
	TeamId            TeamID            `json:"team_id"`
}

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

type CreateRouteSessionParams struct {
	IdempotencyKey IdempotencyKey `json:"Idempotency-Key"`
}

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

type Cursor = ResourceID

type DNSAuthority struct {
	CanonicalDomain CanonicalHostname `json:"canonical_domain"`
	CreatedAt       time.Time         `json:"created_at"`
	DomainId        DomainID          `json:"domain_id"`
	LastError       *string           `json:"last_error,omitempty"`
	Reference       string            `json:"reference"`
	RequiredRecords []DNSRecord       `json:"required_records"`
	State           DNSAuthorityState `json:"state"`
	TeamId          TeamID            `json:"team_id"`
	UpdatedAt       time.Time         `json:"updated_at"`
}

type DNSAuthorityReference = string

type DNSAuthorityState string

type DNSRecord struct {
	Name  CanonicalHostname `json:"name"`
	Type  DNSRecordType     `json:"type"`
	Value string            `json:"value"`
}

type DNSRecordType string

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

type DomainID = ResourceID

type DrainAdminRelayJSONRequestBody = AdminDrainRelayRequest

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

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

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

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

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

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

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

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

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

type HealthResponse struct {
	Status HealthResponseStatus `json:"status"`
}

type HealthResponseStatus string

type HeartbeatRouteSessionJSONRequestBody = RouteSessionVersionRequest

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

type HostedPolicyRevocation struct {
	AllSessions    bool           `json:"all_sessions"`
	DomainIds      []DomainID     `json:"domain_ids"`
	MembershipIds  []MembershipID `json:"membership_ids"`
	PolicyRevision int64          `json:"policy_revision"`
	TeamId         TeamID         `json:"team_id"`
}

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

type IdempotencyKey = string

type IdentityID = ResourceID

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

type IssuanceID = ResourceID

type ListAdminRelaysParams struct {
	Cursor *Cursor `form:"cursor,omitempty" json:"cursor,omitempty"`
}

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

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

type ListRoutesParams struct {
	TeamId TeamIDQuery `form:"team_id" json:"team_id"`
	Cursor *Cursor     `form:"cursor,omitempty" json:"cursor,omitempty"`

	// CanonicalHostname Exact canonical hostname within the selected team. Returns zero or one non-deleted route with no next cursor. Cannot be combined with cursor.
	CanonicalHostname *CanonicalHostnameQuery `form:"canonical_hostname,omitempty" json:"canonical_hostname,omitempty"`
}

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

type MaintenanceControl struct {
	Allowed   bool                   `json:"allowed"`
	Name      MaintenanceControlName `json:"name"`
	Revision  int64                  `json:"revision"`
	UpdatedAt time.Time              `json:"updated_at"`
	UpdatedBy IdentityID             `json:"updated_by"`
}

type MaintenanceControlName string

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

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

type MarkRouteSessionCertificateInstalledJSONRequestBody = CertificateInstalledRequest

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

type MarkRouteSessionReadyJSONRequestBody = RouteSessionVersionRequest

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

type MembershipID = ResourceID

type MiddlewareFunc func(http.Handler) http.Handler

type OIDCAuthenticationFacts struct {
	ClientId  string                           `json:"client_id"`
	Issuer    string                           `json:"issuer"`
	LoginFlow OIDCAuthenticationFactsLoginFlow `json:"login_flow"`
	Scopes    []string                         `json:"scopes"`
}

type OIDCAuthenticationFactsLoginFlow string

type Problem struct {
	Code      ProblemCode             `json:"code"`
	Detail    *string                 `json:"detail,omitempty"`
	Details   *map[string]interface{} `json:"details,omitempty"`
	RequestId string                  `json:"request_id"`
	RetryAt   *time.Time              `json:"retry_at,omitempty"`
	Status    int                     `json:"status"`
	Title     string                  `json:"title"`
	Type      string                  `json:"type"`
}

type ProblemCode string

type PublisherConnectionID = ResourceID

type PublisherConnectionState string

type ReadinessResponse struct {
	Checks struct {
		Database ReadinessResponseChecksDatabase `json:"database"`
	} `json:"checks"`
	Status ReadinessResponseStatus `json:"status"`
}

type ReadinessResponseChecksDatabase string

type ReadinessResponseStatus string

type RelayID = ResourceID

type RelayServiceID = ResourceID

type ReleaseDNSAuthorityParams struct {
	IdempotencyKey IdempotencyKey `json:"Idempotency-Key"`
}

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

type RequestEditorFn func(ctx context.Context, req *http.Request) error

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

type RequiredParamError struct {
	ParamName string
}

type ResourceID = string

type RevokeHostedPolicyJSONRequestBody = HostedPolicyRevocation

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