openapi

type AcceptSuggestionJSONRequestBody = SuggestionAcceptance

type AcceptedSuggestion struct {
	CreatedAt time.Time `json:"created_at"`

	// CreatedId What accepting created, where it created one thing; absent where it changed an entry or created several.
	CreatedId *openapi_types.UUID `json:"created_id,omitempty"`

	// CreatedIds The entries accepting an `ENTRIES` proposal created, in the proposal's order — what an undo trashes. Absent for every other kind.
	CreatedIds *[]openapi_types.UUID `json:"created_ids,omitempty"`

	// DecidedAt When it was accepted or dismissed.
	DecidedAt *time.Time `json:"decided_at,omitempty"`

	// DecidedBy Who accepted or dismissed it. A suggestion is decided by a person.
	DecidedBy *openapi_types.UUID `json:"decided_by,omitempty"`

	// DroppedNodes How many parts of the provider's answer the narrowing dropped before the payload was stored, so that a client can say the draft is not the whole answer. For `TEMPLATE` it is the nodes the collection's profile refused under their parent, each counted with its subtree; zero for every other kind, whose narrowing drops what it drops without a count. Absent on a row written before the count existed, which reads as zero.
	DroppedNodes *int               `json:"dropped_nodes,omitempty"`
	Id           openapi_types.UUID `json:"id"`

	// Kind What accepting does, which is the only thing a kind has to say. `FIELDS` proposes values for the target entry; `DECOMPOSITION` proposes a tree of entries under it. A summary and a classification are `FIELDS` suggestions whose payload happens to be notes or labels — they are not kinds of their own, because accepting them is the same act.
	// `TEMPLATE` proposes a template for the collection it targets: its payload is a `TemplateInput`, and accepting it is `CreateTemplate` performed by the accepting person.
	// `RULE` proposes an automation rule drafted from a sentence, about the account that asked; accepting it is `CreateRule` performed by that person, so the rule is stored switched off.
	// `ANSWER` is a proposed answer to a question, about the account that asked. Like `DUPLICATES` nothing accepts it — it performs no action — and `:dismiss` closes it. `ENTRIES` proposes entries for a collection, made from a piece of text the person pasted, about the account that asked; accepting creates the entries taken — all, or some — with `CreateWorkItem` performed by that person.
	// `DUPLICATES` is the one kind nothing accepts. It says which entries look like this one, and what to do about that is a person's decision through the ordinary use cases — `:accept` refuses it and `:dismiss` closes it. It is also the one kind no prompt produced, so its `prompt_id` and `prompt_version` are empty and its `model` names the embedding model whose vectors were compared.
	Kind SuggestionKind `json:"kind"`

	// Model The model that answered, as the provider named it — not as it was configured.
	Model string `json:"model"`

	// Payload What was proposed, in the shape the kind fixes. For `FIELDS` it is the fields of the target entry, and about a jumble entry it may also carry `subtasks` — the titles the material implied, which accepting creates under the converted entry rather than setting on it. For `DECOMPOSITION` it is a tree of entries proposed under the target. For `DUPLICATES` it is `duplicates`: the entries that look like this one, nearest first, each with the identifier and the similarity that put it there — identifiers only, so what a reader sees of them is what they could have read anyway. For `TEMPLATE` it is a `TemplateInput` for the target collection. For `RULE` it is part of an `AutomationRuleCreate` — `scope`, `trigger`, `conditions`, `actions` — and `not_drafted`, what of the sentence could not be drafted: entries with `part` (words quoted from the sentence) or `code` and `params` (a message code). For `ANSWER` it is `answer` (the proposed answer, at most 2000 characters), `source_ids` (at most five entries it rests on, each one the asker could read when asked) and, where the question is a filter, `filter`: an object of `place_id` and `place_type` (`HUB` or `COLLECTION`), `is_completed`, `due` (`overdue`, `today`, `next_7_days` or `this_month`), `assignee_id` and `label_ids`, each present only where implied. For `ENTRIES` it is `collection_id`, `type` — the level the entries are created at — and `entries`, each with a `key` and a `title`, and `notes`, `amount` (text) or `due_date` (`YYYY-MM-DD`) only where the collection carries them. It is data, never an instruction, and nothing acts on it until somebody accepts.
	Payload map[string]interface{} `json:"payload"`

	// ProducedAt When the provider answered, which is not when the record was written.
	ProducedAt time.Time `json:"produced_at"`
	PromptId   string    `json:"prompt_id"`

	// PromptVersion Which version of the prompt produced this. Prompt files are versioned in their names and the old ones stay, so this resolves to the actual words a year later.
	PromptVersion string `json:"prompt_version"`

	// Source Where the proposal came from. One value today, and a field rather than an assumption: a suggestion whose origin is not recorded is one nobody can tell from a person's own draft.
	Source AcceptedSuggestionSource `json:"source"`

	// Status `DISMISSED` is a state and not a deletion, so "what was proposed and turned down" has an answer; the retention engine ages both decided states out by rule.
	Status   SuggestionStatus   `json:"status"`
	TargetId openapi_types.UUID `json:"target_id"`

	// TargetType What the suggestion is about. `CONTAINER` is a collection rather than an entry: a summary of how it stands is about the collection, and nothing accepts one — a collection has nowhere to put a status summary, so it is read and dismissed. `ACCOUNT` is the person who asked, for a draft of something that does not exist yet — a rule, or entries made from pasted text — or for an answer to their question: only that account lists, accepts or dismisses it.
	TargetType SuggestionTargetType `json:"target_type"`

	// Version The optimistic lock, as everywhere else.
	Version int `json:"version"`
}

type AcceptedSuggestionSource string

type AccessToken struct {
	// AccountId Whose credential it is, and therefore whose rights bound it.
	AccountId openapi_types.UUID `json:"account_id"`
	CreatedAt time.Time          `json:"created_at"`
	ExpiresAt time.Time          `json:"expires_at"`
	Id        openapi_types.UUID `json:"id"`

	// LastUsedAt When a request last presented it, to the minute rather than to the request - the value exists so an owner can spot a credential nobody uses, and writing it on every call would be a write per request.
	LastUsedAt *time.Time `json:"last_used_at,omitempty"`
	Name       string     `json:"name"`

	// RevokedAt When it was withdrawn. Separate from the expiry on purpose: "it ran out" and "somebody pulled it" are different answers.
	RevokedAt *time.Time `json:"revoked_at,omitempty"`

	// Scopes The second bound on what the token may do, on top of the role its holder carries. Both have to allow an operation.
	Scopes []string `json:"scopes"`
}

type AccessTokenCreate struct {
	// AccountId Whose token. Omitted means the caller's own. A service account's needs the member management permission; another person's is refused, whatever the role.
	AccountId *openapi_types.UUID `json:"account_id,omitempty"`

	// ExpiresAt Mandatory, in the future, and at most a year out. There is no default - a caller has to choose.
	ExpiresAt time.Time `json:"expires_at"`

	// Name What this token is for, in the owner's own words. It is what they will read in a year when deciding whether it is still needed.
	Name string `json:"name"`

	// Scopes Requested explicitly, never defaulted to everything. Each has to be one the installation declares; one it does not is refused as a field error naming it.
	Scopes []string `json:"scopes"`
}

type AccessTokenSecret struct {
	// AccountId Whose credential it is, and therefore whose rights bound it.
	AccountId openapi_types.UUID `json:"account_id"`
	CreatedAt time.Time          `json:"created_at"`
	ExpiresAt time.Time          `json:"expires_at"`
	Id        openapi_types.UUID `json:"id"`

	// LastUsedAt When a request last presented it, to the minute rather than to the request - the value exists so an owner can spot a credential nobody uses, and writing it on every call would be a write per request.
	LastUsedAt *time.Time `json:"last_used_at,omitempty"`
	Name       string     `json:"name"`

	// RevokedAt When it was withdrawn. Separate from the expiry on purpose: "it ran out" and "somebody pulled it" are different answers.
	RevokedAt *time.Time `json:"revoked_at,omitempty"`

	// Scopes The second bound on what the token may do, on top of the role its holder carries. Both have to allow an operation.
	Scopes []string `json:"scopes"`

	// Token The credential, in clear, for the only time. Store it or lose it: what is kept is a hash, and nothing can turn that back into this.
	Token string `json:"token"`
}

