errorcode

type ActionPolicy string

type ContractError struct {
	Path    string
	Message string
}

type ErrorComponent struct {
	// Name The component's name, for example `meshery-server`, `meshkit` or `mesheryctl`. It is the prefix of every code the component owns.
	Name string `json:"name" yaml:"name"`

	// Type The kind of component, for example `component` (Meshery Server), `adapter`, `library` (MeshKit) or `client` (mesheryctl). An open set: a new kind of component needs no schema change.
	Type string `json:"type" yaml:"type"`
}

type ErrorDefinition struct {
	// Code The full error code, `<component name>-<numericCode>`, for example `meshery-server-1033`. Codes are scoped to the component that owns them and carry no meaning of their own, so a code is unique only together with its component and nothing may be derived from the number alone.
	Code string `json:"code" yaml:"code"`

	// Moniker The name the code has in source, for example `ErrCreatingUUIDInstanceCode` or `ErrApplyManifest`: what MeshKit's export calls `name`. It is not unique across components.
	Moniker string `json:"moniker" yaml:"moniker"`

	// Component The component that owns an error code: the `type` and `name` of its MeshKit `component_info.json`. Codes are unique only within one component.
	Component ErrorComponent `json:"component" yaml:"component"`

	// NumericCode The number at the end of `code`, as a string of digits so leading zeros survive, for example `1033`. MeshKit's `errorutil` allocates it from the component's `component_info.json` and never reuses it.
	NumericCode string `json:"numericCode" yaml:"numericCode"`

	// Severity How severe an error is, as its definition declares. MeshKit's severities map one to one: `Emergency` to `emergency`, `Alert` to `alert`, `Critical` to `critical` and `Fatal` to `fatal`; MeshKit's `None` is an omitted severity. `error`, `warning`, `informational` and `debug` name the less severe levels of the event severity ladder for components that define them. The event that reports an occurrence carries its own `severity`.
	Severity *ErrorSeverity `json:"severity,omitempty" yaml:"severity,omitempty"`

	// ShortDescription One line saying what went wrong, for example `Unable to create UUID instance`. MeshKit's `ShortDescription` lines are joined with `. `. Omitted only for a code whose details the export could not read.
	ShortDescription *string `json:"shortDescription,omitempty" yaml:"shortDescription,omitempty"`

	// LongDescription The full explanation of the error. Omitted when the definition has only text rendered at run time, which MeshKit's `errorutil` cannot export.
	LongDescription *string `json:"longDescription,omitempty" yaml:"longDescription,omitempty"`

	// ProbableCauses What may have caused the error, most likely first, each with the remediations that answer it. Cause ids are unique within the definition. Omitted for a definition that documents no causes, such as a code declared with MeshKit's flat `errors.New`, whose flat lists are then the only record (and are unpaired).
	ProbableCauses *[]ProbableCause `json:"probableCauses,omitempty" yaml:"probableCauses,omitempty"`

	// ProbableCause The flat list of cause descriptions earlier consumers read (MeshKit's `ProbableCause`). When `probableCauses` is present it equals each cause's `description`, in order. Without `probableCauses` it is the definition's only record of its causes, and nothing pairs an entry with an entry of `suggestedRemediation`.
	ProbableCause *[]string `json:"probableCause,omitempty" yaml:"probableCause,omitempty"`

	// SuggestedRemediation The flat list of remediation descriptions earlier consumers read (MeshKit's `SuggestedRemediation`). When `probableCauses` is present it equals every remediation's `description` across the causes, in order, each remediation `id` once (the first time it appears).
	SuggestedRemediation *[]string `json:"suggestedRemediation,omitempty" yaml:"suggestedRemediation,omitempty"`

	// ReferenceURL The stable docs.meshery.io page for this code, for example `https://docs.meshery.io/reference/error-codes/component-meshery-server/errcreatinguuidinstancecode-1001/`. Always present in a published ErrorReferenceIndex; a component's export may omit it, because the docs build assigns it.
	ReferenceURL *string `json:"referenceUrl,omitempty" yaml:"referenceUrl,omitempty"`
}

type ErrorReferenceIndex struct {
	// Errors The definitions, each code once; the published index orders them by `referenceUrl`.
	Errors []ErrorDefinition `json:"errors" yaml:"errors"`

	// GeneratedAt When the docs build generated the index.
	GeneratedAt *time.Time `json:"generatedAt,omitempty" yaml:"generatedAt,omitempty"`

	// SchemaVersion Version of the index format. `2` is this schema, whose entries are ErrorDefinitions. Version `1` was the flat format the docs build first published, whose entries carry `componentType`, `componentName`, `name`, the numeric `code` and the joined `probableCause` and `suggestedRemediation` strings; a reader that meets it reads it as unpaired definitions.
	SchemaVersion ErrorReferenceIndexSchemaVersion `json:"schemaVersion" yaml:"schemaVersion"`
}

type ErrorReferenceIndexSchemaVersion int

type ErrorSeverity string

type ProbableCause struct {
	// Description What may have caused the error, for example `The service is not running.`
	Description string `json:"description" yaml:"description"`

	// ID Stable id of the cause, unique within the error's definition, for example `service-not-running`. An event names the causes that apply to one occurrence by this id (`EventError.matchedCauses`), and the docs page links to it, so it never changes once published. Lowercase words joined by hyphens.
	ID string `json:"id" yaml:"id"`

	// Remediations What answers this cause, the most likely fix first. A remediation that also answers another cause is repeated under that cause with the same `id` and identical fields.
	Remediations []Remediation `json:"remediations" yaml:"remediations"`
}

type Remediation struct {
	// Action Identifier of an action a client can run to apply this remediation, as dot-separated lowercase words, for example `service.start` or `connection.reconnect`. The client that runs it owns its meaning; the definition only names it. Omitted when only a person can apply the remediation.
	Action *string `json:"action,omitempty" yaml:"action,omitempty"`

	// ActionPolicy Whether a client may apply a remediation on its own. `automatic`: the client may run the remediation's `action` without asking and then tells the person it did. `requiresApproval`: the client runs the `action` only after a person approves it. `manual`: a person applies the remediation; a client shows it and never runs anything. An omitted policy is `manual`, and a reader treats a policy it does not know as `manual`, so a remediation is never run by mistake.
	ActionPolicy *ActionPolicy `json:"actionPolicy,omitempty" yaml:"actionPolicy,omitempty"`

	// Description What to do, written for a person, for example `Start the service.`
	Description string `json:"description" yaml:"description"`

	// ID Stable id of the remediation, unique within the error's definition, for example `start-service`. The same id under two causes is one remediation answering both, so its fields must be identical in each place, and the flattened `suggestedRemediation` list carries it once. Lowercase words joined by hyphens.
	ID string `json:"id" yaml:"id"`
}