hopper

type AppendOpts struct {
	// Key orders the event's deliveries with others of the same key: a
	// consumer handles them one at a time, in order.
	Key string
	// Headers travel with the event and are available on Message.
	Headers map[string]string
}

type AttemptError = driver.AttemptError

type AttemptLog = driver.AttemptLog

type Batch[TTx any] struct {
	// contains filtered or unexported fields
}

type BatchOpts struct {
	OnSuccess  JobArgs
	OnFailure  JobArgs
	OnComplete JobArgs
	// CallbackOpts applies to every callback job.
	CallbackOpts *InsertOpts
	// Metadata is stored with the batch.
	Metadata []byte
}

type BatchResult struct {
	ID   JobID
	Jobs []*InsertResult
}

type BatchRow = driver.BatchRow

type CancelError struct {
	Err error
}

type Client[TTx any] struct {
	// contains filtered or unexported fields
}

type ClientRow = driver.ClientRow

type Codec interface {
	Marshal(v any) ([]byte, error)
	Unmarshal(data []byte, v any) error
}

type Config struct {
	// Queues lists the queues this client works, with per-queue settings. A
	// client with no queues only inserts jobs.
	Queues map[string]QueueConfig
	// Workers is the registry of workers. Required when Queues is set.
	Workers *Workers
	// Periodic lists jobs inserted on a schedule by the leader. See Cron
	// and Every. It is the initial set, which Client.PeriodicJobs changes
	// at runtime. NewClient builds each job's insert and fails if it cannot
	// be built, apart from StrictKinds: a StrictKinds client records only
	// jobs of kinds it has a worker for, checking again as workers are
	// registered, and its own inserts of the others fail.
	Periodic []PeriodicJob
	// Middleware wraps job execution and inserts, outermost first.
	Middleware []Middleware
	// Logger defaults to slog.Default().
	Logger *slog.Logger
	// JobLogs bounds the log lines kept with each job, from its worker's
	// Logger.
	JobLogs JobLogsConfig
	// Codec encodes args and outputs. Defaults to JSONCodec.
	Codec Codec
	// JobTimeout is how long a job may run before its context is canceled,
	// unless its worker's Timeout says otherwise. Defaults to one minute.
	JobTimeout time.Duration
	// MaxAttempts is the default number of attempts before a job is
	// discarded. Defaults to 25.
	MaxAttempts int
	// OnError is called for every failed attempt this client runs, of any
	// kind, with the worker's error: a returned error, a recovered panic
	// (*PanicError), a timeout (ErrJobTimeout), a Cancel, or a kind with no
	// worker (*UnknownKindError). It is not called for a Snooze, nor when the
	// job was canceled with JobCancel or the client is stopping, nor for a
	// job the leader rescues from a lost client or RescueStuckAfter. What it
	// returns overrides the outcome; the zero ErrorOutcome keeps it. It runs
	// on the worker's goroutine, concurrently with other jobs, before the
	// result is written, so it should return quickly; a panic in it is
	// logged and keeps the outcome. Its context carries the client
	// (ClientFromContext) and outlives the job's. It runs after Middleware,
	// which sees the worker's error, not the outcome OnError chooses; the
	// job's events report the outcome.
	OnError func(ctx context.Context, job *JobRow, err error) ErrorOutcome
	// RetryPolicy chooses when a failed job runs again, for workers whose
	// NextRetry returns the zero time, unless the queue's RetryPolicy does.
	// Defaults to attempt^4 + 5 seconds with ±10% jitter, capped at 24
	// hours.
	RetryPolicy RetryPolicy
	// StopTimeout bounds how long Run waits for running jobs after its
	// context is canceled, before canceling them. Defaults to 30 seconds.
	StopTimeout time.Duration
	// PollInterval is how often an idle producer checks its queue for work
	// that arrived without a wake-up. Defaults to one second.
	PollInterval time.Duration
	// StrictKinds rejects inserts whose kind has no worker on this client.
	// By default any kind can be inserted, since another service may work it.
	StrictKinds bool
	// Hostname identifies this process in the clients table. Defaults to
	// os.Hostname().
	Hostname string
	// CompletedRetention is how long completed jobs stay in history.
	// Defaults to 24 hours; negative keeps them forever. Retention is
	// enforced by the leader, so the leader's setting applies cluster-wide.
	CompletedRetention time.Duration
	// FailedRetention is how long canceled and discarded jobs stay in
	// history, which is the dead-letter queue. Defaults to 7 days; negative
	// keeps them forever.
	FailedRetention time.Duration
	// StreamRetention is how long stream events stay in the log, for
	// consumers that start from the earliest event or are moved back.
	// Defaults to 7 days; negative keeps them forever.
	StreamRetention time.Duration
	// NeverLead keeps this client out of leader elections. It still claims
	// and works jobs, but never runs the leader's duties: rescuing jobs from
	// lost clients, retention, maintenance, periodic jobs and stream
	// delivery. Use it for clients that share an install but must not run it,
	// such as a developer's process against a shared environment. At least
	// one client of every install must be able to lead. Its periodic jobs are
	// still recorded, and the leader schedules them while it runs, so such a
	// process registers none it should not run.
	NeverLead bool
	// LeaseTTL is how long this client's lease lasts without a renewal. It
	// is renewed three times per TTL; when it lapses, the client's running
	// jobs are rescued and the client cancels them. A longer lease rides
	// out a longer database outage before interrupting jobs, and delays the
	// rescue of a crashed client's jobs by as much. Defaults to 15 seconds.
	LeaseTTL time.Duration
	// RescueStuckAfter, if set, rescues jobs that have been running longer
	// than this even though their client's lease is live, for workers that
	// ignore their context. Off by default; timeouts cover most cases.
	RescueStuckAfter time.Duration
	// JobLeaseGrace is the least time a job lease is given after a cluster
	// restart, for holders that could not renew while no client ran. A
	// lease whose last renewal predates the start of a client whose own
	// lease is live is due no earlier than the first such start plus the
	// larger of its TTL and JobLeaseGrace, by database time. Zero gives
	// such a lease its TTL from that start; set it to how long remote
	// workers may take to reach the cluster again, such as their reconnect
	// backoff. The start of any client that works a queue counts (one that
	// only inserts registers none), as does one that re-registers after its
	// lease lapsed, so it also delays expiries across a rolling deploy, and
	// clients that each stop within the grace of their start, the next
	// starting before the last stops, keep a lease that is never renewed
	// again from expiring. The leader's setting applies.
	JobLeaseGrace time.Duration
}