type Account struct {
	// AuthenticatorAppRemovable Whether turning the authenticator app off would be accepted now, answered on `GET /accounts/me` and on nothing else: the app is armed, and either the workspace's rule does not require a second factor of this person or a passkey or security key remains.
	AuthenticatorAppRemovable *bool `json:"authenticator_app_removable,omitempty"`

	// AvatarMediaId The picture the person shows beside their name, a media object any member of the workspace may read (`GET /media/{mediaId}`). Absent or null means the initials of the name are the avatar.
	AvatarMediaId *openapi_types.UUID `json:"avatar_media_id,omitempty"`

	// Celebrations Whether the moments are marked for this person - a small celebration when work is completed. Absent or null means the default, which is on.
	Celebrations *bool                `json:"celebrations,omitempty"`
	DisplayName  string               `json:"display_name"`
	Email        *openapi_types.Email `json:"email,omitempty"`

	// HasAccess Whether this account holds a role anywhere in the workspace - on the workspace, a hub, a collection or one entry, directly or through a group - answered on `GET /accounts/me` and on nothing else. False is a person an administrator still has to give access to, such as somebody a sign-in provider brought in with nothing: a screen says so instead of an empty workspace. It is also the condition for creating a private hub of one's own, so where it is false no hub can be created; a person whose only role is on their own private hub, or on one shared entry, holds access.
	HasAccess *bool `json:"has_access,omitempty"`

	// HasAuthenticatorApp Whether an *armed* authenticator app stands on this account, answered on `GET /accounts/me` and on nothing else. An enrolment begun and never confirmed counts as none, the same reading the sign-in path takes.
	HasAuthenticatorApp *bool `json:"has_authenticator_app,omitempty"`

	// HasPassword Whether this account holds a password, answered on `GET /accounts/me` and on nothing else. An account that signs in only through a provider holds none: a screen does not offer it a password change, and no step-up asks it for one.
	HasPassword *bool `json:"has_password,omitempty"`

	// HasSecondFactor Whether a second factor stands on this account - an armed authenticator app, or a passkey or security key of this workspace's address - answered on `GET /accounts/me` and on nothing else. An enrolment begun and never confirmed counts as none. Whether the app itself is armed is `has_authenticator_app`.
	// Until this was answered, nothing in the contract said it, and a screen could not tell an account with no authenticator from one whose recovery codes had all been spent. That is how the security screen came to offer two actions the server refuses - "make new recovery codes" and "turn it off" - under a red banner saying none were left.
	HasSecondFactor *bool              `json:"has_second_factor,omitempty"`
	Id              openapi_types.UUID `json:"id"`
	Kind            AccountKind        `json:"kind"`
	Locale          *string            `json:"locale,omitempty"`

	// OnboardingCompletedAt When the person finished or skipped the first-run tour. Absent or null means the tour has not been taken - or was asked for again.
	OnboardingCompletedAt *time.Time `json:"onboarding_completed_at,omitempty"`

	// RecoveryCodesRemaining How many of the ten recovery codes are still usable, answered on `GET /accounts/me` and on nothing else. **Present exactly when `has_second_factor` is true**, and then zero is answered as zero, because there zero is the number to act on. Absent where there is nothing to count: an account holding no second factor, or an installation wired without one. Its codes are not "zero left" - they are a thing that does not exist yet, and a screen told zero sends somebody to make codes the server would refuse to make.
	// The same number rides along with a sign-in, where nobody can act on it; here it is beside the account, which is where the screen that makes new ones is.
	RecoveryCodesRemaining *int `json:"recovery_codes_remaining,omitempty"`

	// SecondFactorRequired Whether the workspace's sign-in rule in force demands a second factor of this person, answered on `GET /accounts/me` and on nothing else. The same reading signing in and turning the factor off make, so a screen can say "your workspace requires it" instead of offering a control the server would refuse.
	SecondFactorRequired *bool `json:"second_factor_required,omitempty"`

	// SignInName What a managed account signs in with instead of an address: unique in the workspace, stored folded (compatibility form, lower case). Absent on an account that signs in with its address.
	SignInName *string `json:"sign_in_name,omitempty"`

	// Status `RESTRICTED` is Art. 18 GDPR as a technical state: the account works and its content
	// stays, and what stops is this system deciding anything about the person by machine.
	// `ANONYMIZED` is an erasure carried out in the mode that keeps the authorship - the row
	// stays so that the workspace's own content is still readable, and everything of the
	// person's in it is gone.
	Status    AccountStatus     `json:"status"`
	TimeZone  *string           `json:"time_zone,omitempty"`
	WeekStart *AccountWeekStart `json:"week_start,omitempty"`
}

type AccountId = openapi_types.UUID

type AccountInvite struct {
	DisplayName *string             `json:"display_name,omitempty"`
	Email       openapi_types.Email `json:"email"`
}

type AccountKind string

type AccountPreferences struct {
	// Celebrations Whether the moments are marked. `null` clears it; the default is on.
	Celebrations *bool   `json:"celebrations,omitempty"`
	Locale       *string `json:"locale,omitempty"`

	// OnboardingCompletedAt When the tour ended or was skipped, written by the client. `null` clears it, which is how the tour is asked for again.
	OnboardingCompletedAt *time.Time                   `json:"onboarding_completed_at,omitempty"`
	TimeZone              *string                      `json:"time_zone,omitempty"`
	WeekStart             *AccountPreferencesWeekStart `json:"week_start,omitempty"`
}

type AccountPreferencesWeekStart string

type AccountStatus string

type AccountSummary struct {
	// AvatarMediaId The picture the person shows beside their name, readable through `GET /media/{mediaId}` by any member. Absent or null means the initials of the name are the avatar.
	AvatarMediaId *openapi_types.UUID `json:"avatar_media_id,omitempty"`

	// DisplayName An erased account carries the marker its erasure wrote here, so a reader sees that somebody acted without learning who they were.
	DisplayName string `json:"display_name"`

	// HasAddress False for an account that has no mail address - a managed account - so a screen can say that a reminder by mail does not reach this person, instead of letting it fail silently. The address itself is not answered here.
	HasAddress *bool              `json:"has_address,omitempty"`
	Id         openapi_types.UUID `json:"id"`
	Kind       AccountSummaryKind `json:"kind"`

	// Managed True for a managed account: a sign-in name and no address. Only such an account takes a new start password or an address; an erased account has no address either and is not managed.
	Managed *bool                `json:"managed,omitempty"`
	Status  AccountSummaryStatus `json:"status"`
}

type AccountSummaryKind string

type AccountSummaryStatus string

type AccountWeekStart string

type AccountsWithoutProvider struct {
	// Count The active people - service accounts and invitations aside - without an identity at any provider that is a way in here now.
	Count int `json:"count"`
}

type ActivityEntry struct {
	// Actor Who did it. The label is not here: the account is one request away and this record is deleted with its entry, so there is nothing for a copy of somebody's name to outlive.
	Actor struct {
		Id   *openapi_types.UUID    `json:"id"`
		Type ActivityEntryActorType `json:"type"`
	} `json:"actor"`

	// ChangeSet The fields that moved, keyed by field name. A field the history keeps the values of carries `from` and `to` - each present only where there was a value on that side - and one it does not carries `changed: true`: a note is a page of text and its history is that somebody edited it. Empty where the step moved no field at all, and empty for every step of an activity's compact history.
	ChangeSet map[string]interface{} `json:"change_set"`

	// Code The message the client renders, from locales/*.json - activity.item_completed and the rest. A code rather than a sentence, so that one history reads in whichever language each client is set to.
	Code       string             `json:"code"`
	Id         openapi_types.UUID `json:"id"`
	ItemId     openapi_types.UUID `json:"item_id"`
	OccurredAt time.Time          `json:"occurred_at"`
}

type ActivityEntryActorType string

