v1

type ConditionApplyConfiguration struct {
	Type    *string                    `json:"type,omitempty"`
	Status  *kptfilev1.ConditionStatus `json:"status,omitempty"`
	Reason  *string                    `json:"reason,omitempty"`
	Message *string                    `json:"message,omitempty"`
}

type FunctionApplyConfiguration struct {
	// `Image` specifies the function container image.
	// It can either be fully qualified, e.g.:
	//
	// image: ghcr.io/kptdev/krm-functions-catalog/set-labels
	//
	// Optionally, kpt can be configured to use a image
	// registry host-path that will be used to resolve the image path in case
	// the image path is missing (Defaults to ghcr.io/kptdev/krm-functions-catalog).
	// e.g. The following resolves to ghcr.io/kptdev/krm-functions-catalog/set-labels
	//
	// image: set-labels
	Image *string `json:"image,omitempty"`
	// Exec specifies the function binary executable.
	// The executable can be fully qualified or it must exists in the $PATH e.g:
	//
	// exec: set-namespace
	// exec: /usr/local/bin/my-custom-fn
	Exec *string `json:"exec,omitempty"`
	// `ConfigPath` specifies a slash-delimited relative path to a file in the current directory
	// containing a KRM resource used as the function config. The function will
	// not see this resource in its input items — it is passed as configuration
	// only. Other functions in the pipeline can still see and modify the file.
	ConfigPath *string `json:"configPath,omitempty"`
	// `ConfigMap` is a convenient way to specify a function config of kind ConfigMap.
	ConfigMap map[string]string `json:"configMap,omitempty"`
	// `ConfigRef` references an existing resource in the package as the function config.
	// The resource is identified by apiVersion, kind, and name. This is mutually exclusive
	// with `configPath` and `configMap`.
	ConfigRef *ResourceReferenceApplyConfiguration `json:"configRef,omitempty"`
	// `Name` is used to uniquely identify the function declaration
	// this is primarily used for merging function declaration with upstream counterparts
	Name *string `json:"name,omitempty"`
	// `Tag` is an optional field for specifying/overriding the tag of the function image.
	// Can be a semver constraint satisfying this spec: https://github.com/Masterminds/semver?tab=readme-ov-file#checking-version-constraints
	Tag *string `json:"tag,omitempty"`
	// `Selectors` are used to specify resources on which the function should be executed
	// if not specified, all resources are selected
	Selectors []SelectorApplyConfiguration `json:"selectors,omitempty"`
	// `Exclude` are used to specify resources on which the function should NOT be executed.
	// If not specified, all resources selected by `Selectors` are selected.
	Exclusions []SelectorApplyConfiguration `json:"exclude,omitempty"`
	// CelCondition is an optional CEL expression (exposed as 'when' in YAML) that determines whether this
	// function should be executed. The expression is evaluated against the list
	// of KRM resources passed to this function step (after `Selectors` and
	// `Exclude` have been applied) and should return a boolean value.
	// If omitted or evaluates to true, the function executes normally.
	// If evaluates to false, the function is skipped.
	//
	// Example: Check if a specific ConfigMap exists among the selected resources:
	// when: "resources.exists(r, r.kind == 'ConfigMap' && r.metadata.name == 'my-config')"
	//
	// Example: Check resource count among the selected resources:
	// when: "resources.filter(r, r.kind == 'Deployment').size() > 0"
	CelCondition *string `json:"when,omitempty"`
}

type GenericLockApplyConfiguration struct {
	// StoreID is a descriptor of the underlying storage type.
	// e.g. 'DB' for database
	StoreID *string `json:"storeID,omitempty"`
	// ResourceID is a unique identifier of the resource.
	// The format depends on the underlying storage.
	ResourceID *string `json:"resourceID,omitempty"`
	// ResourceVersion indicates the last fetched version of the resource.
	// The format depends on the underlying storage.
	ResourceVersion *string `json:"resourceVersion,omitempty"`
}

type GitApplyConfiguration struct {
	// Repo is the git repository the package.
	// e.g. 'https://github.com/kubernetes/examples.git'
	Repo *string `json:"repo,omitempty"`
	// Directory is the sub directory of the git repository.
	// e.g. 'staging/cockroachdb'
	Directory *string `json:"directory,omitempty"`
	// Ref can be a Git branch, tag, or a commit SHA-1.
	Ref *string `json:"ref,omitempty"`
}

type GitLockApplyConfiguration struct {
	// Repo is the git repository that was fetched.
	// e.g. 'https://github.com/kubernetes/examples.git'
	Repo *string `json:"repo,omitempty"`
	// Directory is the sub directory of the git repository that was fetched.
	// e.g. 'staging/cockroachdb'
	Directory *string `json:"directory,omitempty"`
	// Ref can be a Git branch, tag, or a commit SHA-1 that was fetched.
	// e.g. 'master'
	Ref *string `json:"ref,omitempty"`
	// Commit is the SHA-1 for the last fetch of the package.
	// This is set by kpt for bookkeeping purposes.
	Commit *string `json:"commit,omitempty"`
}

type InventoryApplyConfiguration struct {
	// Namespace for the inventory resource.
	Namespace *string `json:"namespace,omitempty"`
	// Name of the inventory resource.
	Name *string `json:"name,omitempty"`
	// Unique label to identify inventory resource in cluster.
	InventoryID *string           `json:"inventoryID,omitempty"`
	Labels      map[string]string `json:"labels,omitempty"`
	Annotations map[string]string `json:"annotations,omitempty"`
}

