witgo

type CallObserver interface {
	OnCallStart(PluginCallEvent)
	OnCallFinish(PluginCallEvent)
}

type CallbackFuelPolicy func(context.Context, FuelRequest) (FuelDecision, error)

type CapabilityPolicy struct {
	Allow []string
	Deny  []string
}

type CapabilityPolicyError struct {
	Denied []string
}

type CappedFuelAllowance struct {
	MaxGrantPerRequest uint64
	MaxTotalGrant      uint64
	MaxRequestsPerCall uint32
}

type Char rune

type ComponentComposition struct {
	Component    string            `json:"component"`
	Dependencies []CompositionPlug `json:"dependencies,omitempty"`
}

type CompositionPlug struct {
	Interface    string            `json:"interface"`
	Component    string            `json:"component"`
	Dependencies []CompositionPlug `json:"dependencies,omitempty"`
}

type Config struct {
	// WIT is a .wit file or directory. WITMode controls directory traversal.
	WIT string
	// WITFiles is an explicit, ordered-independent set of .wit files. It cannot
	// be combined with WIT and is primarily used by GenerateFiles.
	WITFiles []string
	// WITMode defaults to WITInputAuto for backwards compatibility.
	WITMode WITInputMode
	// GoOverlay is an optional versioned YAML file that changes the public Go
	// representation while preserving the canonical WIT wire types.
	GoOverlay string
	// Output is the directory where generated bindings are written.
	Output string
	// Package is the Go package name. When empty, it is derived from WIT package.
	Package string
	// Filename defaults to bindings.gen.go.
	Filename string
	// EnableRuntimeAPI emits the opt-in witgo:runtime@1.0.0 guest facade and
	// enables its host binding in generated Open functions.
	EnableRuntimeAPI bool
	// Mode selects which side of the component boundary is generated. The zero
	// value is GenerateHost and preserves the historical host SDK.
	Mode GenerationMode
	// World selects the WIT world in guest mode. It may be omitted when the
	// input contains exactly one world.
	World string
	// PackageRoot is the Go import path of Output. Guest bindings use it for
	// the packages generated below Output. When empty it is derived from the
	// nearest go.mod.
	PackageRoot string
	// GuestBindgen is an optional path to wit-bindgen-go. The default searches
	// PATH. It is used only in guest mode.
	GuestBindgen string
}

type Contract struct {
	Imports    []string
	Exports    []string
	Signatures map[string]string
}

type ContractDifference struct {
	Missing    []string
	Unexpected []string
}

type ContractValidationError struct {
	Report ValidationReport
}

type CycleEvent struct{ CallPath []PluginCallFrame }

type DenyFuelRequests struct{}

type ExecutionLimitError struct {
	Function string
	Limit    error
	Cause    error
}

type ExecutionRole string

type FixedFuelAllowance struct{ Grant uint64 }

type FuelDecision struct{ Grant uint64 }

type FuelDenialReason string

type FuelDisabledError struct{ Cause error }

type FuelGrant struct {
	Requested uint64 `json:"requested"`
	Granted   uint64 `json:"granted"`
	Remaining uint64 `json:"remaining"`
}

type FuelRequest struct {
	CallID       string
	ParentCallID string
	PluginID     string
	ProviderID   string
	Interface    string
	Function     string
	CallDepth    int
	Requested    uint64
	Reason       string
	CurrentFuel  uint64
	InitialFuel  uint64
	TotalGranted uint64
	RequestCount uint32
	Deadline     time.Time
}

type FuelRequestError struct {
	PluginID  string
	CallID    string
	Requested uint64
	Reason    FuelDenialReason
	Cause     error
}

type FuelRequestEvent struct {
	Time            time.Time
	CallID          string
	PluginID        string
	CallPath        []PluginCallFrame
	Requested       uint64
	Granted         uint64
	DenialReason    string
	GuestReason     string
	RemainingBefore uint64
	RemainingAfter  uint64
}

type FuelRequestLimits struct {
	Enabled              bool
	MaxGrantPerRequest   uint64
	MaxTotalGrantPerCall uint64
	MaxRequestsPerCall   uint32
	MinRemainingTime     time.Duration
	MaxReasonBytes       int
	PolicyTimeout        time.Duration
}