type ActivityPage struct {
	Data []ActivityEntry `json:"data"`
	Page PageInfo        `json:"page"`
}

type Actor struct {
	Id   *openapi_types.UUID `json:"id"`
	Type ActorType           `json:"type"`
}

type ActorType string

type AddCommentJSONBody struct {
	Body            string              `json:"body"`
	ParentCommentId *openapi_types.UUID `json:"parent_comment_id,omitempty"`
}

type AddCommentJSONRequestBody AddCommentJSONBody

type AddCommentParams struct {
	// IdempotencyKey A UUID; identical requests return the same result for 24 h. Two answers are not kept: a `5xx`, and `403 auth.step_up_required` - neither is an outcome of the request, so the repeat reaches the operation again. A client that is asked for a proof retries with the proof under the same key.
	IdempotencyKey *IdempotencyKey `json:"Idempotency-Key,omitempty"`
}

type AddOperatorJSONRequestBody = OperatorAdd

type AddressConfirm struct {
	// Token The token from the confirmation mail. It dies on use.
	Token string `json:"token"`
}

type AddressRequest struct {
	Email openapi_types.Email `json:"email"`
}

type AddressRequested struct {
	// ExpiresAt Until when the link in the mail confirms the address.
	ExpiresAt time.Time `json:"expires_at"`
}

type AdminTenant struct {
	CreatedAt       time.Time `json:"created_at"`
	DefaultLocale   *string   `json:"default_locale,omitempty"`
	DefaultTimeZone *string   `json:"default_time_zone,omitempty"`
	DisplayName     string    `json:"display_name"`

	// ExternalReference The purchase platform's own reference, where it set one.
	ExternalReference *string            `json:"external_reference,omitempty"`
	Id                openapi_types.UUID `json:"id"`

	// LegalHold Whether a legal hold is in force in the workspace. While one is, a deletion request is refused, and a workspace already pending deletion stays pending until the last hold is lifted. Only the state: which hold, on what and why stay the workspace's.
	LegalHold *bool `json:"legal_hold,omitempty"`

	// PasswordOpening The operator's opening of the password while it is in force, null otherwise - an opening past its end is answered as none, whatever the row still holds.
	PasswordOpening *PasswordOpening `json:"password_opening,omitempty"`

	// Plan The short name of the workspace's plan, null for none.
	Plan *string `json:"plan,omitempty"`

	// PurgeAfter Set while a deletion request stands - when the grace runs out.
	PurgeAfter *time.Time `json:"purge_after,omitempty"`

	// PurgeStartedAt Set once the hard delete has begun removing the workspace. From then on its deletion can no longer be called off.
	PurgeStartedAt *time.Time        `json:"purge_started_at,omitempty"`
	Slug           string            `json:"slug"`
	Status         AdminTenantStatus `json:"status"`

	// Version The workspace's version: it grows with every change to the workspace, by the control plane or by its own administrators. A move names it to refuse a stale one.
	Version *int `json:"version,omitempty"`
}

type AdminTenantId = openapi_types.UUID

type AdminTenantPage struct {
	Data []AdminTenant `json:"data"`
	Page PageInfo      `json:"page"`
}

type AdminTenantStatus string

type AgreeToTermsJSONRequestBody = TermsAgreement

type AiArrivalProposalsChoice struct {
	// Prepare True prepares a proposal for each new jumble entry; false waits for somebody to ask.
	Prepare bool `json:"prepare"`
}

type AiAsk struct {
	// Apply Apply the answer as soon as it arrives instead of proposing it. **False unless it is said**, and deliberately: a result is a suggestion, and applying one without a person reading it is a decision somebody configures rather than one that happens by not thinking about it.
	// An applied answer is not a shortcut past anything. The suggestion is recorded with its provenance first, the acceptance is audited as its own act, and the change goes through the use case that owns it with the caller's own rights — it is the same path with nobody pausing in the middle.
	Apply *bool `json:"apply,omitempty"`
}

type AiBudgetState struct {
	// RenewsAt When the day's budget has room again - the workspace's next midnight. Null for `OFF`.
	RenewsAt *time.Time         `json:"renews_at,omitempty"`
	State    AiBudgetStateState `json:"state"`
}

type AiBudgetStateState string

type AiClassifyJSONRequestBody = AiAsk

type AiFieldsAsk struct {
	// Apply As `AiAsk.apply`.
	Apply *bool `json:"apply,omitempty"`

	// Fields The fields to propose. The answer keeps only these; one that proposes none of them ends the job with `ai.nothing_to_change`.
	Fields *[]AiFieldsAskFields `json:"fields,omitempty"`
}

type AiFieldsAskFields string

type AiGenerateTemplateJSONRequestBody = TemplateGeneration

type AiGenerateTemplateParams struct {
	// IdempotencyKey A UUID; identical requests return the same result for 24 h. Two answers are not kept: a `5xx`, and `403 auth.step_up_required` - neither is an outcome of the request, so the repeat reaches the operation again. A client that is asked for a proof retries with the proof under the same key.
	IdempotencyKey *IdempotencyKey `json:"Idempotency-Key,omitempty"`
}

type AiJurisdiction string

type AiMinJurisdiction string

type AiOptOutBasis string

type AiPersonOptOut string

type AiPersonOptOutChoice struct {
	// Basis The legal basis a workspace names for making AI part of everybody's work.
	Basis *AiOptOutBasis `json:"basis,omitempty"`

	// Contact Whom people may ask about it - a name, a role or an address. Optional; without one, people are told to ask an administrator of this workspace.
	Contact *string `json:"contact,omitempty"`

	// PersonOptOut `OFFERED`: each person may keep their own content out of AI. `NOT_OFFERED`: AI is part of everybody's work, on the legal basis the workspace named.
	PersonOptOut AiPersonOptOut `json:"person_opt_out"`
}

type AiProvider struct {
	// BaseUrl The endpoint the adapter calls. Absent for `NOOP`. Every call to it goes through the guarded client, so an address inside this installation's own network is refused wherever it was typed.
	BaseUrl *string `json:"base_url,omitempty"`

	// CompletionModel The model a suggestion is asked of. Empty means this provider does not complete.
	CompletionModel *string   `json:"completion_model,omitempty"`
	CreatedAt       time.Time `json:"created_at"`

	// EmbeddingModel The model a vector is asked of. Empty means this provider does not embed. The index holds 1536 dimensions: a model that produces fewer is stored exactly, padded, and one that produces more is refused at the first embedding rather than stored truncated. The two Ollama embedding models in common use produce 768 and 1024 and are taken; a model above 1536 cannot be used.
	EmbeddingModel *string `json:"embedding_model,omitempty"`

	// HasApiKey Whether a key is stored, which is the whole of what this surface says about one. The key itself is sealed on the way in and answered by nothing afterwards - so this is the only way an operator can tell "configured with a key" from "configured without one", and a setup screen that could not tell them apart would have to ask for the key again to find out.
	HasApiKey bool `json:"has_api_key"`

	// Jurisdiction Where the provider processes what is sent to it, as the operator declares it. It is a declaration rather than something this software can verify, and it exists so that the decision is documented rather than made by accident.
	// `SELF_HOSTED` is a model this installation runs itself - no transfer to anybody. `EEA` and `ADEQUACY` are transfers Art. 45 covers. `THIRD_COUNTRY` is everything else and needs the operator's confirmation in the installation's configuration; the adequacy decision or the standard contractual clauses, and the transfer impact assessment, remain the operator's obligation.
	Jurisdiction AiJurisdiction `json:"jurisdiction"`

	// Kind Which adapter answers. `OPENAI_COMPATIBLE` covers OpenAI, Azure, Mistral, vLLM and LiteLLM, which agree on a wire format; `OLLAMA` is a local model; `NOOP` calls nothing and is what an installation has until somebody chooses otherwise.
	Kind AiProviderKind `json:"kind"`

	// ProcessingAllowed Whether this workspace's content may be sent to the provider at all (`ai_processing_allowed`). Checked before every call, and false by default - configuring a provider is not the same act as consenting to use it.
	ProcessingAllowed bool       `json:"processing_allowed"`
	UpdatedAt         *time.Time `json:"updated_at,omitempty"`

	// Version The optimistic lock, as everywhere else.
	Version int `json:"version"`
}

