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"`
	EnabledPublicUrls   int                   `json:"enabled_public_urls"`
	IngressLeases       int                   `json:"ingress_leases"`
	ReadyPublishRuns    int                   `json:"ready_publish_runs"`
	RelayLeases         int                   `json:"relay_leases"`
	Role                AdminServerStatusRole `json:"role"`
	StartedAt           time.Time             `json:"started_at"`
	StartingPublishRuns int                   `json:"starting_publish_runs"`
	SuspendedPublicUrls int                   `json:"suspended_public_urls"`
}

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"`
	PublishRunNumber int64      `json:"publish_run_number"`
}

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"`
	PublicUrlId      PublicURLID              `json:"public_url_id"`
	PublishRunId     PublishRunID             `json:"publish_run_id"`
	PublishRunNumber int64                    `json:"publish_run_number"`
	RetryAt          *time.Time               `json:"retry_at,omitempty"`
	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 publish-run 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)

	// ListPublicURLs List public URLs for one team
	//
	// Corresponds with GET /v1/public-urls (the `ListPublicURLs` operationId).
	ListPublicURLs(ctx context.Context, params *ListPublicURLsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreatePublicURLWithBody Create one team public URL
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/public-urls (the `CreatePublicURL` operationId).
	CreatePublicURLWithBody(ctx context.Context, params *CreatePublicURLParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreatePublicURL Create one team public URL
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/public-urls (the `CreatePublicURL` operationId).
	CreatePublicURL(ctx context.Context, params *CreatePublicURLParams, body CreatePublicURLJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeletePublicURL Delete one public URL and close its publish run
	//
	// Corresponds with DELETE /v1/public-urls/{public_url_id} (the `DeletePublicURL` operationId).
	DeletePublicURL(ctx context.Context, publicUrlId PublicURLID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetPublicURL Read one public URL
	//
	// Corresponds with GET /v1/public-urls/{public_url_id} (the `GetPublicURL` operationId).
	GetPublicURL(ctx context.Context, publicUrlId PublicURLID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdatePublicURLWithBody Update a public URL's target and IP policy
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /v1/public-urls/{public_url_id} (the `UpdatePublicURL` operationId).
	UpdatePublicURLWithBody(ctx context.Context, publicUrlId PublicURLID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdatePublicURL Update a public URL's target and IP policy
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /v1/public-urls/{public_url_id} (the `UpdatePublicURL` operationId).
	UpdatePublicURL(ctx context.Context, publicUrlId PublicURLID, body UpdatePublicURLJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreatePublishRun Create a publish run and allocate its publish run number
	//
	// Corresponds with POST /v1/public-urls/{public_url_id}/publish-runs (the `CreatePublishRun` operationId).
	CreatePublishRun(ctx context.Context, publicUrlId PublicURLID, params *CreatePublishRunParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ClosePublishRun Close and drain a publish run without deleting its public URL
	//
	// Corresponds with DELETE /v1/publish-runs/{publish_run_id} (the `ClosePublishRun` operationId).
	ClosePublishRun(ctx context.Context, publishRunId PublishRunID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MarkPublishRunCertificateInstalledWithBody Record installation of the current public URL certificate
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/publish-runs/{publish_run_id}/certificate-installed (the `MarkPublishRunCertificateInstalled` operationId).
	MarkPublishRunCertificateInstalledWithBody(ctx context.Context, publishRunId PublishRunID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MarkPublishRunCertificateInstalled Record installation of the current public URL certificate
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/publish-runs/{publish_run_id}/certificate-installed (the `MarkPublishRunCertificateInstalled` operationId).
	MarkPublishRunCertificateInstalled(ctx context.Context, publishRunId PublishRunID, body MarkPublishRunCertificateInstalledJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	// CreateCertificateIssuance Begin issuance for the publish run's certificate plan
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/publish-runs/{publish_run_id}/certificate-issuances (the `CreateCertificateIssuance` operationId).
	CreateCertificateIssuance(ctx context.Context, publishRunId PublishRunID, params *CreateCertificateIssuanceParams, body CreateCertificateIssuanceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// HeartbeatPublishRunWithBody Renew a publish run and replace missing publisher connections
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/publish-runs/{publish_run_id}/heartbeat (the `HeartbeatPublishRun` operationId).
	HeartbeatPublishRunWithBody(ctx context.Context, publishRunId PublishRunID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// HeartbeatPublishRun Renew a publish run and replace missing publisher connections
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/publish-runs/{publish_run_id}/heartbeat (the `HeartbeatPublishRun` operationId).
	HeartbeatPublishRun(ctx context.Context, publishRunId PublishRunID, body HeartbeatPublishRunJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MarkPublishRunReadyWithBody Mark a publish run ready after its certificate and two publisher connections are ready
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/publish-runs/{publish_run_id}/ready (the `MarkPublishRunReady` operationId).
	MarkPublishRunReadyWithBody(ctx context.Context, publishRunId PublishRunID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MarkPublishRunReady Mark a publish run ready after its certificate and two publisher connections are ready
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/publish-runs/{publish_run_id}/ready (the `MarkPublishRunReady` operationId).
	MarkPublishRunReady(ctx context.Context, publishRunId PublishRunID, body MarkPublishRunReadyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetReadiness Confirm that the tnld role is ready to serve
	//
	// Corresponds with GET /v1/ready (the `GetReadiness` operationId).
	GetReadiness(ctx context.Context, 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 publish runs
	//
	// 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 publish runs
	//
	// 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 publish-run 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)

	// ListPublicURLsWithResponse List public URLs for one team
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/public-urls (the `ListPublicURLs` operationId).
	ListPublicURLsWithResponse(ctx context.Context, params *ListPublicURLsParams, reqEditors ...RequestEditorFn) (*ListPublicURLsResponse, error)

	// CreatePublicURLWithBodyWithResponse Create one team public URL
	//
	// 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/public-urls (the `CreatePublicURL` operationId).
	CreatePublicURLWithBodyWithResponse(ctx context.Context, params *CreatePublicURLParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreatePublicURLResponse, error)

	// CreatePublicURLWithResponse Create one team public URL
	//
	// 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/public-urls (the `CreatePublicURL` operationId).
	CreatePublicURLWithResponse(ctx context.Context, params *CreatePublicURLParams, body CreatePublicURLJSONRequestBody, reqEditors ...RequestEditorFn) (*CreatePublicURLResponse, error)

	// DeletePublicURLWithResponse Delete one public URL and close its publish run
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/public-urls/{public_url_id} (the `DeletePublicURL` operationId).
	DeletePublicURLWithResponse(ctx context.Context, publicUrlId PublicURLID, reqEditors ...RequestEditorFn) (*DeletePublicURLResponse, error)

	// GetPublicURLWithResponse Read one public URL
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/public-urls/{public_url_id} (the `GetPublicURL` operationId).
	GetPublicURLWithResponse(ctx context.Context, publicUrlId PublicURLID, reqEditors ...RequestEditorFn) (*GetPublicURLResponse, error)

	// UpdatePublicURLWithBodyWithResponse Update a public URL'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/public-urls/{public_url_id} (the `UpdatePublicURL` operationId).
	UpdatePublicURLWithBodyWithResponse(ctx context.Context, publicUrlId PublicURLID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdatePublicURLResponse, error)

	// UpdatePublicURLWithResponse Update a public URL'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/public-urls/{public_url_id} (the `UpdatePublicURL` operationId).
	UpdatePublicURLWithResponse(ctx context.Context, publicUrlId PublicURLID, body UpdatePublicURLJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdatePublicURLResponse, error)

	// CreatePublishRunWithResponse Create a publish run and allocate its publish run number
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/public-urls/{public_url_id}/publish-runs (the `CreatePublishRun` operationId).
	CreatePublishRunWithResponse(ctx context.Context, publicUrlId PublicURLID, params *CreatePublishRunParams, reqEditors ...RequestEditorFn) (*CreatePublishRunResponse, error)

	// ClosePublishRunWithResponse Close and drain a publish run without deleting its public URL
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/publish-runs/{publish_run_id} (the `ClosePublishRun` operationId).
	ClosePublishRunWithResponse(ctx context.Context, publishRunId PublishRunID, reqEditors ...RequestEditorFn) (*ClosePublishRunResponse, error)

	// MarkPublishRunCertificateInstalledWithBodyWithResponse Record installation of the current public URL 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/publish-runs/{publish_run_id}/certificate-installed (the `MarkPublishRunCertificateInstalled` operationId).
	MarkPublishRunCertificateInstalledWithBodyWithResponse(ctx context.Context, publishRunId PublishRunID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MarkPublishRunCertificateInstalledResponse, error)

	// MarkPublishRunCertificateInstalledWithResponse Record installation of the current public URL 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/publish-runs/{publish_run_id}/certificate-installed (the `MarkPublishRunCertificateInstalled` operationId).
	MarkPublishRunCertificateInstalledWithResponse(ctx context.Context, publishRunId PublishRunID, body MarkPublishRunCertificateInstalledJSONRequestBody, reqEditors ...RequestEditorFn) (*MarkPublishRunCertificateInstalledResponse, error)

	// CreateCertificateIssuanceWithBodyWithResponse Begin issuance for the publish run'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/publish-runs/{publish_run_id}/certificate-issuances (the `CreateCertificateIssuance` operationId).
	CreateCertificateIssuanceWithBodyWithResponse(ctx context.Context, publishRunId PublishRunID, params *CreateCertificateIssuanceParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateCertificateIssuanceResponse, error)

	// CreateCertificateIssuanceWithResponse Begin issuance for the publish run'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/publish-runs/{publish_run_id}/certificate-issuances (the `CreateCertificateIssuance` operationId).
	CreateCertificateIssuanceWithResponse(ctx context.Context, publishRunId PublishRunID, params *CreateCertificateIssuanceParams, body CreateCertificateIssuanceJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateCertificateIssuanceResponse, error)

	// HeartbeatPublishRunWithBodyWithResponse Renew a publish run 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/publish-runs/{publish_run_id}/heartbeat (the `HeartbeatPublishRun` operationId).
	HeartbeatPublishRunWithBodyWithResponse(ctx context.Context, publishRunId PublishRunID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*HeartbeatPublishRunResponse, error)

	// HeartbeatPublishRunWithResponse Renew a publish run 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/publish-runs/{publish_run_id}/heartbeat (the `HeartbeatPublishRun` operationId).
	HeartbeatPublishRunWithResponse(ctx context.Context, publishRunId PublishRunID, body HeartbeatPublishRunJSONRequestBody, reqEditors ...RequestEditorFn) (*HeartbeatPublishRunResponse, error)

	// MarkPublishRunReadyWithBodyWithResponse Mark a publish run 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/publish-runs/{publish_run_id}/ready (the `MarkPublishRunReady` operationId).
	MarkPublishRunReadyWithBodyWithResponse(ctx context.Context, publishRunId PublishRunID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MarkPublishRunReadyResponse, error)

	// MarkPublishRunReadyWithResponse Mark a publish run 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/publish-runs/{publish_run_id}/ready (the `MarkPublishRunReady` operationId).
	MarkPublishRunReadyWithResponse(ctx context.Context, publishRunId PublishRunID, body MarkPublishRunReadyJSONRequestBody, reqEditors ...RequestEditorFn) (*MarkPublishRunReadyResponse, error)

	// GetReadinessWithResponse Confirm that the tnld role is ready to serve
	//
	// 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)

	// 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 publish runs
	//
	// 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 publish runs
	//
	// 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 ClosePublishRunResponse 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"`
	PublishRunNumber int64  `json:"publish_run_number"`
}

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 CreatePublicURLJSONRequestBody = CreatePublicURLRequest

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

type CreatePublicURLRequest 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"`
	PublicUrlScope    PublicURLScope    `json:"public_url_scope"`
	Target            string            `json:"target"`
	TeamId            TeamID            `json:"team_id"`
}

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

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

type CreatePublishRunResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *PublishRunSetup
	// 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 DeletePublicURLResponse 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 GetPublicURLResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *PublicURL
	// 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 HealthResponse struct {
	Status HealthResponseStatus `json:"status"`
}

type HealthResponseStatus string

type HeartbeatPublishRunJSONRequestBody = PublishRunVersionRequest

type HeartbeatPublishRunResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *PublishRunHeartbeat
	// 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 ListPublicURLsParams 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 public URL with no next cursor. Cannot be combined with cursor.
	CanonicalHostname *CanonicalHostnameQuery `form:"canonical_hostname,omitempty" json:"canonical_hostname,omitempty"`
}

type ListPublicURLsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *PublicURLPage
	// 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 MarkPublishRunCertificateInstalledJSONRequestBody = CertificateInstalledRequest

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

type MarkPublishRunReadyJSONRequestBody = PublishRunVersionRequest

type MarkPublishRunReadyResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *PublishRun
	// 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 PublicURL struct {
	AllowedIpPrefixes    *[]string               `json:"allowed_ip_prefixes,omitempty"`
	CanonicalHostname    CanonicalHostname       `json:"canonical_hostname"`
	CreatedAt            time.Time               `json:"created_at"`
	DomainId             DomainID                `json:"domain_id"`
	Ephemeral            bool                    `json:"ephemeral"`
	ExpiresAt            *time.Time              `json:"expires_at,omitempty"`
	Id                   PublicURLID             `json:"id"`
	LifecycleState       PublicURLLifecycleState `json:"lifecycle_state"`
	MembershipId         *MembershipID           `json:"membership_id,omitempty"`
	NextPublishRunNumber int64                   `json:"next_publish_run_number"`
	OpenPublishRunId     *PublishRunID           `json:"open_publish_run_id,omitempty"`
	PolicyRevision       int64                   `json:"policy_revision"`
	PublicUrlScope       PublicURLScope          `json:"public_url_scope"`
	Target               string                  `json:"target"`
	TeamId               TeamID                  `json:"team_id"`
	UpdatedAt            time.Time               `json:"updated_at"`
}

type PublicURLID = ResourceID

type PublicURLLifecycleState string

type PublicURLPage struct {
	NextCursor *PublicURLID `json:"next_cursor,omitempty"`
	PublicUrls []PublicURL  `json:"public_urls"`
}

type PublicURLScope string

type PublishRun struct {
	ClosedAt                  *time.Time      `json:"closed_at,omitempty"`
	CreatedAt                 time.Time       `json:"created_at"`
	ExpiresAt                 time.Time       `json:"expires_at"`
	Id                        PublishRunID    `json:"id"`
	MembershipId              *MembershipID   `json:"membership_id,omitempty"`
	PolicyRevision            int64           `json:"policy_revision"`
	PublicUrlId               PublicURLID     `json:"public_url_id"`
	PublishRunNumber          int64           `json:"publish_run_number"`
	ReadyAt                   *time.Time      `json:"ready_at,omitempty"`
	ReadyPublisherConnections *int            `json:"ready_publisher_connections,omitempty"`
	State                     PublishRunState `json:"state"`
	TeamId                    TeamID          `json:"team_id"`
}

type PublishRunHeartbeat struct {
	// PolicyDenials Total IP policy denials reported so far for this publish run number. The total may lag.
	PolicyDenials        int64                  `json:"policy_denials"`
	PublishRun           PublishRun             `json:"publish_run"`
	PublisherConnections []ConnectionAssignment `json:"publisher_connections"`
}

type PublishRunID = ResourceID

type PublishRunSetup struct {
	CertificatePlan      CertificatePlan        `json:"certificate_plan"`
	PublicUrl            PublicURL              `json:"public_url"`
	PublishRun           PublishRun             `json:"publish_run"`
	PublishRunToken      string                 `json:"publish_run_token"`
	PublisherConnections []ConnectionAssignment `json:"publisher_connections"`
}

type PublishRunState string

type PublishRunVersionRequest struct {
	PublishRunNumber int64 `json:"publish_run_number"`
}

type PublisherConnectionID = ResourceID

type PublisherConnectionState string

type ReadinessResponse struct {
	Checks struct {
		// Control Control listeners and public control certificate are ready.
		Control  ReadinessResponseChecksControl  `json:"control"`
		Database ReadinessResponseChecksDatabase `json:"database"`

		// Ingress Present in standalone; checks the ingress lease, routing table, and listener.
		Ingress *ReadinessResponseChecksIngress `json:"ingress,omitempty"`

		// Relay Present in standalone; checks both relay services and their listeners.
		Relay *ReadinessResponseChecksRelay `json:"relay,omitempty"`

		// Route53Credentials Present when control uses Route 53; checks that its AWS credentials can be obtained.
		Route53Credentials *ReadinessResponseChecksRoute53Credentials `json:"route53_credentials,omitempty"`
	} `json:"checks"`
	Status ReadinessResponseStatus `json:"status"`
}