type FuelRequestPolicy interface {
	DecideFuel(context.Context, FuelRequest) (FuelDecision, error)
}

type GenerationMode uint8

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

type GuestBuildConfig struct {
	// Main is the plugin main package or .go file.
	Main string
	// WITPackage is a WIT package accepted by TinyGo --wit-package. TinyGo
	// accepts a WIT package directory; a packaged .wasm may also be used.
	WITPackage string
	// World is the implemented WIT world.
	World string
	// Output is the resulting component .wasm path.
	Output string
	// TinyGo optionally overrides the tinygo executable path.
	TinyGo string
	// NoDebug removes debug data from the component.
	NoDebug bool
	// Manifest is embedded after a successful build. A nil manifest omits the
	// witgo custom section; an empty non-nil manifest is still embedded.
	Manifest *PluginManifest
}

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

type HandleKind string

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

type HostFunc func(args []any) (any, error)

type HostFuncContext func(ctx context.Context, args []any) (any, error)

type HostImport struct {
	Interface   string
	Function    string
	Call        HostFunc
	CallContext HostFuncContext
}

type HostOptions struct {
	MaxCallDepth      int
	RejectCycles      bool
	CallTimeout       time.Duration
	Observer          CallObserver
	FuelRequestPolicy FuelRequestPolicy
	FuelRequestLimits FuelRequestLimits
	SecurityObserver  RuntimeSecurityObserver
}

type HostPolicy struct {
	Public       PluginGrant
	Plugins      map[string]PluginGrant
	RuntimeAPI   bool
	SearchPaths  []string
	Observer     RuntimeSecurityObserver
	BridgePath   string
	BridgeSHA256 string
}

type InterfaceDescriptor struct {
	ID        string
	Functions map[string]string
}

type LimitEvent struct {
	PluginID, Limit string
	Maximum, Actual uint64
}

type Map[K comparable, V any] map[K]V

type NativeBridgeBackend string

type NestedPluginOptions struct {
	Disabled bool
	// SearchPaths is only a fallback for components without PluginManifest.
	SearchPaths []string
	// AllowedRoots restricts relative dependency paths declared by plugins.
	// The zero value allows only the parent component directory tree.
	AllowedRoots  []string
	MaxCandidates int
	Resolver      NestedPluginResolver
}

type NestedPluginRequest struct {
	Parent    string
	Import    string
	Signature string
}

type NestedPluginResolver func(ctx context.Context, request NestedPluginRequest) (string, error)

type Option[T any] struct {
	Value T
	Some  bool
}

type PerPluginFuelAllowance map[string]FuelRequestPolicy

type Permissions struct {
	All        bool
	System     bool
	Network    bool
	Files      bool
	LoadPlugin bool
	Allow      []string
	Deny       []string
}

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

type PluginBuildConfig struct {
	Generate Config
	Build    GuestBuildConfig
}

type PluginCallContext struct {
	ID       string
	ParentID string
	Depth    int
	Path     []PluginCallFrame
	Deadline time.Time
}

type PluginCallError struct {
	Consumer string
	Provider string
	Frame    PluginCallFrame
	Path     []PluginCallFrame
	Cause    error
}

type PluginCallEvent struct {
	CallID       string
	ParentCallID string
	Depth        int
	Consumer     string
	Provider     string
	Interface    string
	Function     string
	Path         []PluginCallFrame
	Started      time.Time
	Duration     time.Duration
	Err          error
}

type PluginCallFrame struct {
	Plugin    string
	Interface string
	Function  string
}

type PluginDependencyError struct {
	Consumer  string
	Provider  string
	Interface string
	Report    ValidationReport
	CallPath  []PluginCallFrame
}

type PluginGrant struct {
	Permissions Permissions
	Limits      PluginLimits
	// AllowedPluginRoots bounds components loaded through a plugin manifest.
	AllowedPluginRoots []string
}

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

type PluginLimits struct {
	Fuel             uint64
	FuelPerCall      uint64
	Timeout          time.Duration
	MemoryLimitBytes int64
	MaxResultBytes   uint64
	InstanceLimit    int64
	ValueLimits      ValueLimits
	FuelRequests     FuelRequestLimits
	FuelPolicy       FuelRequestPolicy
}