type AiProviderConfiguration struct {
	// ApiKey Sealed on the way in and answered by nothing afterwards. Omit it on a later write to keep the key already stored; send an empty string to clear it, which is what a local provider that needs none wants.
	ApiKey *string `json:"api_key,omitempty"`

	// BaseUrl Required for every kind but `NOOP`, which calls nothing.
	BaseUrl         *string `json:"base_url,omitempty"`
	CompletionModel *string `json:"completion_model,omitempty"`
	EmbeddingModel  *string `json:"embedding_model,omitempty"`

	// Jurisdiction Where the provider processes what is sent to it, as the operator declares it. It is a declaration rather than something this software can verify, and it exists so that the decision is documented rather than made by accident.
	// `SELF_HOSTED` is a model this installation runs itself - no transfer to anybody. `EEA` and `ADEQUACY` are transfers Art. 45 covers. `THIRD_COUNTRY` is everything else and needs the operator's confirmation in the installation's configuration; the adequacy decision or the standard contractual clauses, and the transfer impact assessment, remain the operator's obligation.
	Jurisdiction AiJurisdiction `json:"jurisdiction"`

	// Kind Which adapter answers. `OPENAI_COMPATIBLE` covers OpenAI, Azure, Mistral, vLLM and LiteLLM, which agree on a wire format; `OLLAMA` is a local model; `NOOP` calls nothing and is what an installation has until somebody chooses otherwise.
	Kind AiProviderKind `json:"kind"`

	// ProcessingAllowed Defaults to false. Configuring a provider and consenting to send this workspace's content to it are two decisions, and a default that ran them together would make the second one by accident.
	ProcessingAllowed *bool `json:"processing_allowed,omitempty"`
}

type AiProviderKind string

type AiSource struct {
	// InstallationSources What the levels above the workspace allow - the installation and the workspace's plan together - which is what the workspace may narrow.
	InstallationSources AiSources `json:"installation_sources"`

	// KeepingOutCount How many people keep their own content out now, or whose objection stops taking effect under `NOT_OFFERED`. A number, never who: the consent register names them.
	KeepingOutCount int `json:"keeping_out_count"`

	// MinJurisdiction The least a workspace's own model must declare about where it processes content, further right being stricter.
	MinJurisdiction       AiMinJurisdiction             `json:"min_jurisdiction"`
	MinJurisdictionLock   *AiSourceMinJurisdictionLock  `json:"min_jurisdiction_lock,omitempty"`
	MinJurisdictionOrigin AiSourceMinJurisdictionOrigin `json:"min_jurisdiction_origin"`

	// Narrowing Which sources a workspace may use: none, only a model the installation offers, only its own (the default), or either.
	Narrowing *AiSources `json:"narrowing,omitempty"`

	// Offered The models the installation offers, where it allows them at all: name, processor and jurisdiction, never an address, a model name or a key.
	Offered []OfferedAiModelSummary `json:"offered"`

	// OfferedModelId The offered model chosen. Absent with any other source - and absent while the source is `OFFERED` once the installation withdrew the model chosen: then nothing answers until the workspace chooses again.
	OfferedModelId *openapi_types.UUID `json:"offered_model_id,omitempty"`

	// PersonOptOut `OFFERED`: each person may keep their own content out of AI. `NOT_OFFERED`: AI is part of everybody's work, on the legal basis the workspace named.
	PersonOptOut AiPersonOptOut `json:"person_opt_out"`

	// PersonOptOutBasis The legal basis a workspace names for making AI part of everybody's work.
	PersonOptOutBasis *AiOptOutBasis `json:"person_opt_out_basis,omitempty"`

	// PersonOptOutContact Whom people may ask about the basis. Absent for an administrator of this workspace.
	PersonOptOutContact *string `json:"person_opt_out_contact,omitempty"`

	// PersonOptOutLock Present where a level above holds the workspace at `OFFERED`: then only the installation or the plan can change it.
	PersonOptOutLock   *AiSourcePersonOptOutLock  `json:"person_opt_out_lock,omitempty"`
	PersonOptOutOrigin AiSourcePersonOptOutOrigin `json:"person_opt_out_origin"`

	// PersonOptOutSince When the workspace made AI part of everybody's work. Absent with `OFFERED`.
	PersonOptOutSince *time.Time `json:"person_opt_out_since,omitempty"`

	// PrepareOnArrival Whether AI prepares a proposal for each new jumble entry as it arrives (`PUT /ai-arrival-proposals`). Off by default.
	PrepareOnArrival bool `json:"prepare_on_arrival"`

	// SearchRebuilding True while search by meaning is being rebuilt for the model now in use. Search by words keeps working meanwhile.
	SearchRebuilding *bool `json:"search_rebuilding,omitempty"`

	// Source Which source answers a workspace.
	Source AiSourceKind `json:"source"`

	// Sources Which sources a workspace may use: none, only a model the installation offers, only its own (the default), or either.
	Sources AiSources `json:"sources"`

	// SourcesLock Present where a level above locked what the workspace may use.
	SourcesLock   *AiSourceSourcesLock  `json:"sources_lock,omitempty"`
	SourcesOrigin AiSourceSourcesOrigin `json:"sources_origin"`
	UpdatedAt     *time.Time            `json:"updated_at,omitempty"`
	Version       int                   `json:"version"`
}

type AiSourceChoice struct {
	// OfferedModelId The offered model, with `OFFERED` only.
	OfferedModelId *openapi_types.UUID `json:"offered_model_id,omitempty"`

	// Source Which source answers a workspace.
	Source AiSourceKind `json:"source"`

	// Sources This workspace's own narrowing of what it may use: a value narrows, `INHERIT` takes what the installation allows, absent keeps it.
	Sources *AiSourceChoiceSources `json:"sources,omitempty"`
}

type AiSourceChoiceSources string

type AiSourceKind string

type AiSourceMinJurisdictionLock string

type AiSourceMinJurisdictionOrigin string

type AiSourcePersonOptOutLock string

type AiSourcePersonOptOutOrigin string

type AiSourceSourcesLock string

type AiSourceSourcesOrigin string

type AiSources string

type AiSuggestFieldsJSONRequestBody = AiFieldsAsk

type AiSummarizeContainerJSONRequestBody = AiAsk

type AiSummarizeJSONRequestBody = AiAsk

type AiSummarizeThreadJSONRequestBody = AiAsk

type AiTranslateJSONRequestBody = AiTranslateRequest

type AiTranslateRequest struct {
	// TargetLocale BCP 47 (`de`, `pt-BR`). Absent, the caller's own locale — the account's, else the request's — which is the language they read anything in. A tag the installation has no catalogue for is fine: the provider translates into languages the product does not render.
	TargetLocale *string `json:"target_locale,omitempty"`
}

type AiTranslation struct {
	Model string `json:"model"`

	// Notes Empty where the entry has no notes.
	Notes         string              `json:"notes"`
	ProducedAt    time.Time           `json:"produced_at"`
	PromptId      string              `json:"prompt_id"`
	PromptVersion string              `json:"prompt_version"`
	Source        AiTranslationSource `json:"source"`

	// SourceLanguage The entry's `content_language`, which is what the provider was told the source is; null where the entry states none.
	SourceLanguage *string `json:"source_language,omitempty"`
	TargetLocale   string  `json:"target_locale"`
	Title          string  `json:"title"`
}

type AiTranslationSource string

type AnswerAlexaJSONBody map[string]interface{}

type AnswerAlexaJSONRequestBody AnswerAlexaJSONBody

type ArchiveContainerParams struct {
	// IdempotencyKey A UUID; identical requests return the same result for 24 h. Two answers are not kept: a `5xx`, and `403 auth.step_up_required` - neither is an outcome of the request, so the repeat reaches the operation again. A client that is asked for a proof retries with the proof under the same key.
	IdempotencyKey *IdempotencyKey `json:"Idempotency-Key,omitempty"`
}

