v1beta1

type Combine struct {
	// Variables are the list of variables whose values will be retrieved and
	// combined.
	// +kubebuilder:validation:MinItems=1
	Variables []CombineVariable `json:"variables"`

	// Strategy defines the strategy to use to combine the input variable values.
	// Currently only string is supported.
	// +kubebuilder:validation:Enum=string
	Strategy CombineStrategy `json:"strategy"`

	// String declares that input variables should be combined into a single
	// string, using the relevant settings for formatting purposes.
	// +optional
	String *StringCombine `json:"string,omitempty"`
}

type CombineStrategy string

type CombineVariable struct {
	// FromFieldPath is the path of the field on the source whose value is
	// to be used as input.
	FromFieldPath string `json:"fromFieldPath"`
}

type ComposedPatch struct {
	// Type sets the patching behaviour to be used. Each patch type may require
	// its own fields to be set on the ComposedPatch object.
	// +optional
	// +kubebuilder:validation:Enum=FromCompositeFieldPath;PatchSet;ToCompositeFieldPath;CombineFromComposite;CombineToComposite;FromEnvironmentFieldPath;ToEnvironmentFieldPath;CombineFromEnvironment;CombineToEnvironment
	// +kubebuilder:default=FromCompositeFieldPath
	Type PatchType `json:"type,omitempty"`

	// PatchSetName to include patches from. Required when type is PatchSet.
	// +optional
	PatchSetName *string `json:"patchSetName,omitempty"`

	Patch `json:",inline"`
}

type ComposedTemplate struct {
	// A Name uniquely identifies this entry within its resources array.
	Name string `json:"name"`

	// Base of the composed resource that patches will be applied to and from.
	// If base is omitted, a previous Function within the pipeline must have
	// produced the named composed resource. Patches will be applied to and from
	// that resource. If base is specified, and a previous Function within the
	// pipeline produced the name composed resource, it will be overwritten.
	// +kubebuilder:pruning:PreserveUnknownFields
	// +kubebuilder:validation:EmbeddedResource
	// +optional
	Base *runtime.RawExtension `json:"base,omitempty"`

	// Patches to and from the composed resource.
	// +optional
	Patches []ComposedPatch `json:"patches,omitempty"`

	// ConnectionDetails lists the propagation secret keys from this composed
	// resource to the composition instance connection secret.
	// +optional
	ConnectionDetails []ConnectionDetail `json:"connectionDetails,omitempty"`

	// ReadinessChecks allows users to define custom readiness checks. All
	// checks have to return true in order for resource to be considered ready.
	// The default readiness check is to have the "Ready" condition to be
	// "True".
	// +optional
	// +kubebuilder:default={{type:"MatchCondition",matchCondition:{type:"Ready",status:"True"}}}
	ReadinessChecks []ReadinessCheck `json:"readinessChecks,omitempty"`
}

type ConnectionDetail struct {
	// Name of the connection secret key that will be propagated to the
	// connection secret of the composed resource.
	Name string `json:"name"`

	// Type sets the connection detail fetching behavior to be used. Each
	// connection detail type may require its own fields to be set on the
	// ConnectionDetail object.
	// +kubebuilder:validation:Enum=FromConnectionSecretKey;FromFieldPath;FromValue
	Type ConnectionDetailType `json:"type"`

	// FromConnectionSecretKey is the key that will be used to fetch the value
	// from the composed resource's connection secret.
	// +optional
	FromConnectionSecretKey *string `json:"fromConnectionSecretKey,omitempty"`

	// FromFieldPath is the path of the field on the composed resource whose
	// value to be used as input. Name must be specified if the type is
	// FromFieldPath.
	// +optional
	FromFieldPath *string `json:"fromFieldPath,omitempty"`

	// Value that will be propagated to the connection secret of the composite
	// resource. May be set to inject a fixed, non-sensitive connection secret
	// value, for example a well-known port.
	// +optional
	Value *string `json:"value,omitempty"`
}

type ConnectionDetailType string

