transcribe

type CompileError struct {
	Cause       error
	Diagnostics []*Diagnostic
}

type Compiler struct{}

type ContractOptions string

type ContractTypeOverrides struct {
	Input  string
	Output string
}

type CurrentBinding = handlercompiler.CurrentBinding

type Diagnostic struct {
	Code     string   `json:"code"`
	Severity Severity `json:"severity"`
	Message  string   `json:"message"`
	Hint     string   `json:"hint,omitempty"`
	Path     string   `json:"path,omitempty"`
	Span     Span     `json:"span"`
}

type Discovery struct {
	Const *constant.Values
	// Workspace fixes source selection to a Go build when supplied.
	Workspace  *xmodule.Workspace
	BaseDir    string
	ModuleDirs []string
	Include    []string
	// TypeInclude loads package-level type authority without selecting those
	// packages for component discovery or resource loading.
	TypeInclude   []string
	Exclude       []string
	Connector     string
	Types         *typecatalog.Catalog
	ColumnRefiner *column.Refiner
	// Registry is trusted compiled package authority. Selected source descriptors
	// retain linked types so lifecycle methods and typed factories remain executable.
	Registry *x.Registry
	// Holders are build-linked component declarations for the packages selected
	// by Include. They supply concrete Go contracts and factories without init
	// registration; source scanning remains the discovery authority.
	Holders []any
	// RequireLinked rejects source-declared component holders that were not
	// selected by the host's default-import package. Runtime hosts enable it;
	// authoring/transcription may intentionally inspect unlinked source.
	RequireLinked bool
}

type GeneratedPackage struct {
	Result  *gen.Result
	Package *smodel.Package
	Types   *typecatalog.Catalog
}

type GeneratedProject struct {
	Manifest   *ProjectManifest
	Components []*GeneratedPackage
}

type GenerationOptions struct {
	Operation string
	Language  HandlerTarget
}

type GenerationRequest struct {
	Source *Source
	// Compiled accepts the canonical discovery product, including package authority.
	Compiled    *Result
	Destination string
}

type Generator struct {
	Operation          string
	Language           HandlerTarget
	EphemeralOwnership bool
	GenerationPolicy   gen.GenerationPolicy
}

type GoExecution string

type GoHandlerOptions struct {
	Execution   GoExecution
	Factory     string
	Handler     string
	Destination string
}

type HandlerOptions struct {
	Target    HandlerTarget
	Operation WriteOperation
	Input     string
	Output    string
	RootView  string
	Current   string
	Currents  []CurrentBinding
	Table     string
	Key       string
	Hooks     HookOptions
	Go        GoHandlerOptions
	Velty     VeltyHandlerOptions
}

type HandlerTarget string

type HookOptions struct {
	Scaffold    bool
	Destination string
}

type Options struct {
	Contracts ContractOptions
	Handler   HandlerOptions
}

type PackageCompilation struct {
	Source     *Source
	Component  *bootstrap.RouteSource
	InputType  reflect.Type
	OutputType reflect.Type
	Types      *typecatalog.Catalog
	Options    Options
}

type Position struct {
	Offset int `json:"offset"`
	Line   int `json:"line"`
	Char   int `json:"char"`
}

type ProjectComponent struct {
	Key          spec.Key               `json:"key"`
	Source       string                 `json:"source,omitempty"`
	Package      string                 `json:"package"`
	OutputType   string                 `json:"outputType,omitempty"`
	OutputOrigin typecatalog.TypeOrigin `json:"outputOrigin,omitempty"`
	IR           string                 `json:"ir"`
	Diagnostics  string                 `json:"diagnostics"`
	Artifacts    []string               `json:"artifacts"`
	Routes       []ProjectRoute         `json:"routes,omitempty"`
	Dependencies []string               `json:"dependencies,omitempty"`
}

type ProjectGeneration struct {
	Components []*Result
	// Resources is the staged named authority shared by all component sources.
	Resources *resource.Store
}

type ProjectManifest struct {
	Version      int                    `json:"version"`
	Components   []ProjectComponent     `json:"components"`
	Dependencies []string               `json:"dependencies,omitempty"`
	Analysis     ProjectMigrationReport `json:"analysis"`
}

