reflow

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

type CheckpointCollision struct {
	DestKey    string
	Kind       string
	SourceURI  string
	SourceETag string
	SourceSize int64
	DestETag   string
	DestSize   int64
}

type CheckpointItem struct {
	SourceURI    string
	DestURI      string
	SourceKey    string
	DestKey      string
	SourceETag   string
	SourceSize   int64
	Status       string
	Reason       string
	Bytes        int64
	ErrorCode    string
	ErrorMessage string
}

type CheckpointStore interface {
	// ItemDone reports whether a source->dest item completed in a prior run,
	// returning the recorded terminal status when done.
	ItemDone(ctx context.Context, sourceURI, destURI string) (done bool, status string, err error)
	// UpsertItem records the terminal outcome of a reflow item. The item carries
	// only sanitized values.
	UpsertItem(ctx context.Context, item CheckpointItem) error
	// DestKeyObserved reports whether this run/checkpoint has already observed a
	// destination key. It backs in-run arbitration when conditional create is not
	// the whole decision.
	DestKeyObserved(ctx context.Context, destKey string) (bool, error)
	// MarkDestKeyObserved records that a destination key has been observed or
	// written in this run/checkpoint.
	MarkDestKeyObserved(ctx context.Context, destKey string) error
	// NoteDestKeySource records the source identity that produced a destination
	// key after a successful write.
	NoteDestKeySource(ctx context.Context, destKey, sourceURI, sourceETag string, sourceSize int64) error
	// NoteCollision records sanitized collision metadata for audit/resume.
	NoteCollision(ctx context.Context, collision CheckpointCollision) error
	// Close releases store resources.
	Close() error
}

type CheckpointWriterStatsRecord struct {
	MaxBatch int `json:"max_batch"`

	QueueDepthSamples int64 `json:"queue_depth_samples"`
	QueueDepthSum     int64 `json:"queue_depth_sum"`
	QueueDepthPeak    int64 `json:"queue_depth_peak"`

	Admissions            int64 `json:"admissions"`
	AdmissionWaitNanos    int64 `json:"admission_wait_nanos"`
	AdmissionWaitMaxNanos int64 `json:"admission_wait_max_nanos"`
	AdmissionBlocked      int64 `json:"admission_blocked"`

	Barriers            int64 `json:"barriers"`
	BarrierWaitNanos    int64 `json:"barrier_wait_nanos"`
	BarrierWaitMaxNanos int64 `json:"barrier_wait_max_nanos"`
	BarrierOK           int64 `json:"barrier_ok"`
	BarrierRefusal      int64 `json:"barrier_refusal"`
	BarrierWriterFailed int64 `json:"barrier_writer_failed"`
	BarrierWriterClosed int64 `json:"barrier_writer_closed"`
	BarrierCanceled     int64 `json:"barrier_canceled"`

	Batches          int64 `json:"batches"`
	BatchSizeSum     int64 `json:"batch_size_sum"`
	BatchSizeMax     int64 `json:"batch_size_max"`
	BatchSize1       int64 `json:"batch_size_1"`
	BatchSize2To8    int64 `json:"batch_size_2_to_8"`
	BatchSize9To32   int64 `json:"batch_size_9_to_32"`
	BatchSize33To128 int64 `json:"batch_size_33_to_128"`
	BatchSize129Plus int64 `json:"batch_size_129_plus"`

	Commits               int64 `json:"commits"`
	BatchDurationNanos    int64 `json:"batch_duration_nanos"`
	BatchDurationMaxNanos int64 `json:"batch_duration_max_nanos"`
	CommitFatals          int64 `json:"commit_fatals"`
	RequestRefusals       int64 `json:"request_refusals"`

	// Experimental savepoint elision counters (Phase A measure).
	SavepointsCreated int64 `json:"savepoints_created,omitempty"`
	SavepointsElided  int64 `json:"savepoints_elided,omitempty"`
}

type CollisionInfo struct {
	Kind                     string     `json:"kind"`
	DestETagObserved         string     `json:"dest_etag_observed,omitempty"`
	DestSizeObserved         *int64     `json:"dest_size_observed,omitempty"`
	SrcLastModified          *time.Time `json:"src_last_modified,omitempty"`
	DestLastModifiedObserved *time.Time `json:"dest_last_modified_observed,omitempty"`
	DecisionReason           string     `json:"decision_reason,omitempty"`
	DecisionPath             string     `json:"decision_path"`
}

