api

type AttributeDetails struct {
	GetterInvocation  *FunctionInvocation  `json:",omitempty"` // used for matching
	SetterInvocations []FunctionInvocation `json:",omitempty"` // used for matching
	Description       string               `json:",omitempty"` // documentation

}

type AttributeIdentifier struct {
	ResourceInfo
	Path        ResolvedPath `swaggertype:"string"`
	InLiveState bool         `json:",omitempty"`
}

type AttributeInfo struct {
	AttributeIdentifier
	AttributeMetadata
}

type AttributeMetadata struct {
	AttributeName AttributeName     `json:",omitempty" swaggertype:"string"`
	DataType      DataType          `swaggertype:"string"`
	Info          *AttributeDetails `json:",omitempty"`
}

type AttributeName string

type AttributeNameToResourceTypeToPathToVisitorInfoType map[AttributeName]ResourceTypeToPathToVisitorInfoType

type AttributeValue struct {
	AttributeInfo
	Value   any
	Comment string `json:",omitempty"`
	Index   int    // index of the function invocation corresponding to the result
}

type AttributeValueList []AttributeValue

type CustomStringComparator interface {
	// MatchesPath returns true if this comparator should handle the given path
	MatchesPath(path string) bool
	// Evaluate performs the comparison of a value and literal and returns the result
	Evaluate(expr *RelationalExpression, value string) (bool, error)
}

type DataType string

type EmbeddedAccessorType string

type FunctionArgument struct {
	ParameterName string `` /* 133-byte string literal not displayed */
	Value         any    `description:"Argument value; must be a Scalar type, currently string, int, or bool"`
	// DataType is not needed here because it's in the function signature
	Evaluator string `json:",omitempty" description:"Evaluate the provided Value with the specified Evaluator; supported values: template, cel"`
}

type FunctionContext struct {
	// ToolchainType is the ToolchainType of the configuration data and function handlers.
	ToolchainType workerapi.ToolchainType

	// UnitDisplayName is the display name of the configuration Unit.
	UnitDisplayName string

	// UnitSlug is the Slug of the configuration Unit.
	UnitSlug string

	// UnitID is the unique id of the configuration Unit.
	UnitID uuid.UUID

	// UnitLabels contains the labels of the configuration Unit.
	UnitLabels map[string]string

	// UnitAnnotations contains the annotations of the configuration Unit.
	UnitAnnotations map[string]string

	// SpaceID is the id of the Space of the configuration Unit.
	SpaceID uuid.UUID

	// SpaceSlug is the Slug of the Space of the configuration Unit.
	SpaceSlug string

	// OrganizationID is the id of the Organization of the configuration Unit.
	OrganizationID uuid.UUID

	// TargetID of the configuration Unit to determine the target where the function is executed.
	// This field is optional.
	TargetID uuid.UUID

	// BridgeWorkerID is the id of the BridgeWorker that executes the function.
	// This field is optional.
	// If not present, the function is executed by the Internal Function Executor.
	BridgeWorkerID uuid.UUID

	// RevisionID is the unique id of the configuration Revision.
	RevisionID uuid.UUID

	// RevisionNum is the current/previous HeadRevisionNum of the configuration Unit.
	RevisionNum int64

	// New is true if the configuration has never been applied (or has been destroyed).
	New bool

	// PreviousContentHash contains the crc32.ChecksumIEEE of the previous copy of the data,
	// for determining whether it has been changed since it was last written.
	PreviousContentHash RevisionHash

	// Usernames of users that have approved this revision of the configuration data.
	ApprovedBy []string
}

type FunctionIDs struct {
	OrganizationID uuid.UUID `description:"ID of the Unit's Organization"`
	SpaceID        uuid.UUID `description:"ID of the Unit's Space"`
	UnitID         uuid.UUID `description:"ID of the Unit the configuration data is associated with"`
	RevisionID     uuid.UUID `description:"ID of the Revision the configuration data is associated with"`
}

type FunctionInvocation struct {
	FunctionName string             `description:"Function name"`
	Arguments    []FunctionArgument `description:"Function arguments"`
}

