مرجع API

final class PipelineBuilder {
    public static function profile(string $id, string $version): self;
    public function partition(
        string $application,
        string $environment,
        string $subject,
        ?string $tenant = null,
    ): self;
    public function attemptTimeout(
        Duration $maximumDuration,
        AttemptTimeoutRequirement $requirement,
    ): self;
    public function retry(
        int $maxAttempts,
        BackoffMode $backoff,
        Duration $baseDelay,
        Duration $maximumDelay,
        JitterMode $jitter,
        ?Duration $minimumRemainingAttemptAllowance = null,
    ): self;
    public function retryBudget(
        int $capacityTokens,
        int $refillTokens,
        Duration $refillInterval,
        Duration $reservationLease,
    ): self;
    public function rateLimit(
        RateAlgorithmOptions $algorithm,
        int $cost = 1,
    ): self;
    public function circuitBreaker(
        CircuitWindowOptions $window,
        int $minimumSamples,
        Ratio $failureThreshold,
        Duration $openDuration,
        int $probeCapacity,
        int $probeSuccessThreshold,
        Duration $permitLease,
    ): self;
    public function bulkhead(int $capacity, Duration $lease): self;
    public function cooldown(
        Duration $cleanupGrace,
        ?Duration $maximumExtension = null,
    ): self;
    public function fallbackScope(FallbackScope $scope): self;
    public static function tokenBucket(
        int $capacity,
        int $refillTokens,
        Duration $refillInterval,
    ): TokenBucketOptions;
    public static function fixedWindow(
        int $capacity,
        Duration $window,
        FixedWindowAnchor $anchor,
    ): FixedWindowOptions;
    public static function slidingWindow(
        int $capacity,
        Duration $window,
    ): SlidingCounterOptions;
    public static function lastCalls(int $completedSamples): CountCircuitWindow;
    public static function timeWindow(
        Duration $window,
        Duration $bucketGranularity,
    ): TimeCircuitWindow;
    public function definition(): PipelineDefinition;
    public function compile(RuntimeEnvironment $environment): CompiledPipeline;
    public function compileInMemory(
        OutcomeClassifier $classifier,
        ?EventSink $events = null,
    ): CompiledPipeline;
}

final class CompiledPipeline {
    public function newContext(
        Duration $timeout,
        ?OperationSafety $safety = null,
        ?FallbackOperation $fallback = null,
        ?Cancellation $cancellation = null,
        ?BoundedMetadata $attributes = null,
        OperationId|string|null $operationId = null,
        ?PartitionIdentity $partition = null,
    ): ExecutionContext;
    public function execute(
        callable $operation,
        ExecutionContext $context,
    ): mixed;
    public function executeDetailed(
        callable $operation,
        ExecutionContext $context,
    ): ExecutionCompletion;
    public function executeOperation(
        AttemptOperation $operation,
        ExecutionContext $context,
    ): mixed;
    public function executeOperationDetailed(
        AttemptOperation $operation,
        ExecutionContext $context,
    ): ExecutionCompletion;
    public function explain(): PipelineExplanation;
}

final class InMemoryEnvironment {
    public static function for(
        PipelineDefinition $definition,
        OutcomeClassifier $classifier,
        ?EventSink $events = null,
    ): RuntimeEnvironment;
}

final readonly class PipelineExplanation {
    public function __construct(
        public ProfileId $profileId,
        public ProfileVersion $profileVersion,
        public array $enabledPolicies,
        public array $capabilityNotes,
    );
}

final readonly class Duration {
    public function __construct(public int $nanoseconds);
    public static function zero(): self;
    public static function nanoseconds(int $value): self;
    public static function microseconds(int $value): self;
    public static function milliseconds(int $value): self;
    public static function seconds(int $value): self;
    public function isZero(): bool;
    public function isPositive(): bool;
    public function add(self $other): self;
    public function subtract(self $other): self;
    public function saturatingSubtract(self $other): self;
    public function multiply(int $factor): self;
    public function min(self $other): self;
    public function max(self $other): self;
    public function compare(self $other): int;
    public function equals(self $other): bool;
    public function ceilMicroseconds(): int;
}

final readonly class Ratio {
    public const MAX_COMPONENT = 9007199254740991;
    public function __construct(
        public PositiveInt $numerator,
        public PositiveInt $denominator,
    );
    public static function of(int $numerator, int $denominator): self;
}

final readonly class ExecutionContext {
    public function __construct(
        public OperationId $operationId,
        public PartitionIdentity $partition,
        public Deadline $deadline,
        public Cancellation $cancellation,
        public OperationMetadata $metadata,
        public ?FallbackOperation $fallback,
    );
}