type ConvertTransform struct {
	// ToType is the type of the output of this transform.
	// +kubebuilder:validation:Enum=string;int;int64;bool;float64;object;array
	ToType TransformIOType `json:"toType"`

	// The expected input format.
	//
	// * `quantity` - parses the input as a K8s [`resource.Quantity`](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity).
	// Only used during `string -> float64` conversions.
	// * `json` - parses the input as a JSON string.
	// Only used during `string -> object` or `string -> list` conversions.
	//
	// If this property is null, the default conversion is applied.
	//
	// +kubebuilder:validation:Enum=none;quantity;json
	// +kubebuilder:validation:Default=none
	Format *ConvertTransformFormat `json:"format,omitempty"`
}

type ConvertTransformFormat string

type Environment struct {
	// Patches is a list of environment patches that are executed before a
	// composition's resources are composed. These patches are between the XR
	// and the Environment. Either from the Environment to the XR, or vice
	// versa.
	Patches []EnvironmentPatch `json:"patches,omitempty"`
}

type EnvironmentPatch struct {
	// Type sets the patching behaviour to be used. Each patch type may require
	// its own fields to be set on the Patch object.
	// +optional
	// +kubebuilder:validation:Enum=FromCompositeFieldPath;ToCompositeFieldPath;CombineFromComposite;CombineToComposite;FromEnvironmentFieldPath;ToEnvironmentFieldPath
	// +kubebuilder:default=FromCompositeFieldPath
	Type PatchType `json:"type,omitempty"`

	Patch `json:",inline"`
}

type FromFieldPathPolicy string

type MapTransform struct {
	// Pairs is the map that will be used for transform.
	// +optional
	Pairs map[string]extv1.JSON `json:",inline"`
}

type MatchConditionReadinessCheck struct {
	// Type indicates the type of condition you'd like to use.
	// +kubebuilder:default="Ready"
	Type xpv1.ConditionType `json:"type"`

	// Status is the status of the condition you'd like to match.
	// +kubebuilder:default="True"
	Status corev1.ConditionStatus `json:"status"`
}

type MatchFallbackTo string

type MatchTransform struct {
	// The patterns that should be tested against the input string.
	// Patterns are tested in order. The value of the first match is used as
	// result of this transform.
	Patterns []MatchTransformPattern `json:"patterns,omitempty"`

	// The fallback value that should be returned by the transform if now pattern
	// matches.
	FallbackValue extv1.JSON `json:"fallbackValue,omitempty"`
	// Determines to what value the transform should fallback if no pattern matches.
	// +optional
	// +kubebuilder:validation:Enum=Value;Input
	// +kubebuilder:default=Value
	FallbackTo MatchFallbackTo `json:"fallbackTo,omitempty"`
}

type MatchTransformPattern struct {
	// Type specifies how the pattern matches the input.
	//
	// * `literal` - the pattern value has to exactly match (case sensitive) the
	// input string. This is the default.
	//
	// * `regexp` - the pattern treated as a regular expression against
	// which the input string is tested. Crossplane will throw an error if the
	// key is not a valid regexp.
	//
	// +kubebuilder:validation:Enum=literal;regexp
	// +kubebuilder:default=literal
	Type MatchTransformPatternType `json:"type"`

	// Literal exactly matches the input string (case sensitive).
	// Is required if `type` is `literal`.
	Literal *string `json:"literal,omitempty"`

	// Regexp to match against the input string.
	// Is required if `type` is `regexp`.
	Regexp *string `json:"regexp,omitempty"`

	// The value that is used as result of the transform if the pattern matches.
	Result extv1.JSON `json:"result"`
}

type MatchTransformPatternType string

type MathTransform struct {
	// Type of the math transform to be run.
	// +optional
	// +kubebuilder:validation:Enum=Multiply;ClampMin;ClampMax
	// +kubebuilder:default=Multiply
	Type MathTransformType `json:"type,omitempty"`

	// Multiply the value.
	// +optional
	Multiply *int64 `json:"multiply,omitempty"`
	// ClampMin makes sure that the value is not smaller than the given value.
	// +optional
	ClampMin *int64 `json:"clampMin,omitempty"`
	// ClampMax makes sure that the value is not bigger than the given value.
	// +optional
	ClampMax *int64 `json:"clampMax,omitempty"`
}

type MathTransformType string