type Consumer struct {
	// Name identifies the consumer; the delivery job kind is derived from
	// it.
	Name    string
	Pattern string
	// Queue is where deliveries go. Defaults to QueueDefault.
	Queue string
	// Start applies when the consumer is created. Defaults to
	// StreamStartLatest.
	Start StreamStart
	// MaxAttempts is the retry budget of deliveries. Zero means 25, or 10
	// for events with a key, whose retries block their key.
	MaxAttempts int
	// Metadata is merged into every delivery's metadata.
	Metadata json.RawMessage
}

type ConsumerRow = driver.StreamConsumerRow

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

type DependencyFailure = driver.DependencyFailure

type ErrorOutcome struct {
	// RetryAt retries the job at this time, using up the attempt as any
	// failure does: on its last attempt the job is discarded all the same.
	RetryAt time.Time
	// Snooze reschedules the job after this long without using up the
	// attempt, as if the worker had returned Snooze. The error is kept as the
	// snooze reason rather than in the job's errors.
	Snooze time.Duration
	// Discard discards the job now, with the error recorded, as if the
	// worker had returned Cancel.
	Discard bool
}

type Event struct {
	Kind EventKind
	At   time.Time
	// Job is set for job events: the row as claimed, before the outcome;
	// for the EventJobRescued of a job lease's expiry, the row after it.
	Job *JobRow
	// Error is the attempt's error text for failed, discarded and
	// canceled jobs, and the snooze reason, if any, for snoozed jobs.
	Error string
	// ClientID is the client the event happened on.
	ClientID int64
}

type EventKind string

type ExponentialRetry struct {
	Base time.Duration
	Max  time.Duration
}