type FunctionInvocationList []FunctionInvocation

type FunctionInvocationRequest struct {
	FunctionContext
	ConfigData          []byte                 `swaggertype:"string" format:"byte" description:"Configuration data of the Unit to operate on"`
	LiveState           []byte                 `` /* 169-byte string literal not displayed */
	NumFilters          int                    `description:"Number of validating functions to treat as filters: stop, but don't report errors"`
	StopOnError         bool                   `description:"If true, stop executing functions on the first error"`
	FunctionInvocations FunctionInvocationList `description:"List of functions to invoke and their arguments"`
}

type FunctionInvocationResponse struct {
	FunctionIDs
	FunctionInvocationSuccessResponse
	Success       bool     `description:"True if all functions executed successfully"`
	ErrorMessages []string `description:"Error messages from function execution; will be empty if Success is true"`
}

type FunctionInvocationSuccessResponse struct {
	ConfigData []byte                `swaggertype:"string" format:"byte" description:"The resulting configuration data, potentially mutated"`
	Outputs    map[OutputType][]byte `description:"Map of output types to their corresponding output data as embedded JSON"`
	Mutations  ResourceMutationList  `description:"List of mutations in the same order as the resources in ConfigData"`
	Mutators   []int                 `description:"List of function invocation indices that resulted in mutations"`
}

type FunctionOutput struct {
	ResultName  string     `description:"Name of the result in kabob-case"`
	Description string     `description:"Description of the result"`
	OutputType  OutputType `swaggertype:"string" description:"Data type of the JSON embedded in the output"`
}

type FunctionParameter struct {
	ParameterName string   `description:"Name of the parameter in kabob-case"`
	Description   string   `description:"Description of the parameter"`
	Required      bool     `description:"Whether the parameter is required"`
	DataType      DataType `swaggertype:"string" description:"Data type of the parameter"`
	Example       string   `json:",omitempty" description:"Example value"`
	ValueConstraints
}

type FunctionSignature struct {
	FunctionName          string              `description:"Name of the function in kabob-case"`
	Parameters            []FunctionParameter `description:"Function parameters, in order"`
	RequiredParameters    int                 `description:"Number of required parameters"`
	VarArgs               bool                `description:"Last parameter may be repeated"`
	OutputInfo            *FunctionOutput     `description:"Output description"`
	Mutating              bool                `description:"May change the configuration data"`
	Validating            bool                `description:"Returns ValidationResult"`
	Hermetic              bool                `description:"Does not call other systems"`
	Idempotent            bool                `description:"Will return the same result if invoked again"`
	Description           string              `description:"Description of the function"`
	FunctionType          FunctionType        `swaggertype:"string" description:"Implementation pattern of the function: PathVisitor or Custom"`
	AttributeName         AttributeName       `json:",omitempty" swaggertype:"string" description:"Attribute corresponding to registered paths, if a path visitor; optional"`
	AffectedResourceTypes []ResourceType      `json:",omitempty" description:"Resource types the function applies to; * if all"`
}

type FunctionType string

type ImportFilter struct {
	// Type specifies the filter type (namespace, label, resource_type, etc.)
	Type string `json:",omitempty"`

	// Operator specifies how to apply the filter (include, exclude, equals, contains, matches)
	Operator string `json:",omitempty"`

	// Values specifies the filter values
	Values []string `json:",omitempty"`
}

type ImportOptions map[string]interface{}

type MutationInfo struct {
	MutationType MutationType `` /* 133-byte string literal not displayed */
	Index        int64        `description:"Function index or sequence number corresponding to the change"`
	Predicate    bool         `description:"Used to decide how to use the mututation"`
	Value        string       `description:"Removed configuration data if MutationType is Delete and otherwise the new data"`
}

type MutationMap map[ResolvedPath]MutationInfo

type MutationMapEntry struct {
	Path         ResolvedPath
	MutationInfo *MutationInfo
}

type MutationType string

type OutputType string

type PatchMap map[ResourceTypeAndName]ResourcePatch

type PathToVisitorInfoType map[UnresolvedPath]*PathVisitorInfo

