client

type APICredential struct {
	Token        string   `json:"token"`
	CredentialID string   `json:"credential_id"`
	Audience     string   `json:"audience"`
	Scopes       []string `json:"scopes"`
	ExpiresAt    int64    `json:"expires_at"`
	ID           string   `json:"id"`
	Name         string   `json:"name"`
	Role         string   `json:"role"`
}

type Account struct {
	ID           string `json:"id"`
	Name         string `json:"name"`
	Role         string `json:"role"`
	AccountKey   string `json:"account_key"`
	RecoveryCode string `json:"recovery_code"`
}

type Allowance = wire.Allowance

type AttributionCandidate = wire.AttributionCandidate

type AttributionCandidates = wire.AttributionCandidates

type AttributionKey = wire.AttributionKey

type AttributionKeys = wire.AttributionKeys

type AttributionSchedule = wire.AttributionSchedule

type CancellationDocument = wire.Cancellation

type CaptureError struct {
	// Offset is the byte offset of the offending record, -1 when none.
	Offset int64
	Msg    string
}

type CapturedPacket struct {
	// Data is the IP packet, starting at the IPv4 or IPv6 header, without
	// the link-layer header. An IPv4 packet is cut to its Total Length, so
	// link-layer padding and trailers are not part of it; a packet the
	// capture recorded only partly (snap length) is kept as recorded. Data
	// is empty for a frame of a link type ReadCapture does not know.
	Data []byte
	// CapturedAt is the capture's timestamp of the frame: the capture host's
	// clock, which offline verification has to trust.
	CapturedAt time.Time
	// LinkType is the capture's link-layer header type of the frame.
	LinkType uint16
}

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

type ConnectionInfo struct {
	SchemaVersion int    `json:"schema_version"`
	Mode          string `json:"mode"`
	GRPCAddress   string `json:"grpc_address"`
	YamuxAddress  string `json:"yamux_address"`
}

type ControlBinding = wire.ControlBinding

type CredentialStatus struct {
	ID        string   `json:"id"`
	Kind      string   `json:"kind"`
	Audience  string   `json:"audience"`
	Scopes    []string `json:"scopes"`
	CreatedAt int64    `json:"created_at"`
	ExpiresAt int64    `json:"expires_at"`
}

type DeviceLogin struct {
	DeviceCode      string   `json:"device_code"`
	UserCode        string   `json:"user_code"`
	VerificationURI string   `json:"verification_uri"`
	Audience        string   `json:"audience"`
	Scopes          []string `json:"scopes"`
	ExpiresAt       int64    `json:"expires_at"`
	Interval        int64    `json:"interval"`
}

type DeviceLoginPoll struct {
	State      string         `json:"state"`
	Interval   int64          `json:"interval,omitempty"`
	Credential *APICredential `json:"credential,omitempty"`
}

type Economics = wire.Economics

type Evidence struct {
	Format        string             `json:"format"`
	FormatVersion int                `json:"format_version"`
	CreatedAt     time.Time          `json:"created_at"`
	Tool          EvidenceTool       `json:"tool"`
	TagSpec       int                `json:"tag_spec"`
	Dispatcher    EvidenceDispatcher `json:"dispatcher"`
	// At is the capture time override the verification used, if any; the
	// packets' captured_at already carry it.
	At *time.Time `json:"at,omitempty"`
	// ClockToleranceMS is the capture clock lag bound applied.
	ClockToleranceMS int64           `json:"clock_tolerance_ms"`
	Packets          EvidencePackets `json:"packets"`
	Groups           []EvidenceGroup `json:"groups"`
	// Lookups are the dispatcher's answers to the candidate lookups, one
	// per group formed from them.
	Lookups []EvidenceLookup `json:"lookups"`
	// Chains carry, per executor chain, its schedule and every disclosed key
	// the verification used. Each key hashes to the schedule's k0.
	Chains []EvidenceChain `json:"chains"`
	// Receipts are the dispatcher's signed receipts of server-assisted
	// checks (#341); this client writes none yet.
	Receipts []EvidenceReceipt `json:"receipts"`
}

type EvidenceCandidate struct {
	ExecutorID string    `json:"executor_id"`
	RunID      string    `json:"run_id"`
	ActiveFrom time.Time `json:"active_from"`
	ActiveTo   time.Time `json:"active_to"`
	// IPSource is observed or advertised (see AttributionCandidate).
	IPSource         string           `json:"ip_source,omitempty"`
	Schedule         EvidenceSchedule `json:"schedule"`
	DisclosedThrough int64            `json:"disclosed_through"`
}