type InsertOpts struct {
	// Queue defaults to QueueDefault.
	Queue string
	// Priority defaults to PriorityNormal.
	Priority Priority
	// MaxAttempts defaults to Config.MaxAttempts.
	MaxAttempts int
	// ScheduledAt delays the job until the given time. Zero runs it as soon
	// as possible.
	ScheduledAt time.Time
	// Metadata is a JSON object stored with the job, for trace context and
	// similar. It is not passed to the worker as args.
	Metadata json.RawMessage
	// Unique makes the job unique among jobs of its kind. See UniqueOpts.
	Unique *UniqueOpts
	// TTL bounds how long the job may wait to run, measured from its
	// insert: before its first attempt, between retries, and while snoozed.
	// A job still waiting when it passes is discarded without running again.
	// A running job is not interrupted. Zero means no limit.
	TTL time.Duration
	// Await announces the job's finalize, so that Await returns as soon as
	// it commits instead of on its next poll.
	Await bool
	// OrderingKey serializes the job with others of the same key in its
	// queue: at most one runs at a time, oldest first, and a failing job
	// blocks its key while it retries. See PublishOpts.OrderingKey.
	OrderingKey string
	// PartitionKey groups the job for the queue's PartitionLimit, for
	// example a customer ID.
	PartitionKey string
	// Tags label the job, for finding it with JobFilter.TagsAny and
	// TagsAll, for example a tenant or a release. Each is a non-empty
	// string of valid UTF-8, at most MaxTagBytes, without control
	// characters. Repeats are dropped, keeping the first; more than MaxTags
	// distinct tags fail the insert. They replace, not add to, the tags of
	// the JobArgs' own InsertOpts.
	Tags []string
}

type InsertParams struct {
	Args JobArgs
	Opts *InsertOpts
	// contains filtered or unexported fields
}

type InsertResult struct {
	Job *JobRow
	// Duplicate reports that a job with the same unique key already
	// existed: a live one, or a finished one UniqueOpts.Finished counts. Job
	// is then that existing job.
	Duplicate bool
}

type IntervalSchedule struct {
	Interval time.Duration
}

type JSONCodec struct{}

type Job[T JobArgs] struct {
	*JobRow
	Args T
}

type JobArgs interface {
	Kind() string
}

type JobArgsWithInsertOpts interface {
	JobArgs
	InsertOpts() InsertOpts
}

type JobArgsWithKindAliases interface {
	JobArgs
	KindAliases() []string
}

type JobFailedError struct {
	Job *JobRow
}

type JobFilter struct {
	Queue  string
	Kinds  []string
	States []JobState
	// OrderingKey lists one ordering key's jobs, its lane. Keys are scoped
	// to a queue, so it needs Queue; the listing fails without one.
	OrderingKey string
	// NewestFirst lists in descending ID order: the latest inserted jobs
	// first, though IDs from the same millisecond can sort either way.
	NewestFirst bool
	// After starts the listing after the given job, for paging: pass the
	// last ID of one page to get the next.
	After JobID
	// IDs lists only the jobs with one of the given IDs.
	IDs []JobID
	// Priorities lists only the jobs with one of the given priorities.
	Priorities []Priority
	// TagsAny lists jobs with at least one of the tags, and TagsAll jobs
	// with all of them. Both can be set, each with at most MaxTags distinct
	// tags.
	TagsAny []string
	TagsAll []string
	// Metadata, a JSON object, lists jobs whose metadata contains it: every
	// key it has, with an equal value, where an object value contains the
	// same way and an array value contains each of its elements, as
	// Postgres's jsonb containment (@>) does. {"tenant": "acme"} lists the
	// jobs with that tenant, whatever else their metadata holds. Unlike
	// tags, it has no index: it narrows what the other filters find, and
	// alone reads every job.
	Metadata json.RawMessage
}

type JobID = driver.JobID

type JobLease struct {
	// Job is the job as claimed: running with no owning client, its attempt
	// and fence incremented.
	Job   *JobRow
	Token LeaseToken
	// ExpiresAt is when the lease expires unless renewed, by database time.
	ExpiresAt time.Time
}

