authwire

type APIKeyView struct {
	ID    uuid.UUID `json:"id"`
	Name  string    `json:"name"`
	KeyID string    `json:"keyId"`
	// Kind is Integration or Personal. A client cannot tell them apart without
	// it, and they behave differently enough that an administration screen
	// showing a list of keys has to say which is which.
	Kind          string     `json:"kind"`
	Scopes        []string   `json:"scopes"`
	CIDRAllowList []string   `json:"cidrAllowList,omitempty"`
	CreatedAt     time.Time  `json:"createdAt"`
	ExpiresAt     *time.Time `json:"expiresAt,omitempty"`
	LastUsedAt    *time.Time `json:"lastUsedAt,omitempty"`
	RevokedAt     *time.Time `json:"revokedAt,omitempty"`
}

type AcceptAsMeRequest struct {
	InvitationID uuid.UUID `json:"invitationId"`
	Client       string    `json:"client"`
}

type AcceptRequest struct {
	Token string `json:"token"`
	// Password is only read when the person has none yet. Somebody joining a
	// second tenant already has one, and it is not this endpoint's business.
	Password string `json:"password"`
	Client   string `json:"client"`
}

type AccountView struct {
	// ID names the account — the person inside this tenant. It is not the
	// identity: somebody in two tenants has one identity and two accounts, and
	// this is the one that was just created.
	ID           uuid.UUID `json:"id"`
	TenantID     uuid.UUID `json:"tenantId"`
	EmailAddress string    `json:"emailAddress"`
	DisplayName  string    `json:"displayName"`
	// Kind and Role are the values the database stores, as strings, so that a
	// client sends back the same words it was given.
	Kind string `json:"kind"`
	Role string `json:"role"`
	// TimeZone is an IANA name, for example Europe/Stockholm. Empty means UTC.
	TimeZone  string    `json:"timeZone,omitempty"`
	CreatedAt time.Time `json:"createdAt"`
}

type AuthLogEntryView struct {
	ID uuid.UUID `json:"id"`
	// At is when it happened, in UTC.
	At time.Time `json:"at"`
	// Event is what happened — one of the values of the rig_auth_event enum.
	Event string `json:"event"`
	// Outcome is whether it worked: Succeeded or Failed, and no third value.
	Outcome string `json:"outcome"`

	// AccountID is who it happened to, absent when the attempt never resolved
	// to an account — which is what a wrong address looks like.
	AccountID *uuid.UUID `json:"accountId,omitempty"`
	// EmailAddress is the address as presented, lowercased. Present even when no
	// account matched, which is the case worth reading.
	EmailAddress string `json:"emailAddress,omitempty"`

	IPAddress string `json:"ipAddress,omitempty"`
	UserAgent string `json:"userAgent,omitempty"`

	// APIKeyID is the key involved, when one was.
	APIKeyID *uuid.UUID `json:"apiKeyId,omitempty"`
	// APIKeyRef is the public half of a key as presented, whether or not it
	// resolved to a row.
	APIKeyRef string `json:"apiKeyRef,omitempty"`

	// SessionID is the session family involved, named the way [TokenPair] names
	// it rather than after the root token it is stored as.
	SessionID *uuid.UUID `json:"sessionId,omitempty"`

	// Detail is whatever else was worth recording. Reuse detection puts the
	// original and current address and user agent here, which is what turns
	// "somebody replayed a token" into "somebody replayed it from Frankfurt".
	Detail map[string]any `json:"detail,omitempty"`
}

type ChangePasswordRequest struct {
	CurrentPassword string `json:"currentPassword"`
	NewPassword     string `json:"newPassword"`
}

type ConfirmResetRequest struct {
	Token       string `json:"token"`
	NewPassword string `json:"newPassword"`
}

type CreateKeyRequest struct {
	Name          string     `json:"name"`
	Scopes        []string   `json:"scopes"`
	CIDRAllowList []string   `json:"cidrAllowList"`
	ExpiresAt     *time.Time `json:"expiresAt"`
	// Kind is Integration or Personal, and defaults to Integration.
	//
	// A personal key acts as its creator, so it cannot name a service account —
	// the manager refuses that combination and so does a CHECK on the table. An
	// integration key is the default because it is the one whose writes stay
	// attributable after the person who set it up has left.
	Kind string `json:"kind"`
	// ServiceAccountID is who the key acts as. It defaults to the caller, which
	// is the common case and the one that keeps the writes attributable.
	ServiceAccountID *uuid.UUID `json:"serviceAccountId"`
}

type CreateKeyResponse struct {
	Key APIKeyView `json:"key"`
	// Secret is shown exactly once. Nothing stored can produce it again, which
	// is what makes storing only a hash safe.
	Secret string `json:"secret"`
}

type CreateTenantRequest struct {
	Name string `json:"name"`
	// Client is web, mobile or machine, for the session the new tenant is
	// entered with.
	Client string `json:"client"`
}

type ImpersonateRequest struct {
	AccountID uuid.UUID `json:"accountId"`
}