type PathVisitorInfo struct {
	Path                   UnresolvedPath            `swaggertype:"string"`                   // unresolved path pattern
	ResolvedPath           ResolvedPath              `json:",omitempty" swaggertype:"string"` // specific resolved path
	AttributeName          AttributeName             `swaggertype:"string"`                   // AttributeName for the path
	DataType               DataType                  `swaggertype:"string"`                   // DataType of the attribute at the path
	Info                   *AttributeDetails         `json:",omitempty"`                      // additional attribute details
	TypeExceptions         map[ResourceType]struct{} `json:",omitempty"`                      // resource types to skip
	EmbeddedAccessorType   EmbeddedAccessorType      `json:",omitempty" swaggertype:"string"` // embedded accessor to use, if any
	EmbeddedAccessorConfig string                    `json:",omitempty"`                      // configuration of the embedded accessor, if any
}

type RelationalExpression struct {
	Path               string // The path of the left operand, which must be an attribute. During evaluation this is used to trigger custom evaluators.
	Operator           string
	Literal            string
	DataType           DataType
	IsLengthExpression bool // True if this is a LEN(attribute) expression
}

type ResolvedPath string

type Resource struct {
	ResourceInfo
	ResourceBody string `json:",omitempty" description:"Full configuration data of the resource"`
}

type ResourceCategory string

type ResourceCategoryType struct {
	ResourceCategory ResourceCategory
	ResourceType     ResourceType
}

type ResourceInfo struct {
	ResourceName             ResourceName     `` /* 324-byte string literal not displayed */
	ResourceNameWithoutScope ResourceName     `` /* 270-byte string literal not displayed */
	ResourceType             ResourceType     `` /* 217-byte string literal not displayed */
	ResourceCategory         ResourceCategory `` /* 247-byte string literal not displayed */
}

type ResourceInfoList []ResourceInfo

type ResourceList []Resource

type ResourceMutation struct {
	Resource             ResourceInfo              `description:"Identifiers of the resource to which the mutations correspond"`
	ResourceMutationInfo MutationInfo              `description:"Resource-level mutation information, such as for Add, Delete, or Replace"`
	PathMutationMap      MutationMap               `description:"Path-level mutation information; more deeply nested paths override values represented at higher levels"`
	Aliases              map[ResourceName]struct{} `json:",omitempty" description:"Names (with scopes, if any) used in current and prior revisions of this resource"`
	AliasesWithoutScopes map[ResourceName]struct{} `json:",omitempty" description:"Names without scopes used in current and prior revisions of this resource"`
}

type ResourceMutationList []ResourceMutation

type ResourceName string

type ResourcePatch struct {
	Patches yamlpatch.Patch
}

type ResourceType string

type ResourceTypeAndName string

type ResourceTypeToPathToVisitorInfoType map[ResourceType]PathToVisitorInfoType

type RevisionHash int32

type Scalar interface {
	~string | ~int | ~bool
}

type UnresolvedPath string

type ValidationResult struct {
	Passed           bool               // true if valid, false otherwise
	Index            int                // index of the function invocation corresponding to the result
	Details          []string           `json:",omitempty"` // optional list of failure details
	FailedAttributes AttributeValueList `json:",omitempty"` // optional list of failed attributes; preferred over Details
}

type ValidationResultList []ValidationResult

type ValueConstraints struct {
	Regexp     string   `json:",omitempty" description:"Regular expression matching valid values; applies to string parameters"`
	Min        *int     `json:",omitempty" description:"Minimum allowed value; applies to int parameters"`
	Max        *int     `json:",omitempty" description:"Maximum allowed value; applies to int parameters"`
	EnumValues []string `json:",omitempty" description:"List of valid enum values; applies to enum parameters"`
}

type VisitorRelationalExpression struct {
	RelationalExpression
	// Fields for split path feature used by function visitors
	VisitorPath string // Left side of .| for visitor
	SubPath     string // Right side of .| for property check
	IsSplitPath bool   // Whether this uses the .|syntax
}

type YAMLPayload struct {
	Payload string
}