api

type AppendedWebhook struct {
	Slug     string
	Body     []byte
	Headers  map[string]string
	SourceIP string
}

type Area struct {
	ID          string
	DisplayName string
	ParentID    string
}

type AreaReader interface {
	ListAreas(ctx context.Context, page PageReq) ([]Area, Cursor, error)
	GetArea(ctx context.Context, id string) (Area, error)
}

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

type AuthDeps struct {
	Identity   *identity.Store
	Password   *credentials.Password
	Tokens     *credentials.Tokens
	Sessions   *sessions.Store
	Enrollment *credentials.Enrollment
	Throttle   *throttle.Throttle
	Audit      *audit.Recorder
	Policy     *policy.Runtime
	Metrics    *observability.Metrics
}

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

type Automation struct {
	ID, DisplayName, Mode string
	Enabled               bool
	InFlight              uint32
}

type AutomationControl interface {
	List(ctx context.Context, page PageReq) ([]Automation, Cursor, error)
	Get(ctx context.Context, id string) (Automation, error)
	SetEnabled(ctx context.Context, id string, enabled bool, actor string) (Automation, error)
	Trigger(ctx context.Context, id, actor string) (runID string, err error)
	Trace(ctx context.Context, automationID, runID string, fromCursor uint64) (<-chan TraceEvent, func(), error)
}

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

type CapabilityCaller interface {
	// Call dispatches the capability invocation through the carport supervisor;
	// blocks until the driver acks or ctx is cancelled. Returns the command's
	// correlation id (the CommandIssued event id) on success.
	Call(ctx context.Context, entityID, capability string, params map[string]any) (correlationID string, err error)
}

type ConfigApplier interface {
	Validate(ctx context.Context, pklBundle []byte) (valid bool, errs []string, diff ConfigDiff, hash string, err error)
	Apply(ctx context.Context, pklBundle []byte, message, expectedHash string, dryRun, strict bool, actor string) (ConfigApplyResult, error)
	Reload(ctx context.Context, actor string) (diff ConfigDiff, correlationID string, err error)
	CurrentArtifact(ctx context.Context) (*configv1.ConfigSnapshot, error)
}

type ConfigApplyResult struct {
	Applied       bool
	Diff          ConfigDiff
	CorrelationID string
	BundleHash    string
	Errors        []string
}

type ConfigDiff struct {
	DriverAdded, DriverRemoved, DriverChanged int32
	EntitiesAdded, EntitiesRemoved            int32
	AutomationsChanged                        int32
	Lines                                     []string
}

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

type Cursor struct {
	Position uint64
	Tiebreak string
}

type DashboardService struct{}

type Device struct {
	ID               string
	FriendlyName     string
	AreaID           string
	DriverInstanceID string
	EntityIDs        []string
}

type DeviceReader interface {
	ListDevices(ctx context.Context, areaID string, page PageReq) ([]Device, Cursor, error)
	GetDevice(ctx context.Context, id string) (Device, error)
}

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

type DeviceWriter interface {
	RenameDevice(ctx context.Context, id, newName, actor string) (Device, error)
	ReassignDevice(ctx context.Context, id, newAreaID, actor string) (Device, error)
}

type Driver struct {
	Name, Version, Description string
	EntityClasses              []string
}

type DriverControl interface {
	ListDrivers(ctx context.Context, page PageReq) ([]Driver, Cursor, error)
	ListInstances(ctx context.Context, page PageReq) ([]DriverInstance, Cursor, error)
	InstanceHealth(ctx context.Context, instanceID string) (ok bool, detail string, err error)
	RestartInstance(ctx context.Context, instanceID, reason, actor string) error
}

type DriverInstance struct {
	ID, DriverName, Status string
	EntityCount            uint32
	LastHandshakeUnixMs    int64
}

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

type Entity struct {
	ID, Type, DeviceID, AreaID, ZoneID, FriendlyName string
	State                                            *entityv1.Attributes
	Capabilities                                     *entityv1.Attributes
}

type EntityChange struct {
	EntityID string
	Cursor   uint64
	AtUnixMs int64
	Entity   Entity
}

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

type EntityReader interface {
	ListEntities(ctx context.Context, sel EntitySelector, page PageReq) ([]Entity, Cursor, error)
	GetEntity(ctx context.Context, id string) (Entity, error)
}

