pkl

type Checksums struct {
	Sha256 string `pkl:"sha256"`
}

type Class struct {
	// ModuleUri of the Pkl module containing the class.
	// Will be an empty string for values encoded by Pkl versions older than 0.30.
	ModuleUri string

	// Name of the Pkl class.
	// Will be an empty string for values encoded by Pkl versions older than 0.30.
	Name string
}

type DataSize struct {
	// Value is the value of this data size.
	Value float64

	// Unit is the unit of this data size.
	Unit DataSizeUnit
}

type DataSizeUnit int64

type Duration struct {
	Value float64

	Unit DurationUnit
}

type DurationUnit int64

type EvalError struct {
	ErrorOutput string
}

type Evaluator interface {
	// EvaluateModule evaluates the given module, and writes it to the value pointed by
	// out.
	//
	// This method is designed to work with Go modules that have been code generated from Pkl
	// sources.
	EvaluateModule(ctx context.Context, source *ModuleSource, out any) error

	// EvaluateOutputText evaluates the `output.text` property of the given module.
	EvaluateOutputText(ctx context.Context, source *ModuleSource) (string, error)

	// EvaluateOutputBytes evaluates the `output.bytes` property of the given module.
	//
	// Supported on Pkl 0.29 and higher.
	EvaluateOutputBytes(ctx context.Context, source *ModuleSource) ([]byte, error)

	// EvaluateOutputValue evaluates the `output.value` property of the given module,
	// and writes to the value pointed by out.
	EvaluateOutputValue(ctx context.Context, source *ModuleSource, out any) error

	// EvaluateOutputFiles evaluates the `output.files` property of the given module, giving the text of each file.
	EvaluateOutputFiles(ctx context.Context, source *ModuleSource) (map[string]string, error)

	// EvaluateOutputFilesBytes evaluates the `output.files` property of the given module, giving the bytes of each file.
	//
	// Supported on Pkl 0.29 and higher.
	EvaluateOutputFilesBytes(ctx context.Context, source *ModuleSource) (map[string][]byte, error)

	// EvaluateExpression evaluates the provided expression on the given module source, and writes
	// the result into the value pointed by out.
	EvaluateExpression(ctx context.Context, source *ModuleSource, expr string, out any) error

	// EvaluateExpressionRaw evaluates the provided module, and returns the underlying value's raw
	// bytes.
	//
	// This is a low level API.
	EvaluateExpressionRaw(ctx context.Context, source *ModuleSource, expr string) ([]byte, error)

	// Close closes the evaluator and releases any underlying resources.
	Close() error

	// Closed tells if this evaluator is closed.
	Closed() bool
}

type EvaluatorManager interface {
	// Close closes the evaluator manager and all of its evaluators.
	//
	// If running Pkl as a child process, closes all evaluators as well as the child process.
	// If calling into Pkl through the C API, close all existing evaluators.
	Close() error

	// GetVersion returns the version of Pkl backing this evaluator manager.
	GetVersion() (string, error)

	// NewEvaluator constructs an evaluator instance.
	//
	// If calling into Pkl as a child process, the first time NewEvaluator is called, this will
	// start the child process.
	NewEvaluator(ctx context.Context, opts ...func(options *EvaluatorOptions)) (Evaluator, error)

	// NewProjectEvaluator is an easy way to create an evaluator whose project directory is determined
	// by `projectBaseUrl`.
	// It loads the project from the `PklProject` and `PklProject.deps.json` files within `projectBaseUrl`.
	//
	// It is similar to running the `pkl eval` or `pkl test` CLI command with a set `--project-dir`.
	//
	// When using project dependencies, they must first be resolved using the `pkl project resolve`
	// CLI command.
	NewProjectEvaluator(ctx context.Context, projectBaseUrl *url.URL, opts ...func(options *EvaluatorOptions)) (Evaluator, error)
}