type LocatorApplyConfiguration struct {
	// Type is the type of origin.
	Type *kptfilev1.OriginType `json:"type,omitempty"`
	// Git is the resolved locator for a package on Git.
	Git *GitLockApplyConfiguration `json:"git,omitempty"`
	// Generic is a minimal locator for a package stored in some generic storage type (e.g.: a database)
	Generic *GenericLockApplyConfiguration `json:"generic,omitempty"`
}

type PackageInfoApplyConfiguration struct {
	// Site is the URL for package web page.
	Site *string `json:"site,omitempty"`
	// Email is the list of emails for the package authors.
	Emails []string `json:"emails,omitempty"`
	// SPDX license identifier (e.g. "Apache-2.0"). See: https://spdx.org/licenses/
	License *string `json:"license,omitempty"`
	// Relative slash-delimited path to the license file (e.g. LICENSE.txt)
	LicenseFile *string `json:"licenseFile,omitempty"`
	// Description contains a short description of the package.
	Description *string `json:"description,omitempty"`
	// Keywords is a list of keywords for this package.
	Keywords []string `json:"keywords,omitempty"`
	// Man is the path to documentation about the package
	Man            *string                           `json:"man,omitempty"`
	ReadinessGates []ReadinessGateApplyConfiguration `json:"readinessGates,omitempty"`
}

type PipelineApplyConfiguration struct {
	// Mutators defines a list of of KRM functions that mutate resources.
	Mutators []FunctionApplyConfiguration `json:"mutators,omitempty"`
	// Validators defines a list of KRM functions that validate resources.
	// Validators are not permitted to mutate resources.
	Validators []FunctionApplyConfiguration `json:"validators,omitempty"`
}

type PipelineStepResultApplyConfiguration struct {
	Name           *string                 `json:"name,omitempty"`
	Image          *string                 `json:"image,omitempty"`
	ExecPath       *string                 `json:"exec,omitempty"`
	ExecutionError *string                 `json:"executionError,omitempty"`
	Stderr         *string                 `json:"stderr,omitempty"`
	ExitCode       *int                    `json:"exitCode,omitempty"`
	Results        []fnresultv1.ResultItem `json:"results,omitempty"`
	ErrorResults   []fnresultv1.ResultItem `json:"errorResults,omitempty"`
	// When is the CEL condition expression that was evaluated
	When *string `json:"when,omitempty"`
	// Skipped indicates if the function was skipped due to a condition
	Skipped *bool `json:"skipped,omitempty"`
}

type ReadinessGateApplyConfiguration struct {
	ConditionType *string `json:"conditionType,omitempty"`
}

type RenderStatusApplyConfiguration struct {
	MutationSteps   []PipelineStepResultApplyConfiguration `json:"mutationSteps,omitempty"`
	ValidationSteps []PipelineStepResultApplyConfiguration `json:"validationSteps,omitempty"`
	ErrorSummary    *string                                `json:"errorSummary,omitempty"`
}

type ResourceReferenceApplyConfiguration struct {
	// APIVersion of the referenced resource (e.g. "v1"). Optional; when omitted,
	// matches resources regardless of apiVersion.
	APIVersion *string `json:"apiVersion,omitempty"`
	// Kind of the referenced resource (e.g. "ConfigMap"). Required.
	Kind *string `json:"kind,omitempty"`
	// Name of the referenced resource. Required.
	Name *string `json:"name,omitempty"`
	// Namespace of the referenced resource. Optional; when omitted, matches
	// resources regardless of namespace.
	Namespace *string `json:"namespace,omitempty"`
}

type SelectorApplyConfiguration struct {
	// APIVersion of the target resources
	APIVersion *string `json:"apiVersion,omitempty"`
	// Kind of the target resources
	Kind *string `json:"kind,omitempty"`
	// Name of the target resources
	Name *string `json:"name,omitempty"`
	// Namespace of the target resources
	Namespace *string `json:"namespace,omitempty"`
	// Labels on the target resources
	Labels map[string]string `json:"labels,omitempty"`
	// Annotations on the target resources
	Annotations map[string]string `json:"annotations,omitempty"`
	// ResourceFileRegexp a regular expression matched against the path of the file
	// containing the resource, relative to the package root. Resources whose file path
	// matches the expression will be selected.
	ResourceFileRegexp *string `json:"resourceFileRegexp,omitempty"`
}

type StatusApplyConfiguration struct {
	Conditions   []ConditionApplyConfiguration   `json:"conditions,omitempty"`
	RenderStatus *RenderStatusApplyConfiguration `json:"renderStatus,omitempty"`
}

type UpstreamApplyConfiguration struct {
	// Type is the type of origin.
	Type *kptfilev1.OriginType `json:"type,omitempty"`
	// Git is the locator for a package stored on Git.
	Git *GitApplyConfiguration `json:"git,omitempty"`
	// UpdateStrategy declares how a package will be updated from upstream.
	UpdateStrategy *kptfilev1.UpdateStrategyType `json:"updateStrategy,omitempty"`
	// PreserveExplicitNull, when true, keeps a field explicitly nulled in the
	// local package during resource-merge instead of deleting it. Only applies
	// to the resource-merge update strategy.
	PreserveExplicitNull *bool `json:"preserveExplicitNull,omitempty"`
}