meeting

type Anchor struct {
	ID   string `json:"id"`
	Text string `json:"text"`
	TsMs int64  `json:"tsMs"`
}

type ChannelSnapshot struct {
	Channel string       `json:"channel"`
	State   ChannelState `json:"state"`
	Message string       `json:"message,omitempty"`
}

type ChannelState string

type Detection struct {
	App   string
	Since time.Time
}

type EndWatcher struct {
	// Interval is how often the microphone is read.
	Interval time.Duration
	// Grace is how long the microphone must stay free of calling applications
	// before the call is considered over.
	Grace time.Duration
	// Apps is the detection allowlist, same as Watcher's.
	Apps []string
	// Read returns the applications currently recording.
	Read func() ([]MicrophoneUser, error)
	// Recording reports whether a meeting is currently being recorded. The
	// watcher only ever acts while this is true.
	Recording func() bool
	// End is called at most once per recording, when the call is over. It runs
	// on the watch loop, so anything slow belongs in a goroutine.
	End func()
	// Now is overridable for tests.
	Now func() time.Time
	// contains filtered or unexported fields
}

type MicrophoneUser struct {
	App   string
	Since time.Time
}

type NotesBullet struct {
	Text string `json:"text"`
	// SourceSegmentIDs are the transcript segments this bullet came from. A
	// reader can follow them back to what was actually said; a bullet with none
	// is one the model could not ground.
	SourceSegmentIDs []int64 `json:"sourceSegmentIds,omitempty"`
	// AnchorID names the user's own note this bullet came from. Bullets with an
	// anchor are rendered from the stored note rather than from the model's
	// paraphrase, so the user's words survive verbatim.
	AnchorID string `json:"anchorId,omitempty"`
	// Owner and Due are filled for action items where the conversation named
	// them; both stay empty rather than being guessed.
	Owner string `json:"owner,omitempty"`
	Due   string `json:"due,omitempty"`
}

type NotesDocument struct {
	TemplateSlug   string         `json:"templateSlug"`
	Locale         string         `json:"locale,omitempty"`
	ExecutiveBrief []string       `json:"executiveBrief,omitempty"`
	Sections       []NotesSection `json:"sections"`
}

type NotesSection struct {
	Slug    string        `json:"slug"`
	Title   string        `json:"title"`
	Bullets []NotesBullet `json:"bullets"`
}

type Options struct {
	NewPipeline PipelineFactory
	// Log receives host-visible progress lines; kind is "info", "warn" or
	// "error", matching the desktop log levels.
	Log func(message, kind string)
	// Now is overridable for tests.
	Now func() time.Time
	// DrainTimeout bounds how long Stop waits for in-flight transcription to
	// land before the meeting is finished anyway.
	DrainTimeout time.Duration
	// DrainPoll is how often the drain wait re-checks. Tests shorten it.
	DrainPoll time.Duration
	// OnEnded fires once a meeting has finished and its transcript drain has
	// either settled or been marked degraded.
	//
	// It is a direct call rather than a snapshot subscription because finishing
	// a meeting — recording that it ended, writing it up — must not be
	// best-effort: subscribers can miss a broadcast, and a meeting that ends
	// without being recorded as ended looks to the user like it is still
	// running. It runs on the caller's goroutine, so slow work belongs in one
	// of its own.
	OnEnded func(sessionID int64)
}

type Pipeline interface {
	// Channel names the capture source, one of the Channel* constants.
	Channel() string
	Start(opts speechkit.RecordingStartOptions) error
	Stop(opts speechkit.RecordingStopOptions) error
	// Events surfaces capture-device trouble (stalls, unplugs, driver errors)
	// so the runtime can mark this channel degraded without killing the other.
	Events() <-chan capturepkg.Event
	Close() error
}

type PipelineFactory func(channel string) (Pipeline, error)

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

type Snapshot struct {
	SessionID       int64             `json:"sessionId"`
	State           State             `json:"state"`
	StartedAt       time.Time         `json:"startedAt,omitempty"`
	Channels        []ChannelSnapshot `json:"channels"`
	PendingSegments int               `json:"pendingSegments"`
	// Degraded is true when capture ended with accepted transcript segments
	// unresolved. PendingSegments reports how much transcript may be missing.
	Degraded bool `json:"degraded"`
}

type StartOptions struct {
	// SessionID is the persisted recording session this capture belongs to.
	SessionID int64
	// Title is used for host-visible capture labels only.
	Title    string
	Language string
	// Channels to record. Defaults to microphone plus system loopback.
	Channels []string
	// Recording carries the transcription settings the host resolved for this
	// meeting (provider stream, streaming segments, ...). The runtime fills in
	// the session, channel and epoch fields per channel.
	Recording speechkit.RecordingStartOptions
}

type State string

type Template struct {
	Slug string `json:"slug"`
	Name string `json:"name"`
	// Prompt frames the meeting for the model: what this kind of conversation
	// is and what a good write-up of it does.
	Prompt   string            `json:"prompt"`
	Sections []TemplateSection `json:"sections"`
}

type TemplateSection struct {
	Slug     string `json:"slug"`
	Title    string `json:"title"`
	Guidance string `json:"guidance"`
}

type TranscriptLine struct {
	SegmentID int64  `json:"segmentId"`
	Speaker   string `json:"speaker"`
	Channel   string `json:"channel"`
	StartMs   int64  `json:"startMs"`
	Text      string `json:"text"`
}

type Watcher struct {
	// Interval is how often the microphone is read. Reading it is a handful of
	// registry lookups, so this is cheap.
	Interval time.Duration
	// Rearm is how long an application must be off the microphone before a new
	// call from it is announced.
	Rearm time.Duration
	// Apps is the detection allowlist.
	Apps []string
	// Read returns the applications currently recording.
	Read func() ([]MicrophoneUser, error)
	// Announce is called once per detected call. It runs on the watch loop, so
	// anything slow belongs in a goroutine.
	Announce func(Detection)
	// Suspended reports whether detection should stand down — while a meeting is
	// already being recorded, most obviously.
	Suspended func() bool
	// Now is overridable for tests.
	Now func() time.Time
	// contains filtered or unexported fields
}