final readonly class AttemptContext {
    public function __construct(
        public OperationId $operationId,
        public AttemptId $attemptId,
        public int $dispatchedAttemptNumber,
        public Deadline $deadline,
        public Cancellation $cancellation,
        public Duration $attemptTimeout,
    );
}

final readonly class OperationSafety {
    public static function unsafe(): self;
    public static function replayableRead(ReplaySafetyContract $contract): self;
    public static function providerIdempotentMutation(
        ReplaySafetyContract $contract,
    ): self;
}

final readonly class ReplaySafetyContract {
    public static function forReadOnlyCallable(
        string $operationName,
        Duration $validFor,
        ?Clock $clock = null,
        ?array $retryableOutcomeCodes = null,
    ): self;
    public function __construct(
        public string $contractReference,
        public string $identityValue,
        public string $identityScope,
        public string $duplicateHandlingContract,
        public DateTimeImmutable $establishedAt,
        public DateTimeImmutable $validUntil,
        public Duration $retention,
        public ReplayPreparation $preparation,
        public array $retryableOutcomeCodes,
    );
}

enum OperationSafetyKind: string {
    case Unsafe = 'unsafe';
    case ReplayableRead = 'replayable_read';
    case ProviderIdempotentMutation = 'provider_idempotent_mutation';
}

interface FallbackOperation {
    public function invoke(Outcome $original, ExecutionContext $context): mixed;
}

enum FallbackScope: string {
    case BusinessOutcomesOnly = 'business_outcomes_only';
    case IncludeAdmissionRefusals = 'include_admission_refusals';
}

final readonly class ExceptionClassifier implements OutcomeClassifier {
    public static function create(): self;
    public function retryOn(string ...$exceptionClasses): self;
    public function countAsCircuitFailure(string ...$exceptionClasses): self;
    public function ignoreForCircuit(string ...$exceptionClasses): self;
    public function fallbackOn(string ...$exceptionClasses): self;
    public function retryAfterFrom(callable $extractor): self;
    public function unacceptableValuesWhen(callable $predicate): self;
    public function classify(
        Outcome $outcome,
        OperationMetadata $metadata,
    ): OutcomeClassification;
}

interface OutcomeClassifier {
    public function classify(
        Outcome $outcome,
        OperationMetadata $metadata,
    ): OutcomeClassification;
}

final readonly class Outcome {
    public static function fromValue(
        mixed $value,
        BoundedMetadata $metadata,
    ): self;
    public static function fromException(
        Throwable $exception,
        BoundedMetadata $metadata,
    ): self;
    public function value(): mixed;
    public function exception(): Throwable;
}

final readonly class OutcomeClassification {
    public function __construct(
        public RetryEligibility $retry,
        public CircuitVerdict $circuit,
        public FallbackEligibility $fallback,
        public Acceptability $acceptability,
        public string $reasonCode,
        public ?Duration $retryAfterLowerBound,
    );
}

enum OutcomeKind: string {
    case Value = 'value';
    case Exception = 'exception';
}

enum RetryEligibility: string {
    case Eligible = 'eligible';
    case Ineligible = 'ineligible';
}

enum FallbackEligibility: string {
    case Eligible = 'eligible';
    case Ineligible = 'ineligible';
}

enum CircuitVerdict: string {
    case Success = 'success';
    case Failure = 'failure';
    case Neutral = 'neutral';
}

enum Acceptability: string {
    case Acceptable = 'acceptable';
    case Unacceptable = 'unacceptable';
}

enum BackoffMode: string {
    case Constant = 'constant';
    case Exponential = 'exponential';
}

enum JitterMode: string {
    case None = 'none';
    case Full = 'full';
}

enum AttemptTimeoutRequirement: string {
    case Cooperative = 'cooperative';
    case TransportEnforced = 'transport_enforced';
}

enum FixedWindowAnchor: string {
    case Aligned = 'aligned';
    case FirstHit = 'first_hit';
}

final readonly class TokenBucketOptions implements RateAlgorithmOptions {
    public function __construct(
        public PositiveInt $capacityUnits,
        public PositiveInt $refillUnits,
        public Duration $refillInterval,
    );
}

final readonly class FixedWindowOptions implements RateAlgorithmOptions {
    public function __construct(
        public PositiveInt $capacityUnits,
        public Duration $window,
        public FixedWindowAnchor $anchor,
    );
}

final readonly class SlidingCounterOptions implements RateAlgorithmOptions {
    public function __construct(
        public PositiveInt $capacityUnits,
        public Duration $window,
    );
}

final readonly class CountCircuitWindow implements CircuitWindowOptions {
    public function __construct(public PositiveInt $completedSamples);
}

final readonly class TimeCircuitWindow implements CircuitWindowOptions {
    public function __construct(
        public Duration $window,
        public Duration $bucketGranularity,
    );
}