type ArchiveWorkItemParams struct {
	// IdempotencyKey A UUID; identical requests return the same result for 24 h. Two answers are not kept: a `5xx`, and `403 auth.step_up_required` - neither is an outcome of the request, so the repeat reaches the operation again. A client that is asked for a proof retries with the proof under the same key.
	IdempotencyKey *IdempotencyKey `json:"Idempotency-Key,omitempty"`
}

type AskWorkspaceJSONRequestBody = WorkspaceQuestion

type AskWorkspaceParams struct {
	// IdempotencyKey A UUID; identical requests return the same result for 24 h. Two answers are not kept: a `5xx`, and `403 auth.step_up_required` - neither is an outcome of the request, so the repeat reaches the operation again. A client that is asked for a proof retries with the proof under the same key.
	IdempotencyKey *IdempotencyKey `json:"Idempotency-Key,omitempty"`
}

type AssignWorkItemJSONRequestBody = Assignment

type AssignWorkItemParams struct {
	// IdempotencyKey A UUID; identical requests return the same result for 24 h. Two answers are not kept: a `5xx`, and `403 auth.step_up_required` - neither is an outcome of the request, so the repeat reaches the operation again. A client that is asked for a proof retries with the proof under the same key.
	IdempotencyKey *IdempotencyKey `json:"Idempotency-Key,omitempty"`

	// IfMatch The ETag of the state last read (optimistic locking).
	IfMatch *IfMatch `json:"If-Match,omitempty"`
}

type Assignment struct {
	// AccountId The account to assign. It has to hold a membership on the path above the entry; one that does not is refused with the same answer as an account that does not exist.
	AccountId openapi_types.UUID `json:"account_id"`
}

type AuditActor struct {
	Id    *openapi_types.UUID `json:"id,omitempty"`
	Label *string             `json:"label,omitempty"`

	// OnBehalfOf The run_as principal for automation and agents
	OnBehalfOf *openapi_types.UUID `json:"on_behalf_of,omitempty"`
	Type       *AuditActorType     `json:"type,omitempty"`
}

type AuditActorType string

type AuditAnchoring struct {
	ConfiguredAt time.Time           `json:"configured_at"`
	ConfiguredBy *openapi_types.UUID `json:"configured_by,omitempty"`

	// TargetId The target anchoring writes to, or null where it is off.
	TargetId *openapi_types.UUID `json:"target_id,omitempty"`
}

type AuditAnchoringConfiguration struct {
	// TargetId The workspace's backup target the daily anchor is written to; null switches anchoring off.
	TargetId *openapi_types.UUID `json:"target_id"`
}

type AuditChange struct {
	Changed  *bool       `json:"changed,omitempty"`
	Field    *string     `json:"field,omitempty"`
	From     interface{} `json:"from,omitempty"`
	FromHash *string     `json:"from_hash,omitempty"`
	To       interface{} `json:"to,omitempty"`
	ToHash   *string     `json:"to_hash,omitempty"`
}

type AuditContext struct {
	ApiClient *string              `json:"api_client,omitempty"`
	Channel   *AuditContextChannel `json:"channel,omitempty"`
	IpPrefix  *string              `json:"ip_prefix,omitempty"`
	RequestId *string              `json:"request_id,omitempty"`

	// RuleId The automation rule that acted
	RuleId         *openapi_types.UUID `json:"rule_id,omitempty"`
	TraceId        *string             `json:"trace_id,omitempty"`
	UserAgentClass *string             `json:"user_agent_class,omitempty"`
}

type AuditContextChannel string

type AuditEntry struct {
	Action string `json:"action"`

	// Actor Who acted, as the entry recorded them. The label is the one that was valid at the time and
	// is stored denormalised: an entry that only pointed at a foreign key would become
	// unreadable the moment the account was deleted, and a trail that loses its meaning through
	// a deletion does not do its job.
	Actor   AuditActor     `json:"actor"`
	Changes *[]AuditChange `json:"changes,omitempty"`

	// Context The request the entry belongs to. The address is truncated where the entry is
	// written - IPv4 /24, IPv6 /48 - and the user agent is reduced to a class, because the trail
	// is evidence about actions rather than a second analytics dataset.
	Context    *AuditContext       `json:"context,omitempty"`
	Hash       *string             `json:"hash,omitempty"`
	Id         openapi_types.UUID  `json:"id"`
	LegalBasis *string             `json:"legal_basis,omitempty"`
	OccurredAt time.Time           `json:"occurred_at"`
	Outcome    AuditEntryOutcome   `json:"outcome"`
	Seq        *int                `json:"seq,omitempty"`
	Severity   *AuditEntrySeverity `json:"severity,omitempty"`

	// Target The object the entry is about.
	Target *AuditTarget `json:"target,omitempty"`
}

type AuditEntryOutcome string

type AuditEntrySeverity string

type AuditExport struct {
	// Format JSON Lines keeps the entry as it is - the nested actor, target, context and changes - and
	// is what a second system reads. CSV flattens it for a spreadsheet, and what does not fit a
	// column travels as JSON inside one.
	Format *AuditExportFormat `json:"format,omitempty"`
	From   time.Time          `json:"from"`

	// TargetId The backup target the archive is written to.
	TargetId openapi_types.UUID `json:"target_id"`
	To       time.Time          `json:"to"`
}

type AuditExportFormat string

type AuditTarget struct {
	Id    *openapi_types.UUID `json:"id,omitempty"`
	Label *string             `json:"label,omitempty"`
	Type  *string             `json:"type,omitempty"`
}

type AuthenticatorReplacement struct {
	// ExpiresAt Until when the replacement can be confirmed; after that it lapses unarmed.
	ExpiresAt time.Time `json:"expires_at"`

	// OtpauthUri What a QR image is rendered from - the rendering is the client's job.
	OtpauthUri string `json:"otpauth_uri"`

	// Secret Base32, for typing by hand where no camera reaches the QR.
	Secret string `json:"secret"`
}

type AuthenticatorReplacementConfirmation struct {
	// Code The current code of the new authenticator.
	Code string `json:"code"`
}

type AuthorizeMailboxJSONRequestBody = MailboxAuthorizationRequest

type AuthorizeMailboxParams struct {
	// IdempotencyKey A UUID; identical requests return the same result for 24 h. Two answers are not kept: a `5xx`, and `403 auth.step_up_required` - neither is an outcome of the request, so the repeat reaches the operation again. A client that is asked for a proof retries with the proof under the same key.
	IdempotencyKey *IdempotencyKey `json:"Idempotency-Key,omitempty"`
}

type AuthorizeOauthClientJSONRequestBody = OauthAuthorization

type AutoAssignCandidate struct {
	Id   openapi_types.UUID      `json:"id"`
	Kind AutoAssignCandidateKind `json:"kind"`
}

type AutoAssignCandidateKind string

type AutoAssignOutcome struct {
	Assigned bool    `json:"assigned"`
	Code     *string `json:"code,omitempty"`

	// Strategy How a candidate is picked. FIXED always assigns the one configured account. RANDOM_MEMBER draws uniformly from the candidate accounts. RANDOM_GROUP_MEMBER draws a group first and one of its members second, so each group carries an equal share of the work regardless of its size. ROUND_ROBIN walks the candidate list in order. LEAST_LOADED picks the candidate with the fewest open entries. /meta/capabilities returns the valid values.
	Strategy AutoAssignStrategy `json:"strategy"`
}

type AutoAssignPolicy struct {
	// Candidates The pool the strategy draws from, in the order that matters to ROUND_ROBIN. FIXED takes exactly one ACCOUNT; RANDOM_GROUP_MEMBER takes GROUP candidates; every other strategy takes ACCOUNT candidates.
	Candidates []AutoAssignCandidate `json:"candidates"`

	// Enabled Whether the policy applies itself to everything created in the collection. A policy that is not enabled is applied only to a create that asks with auto_assign.
	Enabled *bool `json:"enabled,omitempty"`

	// Strategy How a candidate is picked. FIXED always assigns the one configured account. RANDOM_MEMBER draws uniformly from the candidate accounts. RANDOM_GROUP_MEMBER draws a group first and one of its members second, so each group carries an equal share of the work regardless of its size. ROUND_ROBIN walks the candidate list in order. LEAST_LOADED picks the candidate with the fewest open entries. /meta/capabilities returns the valid values.
	Strategy AutoAssignStrategy `json:"strategy"`
}

