sdk

type ApplyOption func(*applyOptions)

type Backends struct {
	// KV overrides the KVStore backend for ALL kv bindings ("memory" | a dsn/path override).
	KV string `json:"kv,omitempty"`
	// Blob overrides the Bucket backend for ALL blob bindings ("memory" | "file://…").
	Blob string `json:"blob,omitempty"`
	// Catalog overrides the CatalogService backend for ALL catalog bindings ("file://…", a local DuckLake).
	Catalog string `json:"catalog,omitempty"`
}

type Bindings struct {
	Blob     []v1.FunctionBlob    `json:"blob,omitempty"`
	KV       []v1.FunctionKV      `json:"kv,omitempty"`
	Catalogs []v1.FunctionCatalog `json:"catalogs,omitempty"`
	Links    []v1.FunctionLink    `json:"links,omitempty"`
	Config   []v1.ObjectName      `json:"config,omitempty"`
	Secrets  []v1.ObjectName      `json:"secrets,omitempty"`
}

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

type Contract struct {
	Input  json.RawMessage `json:"input"`
	Output json.RawMessage `json:"output"`
}

type DeleteOption func(*deleteOptions)

type Dev struct {
	// Python is the interpreter `funcdctl dev` launches a python* handler with — a path relative to the
	// manifest dir (e.g. `.venv/bin/python`) or absolute. Lets a project pin its virtualenv (which carries
	// the handler's deps, ADR-0125's local-deps boundary) in the committable manifest instead of the
	// FUNCD_PYTHON env. Precedence: FUNCD_PYTHON env > this > `python3` on PATH. GLOBAL per run (the first
	// function's block is representative, like Backends).
	Python string `json:"python,omitempty"`
	// Node is the interpreter for a nodejs* handler (path relative to the manifest dir, or absolute).
	// Precedence: FUNCD_NODE env > this > `node` on PATH.
	Node string `json:"node,omitempty"`
	// Catalog declares the PROVIDER side of a `catalogs:` binding so `funcdctl dev` can stand the
	// CatalogService up locally, keyed by catalog name (matching a `bindings.catalogs[].catalog`). The
	// consumer binding names WHICH catalog; this block gives dev the storage layout it cannot infer (which
	// buckets/prefixes the DuckLake reads + owns) — the provider analogue of dev.backends. GLOBAL per run
	// (first function that declares a given catalog wins). Empty ⇒ no catalog auto-provisioned.
	Catalog map[string]DevCatalog `json:"catalog,omitempty"`
	// Backends overrides the auto-provisioned backend per kind, GLOBALLY (not per binding). Empty ⇒ the
	// built-in default (memory).
	Backends Backends `json:"backends,omitempty"`
	// Config carries inline ConfigMap values, keyed by ConfigMap name → {key: value}. Non-sensitive and
	// committable (a plain env inject in dev — no ConfigMap CRD on disk).
	Config map[string]map[string]string `json:"config,omitempty"`
	// Secrets carries Secret values keyed by Secret name → key → "${ENV_VAR}". The value is NEVER read
	// from the file — `funcdctl dev` resolves each ${ENV_VAR} from the process environment (a missing var
	// fails fast), so funcdctl.yaml stays committable.
	Secrets map[string]map[string]string `json:"secrets,omitempty"`
}

type DevCatalog struct {
	Blob    []v1.FunctionBlob `json:"blob,omitempty"`
	Catalog v1.CatalogRef     `json:"catalog"`
}

type LogsOptions struct {
	Since    string // logread.SinceForms: a duration ("15m") or a timestamp ("2026-10-07T22:00:00.000Z"); "" ⇒ no lower bound
	Severity string // minimum level (trace|debug|info|warn|error|fatal); "" ⇒ all
	Limit    int    // max records (most-recent); <= 0 ⇒ the server default
	Step     string // RunLogs only (ADR-0106): narrow to one step's function (the --step drill-down); "" ⇒ all
}

type Manifest struct {
	// Runtime is the runtime class (e.g. python314, nodejs22) recorded as the push runtime annotation.
	Runtime v1.RuntimeName `json:"runtime"`
	// Handler is the entrypoint the shim resolves.
	Handler string `json:"handler"`
	// Main is the handler SOURCE FILE, relative to the manifest dir — the wrangler `main` convention
	// (wrangler.toml `main = "src/entry.py"`). Empty ⇒ the default entry co-located with the manifest
	// (handler.py for python*, handler.mjs otherwise, or `<stem>.py`/`<stem>.mjs` for a stem manifest).
	// It lets a `<stem>.funcdctl.yaml` point at a NESTED handler (e.g. functions/extract/handler.py),
	// so an existing per-function layout runs under `funcdctl dev` without flattening.
	Main string `json:"main,omitempty"`
	// Bindings holds blob/kv/catalogs/links/config/secrets — needed to run the function and to type its
	// binding context (GenerateTypes). It is not a deploy field; it describes the capabilities the code uses.
	Bindings Bindings `json:"bindings,omitempty"`
	// Contract is the inline {input, output} JSON Schema; both sides always present (a void side is VoidSchema).
	Contract Contract `json:"contract"`
	// Dev is the funcdctl-dev-only block (ADR-0125): auto-provisioned/globally-overridable backends,
	// inline ConfigMap values, and env-sourced Secret values. It is ADDITIVE and dev-only — `funcdctl
	// push` and `funcdctl types` ignore it entirely (they read only the four fields above), so a
	// funcdctl.yaml carrying a `dev:` block pushes and types identically to one without it.
	Dev Dev `json:"dev,omitempty"`
}

type ManifestDocument struct {
	Number int
	Object v1.Object
}

type Option func(*Client)