fetch

type AsyncResource[T any] struct {
	// contains filtered or unexported fields
}

type BreakerConfig struct {
	// FailureThreshold is the consecutive-failure count that trips the breaker.
	FailureThreshold int

	// OpenDuration is how long the breaker stays open before probing with
	// half-open calls.
	OpenDuration time.Duration

	// HalfOpenMaxCalls is the maximum number of calls allowed in the half-open
	// state before the breaker re-opens (if all half-open calls succeed, it
	// instead resets to closed). Zero or negative values allow unlimited
	// half-open probes until a probe records success or failure.
	HalfOpenMaxCalls int
}

type BreakerState int

type CacheBootstrap struct {
	Entries []CacheBootstrapEntry `json:"entries,omitempty"`
}

type CacheBootstrapEntry struct {
	Key          string            `json:"key,omitempty"`
	Value        any               `json:"value,omitempty"`
	UpdatedAt    time.Time         `json:"updatedAt"`
	ResumePolicy CacheResumePolicy `json:"resumePolicy,omitempty"`
	StaleAfter   time.Duration     `json:"staleAfter,omitempty"`
}

type CacheOptions struct {
	StaleAfter   time.Duration
	MaxAge       time.Duration
	DisposeAfter time.Duration
	Persist      bool
}

type CacheResumePolicy string

type CachedResource[T any] struct {
	// contains filtered or unexported fields
}

type CachedResourceInspection struct {
	Key             string
	Tags            []string
	Loading         bool
	Ready           bool
	Stale           bool
	LastError       string
	UpdatedAt       time.Time
	LastLoaded      time.Time
	SubscriberCount int
	OwnerPaths      []string
	ResumePolicy    CacheResumePolicy
}

type CachedResourceState[T any] struct {
	Value     T
	Loading   bool
	Error     error
	Ready     bool
	Stale     bool
	UpdatedAt time.Time
}

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

type DurableMutationRunner[T any] func(parseOptimistic T, parseDraft MutationDraft, parseCommit func(context.Context, QueuedMutation) (T, error)) (QueuedMutation, error)

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

type EventSourceOptions struct {
	WithCredentials   bool
	Manual            bool
	DisableReconnect  bool
	MaxReconnects     int
	InitialBackoff    time.Duration
	MaxBackoff        time.Duration
	BackoffFactor     float64
	HeartbeatInterval time.Duration
	HeartbeatTimeout  time.Duration
	MaxMessages       int
	MaxErrors         int
	Now               func() time.Time
}

type HTTPError struct {
	Status     int
	StatusText string
	Body       string
	Headers    map[string]string
}

type InfiniteQuery[T any, C any] struct {
	// contains filtered or unexported fields
}

type InfiniteQueryData[T any, C any] struct {
	Pages      []QueryPage[T, C]
	Items      []T
	NextCursor C
	HasNext    bool
}

type InfiniteQueryOptions[C any] struct {
	Cache         CacheOptions
	Tags          []string
	InitialCursor C
}

type InfiniteQueryState[T any, C any] struct {
	InfiniteQueryData[T, C]
	Loading   bool
	Error     error
	Ready     bool
	Stale     bool
	UpdatedAt time.Time
}

type MultipartBody struct {
	Fields map[string]string
	Files  []MultipartFile
}

type MultipartFile struct {
	FieldName string
	File      ui.File
	Filename  string
}

type MutationConflict struct {
	Code          string            `json:"code,omitempty"`
	Message       string            `json:"message,omitempty"`
	LocalVersion  string            `json:"localVersion,omitempty"`
	RemoteVersion string            `json:"remoteVersion,omitempty"`
	Fields        map[string]string `json:"fields,omitempty"`
}

type MutationConflictError struct {
	Conflict MutationConflict
	Err      error
}

type MutationConflictHandler func(context.Context, QueuedMutation, MutationConflict) (MutationConflictResolution, error)

type MutationConflictResolution struct {
	Action  MutationResolutionAction
	Draft   MutationDraft
	Message string
}

type MutationDraft struct {
	ID       string            `json:"id,omitempty"`
	Kind     string            `json:"kind,omitempty"`
	DedupKey string            `json:"dedupKey,omitempty"`
	Method   string            `json:"method,omitempty"`
	URL      string            `json:"url,omitempty"`
	Headers  map[string]string `json:"headers,omitempty"`
	Body     any               `json:"body,omitempty"`
	Metadata map[string]string `json:"metadata,omitempty"`
}

type MutationExecutor func(context.Context, QueuedMutation) error

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

type MutationQueueOptions struct {
	StorageKey         string
	MaxAttempts        int
	BaseDelay          time.Duration
	MaxDelay           time.Duration
	DeleteOnCorruption bool
	StoreResolver      func(context.Context) (interop.PersistentStore, error)
	StorageResolver    func() (interop.Storage, error)
	Now                func() time.Time
}

type MutationReplayOptions struct {
	ConflictHandler MutationConflictHandler
}