type JobLogsConfig struct {
	// Store, if set, receives each attempt's lines as they are logged
	// instead of the job's row in the database, and Client.JobLogs reads
	// them from it, after any the job's row holds. MaxBytes then neither
	// applies nor is checked, and MaxAttempts bounds what Client.JobLogs
	// returns: what the store keeps is its own choice.
	Store LogStore
	// MaxBytes is how much of an attempt's log is kept. Once a line would
	// pass it, that line and the rest are dropped, and the log ends with a
	// line that counts them. Defaults to 32 KiB, and is at most 1 MiB,
	// and MaxBytes times MaxAttempts at most 4 MiB; negative keeps no
	// lines. For larger logs, use a Store. A finished attempt's lines
	// wait in memory with its result until it is written, so a client
	// holds at most 64 MiB of them; past that, finished jobs wait to hand
	// in their results, as they do when the finalizer's buffer is full.
	MaxBytes int
	// MaxAttempts is how many attempts' logs a job keeps, the latest. Each
	// snooze keeps its own until the next snooze of the same attempt
	// number, which replaces it, or removes it if that snooze logged
	// nothing. A store keeps what it is given: a snooze that logs nothing
	// writes nothing to it, so it removes only a snooze's log that the
	// job's row holds. Defaults to 10, and is at most 100.
	MaxAttempts int
	// Level is the lowest level kept. Defaults to slog.LevelInfo. Lines
	// go to Config.Logger at whatever level its handler takes.
	Level slog.Leveler
	// ReplaceAttr, if set, rewrites or drops each attribute of a kept line,
	// as slog.HandlerOptions.ReplaceAttr does. The options of
	// Config.Logger's handler do not apply to the kept lines, so whatever
	// that handler redacts is redacted here too, or it is stored with the
	// job and shown by hopper jobs get and hopperui.
	ReplaceAttr func(groups []string, a slog.Attr) slog.Attr
}

type JobRow = driver.JobRow

type JobState = driver.JobState

type JobStep[T JobArgs] struct {
	// contains filtered or unexported fields
}

type LeaseOpts struct {
	// TTL is how long the lease lasts from the claim and from each renewal,
	// by database time: DefaultJobLeaseTTL if zero. Renew about every TTL/3.
	TTL time.Duration
}

type LeaseResult struct {
	Err error
	// Output is the completed job's output, encoded with Config.Codec and
	// kept as SetOutput's is. It is ignored unless the attempt ends the
	// job.
	Output any
}

type LeaseStatus struct {
	// ExpiresAt is when the lease now expires, by database time.
	ExpiresAt time.Time
	// CancelRequested reports that JobCancel was called on the job. The
	// holder should stop, and Finish with an error, which cancels the job.
	CancelRequested bool
}

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

type Leases[TTx any] struct {
	// contains filtered or unexported fields
}

type LogStore interface {
	// Writer returns where the lines of the attempt of job that is running
	// go, as Logger logs them: one line per Write, in slog's text format,
	// in the order they were logged. job is the row as it was claimed.
	//
	// Logging never waits for the store: lines are queued, and one
	// goroutine per attempt opens the writer with the first line and hands
	// the lines to it. Up to 256 KiB of lines wait for a store that falls
	// behind; lines past that are dropped, and a line counting them follows.
	// Writer's context carries the values of the context the worker first
	// called Logger with, such as a trace span its middleware started, but
	// not its cancellation, deadline or attempt (Logger called with it logs
	// as outside a job). It is canceled once the writer is closed, or once
	// hopper stops waiting for it.
	//
	// Hopper closes the writer once the worker returns and waits for the
	// queued lines and Close for up to 5 seconds before it hands in the
	// attempt's result, so a store that saves on Close has the log by the
	// time the job is finished; past that, the context is canceled and the
	// result goes ahead. A client that stops hard waits for at most half its
	// stop grace, so the result of the job it canceled is still written. A
	// job completed with CompleteTx is finished when the worker's
	// transaction commits, which may be before. Lines logged after the
	// close go to Config.Logger only.
	//
	// A snooze gives the attempt back, so the run after it calls Writer
	// again with the same job ID and attempt: keep both, in order. A failed
	// or panicking Writer, Write or Close, or a nil writer, is logged to
	// Config.Logger once and drops the attempt's remaining lines; the job's
	// outcome does not depend on it.
	Writer(ctx context.Context, job *JobRow) (io.WriteCloser, error)
	// Logs returns the logs of a job's attempts, oldest first, for
	// Client.JobLogs and hopperui, with no entry for a job it has none of.
	Logs(ctx context.Context, id JobID) ([]AttemptLog, error)
}

type Message[T any] struct {
	*JobRow
	Payload T
	Topic   string
	// ID identifies the published message; every subscription's delivery of
	// it shares the ID.
	ID          string
	Headers     map[string]string
	OrderingKey string
	// Stream and Position are set for a consumer's deliveries: the
	// consumer's name and the event's place in the log.
	Stream   string
	Position StreamPosition
}