type CollisionPolicy struct {
	Mode             string
	QuarantinePrefix string
}

type ConcurrencyConfig struct {
	RequestedCeiling int
	EffectiveCeiling int
	CeilingReason    string
	AdaptiveEnabled  bool
	Floor            int
	Initial          int

	MemoryLimitBytes           int64
	MemoryLimitSource          string
	MemoryBudgetRequestedBytes int64
	MemoryBudgetEffectiveBytes int64
	MemoryBudgetSource         string
	// RetryBufferCapBytes is the resolved per-copy in-memory retry-buffer
	// bound (min of the transfer default and the effective budget); the copy
	// paths must allocate against this value, spooling above it. Zero means
	// not memory-resolved — consumers fall back to the transfer default.
	RetryBufferCapBytes int64

	// DestDomainMultiplier scales adaptive `current` for the destination
	// domain only (GON-067 PR2 dest-biased admission). Zero or one = symmetric
	// with source (pre-PR2). Product default is 2 after clamp.
	DestDomainMultiplier int
	// DestDomainCeilingEffective is the hard dest-domain cap after clamp:
	// DestDomainMultiplier * EffectiveCeiling, never silent over-admit.
	// Recorded so clients/pools can size to realize the cap.
	DestDomainCeilingEffective int
}

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

type ConcurrencyStats struct {
	AdaptiveEnabled                   bool   `json:"adaptive_enabled"`
	ConcurrencyFloor                  int    `json:"concurrency_floor"`
	ConcurrencyInitial                int    `json:"concurrency_initial"`
	ConcurrencyCeilingRequested       int    `json:"concurrency_ceiling_requested"`
	ConcurrencyCeilingEffective       int    `json:"concurrency_ceiling_effective"`
	ConcurrencyCeilingReason          string `json:"concurrency_ceiling_reason"`
	ConcurrencyFinal                  int    `json:"concurrency_final"`
	ConcurrencyThrottleBackoffs       int64  `json:"concurrency_throttle_backoffs"`
	ConcurrencyAdditiveIncreases      int64  `json:"concurrency_additive_increases"`
	ConcurrencyConnectionErrorFreezes int64  `json:"concurrency_connection_error_freezes"`
	ConcurrencyMaxActive              int    `json:"concurrency_max_active"`
	// ConcurrencyTimeAvgActive is limiter-active provider-operation-seconds
	// divided by the common execution window (rounded to 3 decimals) — the
	// window starts when the run record is emitted on either path, so setup
	// and preflight are excluded identically. The run record's startup sample
	// is always 0; the summary value is the completed-run diagnostic. Low
	// time-average under a high effective ceiling is a signal to read
	// together with throttle/freeze counters and memory-pressure evidence,
	// not standalone proof of a starved producer.
	ConcurrencyTimeAvgActive float64 `json:"concurrency_time_avg_active"`
	// Memory fields are omitted when the ceiling was not memory-resolved
	// (configs constructed directly with an explicit EffectiveCeiling and no
	// probe); probe-resolved runs always populate limit, budget, and sources.
	MemoryLimitBytes           int64  `json:"memory_limit_bytes,omitempty"`
	MemoryLimitSource          string `json:"memory_limit_source,omitempty"`
	MemoryBudgetRequestedBytes int64  `json:"memory_budget_requested_bytes,omitempty"`
	MemoryBudgetEffectiveBytes int64  `json:"memory_budget_effective_bytes,omitempty"`
	MemoryBudgetSource         string `json:"memory_budget_source,omitempty"`
	RetryBufferCapBytes        int64  `json:"retry_buffer_cap_bytes,omitempty"`
	// Ledger pressure telemetry: peak outstanding copy-buffer reservation and
	// admission-wait evidence. Read together with occupancy — waits with peak
	// near the budget indicate memory admission, not a starved producer.
	MemoryReservedPeakBytes int64 `json:"memory_reserved_peak_bytes,omitempty"`
	MemoryReservationWaits  int64 `json:"memory_reservation_waits,omitempty"`
	MemoryReservationWaitMS int64 `json:"memory_reservation_wait_ms,omitempty"`

	// Dest-domain admission (GON-067 PR2). Multiplier and resolved ceiling are
	// static for the run; per-domain peaks prove capacity was used.
	DestDomainMultiplier       int `json:"dest_domain_multiplier,omitempty"`
	DestDomainCeilingEffective int `json:"dest_domain_ceiling_effective,omitempty"`
	ConcurrencyMaxActiveSource int `json:"concurrency_max_active_source,omitempty"`
	ConcurrencyMaxActiveDest   int `json:"concurrency_max_active_dest,omitempty"`
	ConcurrencyMaxActiveProbe  int `json:"concurrency_max_active_probe,omitempty"`
}

