view

type Accessor struct {
	// GoName is the method name (e.g. "AsChunkSize").
	GoName string
	// Offset is the byte offset within the backing array.
	Offset int
	// GoType is the type a plain reinterpret accessor returns (empty for a
	// function-pointer accessor).
	GoType string
	// FuncType, when non-empty, is the Go func type ("func(unsafe.Pointer) int32")
	// a function-pointer accessor returns, bound via purego.RegisterFunc.
	FuncType string
	// Field is the original C field name, for the method's doc comment.
	Field string
}

type AsyncMethod struct {
	// DocComment is the rendered doc comment block, or empty.
	DocComment string
	// Recv is the receiver clause "(x *Type) " or "" for a class function.
	Recv string
	// GoName is the exported Go method name.
	GoName string
	// ParamStr is the signature parameter list (always begins with
	// "ctx context.Context").
	ParamStr string
	// HasResult is true when the block carries one non-error value, so the
	// wrapper returns (ResultGoType, error) instead of plain error.
	HasResult bool
	// ResultGoType is the wrapped Go result type (set only when HasResult).
	ResultGoType string
	// ClosureParams are the completion block's Go parameter declarations, in
	// order (for example "_p0 objc.ID").
	ClosureParams []string
	// SendCall is the objc.Send expression that hands the block to Objective-C
	// (it references the local _block); an expression, not a declaration.
	SendCall string
	// ErrConvExpr is the right-hand side that converts the block's NSError
	// parameter to a Go error, or "" when the block has no error parameter.
	ErrConvExpr string
	// ResultConvExpr is the right-hand side that converts the block's result
	// parameter to ResultGoType (set only when HasResult).
	ResultConvExpr string
	// KeepAlive names the receiver and object-typed parameters kept alive until
	// the method returns (see Method.KeepAlive).
	KeepAlive []string
}

type BoolNSErrorMethod struct {
	// DocComment is the rendered doc comment block, or empty.
	DocComment string
	// Recv is the receiver clause "(x *Type) " or "".
	Recv string
	// GoName is the exported Go method name.
	GoName string
	// RecvExpr is the object the Objective-C call is sent to.
	RecvExpr string
	// Selector is the Objective-C selector being sent.
	Selector string
	// MainThread runs the Objective-C call on the main thread (purego.Main) when
	// the selector is @MainActor-isolated.
	MainThread bool
	// KeepAlive names the receiver kept alive until the method returns (see
	// Method.KeepAlive).
	KeepAlive []string
}

type ByteArrayStruct struct {
	// Doc is the one-line comment describing the struct; empty when none.
	Doc string
	// GoName is the exported struct type name.
	GoName string
	// Size is the total backing-array size in bytes (the authoritative C size).
	Size int
	// AlignElem, when non-empty, is the Go type of a leading zero-size field
	// (`_ [0]<AlignElem>`) that forces the backing struct's alignment to match C.
	// Empty for a packed struct (C alignment 1 = Go [N]byte alignment 1).
	AlignElem string
	// Accessors are the typed field views over the backing bytes.
	Accessors []Accessor
}

type ConstKind string

type Constant struct {
	// GoName is the exported Go accessor name.
	GoName string
	// ExternName is the underlying framework symbol whose address is read.
	ExternName string
	// CommentBlock is the rendered doc comment (already "// …\n"), or empty.
	CommentBlock string
	// Kind selects how the symbol's value is produced and typed.
	Kind ConstKind
	// GoTypeName is the resolved Go return type: the wrapper type name for
	// ConstObjcClass, or the value type (a scalar, enum, or value struct) for
	// ConstValue.
	GoTypeName string
	// Zero is the zero-value literal returned when the symbol is missing; set only
	// for ConstValue (e.g. "0", "corefoundation.CGPoint{}").
	Zero string
}