final readonly class ExecutionCompletion {
    public function __construct(
        public CompletionDisposition $disposition,
        public ?Outcome $terminalOutcome,
        public ?Outcome $fallbackOutcome,
        public ?ReqtideException $policyCause,
        public ?ClassificationFailedException $classifierCause,
        public array $attempts,
        public array $diagnostics,
        public ExecutionSummary $summary,
    );
    public function problem(): ?Problem;
}

enum CompletionDisposition: string {
    case Succeeded = 'succeeded';
    case Failed = 'failed';
    case Rejected = 'rejected';
    case Deferred = 'deferred';
    case Cancelled = 'cancelled';
    case DeadlineExceeded = 'deadline_exceeded';
    case FallbackSucceeded = 'fallback_succeeded';
    case FallbackFailed = 'fallback_failed';
}

final readonly class ExecutionSummary {
    public function __construct(
        public OperationId $operationId,
        public ProfileVersion $profileVersion,
        public CompletionDisposition $disposition,
        public int $dispatched,
        public int $admittedNotDispatched,
        public int $retries,
        public int $successfulAttempts,
        public int $failedAttempts,
        public int $neutralAttempts,
        public int $actualValues,
        public int $actualExceptions,
        public int $fallbackExecutions,
        public bool $accountingComplete,
        public int $omittedDiagnostics,
        public ?Duration $elapsed,
        public int $admissionUncertain = 0,
    );
}

final readonly class AttemptRecord {
    public function __construct(
        public AttemptId $attemptId,
        public int $dispatchedAttemptNumber,
        public ActualAttemptDisposition $disposition,
        public Outcome $outcome,
        public ?Duration $elapsed,
        public SettlementOverride $logicalOverride,
        public ?OutcomeClassification $classification,
        public CircuitVerdict $circuitVerdict,
    );
}

final readonly class Diagnostic {
    public function __construct(
        public string $stageCode,
        public string $reasonCode,
    );
    public static function of(Stage $stage, ReasonCode $reason): self;
    public function stage(): ?Stage;
    public function reason(): ?ReasonCode;
}

final readonly class Problem {
    public const TYPE_PREFIX = 'tag:enaloo.com,2026:reqtide:problem:';
    public ?Stage $stage;
    public ?string $correlationId;
    public array $causes;
    public function __construct(
        public ReasonCode $code,
        ?Stage $stage = null,
        public ?OperationId $operationId = null,
        public ?ProfileVersion $profileVersion = null,
        public ?AttemptId $attemptId = null,
        ?string $correlationId = null,
        array $causes = [],
    );
    public function withContext(
        OperationId $operationId,
        ProfileVersion $profileVersion,
        ?AttemptId $attemptId = null,
        ?string $correlationId = null,
    ): self;
    public function type(): string;
    public function title(): string;
    public function category(): Category;
    public function severity(): Severity;
    public function retryability(): Retryability;
    public function detail(): string;
    public function toArray(): array;
    public function jsonSerialize(): array;
}

interface ProblemCarrier extends ReqtideException {
    public function reason(): ReasonCode;
    public function problem(): Problem;
}

interface ReqtideException {
}