type Patch struct {
	// FromFieldPath is the path of the field on the resource whose value is
	// to be used as input. Required when type is FromCompositeFieldPath or
	// ToCompositeFieldPath.
	// +optional
	FromFieldPath *string `json:"fromFieldPath,omitempty"`

	// Combine is the patch configuration for a CombineFromComposite,
	// CombineToComposite patch.
	// +optional
	Combine *Combine `json:"combine,omitempty"`

	// ToFieldPath is the path of the field on the resource whose value will
	// be changed with the result of transforms. Leave empty if you'd like to
	// propagate to the same path as fromFieldPath.
	// +optional
	ToFieldPath *string `json:"toFieldPath,omitempty"`

	// Transforms are the list of functions that are used as a FIFO pipe for the
	// input to be transformed.
	// +optional
	Transforms []Transform `json:"transforms,omitempty"`

	// Policy configures the specifics of patching behaviour.
	// +optional
	Policy *PatchPolicy `json:"policy,omitempty"`
}

type PatchPolicy struct {
	// FromFieldPath specifies how to patch from a field path. The default is
	// 'Optional', which means the patch will be a no-op if the specified
	// fromFieldPath does not exist. Use 'Required' to prevent the creation of a
	// new composed resource until the required path exists.
	// +kubebuilder:validation:Enum=Optional;Required
	// +optional
	FromFieldPath *FromFieldPathPolicy `json:"fromFieldPath,omitempty"`

	// ToFieldPath specifies how to patch to a field path. The default is
	// 'Replace', which means the patch will completely replace the target field,
	// or create it if it does not exist. Use 'MergeObjects' to recursively merge the patch
	// object with the target object, while keeping target object keys, but overwriting any array values, or use
	// 'MergeObjectsAppendArrays' to recursively merge the patch object with the target object, while keeping
	// target object keys and appending any array values to target array values, or use
	// 'ForceMergeObjects' to recursively merge the patch object with the target object, overwriting
	// any target object keys, including array values, or use
	// 'ForceMergeObjectsAppendArrays' to recursively merge the patch object with the target object,
	// overwriting target object keys, and appending any array values to target array values.
	// 'MergeObject' is deprecated, use 'MergeObjects' instead, which is functionally identical.
	// 'AppendArray' is deprecated, use 'ForceMergeObjectsAppendArrays' instead, which is functionally identical.
	// +kubebuilder:validation:Enum=Replace;MergeObjects;MergeObjectsAppendArrays;ForceMergeObjects;ForceMergeObjectsAppendArrays;MergeObject;AppendArray
	// +optional
	ToFieldPath *ToFieldPathPolicy `json:"toFieldPath,omitempty"`
}

type PatchSet struct {
	// Name of this PatchSet.
	Name string `json:"name"`

	// Patches will be applied as an overlay to the base resource.
	Patches []PatchSetPatch `json:"patches"`
}

type PatchSetPatch struct {
	// Type sets the patching behaviour to be used. Each patch type may require
	// its own fields to be set on the ComposedPatch object.
	// +optional
	// +kubebuilder:validation:Enum=FromCompositeFieldPath;ToCompositeFieldPath;CombineFromComposite;CombineToComposite;FromEnvironmentFieldPath;ToEnvironmentFieldPath;CombineFromEnvironment;CombineToEnvironment
	// +kubebuilder:default=FromCompositeFieldPath
	Type PatchType `json:"type,omitempty"`

	Patch `json:",inline"`
}

type PatchType string

type ReadinessCheck struct {
	// Type indicates the type of probe you'd like to use.
	// +kubebuilder:validation:Enum="MatchString";"MatchInteger";"NonEmpty";"MatchCondition";"MatchTrue";"MatchFalse";"None"
	Type ReadinessCheckType `json:"type"`

	// FieldPath shows the path of the field whose value will be used.
	// +optional
	FieldPath *string `json:"fieldPath,omitempty"`

	// MatchString is the value you'd like to match if you're using "MatchString" type.
	// +optional
	MatchString *string `json:"matchString,omitempty"`

	// MatchInt is the value you'd like to match if you're using "MatchInt" type.
	// +optional
	MatchInteger *int64 `json:"matchInteger,omitempty"`

	// MatchCondition specifies the condition you'd like to match if you're using "MatchCondition" type.
	// +optional
	MatchCondition *MatchConditionReadinessCheck `json:"matchCondition,omitempty"`
}