type AutoAssignStrategy string

type AutoAssignWorkItemParams struct {
	// IdempotencyKey A UUID; identical requests return the same result for 24 h. Two answers are not kept: a `5xx`, and `403 auth.step_up_required` - neither is an outcome of the request, so the repeat reaches the operation again. A client that is asked for a proof retries with the proof under the same key.
	IdempotencyKey *IdempotencyKey `json:"Idempotency-Key,omitempty"`

	// IfMatch The ETag of the state last read (optimistic locking).
	IfMatch *IfMatch `json:"If-Match,omitempty"`
}

type AutomationActionField struct {
	// Description Protocol documentation, in English, as the descriptions in this document are - never display text.
	Description *string `json:"description,omitempty"`

	// Enum The closed set of values the field takes, where it takes one.
	Enum *[]string `json:"enum,omitempty"`

	// Format The shape of a string field where a form draws it better than as text, in the vocabulary of this document's own `format` keyword: `date-time` for an RFC 3339 instant. Absent for a string that is just a string; a client tolerates a value it does not know and draws the field as text.
	Format   *string                   `json:"format,omitempty"`
	Kind     AutomationActionFieldKind `json:"kind"`
	Name     string                    `json:"name"`
	Required bool                      `json:"required"`

	// Rule Whether a rule sets this field. `false` for the caller's plumbing - the identifier a client minted for offline work, the version it last read for If-Match, a reserved switch - which a person typing a call supplies and a rule never does, because a run has no version it read and mints nothing. A rule editor hides such a field; the call still accepts it. Absent means `true`.
	Rule *bool `json:"rule,omitempty"`
}

type AutomationActionFieldKind string

type AutomationRule struct {
	Actions []RuleAction `json:"actions"`

	// CheckedAt When the check last ran over this rule, and absent for a rule it never has — or for one edited since: an edit leaves the rule unchecked and its findings empty, because they described the definition the check read, not this one.
	CheckedAt *time.Time `json:"checked_at,omitempty"`

	// Conditions Up to twenty, evaluated in order, and all of them have to hold for the rule to act. An empty list is a rule with no conditions, which runs on every match; an empty *expression* is not a condition at all and is refused as the empty field it is.
	Conditions []RuleCondition    `json:"conditions"`
	CreatedAt  time.Time          `json:"created_at"`
	CreatedBy  openapi_types.UUID `json:"created_by"`

	// Enabled Switched off when the rule is written. `:enable` and `:disable` are what move it, so that the trail says which of the two somebody did.
	Enabled bool `json:"enabled"`

	// FailureCount Consecutive failed runs. A run of them disables the rule by itself, and enabling it by hand clears the count.
	FailureCount int `json:"failure_count"`

	// Findings What the last check found: every reference of the rule resolved against what exists now. Empty for a rule with nothing wrong, and empty for a rule that has never been checked - `checked_at` tells the two apart. A `BROKEN` finding is one the check acted on: the rule is switched off. An `ATTENTION` finding is information.
	Findings *[]RuleFinding     `json:"findings,omitempty"`
	Id       openapi_types.UUID `json:"id"`

	// InboundRotatedAt When an `INBOUND_WEBHOOK` rule's address was last minted, and absent for a rule that has none. The moment and nothing else: a prefix or a masked value beside it would be a credential whose guessing space has been narrowed for whoever reads the listing.
	InboundRotatedAt *time.Time `json:"inbound_rotated_at,omitempty"`

	// LastRun The rule's most recent run — when it started and how it ended — read beside the rule so that a list of rules says it without a page of runs per rule. Absent for a rule that never ran. Not part of the definition: a write ignores it.
	LastRun *struct {
		At time.Time `json:"at"`

		// Status How a run ended. `RUNNING` is a run in flight or one whose process died - the engine writes it when the run starts, so a row left in it is a crash rather than a state anything reaches deliberately. `WAITING` is a run parked on a `WAIT` action: its results so far are written, a scheduled job holds the resume point, and no worker is held while the delay passes.
		Status RuleRunStatus `json:"status"`
	} `json:"last_run,omitempty"`
	Name string `json:"name"`

	// NextRunAt When a `SCHEDULE` rule next fires. Absent for every other kind, and for a schedule whose recurrence is exhausted - such a rule stays, visible and editable, and fires no more.
	NextRunAt *time.Time            `json:"next_run_at,omitempty"`
	OnError   AutomationRuleOnError `json:"on_error"`

	// RunAs The account the rule acts as. It can never do more than that account may, which is why the writer has to hold those rights too.
	RunAs openapi_types.UUID `json:"run_as"`

	// Scope Where the rule applies: the whole workspace, one hub, or one collection. Descendants are included by the ordinary rule rather than by a flag: a permission held at a hub applies downwards, and a rule scoped to a hub sees what happens in its collections.
	Scope RuleScope `json:"scope"`

	// Throttle What bounds a storm. Both are optional, and both are stored rather than enforced here: the engine that runs a rule is what observes them.
	Throttle *RuleThrottle `json:"throttle,omitempty"`

	// Trigger What starts a run. Six kinds, each with the fields its kind needs and no others - a trigger carrying a cron expression and an event type would be a rule nobody can read.
	Trigger   RuleTrigger `json:"trigger"`
	UpdatedAt time.Time   `json:"updated_at"`
	Version   int         `json:"version"`
}

type AutomationRuleCreate struct {
	Actions    []RuleAction                 `json:"actions"`
	Conditions *[]RuleCondition             `json:"conditions,omitempty"`
	Name       string                       `json:"name"`
	OnError    *AutomationRuleCreateOnError `json:"on_error,omitempty"`
	RunAs      openapi_types.UUID           `json:"run_as"`

	// Scope Where the rule applies: the whole workspace, one hub, or one collection. Descendants are included by the ordinary rule rather than by a flag: a permission held at a hub applies downwards, and a rule scoped to a hub sees what happens in its collections.
	Scope RuleScope `json:"scope"`

	// Throttle What bounds a storm. Both are optional, and both are stored rather than enforced here: the engine that runs a rule is what observes them.
	Throttle *RuleThrottle `json:"throttle,omitempty"`

	// Trigger What starts a run. Six kinds, each with the fields its kind needs and no others - a trigger carrying a cron expression and an event type would be a rule nobody can read.
	Trigger RuleTrigger `json:"trigger"`
}

type AutomationRuleCreateOnError string

type AutomationRuleOnError string

type AutomationRulePage struct {
	Data []AutomationRule `json:"data"`
	Page PageInfo         `json:"page"`
}

type AutomationRuleUpdate struct {
	Actions    *[]RuleAction    `json:"actions,omitempty"`
	Conditions *[]RuleCondition `json:"conditions,omitempty"`

	// ExpectedVersion The version last read. A mismatch is a conflict rather than an overwrite.
	ExpectedVersion *int                         `json:"expected_version,omitempty"`
	Name            *string                      `json:"name,omitempty"`
	OnError         *AutomationRuleUpdateOnError `json:"on_error,omitempty"`
	RunAs           *openapi_types.UUID          `json:"run_as,omitempty"`

	// Scope Where the rule applies: the whole workspace, one hub, or one collection. Descendants are included by the ordinary rule rather than by a flag: a permission held at a hub applies downwards, and a rule scoped to a hub sees what happens in its collections.
	Scope *RuleScope `json:"scope,omitempty"`

	// Throttle What bounds a storm. Both are optional, and both are stored rather than enforced here: the engine that runs a rule is what observes them.
	Throttle *RuleThrottle `json:"throttle,omitempty"`

	// Trigger What starts a run. Six kinds, each with the fields its kind needs and no others - a trigger carrying a cron expression and an event type would be a rule nobody can read.
	Trigger *RuleTrigger `json:"trigger,omitempty"`
}

type AutomationRuleUpdateOnError string