type Delegate struct {
	// DocComment is the rendered doc comment for the interface type.
	DocComment string
	// IfaceName is the Go interface name (VirtualMachineDelegate).
	IfaceName string
	// ProtocolName is the Objective-C protocol (VZVirtualMachineDelegate).
	ProtocolName string
	// ShimClassName is the runtime-registered Objective-C class name; globally
	// unique (GoShimVirtualizationVirtualMachineDelegate).
	ShimClassName string
	// ShimFuncName is the unexported builder that wraps a Go value
	// (newVirtualMachineDelegateShim).
	ShimFuncName string
	// ClassVar is the package-level variable base holding the registered class
	// and its sync.Once (_virtualMachineDelegateShimClass).
	ClassVar string
	// Required are the protocol's required methods — the interface's method
	// set. Optional are the @optional methods, each carried by its own
	// one-method upgrade interface.
	Required []DelegateMethod
	Optional []DelegateMethod
}

type DelegateMethod struct {
	// DocComment is the rendered doc line(s) for the interface method (already
	// "// "-prefixed, trailing newline), or empty.
	DocComment string
	// OptionalDoc is the rendered doc comment for an optional method's upgrade
	// interface type (empty for required methods).
	OptionalDoc string
	// OptIfaceName is the one-method upgrade interface for an optional method
	// (VirtualMachineDelegateGuestDidStopHandler); empty for required methods.
	OptIfaceName string
	// GoName is the Go method name.
	GoName string
	// Selector is the Objective-C selector this method answers.
	Selector string
	// SigParams is the Go interface signature parameter list.
	SigParams string
	// RetSig is the Go return clause (" bool", "" for void).
	RetSig string
	// AssertIface is the interface the callback type-asserts shim.Value to —
	// the delegate interface for required methods, OptIfaceName for optional.
	AssertIface string
	// ABIParams are the callback's parameter declarations after (self, _cmd),
	// in order ("_p0 objc.ID", "_p1 int").
	ABIParams []string
	// ABIRet is the callback's return type ("" for void).
	ABIRet string
	// CallArgs are the converted argument expressions passed to the Go method,
	// parallel to the interface signature.
	CallArgs []string
	// RetExpr converts the Go method call's result into the callback's return
	// value (set only when RetSig is non-empty); it embeds the full
	// _h.<GoName>(…) call.
	RetExpr string
	// RetZero is the callback's zero return when the Go value does not
	// implement the method (set only when RetSig is non-empty).
	RetZero string
}

type Dispatch struct {
	// Guards are pre-call statements rendered first as early returns or panics
	// (for example a bounds check before an index accessor); empty for most
	// methods.
	Guards []string
	// Call is the Objective-C call expression, already marshaled
	// (objc.Send[T](recv, sel, args…)); it is an expression, not a declaration.
	Call string
	// Error is true when the selector took a trailing NSError**: the body then
	// emits the `if _nsErr != 0` early return and a trailing nil on success.
	Error bool
	// RetKind selects how Call's result is converted back to Go.
	RetKind RetKind
	// RetWrap is the conversion expression for an object/array result, with one
	// %s placeholder for the raw result pointer (empty for other kinds).
	RetWrap string
	// RetZero is the zero literal returned on the error path before the error
	// (empty for void).
	RetZero string
	// Outs are value out-parameters lifted from the signature into extra return
	// values, in declaration order.
	Outs []DispatchOut
}

type DispatchOut struct {
	// GoName is the local variable / return name.
	GoName string
	// GoType is the out-parameter's Go type.
	GoType string
	// Zero is the type's zero literal for the error-path return.
	Zero string
}

type Enum struct {
	// GoName is the de-prefixed exported Go type name (VZVirtualMachineState ->
	// VirtualMachineState).
	GoName string
	// GoType is the underlying integer type (for example int64 or uint).
	GoType string
	// IsBitmask is true when the values are option flags meant to be combined
	// with |, which selects the bitwise String rendering.
	IsBitmask bool
	// CommentBlock is the fully-rendered doc + deprecation comment for the type,
	// already prefixed with "// " on every line (empty when undocumented).
	CommentBlock string
	// Members are the enum constants in declaration order, deduplicated by
	// (name, value); they populate the const block.
	Members []EnumMember
	// UniqueMembers are the members deduplicated by value alone; they populate
	// the non-bitmask String switch so two names for one value do not produce a
	// duplicate case.
	UniqueMembers []EnumMember
	// DefaultFmt is the fmt verb string for the String default branch (for
	// example "VirtualMachineState(%d)").
	DefaultFmt string
}