type EvaluatorOptions struct {
	// Properties is the set of properties available to the `prop:` resource reader.
	Properties map[string]string

	// Env is the set of environment variables available to the `env:` resource reader.
	Env map[string]string

	// ModulePaths is the set of directories, ZIP archives, or JAR archives to search when
	// resolving `modulepath`: resources and modules.
	//
	// This option must be non-emptyMirror if ModuleReaderModulePath or ResourceModulePath are used.
	ModulePaths []string

	// Logger is the logging interface for messages emitted by the Pkl evaluator.
	Logger Logger

	// OutputFormat controls the renderer to be used when rendering the `output.text`
	// property of a module.
	//
	// The supported built-in values are:
	//   - `"json"`
	//   - `"jsonnet"`
	//   - `"pcf"` (default)
	//   - `"plist"`
	//   - `"properties"`
	//   - `"textproto"`
	//   - `"xml"`
	//   - `"yaml"`
	//   - `"pkl-binary"`
	OutputFormat string

	// AllowedModules defines URI patterns that determine which modules are permitted to be loaded and evaluated.
	// Patterns are regular expressions in the dialect understood by [java.util.regex.Pattern].
	//
	// [java.util.regex.Pattern]: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html
	AllowedModules []string

	// AllowedResources defines URI patterns that determine which resources are permitted to be loaded and evaluated.
	// Patterns are regular expressions in the dialect understood by [java.util.regex.Pattern].
	//
	// [java.util.regex.Pattern]: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html
	AllowedResources []string

	// ResourceReaders are the resource readers to be used by the evaluator.
	ResourceReaders []ResourceReader

	// ModuleReaders are the set of custom module readers to be used by the evaluator.
	ModuleReaders []ModuleReader

	// CacheDir is the directory where `package:` modules are cached.
	//
	// If empty, no caching is performed.
	CacheDir string

	// RootDir is the root directory for file-based reads within a Pkl program.
	//
	// Attempting to read past the root directory is an error.
	RootDir string

	// ProjectBaseURI sets the project base path for the evaluator.
	//
	// Setting this determines how Pkl resolves dependency notation imports.
	// It causes Pkl to look for the resolved dependencies relative to this base URI,
	// and load resolved dependencies from `PklProject.deps.json` within the base path represented.
	//
	// NOTE:
	// Setting this option is not equivalent to setting the `--project-dir` flag from the CLI.
	// When the `--project-dir` flag is set, the CLI will evaluate the PklProject file,
	// and then applies any evaluator settings and dependencies set in the PklProject file
	// for the main evaluation.
	//
	// In contrast, this option only determines how Pkl considers whether files are part of a
	// project.
	// It is meant to be set by lower level logic in Go that first evaluates the PklProject,
	// which then configures EvaluatorOptions accordingly.
	//
	// To emulate the CLI's `--project-dir` flag, create an evaluator with NewProjectEvaluator,
	// or EvaluatorManager.NewProjectEvaluator.
	ProjectBaseURI string

	// DeclaredProjectDependencies is set of dependencies available to modules within ProjectBaseURI.
	//
	// When importing dependencies, a PklProject.deps.json file must exist within ProjectBaseURI
	// that contains the project's resolved dependencies.
	DeclaredProjectDependencies *ProjectDependencies

	// Settings for controlling how Pkl talks over HTTP(S).
	//
	// Added in Pkl 0.26.
	// If the underlying Pkl does not support HTTP options, NewEvaluator will return with an error.
	Http *Http

	// ExternalModuleReaders registers external commands that implement module reader schemes.
	//
	// Added in Pkl 0.27.
	// If the underlying Pkl does not support external readers, evaluation will fail when a registered scheme is used.
	ExternalModuleReaders map[string]ExternalReader

	// ExternalResourceReaders registers external commands that implement resource reader schemes.
	//
	// Added in Pkl 0.27.
	// If the underlying Pkl does not support external readers, evaluation will fail when a registered scheme is used.
	ExternalResourceReaders map[string]ExternalReader

	// TraceMode dictates how Pkl will format messages logged by `trace()`.
	//
	// Added in Pkl 0.30.
	// If the underlying Pkl does not support trace modes, this option will be ignored.
	TraceMode TraceMode
}

type ExternalReader struct {
	Executable string
	Arguments  []string
}

type ExternalReaderClient interface {
	// Run starts the ExternalReaderClient and blocks until the reader is closed by [ExternalReaderClient.Close] or the Pkl evaluator.
	Run() error

	// Close disconnects the ExternalReaderClient from the Pkl evaluator and cleans up any resources.
	Close()
}

type ExternalReaderClientOptions struct {
	// RequestReader is the interface used to read messages from the Pkl evaluator. If omitted, os.Stdin will be used.
	RequestReader io.Reader

	// ResponseWriter is the interface used to send messages to the Pkl evaluator. If omitted, os.Stdout will be used.
	ResponseWriter io.Writer

	// ResourceReaders are the resource readers to be used by the evaluator.
	ResourceReaders []ResourceReader

	// ModuleReaders are the set of custom module readers to be used by the evaluator.
	ModuleReaders []ModuleReader
}