type InvitationToMeView struct {
	ID uuid.UUID `json:"id"`
	// TenantName is the part that means anything to somebody who has not been
	// there. The identifier is for the accept call.
	TenantID   uuid.UUID `json:"tenantId"`
	TenantName string    `json:"tenantName"`
	Role       string    `json:"role"`
	CreatedAt  time.Time `json:"createdAt"`
	ExpiresAt  time.Time `json:"expiresAt"`
}

type InvitationView struct {
	ID           uuid.UUID `json:"id"`
	EmailAddress string    `json:"emailAddress"`
	DisplayName  string    `json:"displayName"`
	// Role is the role the invitation grants on acceptance, not one the invited
	// person holds yet.
	Role      string    `json:"role"`
	CreatedAt time.Time `json:"createdAt"`
	// ExpiresAt is when the token stops working. A listed invitation past it is
	// history, not something still waiting to be accepted.
	ExpiresAt time.Time `json:"expiresAt"`
}

type List[T any] struct {
	Data []T `json:"data"`
}

type LoginRequest struct {
	EmailAddress string `json:"emailAddress"`
	Password     string `json:"password"`
	// Remember asks for the longer session lifetime.
	Remember bool `json:"remember"`
	// Client is web, mobile or machine. Anything else is read as web.
	Client string `json:"client"`
}

type Page[T any] struct {
	Data       []T        `json:"data"`
	Pagination Pagination `json:"pagination"`
}

type Pagination struct {
	// Offset is how many rows were skipped before this page.
	Offset int `json:"offset"`
	// Limit is the most rows this page could have held.
	Limit int `json:"limit"`
	// Total is every row matching the query, ignoring pagination. It is what
	// tells a caller whether there is another page.
	Total int64 `json:"total"`
}

type ProvisionRequest struct {
	EmailAddress string `json:"emailAddress"`
	DisplayName  string `json:"displayName"`

	// Kind and Role are optional: a person and Basic unless the caller says
	// otherwise. They are strings on the wire so that a client sends the same
	// words the database stores.
	Kind string `json:"kind"`
	Role string `json:"role"`

	TimeZone string `json:"timeZone"`

	// Invite sends a verification link so the person can set a password. It is
	// a request rather than the default, because provisioning during an import
	// of four thousand employees should not send four thousand emails.
	Invite bool `json:"invite"`
}

type RefreshRequest struct {
	RefreshToken string `json:"refreshToken"`
}

type RegisterRequest struct {
	// EmailAddress is the identity. It is what a second registration with the
	// same address collides with, and what verification is sent to.
	EmailAddress string `json:"emailAddress"`
	DisplayName  string `json:"displayName"`
	Password     string `json:"password"`
}

type ResetRequest struct {
	EmailAddress string `json:"emailAddress"`
}

type SessionView struct {
	ID         uuid.UUID `json:"id"`
	CreatedAt  time.Time `json:"createdAt"`
	LastUsedAt time.Time `json:"lastUsedAt"`
	ExpiresAt  time.Time `json:"expiresAt"`
	IPAddress  string    `json:"ipAddress,omitempty"`
	UserAgent  string    `json:"userAgent,omitempty"`
	// AccountID is whose session it is. Always filled in, including in the
	// caller's own list where it is the caller: a member that is present for one
	// reading of an endpoint and absent for another is a member a client cannot
	// rely on.
	AccountID uuid.UUID `json:"accountId"`
	Client    string    `json:"client"`
	// Current marks the session making this request, so an interface can label
	// it rather than inviting somebody to revoke the tab they are looking at
	// without warning.
	Current bool `json:"current"`
}

type SignInResponse struct {
	TokenPair

	// IdentityToken proves who somebody is and names no tenant. It is what
	// the tenant picker runs on, and it is issued even alongside a session,
	// because switching tenant later is the same flow.
	IdentityToken     string    `json:"identityToken"`
	IdentityExpiresAt time.Time `json:"identityExpiresAt"`

	// Tenants is every one this person belongs to, so a client can draw the
	// picker without a second call. Empty means they belong to none yet, which is
	// an ordinary state and no longer a refusal.
	Tenants []TenantView `json:"tenants"`
}

type TenantView struct {
	TenantID   uuid.UUID `json:"tenantId"`
	TenantName string    `json:"tenantName"`
	TenantSlug string    `json:"tenantSlug"`
	AccountID  uuid.UUID `json:"accountId"`
	Role       string    `json:"role"`
	// Current marks the tenant this request was made in, so an interface can
	// show where somebody is without comparing identifiers itself.
	Current bool `json:"current"`
}

type TokenPair struct {
	AccessToken  string    `json:"accessToken,omitempty"`
	RefreshToken string    `json:"refreshToken,omitempty"`
	ExpiresAt    time.Time `json:"expiresAt,omitzero"`
	// RefreshExpiresAt is when the session itself ends. A client needs both:
	// one says when to refresh, the other says when to stop trying.
	RefreshExpiresAt time.Time `json:"refreshExpiresAt,omitzero"`
	SessionID        uuid.UUID `json:"sessionId,omitzero"`
}

type VerifyEmailRequest struct {
	Token string `json:"token"`
}