enum ReasonCode: string {
    case CircuitOpen = 'circuit_open';
    case CircuitProbeCapacityExhausted = 'circuit_probe_capacity_exhausted';
    case ConcurrencyCapacityExhausted = 'concurrency_capacity_exhausted';
    case OwnershipLeaseInsufficient = 'ownership_lease_insufficient';
    case CooldownActive = 'cooldown_active';
    case CooldownExceedsDeadline = 'cooldown_exceeds_deadline';
    case RateAccepted = 'rate.accepted';
    case RateCostExceedsCapacity = 'rate.cost_exceeds_capacity';
    case RateExhausted = 'rate.exhausted';
    case RateWaitUnrepresentable = 'rate.wait_unrepresentable';
    case AdmissionRejected = 'admission_rejected';
    case AdmissionDeferred = 'admission_deferred';
    case AdmissionImpossible = 'admission_impossible';
    case CircuitThresholdExceeded = 'circuit.threshold_exceeded';
    case CircuitProbeFailed = 'circuit.probe_failed';
    case CircuitProbesSucceeded = 'circuit.probes_succeeded';
    case CircuitOpenElapsed = 'circuit.open_elapsed';
    case RetryBudgetExhausted = 'retry_budget_exhausted';
    case RetryBudgetCommitRefused = 'retry_budget_commit_refused';
    case AttemptsExhausted = 'attempts_exhausted';
    case OutcomeNotRetryable = 'outcome_not_retryable';
    case RetryDelayExceedsDeadline = 'retry_delay_exceeds_deadline';
    case AttemptAllowanceUnavailable = 'attempt_allowance_unavailable';
    case ReplayContractNotValid = 'replay_contract_not_valid';
    case ReplayHorizonInadequate = 'replay_horizon_inadequate';
    case ReplayHorizonSaturated = 'replay_horizon_saturated';
    case RetryDeadlineReached = 'retry_deadline_reached';
    case RetryCancelled = 'retry_cancelled';
    case RetryAfterExceedsMaximumDelay = 'retry_after_exceeds_maximum_delay';
    case RetryAfterExceedsDeadline = 'retry_after_exceeds_deadline';
    case DelayFailed = 'delay_failed';
    case OperationCancelled = 'operation_cancelled';
    case DeadlineExceeded = 'deadline_exceeded';
    case StateUnavailable = 'unavailable';
    case StateCorrupt = 'corrupt';
    case StateIndeterminate = 'indeterminate';
    case StateCapacityExceeded = 'capacity_exceeded';
    case ClockFailure = 'clock_failure';
    case UnexpectedBackendFailure = 'unexpected';
    case RuntimeAdapterFailure = 'runtime_adapter_failure';
    case RateConsumeIndeterminate = 'rate_consume_indeterminate';
    case CommitNotConfirmed = 'commit_not_confirmed';
    case ClockUnavailable = 'clock_unavailable';
    case RetryClockUnavailable = 'retry_clock_unavailable';
    case FallbackClockUnavailable = 'fallback_clock_unavailable';
    case TimingUnavailable = 'timing_unavailable';
    case FallbackTimingUnavailable = 'fallback_timing_unavailable';
    case ElapsedUnavailable = 'elapsed_unavailable';
    case CancellationSampleFailed = 'cancellation_sample_failed';
    case RandomOutOfRange = 'random_out_of_range';
    case ConcurrencyReleaseFailed = 'concurrency_release_failed';
    case ConcurrencyReleaseStale = 'concurrency_release_stale';
    case CircuitAbandonFailed = 'circuit_abandon_failed';
    case CircuitAbandonStale = 'circuit_abandon_stale';
    case CircuitRecordFailed = 'circuit_record_failed';
    case CircuitRecordStale = 'circuit_record_stale';
    case RetryReservationReleaseFailed = 'retry_reservation_release_failed';
    case CooldownExtendFailed = 'cooldown_extend_failed';
    case CooldownExtensionCapped = 'cooldown_extension_capped';
    case SettlementAccounting = 'settlement_accounting';
    case CompletionSinkFailed = 'completion_sink_failed';
    case EventSinkFailed = 'event_sink_failed';
    case ClassifierFailed = 'classifier_failed';
    case LateSignalExtractionFailed = 'late_signal_extraction_failed';
    case FallbackFailed = 'fallback_failed';
    case DiscardFailed = 'discard_failed';
    case ValueAccepted = 'value_accepted';
    case ValueUnacceptable = 'value_unacceptable';
    case ExceptionRetryable = 'exception_retryable';
    case ExceptionFailure = 'exception_failure';
    case ExceptionIgnored = 'exception_ignored';
    case PreparationFailed = 'preparation_failed';
    case LifecycleFailure = 'lifecycle_failure';
    case UnexpectedFailure = 'unexpected_failure';
    case InvalidConfiguration = 'invalid_configuration';
    case CapabilityMismatch = 'capability_mismatch';
    public function category(): Category;
    public function severity(): Severity;
    public function retryability(): Retryability;
    public function stage(): ?Stage;
    public function title(): string;
}

enum Retryability: string {
    case Never = 'never';
    case AfterWait = 'after_wait';
    case Transient = 'transient';
    case Unknown = 'unknown';
}

enum Category: string {
    case Policy = 'policy';
    case Infrastructure = 'infrastructure';
    case Configuration = 'configuration';
    case Classification = 'classification';
    case Fallback = 'fallback';
    case Admission = 'admission';
    case Retry = 'retry';
    case Accounting = 'accounting';
    case Preparation = 'preparation';
}

enum Severity: string {
    case Debug = 'debug';
    case Info = 'info';
    case Notice = 'notice';
    case Warning = 'warning';
    case Error = 'error';
    case Critical = 'critical';
    public function psr3Level(): string;
    public function rank(): int;
    public function isAtLeast(self $threshold): bool;
}

enum Stage: string {
    case Preflight = 'preflight';
    case Preparation = 'preparation';
    case RetryBudget = 'retry_budget';
    case Admission = 'admission';
    case Barrier = 'barrier';
    case Dispatch = 'dispatch';
    case Settlement = 'settlement';
    case Classification = 'classification';
    case Finalize = 'finalize';
    case Cleanup = 'cleanup';
    case Discard = 'discard';
    case Retry = 'retry';
    case Fallback = 'fallback';
    case Observation = 'observation';
    case Summary = 'summary';
}