type EntitySelector struct {
	EntityIDs []string
	DeviceIDs []string
	Areas     []string
	Zones     []string
	Classes   []string
}

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

type EntityStreamSource interface {
	// Subscribe returns a channel of EntityChange events filtered by sel,
	// optionally replaying from fromCursor. The returned cancel func MUST be
	// called to release server-side resources.
	Subscribe(ctx context.Context, sel EntitySelector, fromCursor uint64) (<-chan EntityChange, func(), error)
}

type Event struct {
	Cursor        uint64
	At            time.Time
	Kind          string
	Entity        string
	Source        string
	CorrelationID string
	CauseID       string
	Payload       *eventv1.Payload
}

type EventAppender interface {
	Append(ctx context.Context, payload *eventv1.Payload) (uint64, error)
}

type EventFilter struct {
	Kinds        []string
	EntityPrefix string
	Sources      []string
	FromCursor   uint64
	ToCursor     uint64
	FromTime     time.Time
	ToTime       time.Time
}

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

type EventSource interface {
	Query(ctx context.Context, filter EventFilter, page PageReq) ([]Event, Cursor, error)
	Subscribe(ctx context.Context, filter EventFilter) (<-chan Event, func(), error)
}

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

type MCPCapsProvider interface {
	MCPConfig(ctx context.Context) (MCPConfig, error)
}

type MCPConfig struct {
	EvalResultMaxBytes       uint32
	ReadFileMaxBytes         uint32
	EntitySubscriptionBuffer uint32
	TraceSubscriptionBuffer  uint32
	TailDefaultWaitSeconds   uint32
	TailMaxWaitSeconds       uint32
}

type PageReq struct {
	Size   uint32
	Cursor Cursor
}

type ProcedureCatalog interface {
	Resolve(procedure string, requestAny any) (auth.Action, auth.Target, bool)
}

type SceneService struct{}

type Script struct {
	Name, Description string
}

type ScriptRunResult struct {
	RunID  string
	Result *structpb.Value
}

type ScriptRunner interface {
	List(ctx context.Context, page PageReq) ([]Script, Cursor, error)
	Run(ctx context.Context, name string, args map[string]any, actor string) (ScriptRunResult, error)
	Cancel(ctx context.Context, runID string) error
	Eval(ctx context.Context, expr string, actor string) (result *structpb.Value, stdout string, err error)
	RunTests(ctx context.Context, path string) (<-chan StarlarkTestEvent, func(), error)
}

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

type StarlarkTestEvent struct {
	Name, Outcome, Detail string
	At                    time.Time
}

type StreamConfig struct {
	HeartbeatInterval time.Duration
	BufSize           int
}

type SubsystemHealth struct {
	Name   string
	OK     bool
	Detail string
}

type SystemBackend interface {
	Version() VersionInfo
	Health(ctx context.Context) (ok bool, summary string, sub []SubsystemHealth)
	MetricsText() (string, error)
	Diagnostics(ctx context.Context) (bundle []byte, configHash string, generatedAt time.Time, err error)
	CreateSnapshot(ctx context.Context, owner, reason string) (cursor uint64, createdAt time.Time, err error)
	ConfigDir(ctx context.Context) (string, error)
	MCPConfig(ctx context.Context) (MCPConfig, error)
	RecordConfigFileEdit(ctx context.Context, p auth.Principal, sessionID, path, sha256Hex string, sizeBytes uint32) (uint64, error)
}

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

type TraceEvent struct {
	Cursor       uint64
	At           time.Time
	AutomationID string
	RunID        string
	Kind         string
	Detail       string
	Metadata     map[string]string
}

type VersionInfo struct {
	BinaryVersion string
	GitCommit     string
	BuildDate     string
	SchemaVersion string
}

type WebhookAppender interface {
	AppendWebhook(ctx context.Context, w AppendedWebhook) error
}

type WebhookMetrics interface {
	Inc(slug, result string)
}

type WebhookRouter interface {
	SecretFor(slug string) (string, bool)
	MaxBodyBytes() int64
}

type Zone struct {
	ID          string
	DisplayName string
	AreaIDs     []string
}

type ZoneReader interface {
	ListZones(ctx context.Context, page PageReq) ([]Zone, Cursor, error)
	GetZone(ctx context.Context, id string) (Zone, error)
}

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