type MutationReplayReport struct {
	Succeeded   int
	Deferred    int
	Retried     int
	DeadLetters int
	Conflicts   int
	Resolved    int
	Remaining   int
}

type MutationResolutionAction string

type MutationState string

type OptimisticUpdate[T any] struct {
	// contains filtered or unexported fields
}

type Options struct {
	Method string
	// Headers are request headers. Values are typed any (not string) so callers can pass
	// non-string values that are stringified at send time; response headers in Result are
	// always plain strings.
	Headers map[string]any
	Body    any
}

type PersistentCacheOptions struct {
	DatabaseName     string
	StoreName        string
	FallbackResolver func() (interop.Storage, error)
	FallbackBackend  string
	StoreResolver    func(context.Context) (interop.PersistentStore, error)
}

type Query[T any] struct {
	// contains filtered or unexported fields
}

type QueryOptions struct {
	Cache CacheOptions
	Tags  []string
}

type QueryPage[T any, C any] struct {
	Items      []T
	NextCursor C
	HasNext    bool
}

type QueryPageRequest[C any] struct {
	Cursor    C
	PageIndex int
}

type QueuedMutation struct {
	ID            string            `json:"id,omitempty"`
	Kind          string            `json:"kind,omitempty"`
	DedupKey      string            `json:"dedupKey,omitempty"`
	Method        string            `json:"method,omitempty"`
	URL           string            `json:"url,omitempty"`
	Headers       map[string]string `json:"headers,omitempty"`
	Body          any               `json:"body,omitempty"`
	Metadata      map[string]string `json:"metadata,omitempty"`
	State         MutationState     `json:"state,omitempty"`
	Attempts      int               `json:"attempts,omitempty"`
	MaxAttempts   int               `json:"maxAttempts,omitempty"`
	CreatedAt     time.Time         `json:"createdAt"`
	UpdatedAt     time.Time         `json:"updatedAt"`
	NextAttemptAt time.Time         `json:"nextAttemptAt"`
	LastError     string            `json:"lastError,omitempty"`
}

type RealtimeError struct {
	Message string
	At      time.Time
}

type RealtimeMessage struct {
	Data        string
	Type        string
	LastEventID string
	ReceivedAt  time.Time
}

type RealtimeState struct {
	Status            RealtimeStatus
	Supported         bool
	Connecting        bool
	Open              bool
	Closed            bool
	Messages          []RealtimeMessage
	LastMessage       RealtimeMessage
	Errors            []RealtimeError
	Error             error
	ConnectAttempts   int
	ReconnectAttempts int
	Reconnects        int
	NextReconnectAt   time.Time
	LastOpenAt        time.Time
	LastCloseAt       time.Time
	LastHeartbeatAt   time.Time
	HeartbeatMisses   int
}

type RealtimeStatus string

type ResiliencePolicy struct {
	// Retry controls backoff and attempt limits.
	Retry RetryPolicy

	// Breaker, when non-nil, gates every call through circuit-breaker logic.
	Breaker *CircuitBreaker
	// contains filtered or unexported fields
}

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

type ResourceState[T any] struct {
	Value   T
	Loading bool
	Error   error
	Ready   bool
}

type Result struct {
	Data   any
	Status int
	// Headers are response headers, always plain strings (unlike Options.Headers, whose
	// values are typed any for request-side flexibility).
	Headers map[string]string
	Err     error
}

type RetryPolicy struct {
	// MaxAttempts is the total number of times the operation may be called,
	// including the first attempt. Zero or negative values disable retries.
	MaxAttempts int

	// BaseDelay is the wait time before the second attempt.
	BaseDelay time.Duration

	// MaxDelay caps the computed backoff delay so it never grows unboundedly.
	MaxDelay time.Duration

	// Multiplier scales the delay between successive retries. A value of 2.0
	// doubles the delay after each failure. A zero multiplier is honored as
	// zero, so attempts after the second compute a zero delay; prefer
	// DefaultRetryPolicy or an explicit positive multiplier for real backoff.
	Multiplier float64

	// Jitter is a fractional spread added to each delay to prevent thundering
	// herds. A value of 0.1 allows a ±10 % random spread around the base delay.
	Jitter float64

	// RetryIf, when non-nil, is called with each error to decide whether the
	// operation should be retried. Returning false stops retrying immediately
	// and surfaces the error to the caller. When nil, all errors are retried.
	RetryIf func(error) bool
}

type State = runtime.FetchState

type UploadUpdate struct {
	Loaded           int64
	Total            int64
	LengthComputable bool
	Done             bool
	Result           Result
}

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

type WebSocketOptions struct {
	Protocols         []string
	Manual            bool
	DisableReconnect  bool
	MaxReconnects     int
	InitialBackoff    time.Duration
	MaxBackoff        time.Duration
	BackoffFactor     float64
	HeartbeatInterval time.Duration
	HeartbeatTimeout  time.Duration
	HeartbeatMessage  string
	MaxMessages       int
	MaxErrors         int
	Now               func() time.Time
}