type Middleware interface {
	// Work wraps one attempt of a job. next runs the worker (and any inner
	// middleware); its error is the worker's return value.
	Work(ctx context.Context, job *JobRow, next func(ctx context.Context) error) error
	// Insert wraps an insert batch. next performs the insert; middleware may
	// pass it a modified copy of params, for example with trace context in
	// Metadata.
	Insert(ctx context.Context, params []InsertParams, next func(ctx context.Context, params []InsertParams) ([]*InsertResult, error)) ([]*InsertResult, error)
}

type MiddlewareDefaults struct{}

type PanicError struct {
	Value any
	Stack string
}

type PeriodicJob struct {
	// Name identifies the job in the periodic table. It defaults to the
	// args' kind and must be unique among a client's periodic jobs.
	Name     string
	Schedule Schedule
	Args     JobArgs
	Opts     *PeriodicOpts
	// contains filtered or unexported fields
}

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

type PeriodicOpts struct {
	// Name overrides the periodic job's name.
	Name string
	// RunOnStart inserts a job as soon as a leader starts scheduling the
	// periodic job, at the start of its term or when the job is added on
	// it, in addition to the regular slots. Its slot is the database time,
	// so an insert that committed but reported an error, as when the
	// connection drops before the reply, is inserted again when retried.
	RunOnStart bool
	// CatchUp inserts up to this many slots missed while no leader was
	// running (for example during a full outage), oldest first, at most
	// 10000. By default missed slots are skipped, except those due since the
	// last one inserted within the last lease TTL, which covers a leader
	// failover and a job removed and added again; CatchUp never inserts
	// fewer than those. Either way at most the 10000 most recent missed
	// slots are inserted.
	CatchUp int
	// Location evaluates a cron expression in this zone when the
	// expression does not name one. Defaults to UTC.
	Location *time.Location
	// InsertOpts are applied to every inserted job. A UniqueOpts.OnConflict
	// of UniqueReplace is treated as UniqueSkip: a slot whose job is a
	// duplicate keeps the existing job.
	InsertOpts *InsertOpts
}

type Priority int

type Progress = driver.Progress

type PublishOpts struct {
	// OrderingKey makes delivery FIFO per key, per queue: at most one
	// delivery with the key runs at a time, oldest first, and a failing
	// delivery blocks its key while it retries. Keys are independent.
	OrderingKey string
	// DedupKey makes the publish idempotent: while a delivery with the key
	// is live, a repeated publish inserts nothing and reports Duplicate.
	DedupKey string
	// Headers travel with the message and are available on Message.
	Headers map[string]string
	// Delay defers delivery.
	Delay time.Duration
	// TTL bounds how long each delivery may wait to run, as
	// InsertOpts.TTL does: one still waiting when it passes, whether before
	// its first attempt, between retries or while snoozed, is discarded.
	TTL time.Duration
	// Priority defaults to PriorityNormal.
	Priority Priority
	// Await announces each delivery's finalize, for Await.
	Await bool
}

type PublishResult struct {
	// MessageID identifies the message across its deliveries. It is empty
	// when no subscription matched.
	MessageID  string
	Deliveries []*InsertResult
}

type QueueConfig struct {
	// MaxWorkers is the number of jobs this client runs at once from the
	// queue. Required.
	MaxWorkers int
	// DeleteCompleted deletes completed jobs instead of archiving them to
	// history, for maximum throughput. Canceled and discarded jobs are
	// always archived, because history is the dead-letter queue.
	DeleteCompleted bool
	// RetryPolicy overrides Config.RetryPolicy for the queue's jobs on this
	// client.
	RetryPolicy RetryPolicy

	// GlobalLimit caps the queue's running jobs across all clients.
	GlobalLimit int
	// RateLimit caps claims per second across all clients, in a token
	// bucket of RateBurst tokens (defaulting to one second's worth).
	RateLimit float64
	RateBurst int
	// PartitionLimit caps running jobs per InsertOpts.PartitionKey.
	PartitionLimit int
	// PriorityAging raises a waiting job's priority by one level each time
	// it has waited this long, so low priorities cannot starve.
	PriorityAging time.Duration
}

type QueueControl[TTx any] struct {
	// contains filtered or unexported fields
}

type QueueLimits = driver.QueueLimits

type QueueRow = driver.QueueRow

type QueueStats = driver.QueueStats

type Raw = json.RawMessage

type RescueReason = driver.RescueReason

type RetryOption func(*driver.JobRetryParams)

type RetryPolicy interface {
	NextRetry(job *JobRow) time.Time
}