type ProjectMigrationComponent struct {
	Key             spec.Key `json:"key"`
	InputOwnership  string   `json:"inputOwnership"`
	OutputOwnership string   `json:"outputOwnership"`
	GeneratedViews  int      `json:"generatedViews"`
	LinkedViews     int      `json:"linkedViews"`
	Handler         string   `json:"handler"`
}

type ProjectMigrationReport struct {
	Components []ProjectMigrationComponent `json:"components"`
}

type ProjectRoute struct {
	Method string `json:"method"`
	Path   string `json:"path"`
}

type Request struct {
	Component   *bootstrap.RouteSource
	InputType   reflect.Type
	OutputType  reflect.Type
	Source      *Source
	Destination string
	Options     Options
	Generation  GenerationOptions
}

type Result struct {
	Source                *Source
	Component             *spec.Component
	PreparedSQL           string
	Statements            statement.Statements
	SourceMap             *SourceMap
	TypeContext           *typecatalog.ResolutionContext
	TypeResolver          *typecatalog.Resolver
	TypeAuthority         typecatalog.Authority
	Declarations          gen.Declarations
	Contracts             gen.ContractReferences
	Views                 gen.ViewReferences
	ViewBindings          gen.ViewBindings
	GeneratedTypes        []gen.GeneratedTypeReference
	GoHandler             *gen.GoHandlerAsset
	VeltyHandler          *gen.VeltyHandlerAsset
	ContractTypeOverrides ContractTypeOverrides
	Diagnostics           []*Diagnostic
}

type RuntimeContract struct {
	Result     *Result
	Component  *spec.Component
	InputType  reflect.Type
	OutputType reflect.Type
	Resources  *resource.Store
	Types      *typecatalog.Catalog
	Plan       *gen.Plan
}

type SchemaInspection struct {
	Component string   `json:"component"`
	View      string   `json:"view"`
	Connector string   `json:"connector"`
	Table     string   `json:"table,omitempty"`
	Completed []string `json:"completed"`
}

type Severity string

type Source struct {
	Const     *constant.Values
	Scope     string
	Name      string
	Path      string
	Text      string
	Connector string
	// Resources is the Bindly-owned resource authority shared by source
	// expansion, column discovery, and generated-package planning.
	Resources *resource.Store
	Docs      xdocs.Service
	Types     *typecatalog.Catalog
	// ColumnRefiner explicitly enables compile-time SQLX column discovery.
	// A nil refiner keeps ordinary transcription DB-free.
	ColumnRefiner *column.Refiner
	// PackageComponent is optional package-authority canonical metadata used as
	// the base for DQL+package transcription. Authored DQL overlays this graph;
	// ordinary package-only bootstrap does not enter transcribe.
	PackageComponent *spec.Component
	LinkedInputType  reflect.Type
	LinkedOutputType reflect.Type
	LinkedHandler    func() (rhandler.TypedHandler, error)
	// GoHandler is an explicitly accepted custom handler source asset. It is
	// generation input only; canonical metadata retains just its handler name.
	GoHandler *gen.GoHandlerAsset
	// VeltyHandler optionally supplies an accepted template asset. When absent,
	// explicit DQL service programs are transcribed into the same artifact.
	// Runtime state and capabilities remain owned by runtime/handler/velty.
	VeltyHandler *gen.VeltyHandlerAsset
}

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

type Span struct {
	Start Position `json:"start"`
	End   Position `json:"end"`
}

type ValidationReport struct {
	Valid       bool               `json:"valid"`
	Components  []string           `json:"components"`
	Completed   []string           `json:"completed"`
	Skipped     []string           `json:"skipped"`
	Diagnostics []*Diagnostic      `json:"diagnostics,omitempty"`
	Schema      []SchemaInspection `json:"schema,omitempty"`
}

type Validator struct {
	Const      *constant.Values
	BaseDir    string
	ModuleDirs []string
	Include    []string
	Exclude    []string
	// ColumnRefiner explicitly enables database discovery through the existing
	// compiler owner. Nil keeps validation static. Connections remain caller-owned.
	ColumnRefiner *column.Refiner
	Connector     string
}

type VeltyHandlerOptions struct {
	Factory             string
	GoDestination       string
	ResourceDestination string
}

type WriteOperation = handlerast.Operation