type EvidenceChain struct {
	ExecutorID string           `json:"executor_id"`
	Schedule   EvidenceSchedule `json:"schedule"`
	Keys       []EvidenceKey    `json:"keys"`
}

type EvidenceDispatcher struct {
	URL        string `json:"url"`
	APIVersion string `json:"api_version"`
}

type EvidenceGroup struct {
	Verdict      Verdict      `json:"verdict"`
	Reason       string       `json:"reason,omitempty"`
	Method       VerifyMethod `json:"method,omitempty"`
	Source       string       `json:"source,omitempty"`
	RunID        string       `json:"run_id,omitempty"`
	ExecutorID   string       `json:"executor_id,omitempty"`
	Epoch        int64        `json:"epoch,omitempty"`
	PendingUntil *time.Time   `json:"pending_until,omitempty"`
	Packets      []int        `json:"packets"`
	Matched      int          `json:"matched"`
	Unmatched    int          `json:"unmatched"`
	// Split records the group an entry was split from (VerifyGroup.Split).
	Split    *VerifySplit      `json:"split,omitempty"`
	Schedule *EvidenceSchedule `json:"schedule,omitempty"`
	Keys     []EvidenceKey     `json:"keys,omitempty"`
}

type EvidenceKey struct {
	Epoch int64  `json:"epoch"`
	Key   []byte `json:"key"`
}

type EvidenceLookup struct {
	IP           string              `json:"ip"`
	At           time.Time           `json:"at"`
	RetainedFrom time.Time           `json:"retained_from"`
	Truncated    bool                `json:"truncated,omitempty"`
	Candidates   []EvidenceCandidate `json:"candidates"`
}

type EvidenceMismatchError struct {
	Group int
	Msg   string
}

type EvidencePacket struct {
	Data       []byte    `json:"data"`
	CapturedAt time.Time `json:"captured_at"`
}

type EvidencePackets struct {
	Count int `json:"count"`
	// Digest is "sha256:" and the hex SHA-256 over uint16 length ‖ data ‖
	// int64 captured_at_ns (big-endian) of every packet in order.
	Digest string           `json:"digest"`
	Items  []EvidencePacket `json:"items"`
}

type EvidenceReceipt struct {
	KeyID     string `json:"key_id"`
	Payload   []byte `json:"payload"`
	Signature []byte `json:"signature"`
}

type EvidenceSchedule struct {
	// ChainID identifies the chain.
	ChainID string `json:"chain_id"`
	// K0 is the chain anchor; every key hashes to it.
	K0 []byte `json:"k0"`
	// T0UnixNs is the start of epoch 0.
	T0UnixNs int64 `json:"t0_unix_ns"`
	// EpochSeconds is the epoch length I.
	EpochSeconds int64 `json:"epoch_seconds"`
	// DisclosureDelayEpochs is d; below 2 is refused.
	DisclosureDelayEpochs int64 `json:"disclosure_delay_epochs"`
	// ChainLength is L; zero is unknown.
	ChainLength int64 `json:"chain_length"`
	// TagSpec is the executor-reported tag specification version; 0 is the
	// unversioned pre-v1 tag, which is unsupported.
	TagSpec int64 `json:"tag_spec"`
}

type EvidenceTool struct {
	Name    string `json:"name"`
	Version string `json:"version"`
}

type ExecutorEarnings = wire.ExecutorEarnings

type ExecutorFilter struct {
	AddressFamilies    []string // ipv4 or ipv6 with a fresh successful controlled observation.
	ReachableListeners []string // tcp, udp or scion; declared support alone is not a match.
	Protocols          []string
	EnforcementMode    string
	MinCapacityBPS     *int64
	// ISDAS requires the executor-reported SCION ISD-AS, such as 1-ff00:0:110.
	// Equivalent spellings match; an unknown ISD-AS does not.
	ISDAS string
	// ASN matches dispatcher-observed control or advertised-host origin. The
	// separate, unverified hello claim never adds a match. Country matches display location.
	ASN     uint32
	Country string
}

type HTTPError struct {
	Method      string
	Path        string
	StatusCode  int
	Code        string
	Message     string
	FieldErrors []wire.FieldError

	// RetryAfter is the delay a 429 or 503 response asked for in its
	// Retry-After header; zero when it named none.
	RetryAfter time.Duration
	// contains filtered or unexported fields
}