type AvatarInput struct {
	// MediaId A confirmed media object the caller staged with usage `AVATAR`.
	MediaId openapi_types.UUID `json:"media_id"`
}

type BackupArchive struct {
	// ArchiveId The manifest's own identifier - not what a restore names.
	ArchiveId      *string                      `json:"archive_id,omitempty"`
	ChecksumStatus *BackupArchiveChecksumStatus `json:"checksum_status,omitempty"`

	// Complete Whether the run that wrote it finished - whether `checksums.txt` is there. An archive without one is not damaged; it is a run still going or one that died, and the difference matters to whoever is deciding what to restore from.
	Complete        *bool              `json:"complete,omitempty"`
	CreatedAt       *time.Time         `json:"created_at,omitempty"`
	Encrypted       *bool              `json:"encrypted,omitempty"`
	EncryptionKeyId *string            `json:"encryption_key_id,omitempty"`
	ExpiresAt       *time.Time         `json:"expires_at,omitempty"`
	ItemCount       *int               `json:"item_count,omitempty"`
	MediaCount      *int               `json:"media_count,omitempty"`
	Mode            *BackupArchiveMode `json:"mode,omitempty"`
	ParentArchiveId *string            `json:"parent_archive_id,omitempty"`

	// Path Where the archive lies at the target, and what `RestoreRequest.archive_id` takes.
	Path           *string `json:"path,omitempty"`
	ProductVersion *string `json:"product_version,omitempty"`
	SchemaVersion  *string `json:"schema_version,omitempty"`
	Scope          *struct {
		Id    *openapi_types.UUID     `json:"id,omitempty"`
		Kind  *BackupArchiveScopeKind `json:"kind,omitempty"`
		Label *string                 `json:"label,omitempty"`
	} `json:"scope,omitempty"`
	SizeBytes *int `json:"size_bytes,omitempty"`
}

type BackupArchiveChecksumStatus string

type BackupArchiveMode string

type BackupArchiveScopeKind string

type BackupRetention struct {
	KeepDaily   *int `json:"keep_daily,omitempty"`
	KeepLast    *int `json:"keep_last,omitempty"`
	KeepMonthly *int `json:"keep_monthly,omitempty"`
	KeepWeekly  *int `json:"keep_weekly,omitempty"`
	KeepYearly  *int `json:"keep_yearly,omitempty"`
	MinKeep     *int `json:"min_keep,omitempty"`
}

type BackupRun struct {
	// ArchivePath Where the archive lies at the target
	ArchivePath *string `json:"archive_path,omitempty"`

	// ErrorCode The message code of the failure, never a message and never free text.
	ErrorCode *string `json:"error_code,omitempty"`

	// ExpiresAt When the generation plan expects this archive to go. Null while nothing has decided.
	ExpiresAt  *time.Time         `json:"expires_at,omitempty"`
	FinishedAt *time.Time         `json:"finished_at,omitempty"`
	Id         openapi_types.UUID `json:"id"`
	ItemCount  *int               `json:"item_count,omitempty"`
	MediaCount *int               `json:"media_count,omitempty"`
	Mode       BackupRunMode      `json:"mode"`

	// ParentRunId The archive this one continues, on an incremental run.
	ParentRunId *openapi_types.UUID `json:"parent_run_id,omitempty"`
	ScheduleId  *openapi_types.UUID `json:"schedule_id,omitempty"`
	SizeBytes   *int                `json:"size_bytes,omitempty"`

	// SnapshotAt The instant the archive represents, taken from the database's own clock.
	SnapshotAt *time.Time         `json:"snapshot_at,omitempty"`
	StartedAt  time.Time          `json:"started_at"`
	Status     BackupRunStatus    `json:"status"`
	TargetId   openapi_types.UUID `json:"target_id"`

	// TrialRestore What the trial restore found: after a scheduled `FULL` run whose schedule has `trial_restore` on, the same job reads the archive back as an `INSPECT` restore - every member read, every checksum verified, every encrypted member decrypted with the key the schedule names - and records the difference report against the workspace here. Null where no trial ran. A trial that fails fails the run, with `backup.trial_restore_failed` as its `error_code` and the failure recorded here.
	TrialRestore *BackupRunTrial  `json:"trial_restore,omitempty"`
	Trigger      BackupRunTrigger `json:"trigger"`
	VerifiedAt   *time.Time       `json:"verified_at,omitempty"`
	VerifyOk     *bool            `json:"verify_ok,omitempty"`
}

type BackupRunMode string

type BackupRunStatus string

type BackupRunTrial struct {
	// Failure What could not be read back, on a run that failed its trial.
	Failure     *BackupRunTrialFailure `json:"failure,omitempty"`
	InspectedAt time.Time              `json:"inspected_at"`

	// Report What a restore did, or - on a dry run - what it would do. The same shape either way, so that the report a caller approved and the report they get back are comparable.
	Report *RestoreReport `json:"report,omitempty"`
}

type BackupRunTrialFailure struct {
	// Code The reader's message code.
	Code string `json:"code"`

	// Member The member at the target where it stopped.
	Member *string `json:"member,omitempty"`
}

type BackupRunTrigger string

type BackupSchedule struct {
	Enabled      *bool                     `json:"enabled,omitempty"`
	FullRrule    *string                   `json:"full_rrule,omitempty"`
	Id           *openapi_types.UUID       `json:"id,omitempty"`
	IncludeAudit *bool                     `json:"include_audit,omitempty"`
	IncludeMedia *bool                     `json:"include_media,omitempty"`
	Mode         *BackupScheduleMode       `json:"mode,omitempty"`
	NextRunAt    *time.Time                `json:"next_run_at,omitempty"`
	NotifyOn     *[]BackupScheduleNotifyOn `json:"notify_on,omitempty"`

	// Retention The generation principle. `min_keep` prevents no backup being left at all.
	Retention *BackupRetention `json:"retention,omitempty"`
	Rrule     string           `json:"rrule"`
	Scope     struct {
		Id   *openapi_types.UUID      `json:"id,omitempty"`
		Kind *BackupScheduleScopeKind `json:"kind,omitempty"`
	} `json:"scope"`
	TargetId openapi_types.UUID `json:"target_id"`
	Timezone *string            `json:"timezone,omitempty"`

	// TrialRestore Follow every `FULL` run with an `INSPECT` restore of the archive it wrote, in the same job, and store the difference report on the run. A trial that fails fails the run - an archive the product cannot read back is not a backup - and `notify_on` covers it as it covers any failure. On for a new schedule; schedules made before this field existed keep it off, and say so.
	TrialRestore *bool `json:"trial_restore,omitempty"`
}

type BackupScheduleMode string

type BackupScheduleNotifyOn string

type BackupScheduleScopeKind string

type BackupScheduleUpdate struct {
	// Enabled Off keeps the rule and owes nothing: `next_run_at` is cleared, and switching it back on computes the next moment afresh rather than resuming a missed one.
	Enabled      *bool                           `json:"enabled,omitempty"`
	FullRrule    *string                         `json:"full_rrule,omitempty"`
	IncludeAudit *bool                           `json:"include_audit,omitempty"`
	IncludeMedia *bool                           `json:"include_media,omitempty"`
	Mode         *BackupScheduleUpdateMode       `json:"mode,omitempty"`
	NotifyOn     *[]BackupScheduleUpdateNotifyOn `json:"notify_on,omitempty"`

	// Retention The generation principle. `min_keep` prevents no backup being left at all.
	Retention    *BackupRetention `json:"retention,omitempty"`
	Rrule        *string          `json:"rrule,omitempty"`
	Timezone     *string          `json:"timezone,omitempty"`
	TrialRestore *bool            `json:"trial_restore,omitempty"`
}

type BackupScheduleUpdateMode string

type BackupScheduleUpdateNotifyOn string

type BackupStart struct {
	IncludeAudit *bool `json:"include_audit,omitempty"`
	IncludeMedia *bool `json:"include_media,omitempty"`

	// Mode FULL by default, and deliberately: a run somebody asked for by hand is usually asked for because something is about to happen, and an incremental that turns out to have no parent at the target is the wrong thing to discover then. An INCREMENTAL with no parent is refused rather than quietly promoted.
	Mode     *BackupStartMode   `json:"mode,omitempty"`
	TargetId openapi_types.UUID `json:"target_id"`
}