type Config struct {
	// Destination is the structured reflow target.
	Destination Destination
	// Rewrite controls source->destination key mapping.
	Rewrite RewriteConfig
	// Collision selects the destination collision policy.
	Collision CollisionPolicy
	// Concurrency bounds the adaptive copy ceiling. The zero value is resolved to
	// defaults by the runner.
	Concurrency ConcurrencyConfig
	// DryRun plans mappings without writing.
	DryRun bool
	// ReadOnly blocks provider-side mutations, including write-probe preflight.
	ReadOnly bool
	// Metadata controls destination metadata and storage-class PUT options.
	Metadata MetadataPlan
	// Provenance controls per-object provenance sidecar emission. The zero value
	// (mode none) disables sidecars.
	Provenance ProvenancePlan
	// Checkpoint, when non-nil, enables resume via an embedder-supplied store.
	Checkpoint CheckpointStore
	// Events, when non-nil, receives typed redacted engine events.
	Events EventSink
}

type DestLayout struct {
	ProviderID string
	BaseURI    string
	// Object-store decomposition.
	Bucket string
	Prefix string
	// File decomposition.
	BaseDir string
}

type Destination struct {
	// Provider is the injected destination provider handle.
	Provider provider.Provider
	// ProviderID is the internal provider id ("s3", "file", "gcs").
	ProviderID string
	// BaseURI is the destination base prefix, e.g. s3://bucket/base/ or
	// file:///tmp/out/.
	BaseURI string
}

type EnvelopeInspection struct {
	Type                 string
	SanitizedType        string
	Data                 json.RawMessage
	Advisory             bool
	AdvisoryMalformed    bool
	DuplicateEnvelopeKey string
	ProducerVersion      string
	UnmarshalErr         error
}

type ErrorEvent struct {
	Code      string         `json:"code"`
	Key       string         `json:"key,omitempty"`
	Message   string         `json:"message"`
	Details   map[string]any `json:"details,omitempty"`
	Collision any            `json:"collision,omitempty"`
}

type EventSink interface {
	// OnRun reports the resolved run configuration.
	OnRun(ctx context.Context, rec RunRecord) error
	// OnSource reports the resolved source.
	OnSource(ctx context.Context, rec SourceRunRecord) error
	// OnRecord reports a per-object outcome.
	OnRecord(ctx context.Context, rec Record) error
	// OnWarning reports a non-fatal condition (e.g. the IfAbsent fallback notice).
	OnWarning(ctx context.Context, w Warning) error
	// OnError reports a per-object or run error with a redacted message.
	OnError(ctx context.Context, e ErrorEvent) error
	// OnSummary reports the terminal run summary.
	OnSummary(ctx context.Context, rec SummaryRecord) error
}

type FileTreeSource struct {
	Root string
}

type IfAbsentCapability struct {
	ProbeStatus    preflight.IfAbsentProbeStatus
	Honored        *bool
	FallbackActive bool
	ProbeError     string
}

type InvalidInputsError struct{ Count int64 }

type LaneCheckpointStore interface {
	CheckpointStore
	producer.DurableStore

	// UnitDone reconciles a previously committed terminal by stable unit key.
	UnitDone(ctx context.Context, unitKey string) (done bool, status string, err error)
	// ResumeEnabled reports whether this scoped store is being used for replay.
	ResumeEnabled() bool
	// CheckpointUnit atomically records the terminal item and acknowledges the
	// unit. It returns only after the shared durable transaction commits.
	CheckpointUnit(ctx context.Context, item CheckpointItem, unitKey string) error
}