type EnumMember struct {
	// ConstName is the de-prefixed exported constant name.
	ConstName string
	// Value is the integer value as a Go literal string.
	Value string
	// CommentBlock is the rendered doc + deprecation comment for the member,
	// indented inside the const block (empty when undocumented).
	CommentBlock string
	// IsZeroVal is true when Value is "0"; the bitmask String rendering skips
	// zero-valued members because they contribute no flag bit.
	IsZeroVal bool
}

type ErrorSentinel struct {
	// GoName is the exported sentinel variable name (for example ErrInternalError).
	GoName string
	// CommentBlock is the rendered doc comment (already "// …\n").
	CommentBlock string
	// Domain is the NSError domain string the framework reports.
	Domain string
	// Code is the integer error code as a Go literal string.
	Code string
}

type Field struct {
	// GoName is the exported field name.
	GoName string
	// GoType is the field's resolved Go type (a primitive or another value
	// struct in the same package).
	GoType string
}

type Func struct {
	// GoName is the exported Go function name.
	GoName string
	// CName is the underlying C symbol bound via RegisterLibFunc.
	CName string
	// VarName is the package-level bound-function variable (for example _fnFoo).
	VarName string
	// CommentLine is the rendered doc comment line (already "// …\n").
	CommentLine string
	// CommentFirst places CommentLine before the bound-function variable rather
	// than before the func declaration. The CFErrorRef wrappers document the var;
	// the generic and OSStatus wrappers document the func.
	CommentFirst bool
	// ABIParams are the C ABI parameter types for the bound-function variable.
	ABIParams []string
	// ABIRet is the C ABI return type ("" for void).
	ABIRet string
	// SigParams are the Go signature parameters ("name Type").
	SigParams []string
	// RetSig is the Go return clause, including a leading space when non-empty
	// (" error", " (obj.Object, error)", " int", "").
	RetSig string
	// Kind selects the body tail.
	Kind FuncKind
	// PreLines are statements emitted after the bind prologue and before the call
	// (out-parameter declarations, or a CFErrorRef holder).
	PreLines []string
	// Call is the bound-function call expression (for example _fnFoo(a, b)).
	Call string
	// Wrap is the object-result conversion template (one %s); used by FuncObject.
	Wrap string
	// Outs are pointer out-parameters lifted from the signature into extra return
	// values, in declaration order. When non-empty the body renders var decls for
	// each, passes &local to the call, and returns the function's own result (per
	// Kind) followed by each out value; RetSig is then the parenthesised tuple.
	Outs []DispatchOut
	// FailRet is the error-path return list for FuncOSStatus and FuncStatusCode.
	FailRet string
	// OkRet is the success return list for FuncOSStatus and FuncStatusCode.
	OkRet string
	// Fail is the failure condition for FuncCFErrorBool (for example "!_ok").
	Fail string
	// ErrExpr converts the bound call's status-code result (_rc) into a Go
	// error for FuncStatusCode (for example
	// errkit.FromCode("HypervisorReturnDomain", int64(_rc), 0)).
	ErrExpr string
}

type FuncKind int

type HandleType struct {
	// Doc is the one-line comment describing the handle type; empty when none.
	Doc string
	// GoName is the exported handle type name (e.g. "CFArrayRef").
	GoName string
	// ImmutableType, when non-empty, is the immutable counterpart type name of a
	// CFMutable<X>Ref handle (e.g. "CFArrayRef" for "CFMutableArrayRef"); the
	// generated ImmutableMethod converts to it. In C a mutable ref IS-A immutable
	// ref, a subtyping the distinct Go types lose, so this restores the widening.
	ImmutableType string
	// ImmutableMethod is the conversion method name (e.g. "AsArray").
	ImmutableMethod string
}