type Schedule interface {
	// Next returns the first slot strictly after t, or the zero time if
	// there is none within a reasonable horizon.
	Next(t time.Time) time.Time
}

type SeekOpts struct {
	// Position makes the event after it the next delivered.
	Position StreamPosition
	// Time replays from the first event appended at or after it.
	Time time.Time
	// Earliest replays every retained event.
	Earliest bool
	// Latest skips to the events appended from now on.
	Latest bool
}

type SnoozeError struct {
	Duration time.Duration
	// Reason is stored on the job while it waits, as JobRow.SnoozeReason,
	// for operators, and is the Error of the job.snoozed event. It is
	// cleared when the job runs again. A job that expires or is canceled
	// while it waits keeps the reason in the error it is finalized with.
	Reason string
}

type Stats = driver.Stats

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

type StepOpts struct {
	// After lists the steps this one waits for. It is inserted pending and
	// becomes available once they have all finished.
	After []Step
	// OnDependencyFailure defaults to DependencyCancel.
	OnDependencyFailure DependencyFailure
	// Insert holds the job's own options.
	Insert *InsertOpts
}

type StreamEvent = driver.StreamEvent

type StreamPosition = driver.StreamPosition

type StreamStart = driver.StreamStart

type Streams[TTx any] struct {
	// contains filtered or unexported fields
}

type Subscription struct {
	// Name identifies the subscription; the delivery job kind is derived
	// from it.
	Name    string
	Pattern string
	// Queue is where deliveries go. Defaults to QueueDefault.
	Queue string
	// MaxAttempts is the retry budget of deliveries. Zero means 25, or 10
	// for deliveries with an ordering key, whose retries block their key.
	MaxAttempts int
	// Metadata is merged into every delivery's metadata.
	Metadata json.RawMessage
}

type SubscriptionRow = driver.SubscriptionRow

type Topic interface {
	Topic() string
}

type UniqueConflict int

type UniqueOpts struct {
	// ByArgs includes the args in the key: the fields tagged
	// `hopper:"unique"`, or the whole args if no field is tagged.
	ByArgs bool
	// ByQueue includes the queue in the key.
	ByQueue bool
	// ByPeriod includes the current time, truncated to this period, so that
	// at most one job exists per period. For example 24 * time.Hour allows
	// one job per UTC day. A periodic job's key uses its slot instead.
	ByPeriod time.Duration
	// OnConflict is what to do when the job exists.
	OnConflict UniqueConflict
	// Finished also counts finished jobs with the key as duplicates when
	// their state is one of these (JobStateCompleted, JobStateCanceled,
	// JobStateDiscarded), for as long as history keeps them
	// (Config.CompletedRetention, Config.FailedRetention). With ByPeriod a
	// finished job counts only for the rest of its period, which is part of
	// the key. A finished duplicate is reported like a live one, and is
	// never replaced. Looking in history costs an index lookup per history
	// partition, so it grows with retention (docs/operations.md).
	//
	// A duplicate that finalizes while the insert runs is still found,
	// except in a caller's transaction (InsertTx, InsertManyTx) at
	// repeatable read or serializable, which does not see a duplicate
	// finalized after its snapshot.
	Finished []JobState
}

type UnknownKindError struct {
	Kind string
}

type Worker[T JobArgs] interface {
	// Work runs the job. Returning nil completes it. Returning an error
	// schedules a retry with backoff, or discards the job when it is out of
	// attempts. Return Snooze(d) to run again later without using an attempt
	// and Cancel(err) to discard now.
	Work(ctx context.Context, job *Job[T]) error
	// Timeout returns how long the job may run before its context is
	// canceled: 0 for the client's default, or a negative duration for no
	// timeout.
	Timeout(job *Job[T]) time.Duration
	// NextRetry returns when a failed job runs again, or the zero time for
	// the default backoff.
	NextRetry(job *Job[T]) time.Time
}

type WorkerDefaults[T JobArgs] struct{}

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

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

type WorkflowOpts struct {
	OnSuccess  JobArgs
	OnFailure  JobArgs
	OnComplete JobArgs
	// CallbackOpts applies to every callback job.
	CallbackOpts *InsertOpts
	// Metadata is stored with the workflow.
	Metadata json.RawMessage
}

type WorkflowResult struct {
	ID JobID
	// Jobs are in step order.
	Jobs []*InsertResult
}

type WorkflowRow = driver.WorkflowRow