type MetadataBudgetError struct {
	OverLimitKeys []string
	PairLimit     int
	TotalBytes    int
	TotalLimit    int
	Count         int
}

type MetadataDerivationError struct {
	DestKey       string
	Expression    string
	Reason        string
	ResultKind    string
	CollidingKeys []string
}

type MetadataDerivedRule struct {
	DestKey    string
	Expression string
	Raw        string
	// contains filtered or unexported fields
}

type MetadataPlan struct {
	Policy                  string
	Set                     map[string]string
	SourceKeyRules          []MetadataSourceKeyRule
	DerivedRules            []MetadataDerivedRule
	OnMissingSource         string
	PreserveContentType     bool
	DestinationStorageClass string
	MetadataSidecarSuffix   string
}

type MetadataRunConfig struct {
	Policy                  string            `json:"policy"`
	SetKeys                 []string          `json:"set_keys,omitempty"`
	SourceKeyRuleKeys       []string          `json:"source_key_rule_keys,omitempty"`
	DerivedRuleKeys         []string          `json:"derived_rule_keys,omitempty"`
	OnMissingSource         string            `json:"on_missing_source,omitempty"`
	PreserveContentType     bool              `json:"preserve_content_type,omitempty"`
	DestinationStorageClass string            `json:"destination_storage_class,omitempty"`
	MetadataSidecarSuffix   string            `json:"metadata_sidecar_suffix,omitempty"`
	Set                     map[string]string `json:"set,omitempty"`
}

type MetadataSourceKeyRule struct {
	DestKey   string
	SourceKey string
	Raw       string
}

type MissingConditionalCapabilityError struct {
	// Mode is the collision mode that required the missing predicate.
	Mode string
	// MissingCapability is the provider-dispatch capability label, e.g.
	// "ConditionalPutter.IfMatchETag" or "ConditionalMultipartCompleter.IfMatchETag".
	MissingCapability string
	// contains filtered or unexported fields
}

type ObjectErrorsError struct{ Count int64 }

type ObjectPathStageStatsEmitter interface {
	OnObjectPathStageStats(ctx context.Context, rec ObjectPathStageStatsRecord) error
}

type ObjectPathStageStatsRecord struct {
	PermitWaits        int64 `json:"permit_waits"`
	PermitWaitNanos    int64 `json:"permit_wait_nanos"`
	PermitWaitMaxNanos int64 `json:"permit_wait_max_nanos"`

	SourceReads        int64 `json:"source_reads"`
	SourceReadNanos    int64 `json:"source_read_nanos"`
	SourceReadMaxNanos int64 `json:"source_read_max_nanos"`

	DestWrites        int64 `json:"dest_writes"`
	DestWriteNanos    int64 `json:"dest_write_nanos"`
	DestWriteMaxNanos int64 `json:"dest_write_max_nanos"`

	CoupledCopies       int64 `json:"coupled_copies"`
	CoupledCopyNanos    int64 `json:"coupled_copy_nanos"`
	CoupledCopyMaxNanos int64 `json:"coupled_copy_max_nanos"`

	CollisionProbes        int64 `json:"collision_probes"`
	CollisionProbeNanos    int64 `json:"collision_probe_nanos"`
	CollisionProbeMaxNanos int64 `json:"collision_probe_max_nanos"`

	CheckpointWrites        int64 `json:"checkpoint_writes"`
	CheckpointWriteNanos    int64 `json:"checkpoint_write_nanos"`
	CheckpointWriteMaxNanos int64 `json:"checkpoint_write_max_nanos"`

	// PhaseSplitCopies counts copies that used independent source-read and
	// dest-write permits (the default single-part path after PR1).
	PhaseSplitCopies int64 `json:"phase_split_copies"`
	// CoupledCopyOps counts copies that held one permit across source+dest
	// (streaming multipart / coupled path).
	CoupledCopyOps int64 `json:"coupled_copy_ops"`

	// Per-domain permit waits (PR2): prove dest capacity was admitted separately
	// from source. Aggregate PermitWaits remains the sum of domains.
	SourcePermitWaits        int64 `json:"source_permit_waits"`
	SourcePermitWaitNanos    int64 `json:"source_permit_wait_nanos"`
	SourcePermitWaitMaxNanos int64 `json:"source_permit_wait_max_nanos"`
	DestPermitWaits          int64 `json:"dest_permit_waits"`
	DestPermitWaitNanos      int64 `json:"dest_permit_wait_nanos"`
	DestPermitWaitMaxNanos   int64 `json:"dest_permit_wait_max_nanos"`
	ProbePermitWaits         int64 `json:"probe_permit_waits"`
	ProbePermitWaitNanos     int64 `json:"probe_permit_wait_nanos"`
	ProbePermitWaitMaxNanos  int64 `json:"probe_permit_wait_max_nanos"`

	// Peak concurrent tokens observed per domain (from limiter snapshot).
	SourceMaxActive int `json:"source_max_active"`
	DestMaxActive   int `json:"dest_max_active"`
	ProbeMaxActive  int `json:"probe_max_active"`

	// Resolved dest-domain policy for the run (mirrors ConcurrencyStats).
	DestDomainMultiplier       int `json:"dest_domain_multiplier,omitempty"`
	DestDomainCeilingEffective int `json:"dest_domain_ceiling_effective,omitempty"`
}