type Method struct {
	// DocComment is the fully-rendered doc comment block (already "// "-prefixed,
	// trailing newline), or empty when undocumented.
	DocComment string
	// Recv is the receiver clause "(x *Type) " for an instance method, or "" for
	// a package-level class function.
	Recv string
	// GoName is the exported Go method name.
	GoName string
	// ParamStr is the rendered signature parameter list (out-parameters omitted).
	ParamStr string
	// RetSig is the rendered return clause: "", " T", or " (T, error)".
	RetSig string
	// Dispatch is the method body (call + result/error/out-parameter handling).
	Dispatch Dispatch

	// MainThread is set when the underlying selector is @MainActor-isolated: the
	// template runs the body on the main thread via purego.Main. The body
	// sub-template is reused verbatim — it is lifted into an inner closure whose
	// results are captured into RetVars (declared with RetTypes) and returned.
	MainThread bool
	// RetVars are the names of the captured-return locals ("_mainthread0", …),
	// one per return value; empty for a void method. Parallel to RetTypes.
	RetVars []string
	// RetTypes are the Go types of each captured-return local, parallel to
	// RetVars, used only to declare them before the purego.Main call.
	RetTypes []string

	// KeepAlive names the receiver and object-typed parameters whose wrappers
	// must outlive the Objective-C call: their pointer is read before the send,
	// and without a keep-alive the collector could finalize (and release) the
	// object mid-call. The template renders one defer runtime.KeepAlive per
	// name at the top of the body.
	KeepAlive []string
}

type Protocol struct {
	// Doc is the one-line interface comment; empty when none.
	Doc string
	// GoName is the exported Go interface name.
	GoName string
	// Methods are the interface methods (name + full signature).
	Methods []ProtocolMethod
}

type ProtocolMethod struct {
	// GoName is the exported method name.
	GoName string
	// Signature is the method's parenthesised parameter list plus return clause,
	// e.g. "(index uint) obj.Object".
	Signature string
}

type RetKind int

type SliceMethod struct {
	// DocComment is the rendered doc comment block, or empty.
	DocComment string
	// Recv is the receiver clause "(x *Type) " or "".
	Recv string
	// GoName is the exported Go method name.
	GoName string
	// RecvExpr is the object the Objective-C call is sent to.
	RecvExpr string
	// Selector is the Objective-C selector being sent.
	Selector string
	// ElemGoType is the slice element's Go type.
	ElemGoType string
	// HasError is true when the underlying getter reports an NSError, so the
	// wrapper returns ([]T, error).
	HasError bool
	// ConvClosure is the per-element conversion closure expression
	// (func(_id objc.ID) T { return … }).
	ConvClosure string
	// MainThread runs the Objective-C call on the main thread (purego.Main) when
	// the selector is @MainActor-isolated.
	MainThread bool
	// KeepAlive names the receiver kept alive until the method returns (see
	// Method.KeepAlive).
	KeepAlive []string
}

type Struct struct {
	// GoName is the exported Go type name.
	GoName string
	// Doc is the documentation prose, already cleaned of HeaderDoc/Doxygen tags;
	// empty when the symbol has no documentation.
	Doc string
	// Fields are the struct's fields, in declaration order.
	Fields []Field
	// IsOpaque marks a struct the C headers declare with no members (e.g. NSZone).
	// It renders as `struct{}`, matching the raw layer, so callers can still name
	// and pass a pointer to it. A struct whose members all happen to be skipped
	// (private bitfields) is NOT opaque — it renders with an empty body.
	IsOpaque bool
}

type TypedefAlias struct {
	// Doc is the one-line comment describing the alias; empty when none.
	Doc string
	// GoName is the exported alias name.
	GoName string
	// RHS is the aliased type expression.
	RHS string
}