abstract class PolicyTerminationException implements ProblemCarrier, ReqtideException {
    public function problem(): Problem;
}

final class AdmissionRejectedException extends PolicyTerminationException {
    public function __construct(
        public readonly AdmissionDecision $decision,
        ?Throwable $previous = null,
    );
    public function reason(): ReasonCode;
}

final class AdmissionDeferredException extends PolicyTerminationException {
    public function __construct(
        public readonly AdmissionDecision $decision,
        ?Throwable $previous = null,
    );
    public function reason(): ReasonCode;
}

final class ImpossibleAdmissionException extends PolicyTerminationException {
    public function __construct(
        public readonly AdmissionDecision $decision,
        ?Throwable $previous = null,
    );
    public function reason(): ReasonCode;
}

final class DeadlineExceededException extends PolicyTerminationException {
    public function reason(): ReasonCode;
}

final class OperationCancelledException extends PolicyTerminationException {
    public function reason(): ReasonCode;
}

final class FallbackFailedException implements ProblemCarrier, ReqtideException {
    public function __construct(
        public readonly Outcome $originalOutcome,
        public readonly Throwable $fallbackCause,
    );
    public function reason(): ReasonCode;
    public function problem(): Problem;
}

final class InvalidConfigurationException implements ProblemCarrier, ReqtideException {
    public function reason(): ReasonCode;
    public function problem(): Problem;
}

final class CapabilityMismatchException implements ProblemCarrier, ReqtideException {
    public function reason(): ReasonCode;
    public function problem(): Problem;
}

abstract class InfrastructureException implements ProblemCarrier, ReqtideException {
    public function problem(): Problem;
}

final class StateUnavailableException extends InfrastructureException {
    public function reason(): ReasonCode;
}

final class StateCapacityExceededException extends InfrastructureException {
    public function reason(): ReasonCode;
}

final class CorruptStateException extends InfrastructureException {
    public function reason(): ReasonCode;
}

final class IndeterminateStateException extends InfrastructureException {
    public function reason(): ReasonCode;
}

final class ClockFailureException extends InfrastructureException {
    public function reason(): ReasonCode;
}

final class ClassificationFailedException implements ProblemCarrier, ReqtideException {
    public function __construct(
        public readonly Outcome $actualOutcome,
        public readonly Throwable $classifierCause,
    );
    public function reason(): ReasonCode;
    public function problem(): Problem;
}

final class PreparationFailedException implements ProblemCarrier, ReqtideException {
    public function __construct(public readonly Throwable $preparationCause);
    public function reason(): ReasonCode;
    public function problem(): Problem;
}

interface EventSink {
    public function emit(Event $event): void;
}

interface Event {
    public function operationId(): OperationId;
    public function profileVersion(): ProfileVersion;
}

final readonly class RetryScheduled implements Event {
    public function __construct(
        private OperationId $operation,
        private ProfileVersion $profile,
        public int $nextDispatchedAttemptNumber,
        public Duration $delay,
        public string $reasonCode,
    );
    public function operationId(): OperationId;
    public function profileVersion(): ProfileVersion;
}

final readonly class AdmissionRejected implements Event {
    public function __construct(
        private OperationId $operation,
        private ProfileVersion $profile,
        public string $policyKind,
        public string $reasonCode,
    );
    public function operationId(): OperationId;
    public function profileVersion(): ProfileVersion;
    public function reason(): ?ReasonCode;
    public function severity(): Severity;
}

final readonly class AttemptCompleted implements Event {
    public function __construct(
        private OperationId $operation,
        private ProfileVersion $profile,
        public AttemptId $attemptId,
        public CircuitVerdict $verdict,
        public ?Duration $elapsed,
    );
    public function operationId(): OperationId;
    public function profileVersion(): ProfileVersion;
}

final readonly class OperationCompleted implements Event {
    public function __construct(
        private OperationId $operation,
        private ProfileVersion $profile,
        public CompletionDisposition $disposition,
        public ?Duration $elapsed,
        public bool $accountingComplete,
    );
    public function operationId(): OperationId;
    public function profileVersion(): ProfileVersion;
}

final readonly class CircuitTransitioned implements Event {
    public function __construct(
        private OperationId $operation,
        private ProfileVersion $profile,
        public string $fromState,
        public string $toState,
        public string $reasonCode,
    );
    public function operationId(): OperationId;
    public function profileVersion(): ProfileVersion;
    public function reason(): ?ReasonCode;
    public function severity(): Severity;
}

final readonly class BackendErrorObserved implements Event {
    public function __construct(
        private OperationId $operation,
        private ProfileVersion $profile,
        public string $backendKind,
        public string $failureCode,
    );
    public function operationId(): OperationId;
    public function profileVersion(): ProfileVersion;
    public function reason(): ?ReasonCode;
    public function severity(): Severity;
}