type Http struct {
	// PEM format certificates to trust when making HTTP requests.
	//
	// If empty, Pkl will trust its own built-in certificates.
	CaCertificates []byte

	// Configuration of the HTTP proxy to use.
	//
	// If nil, uses the operating system's proxy configuration.
	Proxy *Proxy

	// HTTP URI rewrite rules.
	//
	// Added in Pkl 0.29.
	// If the underlying Pkl does not support HTTP rewrites, NewEvaluator will return an error.
	//
	// Each key-value pair designates a source prefix to a target prefix.
	// Each rewrite rule must start with `http://` or `https://`, and end with `/`.
	//
	// This option is often used for setting up package mirroring.
	//
	// The following example will rewrite a request https://example.com/foo/bar to https://my.other.website/foo/bar:
	//
	//		Rewrites: map[string]string{
	//			"https://example.com/": "https://my.other.website/"
	//		}
	Rewrites map[string]string
}

type IntSeq struct {
	// Start is the start of this sequence.
	Start int

	// End is the end of this sequence.
	End int

	// Step is the common difference of successive members of this sequence.
	Step int
}

type InternalError struct {
	// contains filtered or unexported fields
}

type Logger interface {
	// Trace logs the given message on level TRACE.
	Trace(message string, frameUri string)

	// Warn logs the given message on level WARN.
	Warn(message string, frameUri string)
}

type ModuleReader interface {
	Reader

	// IsLocal tells if the resources represented by this reader is considered local to the runtime.
	// A local module reader enables resolving triple-dot imports.
	IsLocal() bool

	// Read reads the string contents of this module.
	Read(url url.URL) (string, error)
}

type ModuleSource struct {
	// Uri is the URL of the resource.
	Uri *url.URL

	// Contents is the text contents of the resource, if any.
	//
	// If Contents is empty, it gets resolved by Pkl during evaluation time.
	// If the scheme of the Uri matches a ModuleReader, it will be used to resolve the module.
	Contents string
}

type Object struct {
	// ModuleUri is the URI of the module that holds the definition of this object's class.
	ModuleUri string

	// Name is the qualified name of Pkl object's class.
	//
	// Example:
	//
	// 		"pkl.base#Dynamic"
	Name string

	// Properties is the set of name-value pairs in an Object.
	Properties map[string]any

	// Entries is the set of key-value pairs in an Object.
	Entries map[any]any

	// Elements is the set of items in an Object
	Elements []any
}

type Pair[A any, B any] struct {
	// First is the first element of the pair.
	First A

	// Second is the second element of the pair.
	Second B
}

type PathElement interface {
	// Name is the name of the path element.
	Name() string

	// IsDirectory tells if the path element is a directory.
	IsDirectory() bool
}

type Project struct {
	ProjectFileUri    string                   `pkl:"projectFileUri"`
	Package           *ProjectPackage          `pkl:"package"`
	EvaluatorSettings ProjectEvaluatorSettings `pkl:"evaluatorSettings"`
	Tests             []string                 `pkl:"tests"`
	Annotations       []Object                 `pkl:"annotations"`

	// internal field; use Project.Dependencies instead.
	// values are either Project or ProjectRemoteDependency
	RawDependencies map[string]any `pkl:"dependencies"`
	// contains filtered or unexported fields
}

type ProjectDependencies struct {
	LocalDependencies map[string]*ProjectLocalDependency

	RemoteDependencies map[string]*ProjectRemoteDependency
}

type ProjectEvaluatorSettingExternalReader struct {
	Executable string   `pkl:"executable"`
	Arguments  []string `pkl:"arguments"`
}

type ProjectEvaluatorSettings struct {
	ExternalProperties      map[string]string                                `pkl:"externalProperties"`
	Env                     map[string]string                                `pkl:"env"`
	AllowedModules          *[]string                                        `pkl:"allowedModules"`
	AllowedResources        *[]string                                        `pkl:"allowedResources"`
	NoCache                 *bool                                            `pkl:"noCache"`
	ModulePath              []string                                         `pkl:"modulePath"`
	Timeout                 Duration                                         `pkl:"timeout"`
	ModuleCacheDir          string                                           `pkl:"moduleCacheDir"`
	RootDir                 string                                           `pkl:"rootDir"`
	Http                    *ProjectEvaluatorSettingsHttp                    `pkl:"http"`
	Color                   string                                           `pkl:"color"`
	ExternalModuleReaders   map[string]ProjectEvaluatorSettingExternalReader `pkl:"externalModuleReaders"`
	ExternalResourceReaders map[string]ProjectEvaluatorSettingExternalReader `pkl:"externalResourceReaders"`
	TraceMode               *TraceMode                                       `pkl:"traceMode"`
}

