schedule

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

type CatchUp struct {
	Window time.Duration
	Max    int
}

type Config struct {
	Group         Group
	Clock         clock.Clock
	Concurrency   int
	MaxHistory    int
	MaxPerTick    int
	PollInterval  time.Duration
	LeadershipTTL time.Duration
	// Grace bounds lateness for schedules without catch-up. Older occurrences are
	// skipped. Process startup itself skips all missed occurrences by default.
	Grace time.Duration
	// CapacityWait lets a due occurrence wait for a free execution slot when
	// Concurrency is exhausted, before it is skipped as CapacityReached.
	CapacityWait time.Duration
	// DrainTimeout is the graceful-shutdown budget. When Run's context ends or
	// Drain is called, admission stops while running tasks keep leadership and
	// overlap leases for up to DrainTimeout; they are then cancelled. Zero
	// cancels immediately. Keep it within the application shutdown timeout.
	DrainTimeout time.Duration
	// Logger receives skipped occurrences and failures with redacted
	// diagnostics. Module uses the application logger when it is nil.
	Logger *slog.Logger
	// Wake optionally replaces the polling ticker for controlled application time.
	// The caller owns the channel; closing it stops Run with an error. Leadership
	// and overlap heartbeats still use real safety time independent of this clock.
	Wake <-chan struct{}
}

type CursorBackend interface {
	// ScheduleCursor returns the latest retained occurrence for key and whether one exists.
	ScheduleCursor(context.Context, lease.Key) (time.Time, bool, error)
	// AdvanceScheduleCursor stores the maximum handled instant for key, with optional expiry after ttl.
	AdvanceScheduleCursor(context.Context, lease.Key, time.Time, time.Duration) error
}

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

type Description struct {
	ID             ID            `json:"id"`
	Expression     string        `json:"expression"`
	TimeZone       string        `json:"time_zone"`
	Interval       time.Duration `json:"interval,omitzero"`
	Anchor         time.Time     `json:"anchor,omitzero"`
	Timeout        time.Duration `json:"timeout"`
	WithoutOverlap bool          `json:"without_overlap"`
	OverlapTTL     time.Duration `json:"overlap_ttl"`
	Environments   []string      `json:"environments"`
	CatchUp        CatchUp       `json:"catch_up"`
}

type Execution struct{}

type ExecutionID = model.ID[Execution]

type Group string

type Handler func(context.Context, Invocation) error

type ID string

type Invocation struct {
	Schedule   ID
	Occurrence OccurrenceID
	IntendedAt time.Time
	Origin     attribution.Origin
}

type Occurrence struct{}

type OccurrenceID = model.ID[Occurrence]

type Options struct {
	Timeout               time.Duration
	WithoutOverlap        bool
	OverlapTTL            time.Duration
	Environments          []string
	CatchUp               CatchUp
	Days                  []time.Weekday
	Between               Window
	LastDayOfMonth        bool
	When                  Predicate
	EvenInMaintenanceMode bool
	Before                Handler
	After                 Handler
	Failed                func(context.Context, Invocation, error) error
}

type Predicate func(context.Context, Invocation) (bool, error)

type Reason string

type Record struct {
	Execution  ExecutionID
	Invocation Invocation
	State      State
	Reason     Reason
	StartedAt  time.Time
	FinishedAt time.Time
}

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

type ScheduleStatus struct {
	ID      ID
	Enabled bool
	Next    time.Time
	Active  int
}

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

type Snapshot struct {
	Running                bool
	Stopping               bool
	Leader                 bool
	Active                 int
	LeadershipAcquisitions uint64
	LeadershipLosses       uint64
	CoordinationFailures   uint64
	Schedules              []ScheduleStatus
	History                []Record
}

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

type State string

type Window struct {
	From, To temporal.Time
	Unless   bool
}