final readonly class AccountingDegraded implements Event {
    public function __construct(
        private OperationId $operation,
        private ProfileVersion $profile,
        public string $reasonCode,
    );
    public function operationId(): OperationId;
    public function profileVersion(): ProfileVersion;
    public function reason(): ?ReasonCode;
    public function severity(): Severity;
}

final class NullEventSink implements EventSink {
    public function emit(Event $event): void;
}

final class EventSeverity {
    public static function of(Event $event): Severity;
    public static function ofDisposition(
        CompletionDisposition $disposition,
    ): Severity;
}

final class VirtualClock implements Clock {
    public const DEFAULT_WALL_START = '2026-01-01T00:00:00+00:00';
    public function __construct(
        int $initialMonotonicNanoseconds = 1000000000,
        ?DateTimeImmutable $initialWall = null,
    );
    public function startingAt(DateTimeImmutable $wall): self;
    public function monotonicNow(): int;
    public function wallNow(): DateTimeImmutable;
    public function advance(Duration $duration): void;
    public function advanceMonotonicOnly(Duration $duration): void;
    public function setMonotonic(int $nanoseconds): void;
    public function setWall(DateTimeImmutable $wall): void;
    public function failNextMonotonicReads(int $count = 1): void;
    public function failNextWallReads(int $count = 1): void;
    public function monotonicReadCount(): int;
    public function wallReadCount(): int;
    public function peekMonotonic(): int;
}

final class VirtualDelayScheduler implements DelayScheduler {
    public function __construct(private readonly VirtualClock $clock);
    public function capability(): SchedulingCapability;
    public function cancelDuringNextDelay(
        CancellationToken $token,
        Duration $after,
    ): void;
    public function delay(
        Duration $duration,
        Deadline $deadline,
        Cancellation $cancellation,
    ): DelayDisposition;
    public function records(): array;
    public function requestedDelays(): array;
    public function callCount(): int;
    public function totalElapsed(): Duration;
}

final class ControlledRuntimeAdapter implements RuntimeAdapter {
    public function __construct(
        private readonly VirtualClock $clock,
        private readonly ?DispatchScript $default = null,
        private readonly ?RuntimeCapabilities $capabilities = null,
    );
    public static function defaultCapabilities(): RuntimeCapabilities;
    public function enqueue(DispatchScript ...$scripts): void;
    public function capabilities(): RuntimeCapabilities;
    public function invoke(
        PreparedAttempt $operation,
        AttemptContext $context,
        AttemptControls $controls,
    ): RuntimeExecution;
    public function dispatchCount(): int;
    public function dispatches(): array;
    public function attemptContexts(): array;
    public function pendingScripts(): int;
}

final readonly class DispatchScript {
    public static function returning(mixed $value): self;
    public static function throwing(Throwable $exception): self;
    public static function callingOperation(): self;
    public function advancing(Duration $duration): self;
    public function requestingCancellation(CancellationToken $token): self;
}

final class RecordingEventSink implements EventSink {
    public function emit(Event $event): void;
    public function throwOnEmit(Throwable $failure, ?int $times = null): void;
    public function stopThrowing(): void;
    public function events(): array;
    public function ofType(string $class): array;
    public function count(): int;
    public function clear(): void;
}

final class SeededRandomSource implements RandomSource {
    public function __construct(public readonly int $seed);
    public function integer(int $minimumInclusive, int $maximumInclusive): int;
    public function draws(): int;
}

final class ScriptedRandomSource implements RandomSource {
    public function __construct(array $values);
    public function enqueue(int ...$values): void;
    public function integer(int $minimumInclusive, int $maximumInclusive): int;
    public function remaining(): int;
    public function requests(): array;
}

final class RedisEnvironment {
    public static function for(
        PipelineDefinition $definition,
        OutcomeClassifier $classifier,
        RedisConnectionOptions $connection,
        RedisRegistry $registry,
        ?EventSink $events = null,
    ): RuntimeEnvironment;
    public static function explain(
        CompiledPipeline $pipeline,
        RedisConnectionOptions $connection,
        RedisRegistry $registry,
    ): PipelineExplanation;
}

final readonly class RedisRegistry {
    public const SCHEMA_VERSION = 1;
    public const DEFAULT_MAX_PARTITIONS = 10000;
    public const DEFAULT_MAX_RECORDS = 20000;
    public function __construct(
        public string $keyPrefix,
        public string $identity,
        private string $secret,
        public int $maxPartitions = self::DEFAULT_MAX_PARTITIONS,
        public int $maxRecords = self::DEFAULT_MAX_RECORDS,
    );
}