type BackupStartMode string

type BackupTarget struct {
	// Config Endpoint, bucket, path, region - without credentials.
	Config          *map[string]interface{}    `json:"config,omitempty"`
	Enabled         *bool                      `json:"enabled,omitempty"`
	EncryptionKeyId *string                    `json:"encryption_key_id,omitempty"`
	EncryptionMode  BackupTargetEncryptionMode `json:"encryption_mode"`
	Id              openapi_types.UUID         `json:"id"`
	Kind            BackupTargetKind           `json:"kind"`
	LastTestAt      *time.Time                 `json:"last_test_at,omitempty"`
	LastTestOk      *bool                      `json:"last_test_ok,omitempty"`
	Name            string                     `json:"name"`

	// RegionNote Data residency; relevant for third-country targets
	RegionNote *string            `json:"region_note,omitempty"`
	Scope      *BackupTargetScope `json:"scope,omitempty"`

	// Warnings e.g. backup.target_unencrypted, backup.target_plaintext_protocol
	Warnings *[]string `json:"warnings,omitempty"`
}

type BackupTargetCreate struct {
	Config map[string]interface{} `json:"config"`

	// Credentials Only on create/update; stored encrypted and never returned.
	Credentials    *map[string]interface{}           `json:"credentials,omitempty"`
	EncryptionMode *BackupTargetCreateEncryptionMode `json:"encryption_mode,omitempty"`

	// EncryptionPassphrase Not stored. Without this value the archive is irrecoverably unreadable - the
	// caller must keep it safe.
	EncryptionPassphrase *string `json:"encryption_passphrase,omitempty"`

	// InsecureAcknowledged Mandatory for `FTP` or unencrypted storage (encryption_mode NONE).
	InsecureAcknowledged *bool            `json:"insecure_acknowledged,omitempty"`
	Kind                 BackupTargetKind `json:"kind"`
	Name                 string           `json:"name"`
}

type BackupTargetCreateEncryptionMode string

type BackupTargetEncryptionMode string

type BackupTargetKind string

type BackupTargetProbe struct {
	// ErrorCode A message code, never the driver's message.
	ErrorCode *string `json:"error_code"`

	// FreeBytes How much room is left, or `null` where the protocol cannot say. A bucket cannot say at all.
	FreeBytes *int    `json:"free_bytes"`
	LatencyMs float32 `json:"latency_ms"`
	Ok        bool    `json:"ok"`

	// Writable Whether the write half worked. A target that can be read and not written is a permissions mistake somebody can act on, and it is the common one.
	Writable bool `json:"writable"`
}

type BackupTargetScope string

type Bucket struct {
	CollectionId openapi_types.UUID `json:"collection_id"`

	// ColorToken Always present, as null when unset - like wip_limit. A board renders both, and a field that appeared only once somebody had set it is one a client cannot read unconditionally.
	ColorToken   *string            `json:"color_token"`
	Id           openapi_types.UUID `json:"id"`
	IsDoneBucket bool               `json:"is_done_bucket"`
	Name         string             `json:"name"`

	// OrderKey The rank on the board - a fractional index rather than a number.
	OrderKey string `json:"order_key"`

	// Version The optimistic lock, returned as the ETag and sent back as If-Match.
	Version int `json:"version"`

	// WipLimit How many entries the people using this board agreed to have in the column at once. Advisory: nothing refuses the drop that exceeds it, because the requirement is that the column turns red rather than that the work becomes impossible. Null is no limit.
	WipLimit *int `json:"wip_limit"`
}

type BucketCreate struct {
	BeforeBucketId *openapi_types.UUID `json:"before_bucket_id,omitempty"`

	// ColorToken One of the ten label colours: slate, blue, teal, green, lime, amber, orange, red, magenta or violet. Any other name is refused with `buckets.color_token_unknown`; a value stored before that check is kept until it is changed. Null or the empty string means no colour.
	ColorToken   *string `json:"color_token,omitempty"`
	IsDoneBucket *bool   `json:"is_done_bucket,omitempty"`
	Name         string  `json:"name"`
	WipLimit     *int    `json:"wip_limit,omitempty"`
}

type BucketDeletion struct {
	BucketId openapi_types.UUID `json:"bucket_id"`

	// MovedItems How many entries were moved.
	MovedItems int `json:"moved_items"`

	// TargetBucketId The column the entries moved to - the leftmost remaining one. Null when this was the last column on the board, in which case the entries now carry none.
	TargetBucketId *openapi_types.UUID `json:"target_bucket_id"`
}

type BucketId = openapi_types.UUID

type BucketUpdate struct {
	// ColorToken One of the ten label colours: slate, blue, teal, green, lime, amber, orange, red, magenta or violet. Any other name is refused with `buckets.color_token_unknown`; a value stored before that check is kept until it is changed. Null or the empty string clears it.
	ColorToken   *string `json:"color_token,omitempty"`
	IsDoneBucket *bool   `json:"is_done_bucket,omitempty"`
	Name         *string `json:"name,omitempty"`

	// WipLimit Null and 0 both remove the limit. Zero is not a limit anybody could satisfy, so nothing is lost by reading it that way, and it saves a client from a second field beside the number.
	WipLimit *int `json:"wip_limit,omitempty"`
}

type BulkOperation struct {
	// ItemId The entry the operation is about. Required by every operation except CREATE_ITEM, which has no entry yet.
	ItemId *openapi_types.UUID `json:"item_id,omitempty"`

	// Op The operation. Each one is the same operation the route of the same name performs - CREATE_ITEM is POST /items, MOVE_ITEM is POST /items/{itemId}:move, ADD_LABEL is PUT /items/{itemId}/labels/{labelId}, and so on - so what a bulk may do is what a caller may do one entry at a time, never more.
	Op BulkOperationOp `json:"op"`

	// Payload What the single-entry operation takes in its body, by the field names it takes there. A field the operation does not know is refused by name rather than ignored.
	Payload *map[string]interface{} `json:"payload,omitempty"`
}

type BulkOperationOp string

type BulkResult struct {
	// Index The position of the operation in the request, counted from zero.
	Index   int       `json:"index"`
	Item    *WorkItem `json:"item,omitempty"`
	Problem *Problem  `json:"problem,omitempty"`

	// Status The status this operation would have answered on its own: 200 or 201 for one that was applied, the refusal's status for one that failed, and 409 for an operation of an atomic bulk that was rolled back because another one failed.
	Status int `json:"status"`
}

type BulkUpdateWorkItemsJSONBody struct {
	// Atomic All or nothing. Without it a bulk applies what it can and reports the rest.
	Atomic     *bool           `json:"atomic,omitempty"`
	Operations []BulkOperation `json:"operations"`
}

type BulkUpdateWorkItemsJSONRequestBody BulkUpdateWorkItemsJSONBody

type BulkUpdateWorkItemsParams struct {
	// IdempotencyKey A UUID; identical requests return the same result for 24 h. Two answers are not kept: a `5xx`, and `403 auth.step_up_required` - neither is an outcome of the request, so the repeat reaches the operation again. A client that is asked for a proof retries with the proof under the same key.
	IdempotencyKey *IdempotencyKey `json:"Idempotency-Key,omitempty"`
}

type CalendarFeed struct {
	// AccountId The owner, whose authorisation the feed reads with at every fetch.
	AccountId openapi_types.UUID `json:"account_id"`
	CreatedAt time.Time          `json:"created_at"`
	Id        openapi_types.UUID `json:"id"`

	// RevokedAt When the token stopped working. Kept rather than deleted, so that "this token was revoked on Tuesday" is answerable.
	RevokedAt *time.Time `json:"revoked_at,omitempty"`

	// ViewId The view the feed serves, or null once that view has been deleted. Null rather than the row going with it: a feed is the subscriber's and a view is the workspace's, so a deleted view leaves a feed that serves nothing and says so.
	ViewId *openapi_types.UUID `json:"view_id,omitempty"`
}