acme

type Account[EAB any] struct {
	// Status indicates the status of this account
	Status AccountStatus `json:"status"`

	// Contact is an optional array of URLs that the server can use to
	// contact the client for issues related to this account.  For
	// example, the server may wish to notify the client about
	// server-initiated revocation or certificate expiration.
	// For information on supported URL schemes, see
	// https://www.rfc-editor.org/rfc/rfc8555#section-7.3.
	Contact []string `json:"contact,omitempty" validate:"url"`

	// TermsOfServiceAgreed optionally indicates in a newAccount request
	// the client's agreement with the terms of service.
	// This field cannot be updated by the client.
	TermsOfServiceAgreed bool `json:"termsOfServiceAgreed,omitempty"`

	// ExternalAccountBinding is an optional field in a newAccount request
	// indicating approval by the holder of an existing
	// non-ACME account to bind that account to this ACME account.
	// This field is not updateable by the client, see
	// https://www.rfc-editor.org/rfc/rfc8555#section-7.3.4
	ExternalAccountBinding *json.RawMessage `json:"externalAccountBinding,omitempty"`

	// Orders is a URL from which a list of orders
	// submitted by this account can be fetched via a POST-as-GET
	// request, as described in
	// https://www.rfc-editor.org/rfc/rfc8555#section-7.1.2.1
	Orders string `json:"orders" validate:"url"`
}

type AccountStatus string

type Authorization struct {
	// Identifier that the account is authorized to represent
	Identifier Identifier `json:"identifier"`
	// Status of the authorization
	Status AuthorizationStatus `json:"status"`
	// Expires indicates the timestamp after which the server
	// will consider this authorization invalid.
	// This field is REQUIRED for objects with "valid" status
	Expires Timestamp `json:"expires,omitempty"`
	// Challenges is an array of Challenge objects.
	//
	// - For pending authorizations, the challenges that the client
	//   can fulfill in order to prove possession of the identifier.
	// - For valid authorizations, the challenge that was validated.
	// - For invalid authorizations, the challenge that was attempted
	//   and failed.
	//
	// Each array entry is an object with parameters required to
	// validate the challenge.  A client should attempt to fulfill
	// one of these challenges, and a server should consider any one
	// of the challenges sufficient to make the authorization valid.
	Challenges []Challenge `json:"challenges"`

	// Wildcard indicates the authorization was created as a result
	// of a newOrder request containing a DNS identifier with a value
	// that was a wildcard domain name.
	Wildcard bool `json:"wildcard,omitempty"`
}

type AuthorizationStatus string

type Challenge any

type ChallengeState string

type Directory struct {
	NewNonce   string         `json:"newNonce"`
	NewAccount string         `json:"newAccount"`
	NewOrder   string         `json:"newOrder"`
	NewAuthz   string         `json:"newAuthz,omitempty"`
	RevokeCert string         `json:"revokeCert"`
	KeyChange  string         `json:"keyChange"`
	Meta       *DirectoryMeta `json:"meta,omitempty"`
}

type DirectoryMeta struct {
	// TermsOfService is a URL identifying the current terms of service.
	TermsOfService string `json:"termsOfService,omitempty"`

	// Website is an HTTP or HTTPS URL locating a website
	// providing more information about the ACME server.
	Website string `json:"website,omitempty"`

	// CAAIdentities indicates hostnames that the
	// ACME server recognizes as referring to itself for the purposes of
	// CAA record validation as defined in [RFC6844].  Each string MUST
	// represent the same sequence of ASCII code points that the server
	// will expect to see as the "Issuer Domain Name" in a CAA issue or
	// issuewild property tag.  This allows clients to determine the
	// correct issuer domain name to use when configuring CAA records.
	CAAIdentities []string `json:"caaIdentities,omitempty"`

	// ExternalAccountRequired indicates if the CA requires that all
	// newAccount requests include an "externalAccountBinding" field
	// associating the new account with an external account.
	ExternalAccountRequired bool `json:"externalAccountRequired,omitempty"`
}

type ErrorType string

type Identifier struct {
	// Type indicates the type of identifier
	Type IdentifierType `json:"type"`
	// Value indicates the identifier itself
	Value string `json:"value"`
}

type IdentifierType string

type Order struct {
	// Status indicates the status of this order
	Status OrderStatus `json:"status"`

	// Expires indicates the timestamp after which the server
	// will consider this order invalid
	Expires Timestamp `json:"expires,omitempty"`

	// Identifiers is an array of identifier objects that the
	// order pertains to
	Identifiers []Identifier `json:"identifiers"`

	// NotBefore is the requested notBefore value in the
	// certificate
	NotBefore Timestamp `json:"notBefore,omitempty"`

	// NotAfter is the requested notAfter value in the
	// certificate
	NotAfter Timestamp `json:"notAfter,omitempty"`

	// Error indicates a problem that occurred while processing
	// the order
	Error Problem `json:"error,omitempty"`

	// Authorizations is the array of authorizations
	// associated to this Order. For pending orders, the
	// authorizations that the client needs to complete before the
	// requested certificate can be issued (see Section 7.5), including
	// unexpired authorizations that the client has completed in the past
	// for identifiers specified in the order.  The authorizations
	// required are dictated by server policy; there may not be a 1:1
	// relationship between the order identifiers and the authorizations
	// required.  For final orders (in the "valid" or "invalid" state),
	// the authorizations that were completed.  Each entry is a URL from
	// which an authorization can be fetched with a POST-as-GET request.
	Authorizations []Authorization `json:"authorizations"`

	// Finalize is a URL that a CSR must be POSTed to once
	// all of the order's authorizations are satisfied to finalize the
	// order.  The result of a successful finalization will be the
	// population of the certificate URL for the order.
	Finalize string `json:"finalize" validate:"url"`

	// Certificate is a URL for the certificate that has
	// been issued in response to this order.
	Certificate string `json:"certificate" validate:"url"`
}

type OrderStatus string

type Orders struct {
	Orders []string `json:"orders,omitempty" validate:"url"`
}

type Problem struct {
	// Type is a URI that identifies the problem type
	Type ErrorType `json:"type" validate:"uri"`

	// Status is the HTTP status code generated by the server
	// for this occurrence of the problem.
	Status int `json:"status,omitempty"`

	// Detail is a human-readable explanation specific to this
	// occurrence of the problem
	Detail string `json:"detail,omitempty"`

	// Instance is a URI reference that identifies the specific
	// occurrence of the problem.
	Instance string `json:"instance,omitempty" validate:"uri"`

	// Subproblems is an optional slice of particular problems.
	// Subproblems need not all have the same type, and they
	// do not need to match the top level type.
	Subproblems []Problem `json:"subproblems,omitempty"`

	// Identifier refers to the cause of the Problem.
	// The "identifier" field MUST NOT be present at the top
	// level in ACME problem documents.  It can only be
	// present in subproblems.
	Identifier Identifier `json:"identifier,omitempty"`
}

type Timestamp time.Time