final class RedisRegistryAdmin {
    public function __construct(
        RedisConnectionOptions $administrativeConnection,
        private readonly RedisRegistry $registry,
    );
    public function initialize(): RegistryStatus;
    public function verify(): RegistryStatus;
    public function retire(): RegistryStatus;
    public function purgeRetired(): int;
    public function inspectServer(): ServerPolicyReport;
}

final readonly class RedisConnectionOptions {
    public function __construct(
        public string $host,
        public float $connectTimeoutSeconds,
        public float $readWriteTimeoutSeconds,
        public int $port = 6379,
        public ?string $username = null,
        private ?string $password = null,
        public bool $tls = false,
        public ?string $caFile = null,
        public ?string $tlsServerName = null,
    );
}

final class RedisAcl {
    public static function execution(RedisRegistry $registry): array;
    public static function administration(RedisRegistry $registry): array;
}

final readonly class RegistryStatus {
    public function __construct(
        public bool $created,
        public int $watermarkSeconds,
        public int $watermarkMicroseconds,
        public int $partitions,
        public int $records,
        public int $maxPartitions,
        public int $maxRecords,
    );
}

final readonly class ServerPolicyReport {
    public function __construct(
        public ?string $evictionPolicy,
        public ?int $maxMemoryBytes,
    );
    public function protectsState(): ?bool;
}

final class RedisRegistryMaintenance {
    public function __construct(
        RedisConnectionOptions $connection,
        private readonly RedisRegistry $registry,
        ?RedisBridge $bridge = null,
    );
    public function step(): array;
}

final class RedisCircuitAdmin {
    public function __construct(
        RedisConnectionOptions $connection,
        private readonly RedisRegistry $registry,
        ?RedisBridge $bridge = null,
    );
    public function reset(PolicyIdentity $identity): ?Generation;
}

final class RedisRateLimitBackend implements RateLimitBackend, StateBackend {
    public function __construct(
        RedisConnectionOptions $connection,
        private readonly RedisRegistry $registry,
        ?RedisBridge $bridge = null,
    );
    public function capabilities(): StateBackendCapabilities;
    public function consume(
        RateLimitPolicy $policy,
        PositiveInt $cost,
        CommandId $command,
    ): AdmissionDecision;
    public function inspect(
        RateLimitPolicy $policy,
        PositiveInt $requestedCost,
    ): RateLimitInspection;
}

final class RedisCircuitBackend implements CircuitBackend, StateBackend {
    public function __construct(
        RedisConnectionOptions $connection,
        private readonly RedisRegistry $registry,
        ?RedisBridge $bridge = null,
    );
    public function capabilities(): StateBackendCapabilities;
    public function acquire(
        CircuitPolicy $policy,
        AttemptId $attempt,
        PermitOwnerId $owner,
        CommandId $command,
    ): CircuitAdmission;
    public function record(
        CircuitPolicy $policy,
        CircuitPermit $permit,
        CircuitVerdict $verdict,
        CommandId $command,
    ): FinalizationResult;
    public function abandon(
        CircuitPolicy $policy,
        CircuitPermit $permit,
        CommandId $command,
    ): FinalizationResult;
}

final class RedisConcurrencyBackend implements ConcurrencyBackend, StateBackend {
    public function __construct(
        RedisConnectionOptions $connection,
        private readonly RedisRegistry $registry,
        ?RedisBridge $bridge = null,
    );
    public function capabilities(): StateBackendCapabilities;
    public function acquire(
        ConcurrencyPolicy $policy,
        PermitOwnerId $owner,
        CommandId $command,
    ): ConcurrencyAdmission;
    public function release(
        ConcurrencyPolicy $policy,
        ConcurrencyPermit $permit,
        CommandId $command,
    ): FinalizationResult;
}

final class RedisRetryBudgetBackend implements RetryBudgetBackend, StateBackend {
    public function __construct(
        RedisConnectionOptions $connection,
        private readonly RedisRegistry $registry,
        ?RedisBridge $bridge = null,
    );
    public function capabilities(): StateBackendCapabilities;
    public function inspect(RetryBudgetPolicy $policy): RetryBudgetInspection;
    public function reserve(
        RetryBudgetPolicy $policy,
        AttemptId $attempt,
        PermitOwnerId $owner,
        CommandId $command,
    ): RetryReservationDecision;
    public function commit(
        RetryBudgetPolicy $policy,
        RetryBudgetReservation $reservation,
        CommandId $command,
    ): RetryBudgetFinalizationResult;
    public function release(
        RetryBudgetPolicy $policy,
        RetryBudgetReservation $reservation,
        CommandId $command,
    ): RetryBudgetFinalizationResult;
}