type ObjectSource struct {
	Provider provider.Provider
	URI      string
}

type PathErrorOptions struct {
	Verbose bool
}

type PrefixSource struct {
	Provider   provider.Provider
	URI        string
	Enumerator producer.LaneEnumerator
	Authority  *partition.Authority
}

type ProvenanceEmitter interface {
	// EmitProvenanceWarning reports a warn-policy sidecar write failure.
	EmitProvenanceWarning(ctx context.Context, w Warning) error
	// EmitProvenanceError reports a fail-policy sidecar write failure.
	EmitProvenanceError(ctx context.Context, key, message string, cause error, details map[string]any) error
}

type ProvenancePlacementContext struct {
	Mode        string `json:"mode"`
	SidecarRoot string `json:"sidecar_root,omitempty"`
}

type ProvenancePlacementPlan struct {
	Mode        string
	SidecarRoot *ProvenanceSidecarRoot
	// SidecarProvider is an injected second provider handle used only for a
	// file mirrored-root, whose sidecars land under a base directory distinct
	// from the destination provider's. Sibling and same-bucket object-store
	// mirrored placement write through the destination handle, so this stays
	// nil for them. It is redaction-safe: String/GoString expose presence only.
	SidecarProvider provider.Provider
}

type ProvenancePlan struct {
	Mode              string
	Suffix            string
	AllowUnsafeSuffix bool
	OnWriteError      string
	Placement         ProvenancePlacementPlan
	RunID             string
	ToolVersion       string
}

type ProvenancePutFunc func(ctx context.Context, key string, body io.Reader, size int64) error

type ProvenanceRef struct {
	Written bool   `json:"written"`
	Key     string `json:"key"`
	URI     string `json:"uri,omitempty"`
}

type ProvenanceRunConfig struct {
	Mode         string                     `json:"mode"`
	Suffix       string                     `json:"suffix,omitempty"`
	OnWriteError string                     `json:"on_write_error,omitempty"`
	Placement    ProvenancePlacementContext `json:"placement"`
}

type ProvenanceSidecarInput struct {
	SourceURI     string
	SourceETag    string
	SourceSize    int64
	SourceLastMod time.Time
	DestURI       string
	DestETag      string
	DestSize      int64
	RoutingClass  string
	// RewriteTemplate is the rewrite "to" template, when one was used.
	RewriteTemplate string
	// QuarantinePrefix is set only for quarantine routing.
	QuarantinePrefix string
	Collision        *CollisionInfo
	Vars             map[string]string
	Probe            *probe.ProbeAudit
	// Action is the pool action string recorded in the sidecar (e.g. the landed
	// action, "skipped.duplicate", or "quarantined").
	Action string
}

type ProvenanceSidecarPayload struct {
	Schema        string                 `json:"schema"`
	SchemaVersion string                 `json:"schema_version"`
	Source        provenanceSourceBlock  `json:"source"`
	Destination   provenanceDestBlock    `json:"destination"`
	Run           provenanceRunBlock     `json:"run"`
	Routing       provenanceRoutingBlock `json:"routing"`
	Collision     *CollisionInfo         `json:"collision,omitempty"`
	Vars          map[string]string      `json:"vars,omitempty"`
	Probe         *probe.ProbeAudit      `json:"probe,omitempty"`
	Action        string                 `json:"action"`
}