type ProjectEvaluatorSettingsHttp struct {
	Proxy    *ProjectEvaluatorSettingsProxy `pkl:"proxy"`
	Rewrites *map[string]string             `pkl:"rewrites"`
}

type ProjectEvaluatorSettingsProxy struct {
	Address *string   `pkl:"address"`
	NoProxy *[]string `pkl:"noProxy"`
}

type ProjectLocalDependency struct {
	PackageUri string

	ProjectFileUri string

	Dependencies *ProjectDependencies
}

type ProjectPackage struct {
	Name                string   `pkl:"name"`
	BaseUri             string   `pkl:"baseUri"`
	Version             string   `pkl:"version"`
	PackageZipUrl       string   `pkl:"packageZipUrl"`
	Description         string   `pkl:"description"`
	Authors             []string `pkl:"authors"`
	Website             string   `pkl:"website"`
	Documentation       string   `pkl:"documentation"`
	SourceCode          string   `pkl:"sourceCode"`
	SourceCodeUrlScheme string   `pkl:"sourceCodeUrlScheme"`
	License             string   `pkl:"license"`
	LicenseText         string   `pkl:"licenseText"`
	IssueTracker        string   `pkl:"issueTracker"`
	ApiTests            []string `pkl:"apiTests"`
	Exclude             []string `pkl:"exclude"`
	Uri                 string   `pkl:"uri"`
}

type ProjectRemoteDependency struct {
	PackageUri string     `pkl:"uri"`
	Checksums  *Checksums `pkl:"checksums"`
}

type Proxy struct {
	// The proxy to use for HTTP(S) connections.
	//
	// Only HTTP proxies are supported.
	// The address must start with "http://", and cannot contain anything other than a host and an optional port.
	//
	// Example:
	//
	//  	Address: "http://my.proxy.example.com:5080"
	Address string

	// Hosts to which all connections should bypass a proxy.
	//
	// Values can be either hostnames, or IP addresses.
	// IP addresses can optionally be provided using [CIDR notation].
	//
	// The only wildcard is `"*"`, which disables all proxying.
	//
	// A hostname matches all subdomains.
	// For example, `example.com` matches `foo.example.com`, but not `fooexample.com`.
	// A hostname that is prefixed with a dot matches the hostname itself,
	// so `.example.com` matches `example.com`.
	//
	// Optionally, a port can be specified.
	// If a port is omitted, all ports are matched.
	//
	// Example:
	//
	// 		NoProxy: []string{
	//			"127.0.0.1",
	//			"169.254.0.0/16",
	//			"example.com",
	//			"localhost:5050",
	//		}
	//
	// [CIDR notation]: https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation
	NoProxy []string
}

type Reader interface {
	// Scheme returns the scheme part of the URL that this reader can read.
	// The value should be the URI scheme up to (not including) ":"
	Scheme() string

	// IsGlobbable tells if this reader supports globbing via Pkl's `import*` and `glob*` keywords
	IsGlobbable() bool

	// HasHierarchicalUris tells if the URIs handled by this reader are hierarchical.
	// Hierarchical URIs are URIs that have hierarchy elements like host, origin, query, and
	// fragment.
	//
	// A hierarchical URI must start with a "/" in its scheme specific part. For example, consider
	// the following two URIS:
	//
	//   flintstone:/persons/fred.pkl
	//   flintstone:persons/fred.pkl
	//
	// The first URI conveys name "fred.pkl" within parent "/persons/". The second URI
	// conveys the name "persons/fred.pkl" with no hierarchical meaning.
	HasHierarchicalUris() bool

	// ListElements returns the list of elements at a specified path.
	// If HasHierarchicalUris is false, path will be empty and ListElements should return all
	// available values.
	//
	// This method is only called if it is hierarchical and local, or if it is globbable.
	ListElements(url url.URL) ([]PathElement, error)
}

type Regex struct {
	// Pattern is the regex pattern expression in string form.
	Pattern string
}

type ResourceReader interface {
	Reader

	// Read reads the byte contents of this resource.
	Read(url url.URL) ([]byte, error)
}

type TraceMode string

type TypeAlias struct {
	// ModuleUri of the Pkl module containing the typealias.
	// Will be an empty string for values encoded by Pkl versions older than 0.30.
	ModuleUri string

	// Name of the Pkl typealias.
	// Will be an empty string for values encoded by Pkl versions older than 0.30.
	Name string
}