type ReadinessCheckType string

type Resources struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// PatchSets define a named set of patches that may be included by any
	// resource. PatchSets cannot themselves refer to other PatchSets.
	// +optional
	PatchSets []PatchSet `json:"patchSets,omitempty"`

	// Environment represents the Composition environment.
	//
	// THIS IS AN ALPHA FIELD.
	// Do not use it in production. It may be changed or removed without notice.
	// +optional
	Environment *Environment `json:"environment,omitempty"`

	// Resources is a list of resource templates that will be used when a
	// composite resource is created.
	Resources []ComposedTemplate `json:"resources"`
}

type StringCombine struct {
	// Format the input using a Go format string. See
	// https://golang.org/pkg/fmt/ for details.
	Format string `json:"fmt"`
}

type StringConversionType string

type StringTransform struct {

	// Type of the string transform to be run.
	// +kubebuilder:validation:Enum=Format;Convert;TrimPrefix;TrimSuffix;Regexp
	// +kubebuilder:default=Format
	Type StringTransformType `json:"type"`

	// Format the input using a Go format string. See
	// https://golang.org/pkg/fmt/ for details.
	// +optional
	Format *string `json:"fmt,omitempty"`

	// Optional conversion method to be specified.
	// `ToUpper` and `ToLower` change the letter case of the input string.
	// `ToBase64` and `FromBase64` perform a base64 conversion based on the input string.
	// `ToJson` converts any input value into its raw JSON representation.
	// `ToSha1`, `ToSha256` and `ToSha512` generate a hash value based on the input
	// converted to JSON.
	// +optional
	// +kubebuilder:validation:Enum=ToUpper;ToLower;ToBase64;FromBase64;ToJson;ToSha1;ToSha256;ToSha512
	Convert *StringConversionType `json:"convert,omitempty"`

	// Trim the prefix or suffix from the input
	// +optional
	Trim *string `json:"trim,omitempty"`

	// Extract a match from the input using a regular expression.
	// +optional
	Regexp *StringTransformRegexp `json:"regexp,omitempty"`

	// Join the input strings.
	// +optional
	Join *StringTransformJoin `json:"join,omitempty"`

	// Search/Replace applied to the input string.
	// +optional
	Replace *StringTransformReplace `json:"replace,omitempty"`
}

type StringTransformJoin struct {
	// Separator to join the input strings.
	Separator string `json:"separator"`
}

type StringTransformRegexp struct {
	// Match string. May optionally include submatches, aka capture groups.
	// See https://pkg.go.dev/regexp/ for details.
	Match string `json:"match"`

	// Group number to match. 0 (the default) matches the entire expression.
	// +optional
	Group *int `json:"group,omitempty"`
}

type StringTransformReplace struct {
	// The Search string to match.
	Search string `json:"search"`

	// The Replace string replaces all occurrences of the search string.
	Replace string `json:"replace"`
}

type StringTransformType string

type ToFieldPathPolicy string

type Transform struct {
	// Type of the transform to be run.
	// +kubebuilder:validation:Enum=map;match;math;string;convert
	Type TransformType `json:"type"`

	// Math is used to transform the input via mathematical operations such as
	// multiplication.
	// +optional
	Math *MathTransform `json:"math,omitempty"`

	// Map uses the input as a key in the given map and returns the value.
	// +optional
	Map *MapTransform `json:"map,omitempty"`

	// Match is a more complex version of Map that matches a list of patterns.
	// +optional
	Match *MatchTransform `json:"match,omitempty"`

	// String is used to transform the input into a string or a different kind
	// of string. Note that the input does not necessarily need to be a string.
	// +optional
	String *StringTransform `json:"string,omitempty"`

	// Convert is used to cast the input into the given output type.
	// +optional
	Convert *ConvertTransform `json:"convert,omitempty"`
}

type TransformIOType string

type TransformType string

type TypeReference struct {
	// APIVersion of the type.
	APIVersion string `json:"apiVersion"`

	// Kind of the type.
	Kind string `json:"kind"`
}