type ProvenanceSidecarRoot struct {
	Provider         string
	Bucket           string
	Prefix           string
	BaseDir          string
	BaseURI          string
	SameBucketAsDest bool
}

type Record struct {
	SourceURI          string         `json:"source_uri"`
	SourceBucket       string         `json:"source_bucket,omitempty"`
	SourceRoot         string         `json:"source_root,omitempty"`
	SourceKey          string         `json:"source_key"`
	SourceETag         string         `json:"source_etag,omitempty"`
	SourceSize         int64          `json:"source_size_bytes,omitempty"`
	SourceLastModified string         `json:"source_last_modified,omitempty"`
	DestSHA256         string         `json:"dest_sha256,omitempty"`
	DestVersionID      string         `json:"dest_version_id,omitempty"`
	DestETag           string         `json:"dest_etag,omitempty"`
	DestURI            string         `json:"dest_uri"`
	DestKey            string         `json:"dest_key"`
	Bytes              int64          `json:"bytes,omitempty"`
	Status             string         `json:"status"`
	Reason             string         `json:"reason,omitempty"`
	RoutingClass       string         `json:"routing_class,omitempty"`
	Collision          *CollisionInfo `json:"collision,omitempty"`
	Provenance         *ProvenanceRef `json:"provenance,omitempty"`
	Details            map[string]any `json:"details,omitempty"`
}

type RecordStreamSource struct {
	Records io.Reader
	Resolve SourceResolver
}

type ResourceProbe struct {
	MemoryLimitBytes func() (int64, string, error)
	FDSoftLimit      func() (int64, error)
}

type RewriteConfig struct {
	From string
	To   string
}

type RunRecord struct {
	DestURI        string `json:"dest_uri"`
	CheckpointPath string `json:"checkpoint_path"`
	DryRun         bool   `json:"dry_run"`
	Resume         bool   `json:"resume"`
	Parallel       int    `json:"parallel"`
	ExecutionPath  string `json:"execution_path"`
	ConcurrencyStats
	Provenance *ProvenanceRunConfig `json:"provenance,omitempty"`
	Metadata   *MetadataRunConfig   `json:"metadata,omitempty"`
}

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

type Source interface {
	// contains filtered or unexported methods
}

type SourceEnumerationError struct {
	Selector string
	Err      error
}

type SourceMetadataCollisionError struct {
	Keys []string
}

type SourceResolver func(ctx context.Context, sourceURI string) (provider.Provider, error)

type SourceRunMetadata struct {
	Provider string
	Bucket   string
	Root     string
	URI      string
}

type SourceRunMetadataStore interface {
	// SetSourceRunMetadata records the resolved run-level source.
	SetSourceRunMetadata(ctx context.Context, meta SourceRunMetadata) error
}

type SourceRunRecord struct {
	Provider   string `json:"provider"`
	Bucket     string `json:"source_bucket,omitempty"`
	Root       string `json:"source_root,omitempty"`
	URI        string `json:"source_uri"`
	OutputOnly bool   `json:"source_uri_output_only,omitempty"`
}

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

type Summary struct {
	SummaryRecord
}

type SummaryRecord struct {
	DestURI       string `json:"dest_uri"`
	DryRun        bool   `json:"dry_run"`
	OnCollision   string `json:"on_collision"`
	ExecutionPath string `json:"execution_path"`
	ConcurrencyStats
	DestIfAbsentHonored     *bool            `json:"dest_ifabsent_honored"`
	DestIfAbsentProbeStatus string           `json:"dest_ifabsent_probe_status,omitempty"`
	FallbackActive          bool             `json:"fallback_active"`
	IfAbsentFallbackObjects int64            `json:"ifabsent_fallback_objects"`
	Statuses                map[string]int64 `json:"statuses,omitempty"`
	Collisions              map[string]int64 `json:"collisions,omitempty"`
	InvalidInputs           int64            `json:"invalid_inputs,omitempty"`
	Errors                  int64            `json:"errors,omitempty"`
}

type Warning struct {
	Code    string         `json:"code"`
	Message string         `json:"message"`
	Key     string         `json:"key,omitempty"`
	Details map[string]any `json:"details,omitempty"`
}