type PluginManifest struct {
	Dependencies map[string]string `json:"dependencies,omitempty"`
}

type ProviderCall func(context.Context, string, []any) (any, error)

type ProviderEvent struct {
	PluginID, ProviderID, Interface string
	Reason                          string
}

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

type RegisterOption func(*RegisterOptions)

type RegisterOptions struct {
	Owned       bool
	Close       func() error
	Composition ComponentComposition
}

type Result[T, E any] struct {
	// contains filtered or unexported fields
}

type Runtime struct {
	Kind iwasm.Kind
	// contains filtered or unexported fields
}

type RuntimeCallInfo struct {
	CallID            string         `json:"call-id"`
	ParentCallID      Option[string] `json:"parent-call-id"`
	Depth             uint32         `json:"depth"`
	PluginID          string         `json:"plugin-id"`
	DeadlineUnixNanos Option[int64]  `json:"deadline-unix-nanos"`
}

type RuntimeFuelInfo struct {
	Enabled   bool           `json:"enabled"`
	Remaining Option[uint64] `json:"remaining"`
	Initial   Option[uint64] `json:"initial"`
	Consumed  Option[uint64] `json:"consumed"`
	PerCall   bool           `json:"per-call"`
}

type RuntimeLimitError struct {
	Limit   string
	Maximum uint64
	Actual  uint64
	Cause   error
}

type RuntimeLimits struct {
	MaxCallDepth       uint32         `json:"max-call-depth"`
	RemainingCallDepth uint32         `json:"remaining-call-depth"`
	MemoryLimitBytes   Option[uint64] `json:"memory-limit-bytes"`
	MaxMessageBytes    Option[uint64] `json:"max-message-bytes"`
	DeadlineUnixNanos  Option[int64]  `json:"deadline-unix-nanos"`
}

type RuntimeOptions struct {
	Fuel             uint64
	FuelPerCall      uint64
	Timeout          time.Duration
	MemoryLimitBytes int64
	MaxResultBytes   uint64
	InstanceLimit    int64
	// EnableRuntimeAPI binds the versioned witgo:runtime/runtime@1.0.0 vendor
	// capability. Read-only queries are safe; additional fuel remains default-deny.
	EnableRuntimeAPI bool
	// PluginID is the sanitized logical identity reported by RuntimeSystem.
	// It must not contain a path or secret. The zero value is "plugin".
	PluginID string
	// Fuel request settings are used when no CompositionHost is attached.
	FuelRequestPolicy FuelRequestPolicy
	FuelRequestLimits FuelRequestLimits
	SecurityObserver  RuntimeSecurityObserver
	ValueLimits       ValueLimits
	// BridgePath overrides the bundled library and WITGO_COMPONENT_LIBRARY.
	BridgePath string
	// BridgeSHA256 verifies BridgePath before loading. It is required when a
	// custom bridge is supplied in security-sensitive deployments.
	BridgeSHA256 string
	// DisableEmbeddedBridge prevents extraction or loading of the library
	// shipped with witgo. Set BridgePath to use an administrator-managed library.
	DisableEmbeddedBridge bool
	// Capabilities restricts which host import functions a component may require.
	// Zero value allows everything.
	Capabilities CapabilityPolicy
	// NestedPlugins controls automatic resolution of missing imports through
	// exports of sibling Component Model plugins. The zero value enables it.
	NestedPlugins NestedPluginOptions
	// PluginHost centralizes nested-plugin discovery policy. Every top-level
	// load still creates an independent box of runtime instances.
	PluginHost *PluginHost
	// CompositionHost enables transparent registered-provider routing and call
	// chain protection for this runtime.
	CompositionHost *Host
	// CompositionPlugs are exact provider edges encoded into one Component
	// Model component and instantiated in the same Store. Generated bindings
	// populate this field; ordinary applications should use their typed helpers.
	CompositionPlugs []CompositionPlug
}

type RuntimeSecurityObserver interface {
	OnFuelRequest(FuelRequestEvent)
	OnCycleRejected(CycleEvent)
	OnLimitExceeded(LimitEvent)
	OnProviderRejected(ProviderEvent)
}