final class RedisCooldownBackend implements CooldownBackend, StateBackend {
    public function __construct(
        RedisConnectionOptions $connection,
        private readonly RedisRegistry $registry,
        ?RedisBridge $bridge = null,
    );
    public function capabilities(): StateBackendCapabilities;
    public function inspect(CooldownPolicy $policy): CooldownDecision;
    public function extend(
        CooldownPolicy $policy,
        Duration $extension,
        CommandId $command,
    ): CooldownDecision;
}

final class ReqtideClient {
    public static function inMemory(
        PipelineBuilder $pipeline,
        ?GuzzleConfiguration $configuration = null,
        ?EventSink $events = null,
    ): self;
    public static function withBackends(
        PipelineBuilder $pipeline,
        ?RateLimitBackend $rateLimit = null,
        ?CircuitBackend $circuit = null,
        ?ConcurrencyBackend $concurrency = null,
        ?RetryBudgetBackend $retryBudget = null,
        ?CooldownBackend $cooldown = null,
        ?GuzzleConfiguration $configuration = null,
        ?EventSink $events = null,
    ): self;
    public function uri(UriInterface|string $reference): UriInterface;
    public function send(
        HttpOperation $operation,
        Duration $timeout,
        ?Cancellation $cancellation = null,
    ): ResponseInterface;
    public function sendDetailed(
        HttpOperation $operation,
        Duration $timeout,
        ?Cancellation $cancellation = null,
    ): ExecutionCompletion;
    public function sendAsync(
        HttpOperation $operation,
        Duration $timeout,
        ?Cancellation $cancellation = null,
    ): PromiseInterface;
    public function explain(bool $async = false): PipelineExplanation;
}

final readonly class GuzzleConfiguration {
    public const ALLOWED_CLIENT_DEFAULTS = array (
  0 => 'headers',
  1 => 'auth',
  2 => 'proxy',
  3 => 'verify',
  4 => 'cert',
  5 => 'ssl_key',
  6 => 'crypto_method',
  7 => 'force_ip_resolve',
  8 => 'version',
  9 => 'decode_content',
);
    public HttpOutcomeClassifier $classifier;
    public ?UriInterface $baseUri;
    public function __construct(
        ?HttpOutcomeClassifier $classifier = null,
        public array $clientDefaults = [],
        UriInterface|string|null $baseUri = null,
        public array $credentialHeaders = [],
    );
}

final readonly class HttpOperation {
    public const DEFAULT_MAX_VERIFIED_BODY_BYTES = 16777216;
    public ?Closure $bodyFactory;
    public function forClient(GuzzleConfiguration $configuration): self;
    public static function read(
        RequestInterface $request,
        string $operationGroup,
        Duration $validFor,
        array $retryableOutcomeCodes = [],
        ?Closure $bodyFactory = null,
        ?Clock $clock = null,
        ?string $credentialKey = null,
        BodyIntegrity $bodyIntegrity = BodyIntegrity::Verified,
        int $maxVerifiedBodyBytes = self::DEFAULT_MAX_VERIFIED_BODY_BYTES,
    ): self;
    public static function idempotentMutation(
        RequestInterface $request,
        string $operationGroup,
        string $identityValue,
        string $identityScope,
        string $duplicateHandling,
        Duration $validFor,
        ?Duration $retention = null,
        ?string $identityHeader = 'Idempotency-Key',
        array $retryableOutcomeCodes = [],
        ?Closure $bodyFactory = null,
        ?Clock $clock = null,
        ?string $credentialKey = null,
        BodyIntegrity $bodyIntegrity = BodyIntegrity::Verified,
        int $maxVerifiedBodyBytes = self::DEFAULT_MAX_VERIFIED_BODY_BYTES,
    ): self;
    public static function single(
        RequestInterface $request,
        string $operationGroup,
        ?string $credentialKey = null,
    ): self;
    public function metadata(): OperationMetadata;
}

final readonly class HttpOutcomeClassifier implements OutcomeClassifier {
    public static function starter(?Clock $clock = null): self;
    public static function empty(?Clock $clock = null): self;
    public function withRetryableStatuses(int ...$statuses): self;
    public function withCircuitFailureStatuses(int ...$statuses): self;
    public function withCircuitNeutralStatuses(int ...$statuses): self;
    public function withFallbackStatuses(int ...$statuses): self;
    public function withRetryAfterStatuses(int ...$statuses): self;
    public function withRetryableTransportErrnos(int ...$errnos): self;
    public function retryableOutcomeCodes(): array;
    public function classify(
        Outcome $outcome,
        OperationMetadata $metadata,
    ): OutcomeClassification;
}

final class RetryAfter {
    public const MAX_SECONDS = 9007199254;
    public static function read(
        array $lines,
        DateTimeImmutable $now,
    ): RetryAfterReading;
}

final readonly class RetryAfterReading {
    public function __construct(
        public ?Duration $delay,
        public int $validLines,
        public int $rejectedLines,
        public bool $outOfRange,
    );
}