type IncompleteOutputError struct {
	Output OutputStatus
}

type LogEntry = wire.LogEntry[[]byte]

type LogOptions struct {
	After int64
	Limit int64
}

type LogPage = wire.LogPage[[]byte]

type Measurement = wire.Measurement

type MeasurementOptions struct {
	State, Search string
	Limit, Offset int64
}

type MeasurementPage = wire.MeasurementPage

type MeasurementTemplate = wire.MeasurementTemplate

type Node = wire.Executor

type Options struct {
	// HTTPClient supplies transport settings. It is cloned, never mutated,
	// and redirects are always rejected. nil uses a fresh client.
	HTTPClient *http.Client
	// RequestTimeout bounds each request including its body read. Zero
	// defaults to 10 s; a negative value is invalid.
	RequestTimeout time.Duration
	// AllowRemoteTEST permits TEST submissions to endpoints other than a
	// literal loopback IP. It is an accident guard, not server authorization:
	// an SSH-forwarded loopback endpoint is still an operator-selected remote
	// service.
	AllowRemoteTEST bool
	// Credential is the session token this client presents on every request,
	// as an Authorization bearer header. It is obtained from Login and belongs
	// to exactly one dispatcher: a Client is bound to one origin and refuses
	// redirects, so a credential never travels to another one. It is never
	// written to a log, an error message or a returned diagnostic. Empty makes
	// unauthenticated requests, which a dispatcher serving the local
	// development profile still accepts.
	Credential string
}

type OrderHistory = wire.OrderHistory

type OrdersPage struct {
	Limit  int64
	Before string
}

type OutputStatus = wire.OutputStatus

type Policy = wire.Policy

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

type Profile = wire.Profile

type ProfileConfig = wire.ProfileConfig

type ProfileSummary = wire.ProfileSummary

type Quote = wire.Quote

type RateLimitedError struct {
	// Throttled counts the requests the dispatcher answered 429.
	Throttled int
	// UncheckedGroups is how many groups remain without a verdict (at least
	// this many when Partial is set: the lookups had not reached every
	// packet), and UncheckedPackets how many packets they hold.
	UncheckedGroups  int
	UncheckedPackets int
	Partial          bool
	// Err is the context's error.
	Err error
}

type RecoveryDocument = wire.Recovery

type RecoveryObservation = wire.RecoveryObservation

type RecoveryObserver = wire.RecoveryObserver

type RendezvousOptions struct {
	ReadinessTimeout time.Duration
	Timeout          time.Duration
	Output           func(role, runID string, page LogPage) error
}

type RendezvousResult struct {
	Server   RendezvousRun `json:"server"`
	Client   RendezvousRun `json:"client"`
	Endpoint string        `json:"endpoint"`
}

type RendezvousRun struct {
	ID            string `json:"id"`
	ExecutorID    string `json:"executor_id"`
	TransactionID string `json:"transaction_id"`
	State         string `json:"state"`
	Error         string `json:"error"`
	Cleanup       string `json:"cleanup"`
}

type Request = wire.Request[[]byte]

type Result = wire.Result

type RetainedRun = wire.RetainedRun

type RetryLink = wire.RetryLink

type RunDetail = wire.RunDetail

type ServerVersion = wire.Version

type Session struct {
	Token     string `json:"token"`
	CSRFToken string `json:"csrf_token"`
	ExpiresAt int64  `json:"expires_at"`
	ID        string `json:"id"`
	Name      string `json:"name"`
	Role      string `json:"role"`
}

type State = wire.State

type Submission struct {
	IDs           []string `json:"ids"`
	TransactionID string   `json:"transaction_id"`
}

type SubmissionError struct {
	Stage         string
	TransactionID string
	// AdmittedIDs are durable run identities in request order when a failed
	// submission returned a valid complete list. They prove admission, not
	// upload, execution, cancellation or completion. Inspect each run.
	AdmittedIDs    []string
	OutcomeUnknown bool
	Err            error
}

type User = wire.User

type Verdict string

type VerifyCounts struct {
	Verified    int `json:"verified"`
	Invalid     int `json:"invalid"`
	Pending     int `json:"pending"`
	Missing     int `json:"missing"`
	Unsupported int `json:"unsupported"`
}