type SignatureMismatch struct {
	Function string
	Expected string
	Actual   string
}

type Tuple []any

type Tuple0 struct{}

type Tuple1[A any] struct{ V0 A }

type Tuple2[A, B any] struct {
	V0 A
	V1 B
}

type Tuple3[A, B, C any] struct {
	V0 A
	V1 B
	V2 C
}

type Tuple4[A, B, C, D any] struct {
	V0 A
	V1 B
	V2 C
	V3 D
}

type Tuple5[A, B, C, D, E any] struct {
	V0 A
	V1 B
	V2 C
	V3 D
	V4 E
}

type Tuple6[A, B, C, D, E, F any] struct {
	V0 A
	V1 B
	V2 C
	V3 D
	V4 E
	V5 F
}

type Tuple7[A, B, C, D, E, F, G any] struct {
	V0 A
	V1 B
	V2 C
	V3 D
	V4 E
	V5 F
	V6 G
}

type Tuple8[A, B, C, D, E, F, G, H any] struct {
	V0 A
	V1 B
	V2 C
	V3 D
	V4 E
	V5 F
	V6 G
	V7 H
}

type Tuple9[A, B, C, D, E, F, G, H, I any] struct {
	V0 A
	V1 B
	V2 C
	V3 D
	V4 E
	V5 F
	V6 G
	V7 H
	V8 I
}

type Tuple10[A, B, C, D, E, F, G, H, I, J any] struct {
	V0 A
	V1 B
	V2 C
	V3 D
	V4 E
	V5 F
	V6 G
	V7 H
	V8 I
	V9 J
}

type Tuple11[A, B, C, D, E, F, G, H, I, J, K any] struct {
	V0  A
	V1  B
	V2  C
	V3  D
	V4  E
	V5  F
	V6  G
	V7  H
	V8  I
	V9  J
	V10 K
}

type Tuple12[A, B, C, D, E, F, G, H, I, J, K, L any] struct {
	V0  A
	V1  B
	V2  C
	V3  D
	V4  E
	V5  F
	V6  G
	V7  H
	V8  I
	V9  J
	V10 K
	V11 L
}

type Tuple13[A, B, C, D, E, F, G, H, I, J, K, L, M any] struct {
	V0  A
	V1  B
	V2  C
	V3  D
	V4  E
	V5  F
	V6  G
	V7  H
	V8  I
	V9  J
	V10 K
	V11 L
	V12 M
}

type Tuple14[A, B, C, D, E, F, G, H, I, J, K, L, M, N any] struct {
	V0  A
	V1  B
	V2  C
	V3  D
	V4  E
	V5  F
	V6  G
	V7  H
	V8  I
	V9  J
	V10 K
	V11 L
	V12 M
	V13 N
}

type Tuple15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O any] struct {
	V0  A
	V1  B
	V2  C
	V3  D
	V4  E
	V5  F
	V6  G
	V7  H
	V8  I
	V9  J
	V10 K
	V11 L
	V12 M
	V13 N
	V14 O
}

type Tuple16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P any] struct {
	V0  A
	V1  B
	V2  C
	V3  D
	V4  E
	V5  F
	V6  G
	V7  H
	V8  I
	V9  J
	V10 K
	V11 L
	V12 M
	V13 N
	V14 O
	V15 P
}

type TypeCodec[Wire, Go any] interface {
	Encode(Go) (Wire, error)
	Decode(Wire) (Go, error)
}

type TypeCodecFuncs[Wire, Go any] struct {
	EncodeFunc func(Go) (Wire, error)
	DecodeFunc func(Wire) (Go, error)
}

type Unit struct{}

type ValidationReport struct {
	Compatible bool
	Expected   Contract
	Actual     Contract
	Imports    ContractDifference
	Exports    ContractDifference
	Signatures []SignatureMismatch
}

type ValueLimits struct {
	MaxArgumentBytes uint64
	MaxResultBytes   uint64
	MaxCollectionLen uint64
	MaxValueDepth    uint32
	MaxStringBytes   uint64
}

type WITError[E any] struct {
	Value E
}

type WITInputMode uint8