type VerifyGroup struct {
	Verdict Verdict `json:"verdict"`
	// Reason is the machine reason of any verdict but verified.
	Reason string `json:"reason,omitempty"`
	// Detail explains the verdict in a sentence.
	Detail string `json:"detail"`
	// Method is how the verdict was established; empty when nothing was
	// checked.
	Method VerifyMethod `json:"method,omitempty"`
	// Source is the packets' source address; empty for frames without IP.
	Source     string `json:"source,omitempty"`
	RunID      string `json:"run_id,omitempty"`
	ExecutorID string `json:"executor_id,omitempty"`
	// Epoch is the capture epoch under the run's (or the address's first
	// candidate's) schedule; zero when there is none.
	Epoch int64 `json:"epoch,omitempty"`
	// Time is the capture time of the group's first packet.
	Time time.Time `json:"time"`
	// PendingUntil is when the last key the group needs is disclosed.
	PendingUntil *time.Time `json:"pending_until,omitempty"`
	// Packets are indices into the verified packets, in capture order.
	Packets []int `json:"packets"`
	// Matched counts the packets whose tag some candidate run reproduces,
	// Unmatched those it does not; a count of matches is only meaningful
	// together with the non-matches (docs/tag-spec.md §7). For an entry of
	// a split group they count the entry's own packets; Split has the
	// group's.
	Matched   int `json:"matched"`
	Unmatched int `json:"unmatched"`
	// Candidates counts the runs the group was checked against.
	Candidates int `json:"candidates"`
	// AmbiguousRuns lists the runs that each reproduce every tag.
	AmbiguousRuns []string `json:"ambiguous_runs,omitempty"`
	// FalseMatchBound bounds the probability that packets not sent by the
	// run match it by chance: N·C(n,k)·(E·2⁻¹⁶)^k for N candidates, E = 2
	// epochs and k of the group's n packets, which is N·(E·2⁻¹⁶)^n for an
	// unsplit group (docs/tag-spec.md §7). It underflows to zero for large k.
	FalseMatchBound float64 `json:"false_match_bound,omitempty"`
	// DisclosedAt is when the latest key the verdict used became due for
	// disclosure; packets captured before it (by a trustworthy clock) cannot
	// have been forged with that key.
	DisclosedAt *time.Time `json:"disclosed_at,omitempty"`
	// Split describes the address-and-epoch group this entry was split
	// from, when not all its packets reproduce one run; nil otherwise.
	Split *VerifySplit `json:"split,omitempty"`
	// contains filtered or unexported fields
}

type VerifyMethod string

type VerifyOptions struct {
	// At, when set, is taken as the capture time of every packet instead of
	// the capture's own timestamps.
	At time.Time
	// Offline never uploads packets: groups whose key is not disclosed yet
	// are pending. Server-assisted verification (#341) is not implemented
	// yet, so every verification is offline today.
	Offline bool
	// ClockTolerance bounds how far the capture host's clock may lag true
	// time. A key is used only if it was still secret at the capture time
	// plus this. Zero is DefaultClockTolerance.
	ClockTolerance time.Duration
	// RequestRate (requests per second) and RequestBurst pace the history
	// requests of Client.Verify as a token bucket, to stay within the
	// dispatcher's per-client rate limit. Zero is the documented limit,
	// DefaultVerifyRequestRate and DefaultVerifyRequestBurst; a negative
	// rate disables pacing. After a 429 every request waits for the
	// Retry-After either way.
	RequestRate  float64
	RequestBurst int
}

type VerifyReport struct {
	// TagSpec is the tag specification the tags were checked under.
	TagSpec string `json:"tag_spec"`
	// CheckedAt is the time verification ran (for VerifyEvidence, the time
	// the bundle was created).
	CheckedAt time.Time `json:"checked_at"`
	// At is the capture time override, if any.
	At *time.Time `json:"at,omitempty"`
	// Dispatcher is the dispatcher the history came from.
	Dispatcher string `json:"dispatcher,omitempty"`
	// ClockTolerance is the capture clock lag bound applied.
	ClockToleranceMS int64 `json:"clock_tolerance_ms"`
	// Packets counts the packets checked.
	Packets int           `json:"packets"`
	Counts  VerifyCounts  `json:"counts"`
	Groups  []VerifyGroup `json:"groups"`
	// contains filtered or unexported fields
}

type VerifySplit struct {
	// Packets counts the packets of the whole group.
	Packets int `json:"packets"`
	// Matched counts those some candidate run reproduces, Unmatched those
	// no candidate does.
	Matched   int `json:"matched"`
	Unmatched int `json:"unmatched"`
	// Runs lists the runs packets were attributed to.
	Runs []string `json:"runs"`
}