schemas

type ATOTaskParams struct {
	Usernames []string `json:"usernames"` // A list of usernames to test for vulnerabilities like password spraying.
}

type AgentMissionParams struct {
	MissionBrief string `json:"mission_brief"` // The high-level objective for the agent to achieve.
}

type Artifacts struct {
	HAR         *json.RawMessage `json:"har"`          // The HTTP Archive (HAR) data for network requests.
	DOM         string           `json:"dom"`          // The full HTML source of the page.
	ConsoleLogs []ConsoleLog     `json:"console_logs"` // A log of all console messages.
	Storage     StorageState     `json:"storage"`      // A snapshot of the browser's storage.
}

type BrowserInteractor interface {
	// NavigateAndExtract loads a URL and returns a list of all discovered links.
	NavigateAndExtract(ctx context.Context, url string) ([]string, error)
}

type BrowserManager interface {
	// NewAnalysisContext creates a new, isolated browser session tailored for
	// security analysis, complete with a specified persona and taint tracking
	// configuration.
	NewAnalysisContext(
		sessionCtx context.Context,
		cfg interface{},
		persona Persona,
		taintTemplate string,
		taintConfig string,
		findingsChan chan<- Finding,
	) (SessionContext, error)
	// Shutdown gracefully terminates all browser instances managed by this manager.
	Shutdown(ctx context.Context) error
}

type ClientHints struct {
	Platform        string                   `json:"platform"`
	PlatformVersion string                   `json:"platformVersion"`
	Architecture    string                   `json:"architecture"`
	Bitness         string                   `json:"bitness"`
	Mobile          bool                     `json:"mobile"`
	Brands          []*UserAgentBrandVersion `json:"brands"`
}

type ConsoleLog struct {
	Type      string    `json:"type"`      // The type of console message (e.g., "log", "error").
	Timestamp time.Time `json:"timestamp"` // The time the message was logged.
	Text      string    `json:"text"`      // The content of the console message.
	Source    string    `json:"source,omitempty"`
	URL       string    `json:"url,omitempty"`  // The URL of the script that generated the message.
	Line      int64     `json:"line,omitempty"` // The line number in the script.
}

type Content struct {
	Size     int64  `json:"size"`               // The size of the content in bytes.
	MimeType string `json:"mimeType"`           // The MIME type of the content.
	Text     string `json:"text,omitempty"`     // The content text, if it's not binary.
	Encoding string `json:"encoding,omitempty"` // The encoding of the content (e.g., "base64").
}

type Cookie struct {
	Name     string         `json:"name"`
	Value    string         `json:"value"`
	Domain   string         `json:"domain"`
	Path     string         `json:"path"`
	Expires  float64        `json:"expires"`
	Size     int64          `json:"size"`
	HTTPOnly bool           `json:"httpOnly"`
	Secure   bool           `json:"secure"`
	Session  bool           `json:"session"`
	SameSite CookieSameSite `json:"sameSite,omitempty"`
}

type CookieSameSite string

type Creator struct {
	Name    string `json:"name"`    // The name of the creator application.
	Version string `json:"version"` // The version of the creator application.
}

type Credential struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

type DiscoveryEngine interface {
	// Start begins the discovery process and returns a channel from which new
	// Tasks can be read.
	Start(ctx context.Context, targets []string) (<-chan Task, error)
	// Stop gracefully terminates the discovery process.
	Stop()
}

type Edge struct {
	ID         string           `json:"id"`
	From       string           `json:"from"` // The ID of the source node.
	To         string           `json:"to"`   // The ID of the target node.
	Type       RelationshipType `json:"type"`
	Label      string           `json:"label"`
	Properties json.RawMessage  `json:"properties"`
	CreatedAt  time.Time        `json:"created_at"`
	LastSeen   time.Time        `json:"last_seen"`
}

type EdgeInput struct {
	ID         string           `json:"id"`
	From       string           `json:"from"`
	To         string           `json:"to"`
	Type       RelationshipType `json:"type"`
	Label      string           `json:"label"`
	Properties json.RawMessage  `json:"properties"`
}

type ElementGeometry struct {
	Vertices []float64 `json:"vertices"` // The coordinates of the element's corners.
	Width    int64     `json:"width"`    // The width of the element in pixels.
	Height   int64     `json:"height"`   // The height of the element in pixels.
	// TagName provides the HTML tag of the element (e.g., "INPUT", "BUTTON"),
	// which can be used to influence interaction behavior.
	TagName string `json:"tagName"`
	// Type attribute of the element (e.g., "text", "password", "checkbox"),
	// further specializing interaction logic.
	Type string `json:"type,omitempty"`
}

type Entry struct {
	Pageref         string    `json:"pageref"`         // A reference to the page this entry belongs to.
	StartedDateTime time.Time `json:"startedDateTime"` // The timestamp when the request started.
	Time            float64   `json:"time"`            // The total time for the request-response cycle.
	Request         Request   `json:"request"`         // Detailed information about the HTTP request.
	Response        Response  `json:"response"`        // Detailed information about the HTTP response.
	Cache           struct{}  `json:"cache"`           // Information about the browser cache state.
	Timings         Timings   `json:"timings"`         // Detailed breakdown of the request timing phases.
}

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

type FetchRequest struct {
	URL         string   `json:"url"`         // The URL of the request.
	Method      string   `json:"method"`      // The HTTP method (e.g., "GET", "POST").
	Headers     []NVPair `json:"headers"`     // The request headers.
	Body        []byte   `json:"body"`        // The request body.
	Credentials string   `json:"credentials"` // The credentials policy (e.g., "include", "omit").
}

type FetchResponse struct {
	URL        string   `json:"url"`        // The final URL after any redirects.
	Status     int      `json:"status"`     // The HTTP status code (e.g., 200, 404).
	StatusText string   `json:"statusText"` // The status text (e.g., "OK", "Not Found").
	Headers    []NVPair `json:"headers"`    // The response headers.
	Body       []byte   `json:"body"`       // The response body.
}

type FileNodeProperties struct {
	FilePath string `json:"file_path"` // The full path to the file.
	Language string `json:"language"`  // The programming language of the file.
}

type Finding struct {
	ID     string `json:"id"`      // Unique identifier for the finding.
	ScanID string `json:"scan_id"` // The ID of the scan that produced this finding.
	TaskID string `json:"task_id"` // The ID of the specific task that found this issue.

	// ObservedAt is the timestamp when the finding was discovered.
	ObservedAt time.Time `json:"observed_at"`

	Target string `json:"target"` // The target URL or resource where the vulnerability was found.
	Module string `json:"module"` // The name of the analysis module that reported the finding.

	// VulnerabilityName is a descriptive name for the type of vulnerability (e.g., "Reflected XSS").
	VulnerabilityName string `json:"vulnerability_name"`

	Severity    Severity `json:"severity"`    // The severity level of the finding.
	Description string   `json:"description"` // A detailed description of the vulnerability.

	// Evidence provides structured, machine-readable proof of the vulnerability,
	// stored as JSONB in the database.
	Evidence json.RawMessage `json:"evidence,omitempty"`

	Recommendation string   `json:"recommendation"` // Suggested steps for remediation.
	CWE            []string `json:"cwe,omitempty"`  // A list of relevant Common Weakness Enumeration (CWE) identifiers.
}

type FunctionNodeProperties struct {
	StartLine  int  `json:"start_line"`  // The starting line number of the function in the file.
	EndLine    int  `json:"end_line"`    // The ending line number of the function.
	IsExported bool `json:"is_exported"` // Whether the function is exported for external use.
}

type GenerationOptions struct {
	Temperature     *float64 `json:"temperature"`       // Controls randomness. Lower is more deterministic.
	ForceJSONFormat bool     `json:"force_json_format"` // If true, forces the model to output valid JSON.
	TopP            float64  `json:"top_p"`             // Nucleus sampling parameter.
	TopK            int      `json:"top_k"`             // Top-k sampling parameter.
}

type GenerationRequest struct {
	SystemPrompt string            `json:"system_prompt"` // Instructions for the model's persona and task.
	UserPrompt   string            `json:"user_prompt"`   // The specific query or input from the user.
	Tier         ModelTier         `json:"tier"`          // The desired model tier (fast or powerful).
	Options      GenerationOptions `json:"options"`       // Advanced generation parameters.
}

type HAR struct {
	Log HARLog `json:"log"`
}

type HARCookie struct {
	Name     string `json:"name"`
	Value    string `json:"value"`
	Path     string `json:"path,omitempty"`
	Domain   string `json:"domain,omitempty"`
	Expires  string `json:"expires,omitempty"` // The expiration date in a string format.
	HTTPOnly bool   `json:"httpOnly,omitempty"`
	Secure   bool   `json:"secure,omitempty"`
}

type HARLog struct {
	Version string  `json:"version"` // The version of the HAR format.
	Creator Creator `json:"creator"` // Information about the tool that created the HAR.
	Pages   []Page  `json:"pages"`   // A list of pages loaded during the session.
	Entries []Entry `json:"entries"` // A list of all recorded HTTP requests and responses.
}

type HTTPClient interface {
	// Get performs an HTTP GET request to the specified URL and returns the
	// response body, status code, and any error that occurred.
	Get(ctx context.Context, url string) (body []byte, statusCode int, err error)
}

type HistoryState struct {
	State interface{} `json:"state"` // The serialized state object associated with the history entry.
	Title string      `json:"title"` // The title of the page at this history entry.
	URL   string      `json:"url"`   // The URL of the history entry.
}

type HumanoidActionType string

type HumanoidForceSource struct {
	PositionX float64 `json:"position_x"` // The x-coordinate of the force's origin.
	PositionY float64 `json:"position_y"` // The y-coordinate of the force's origin.
	Strength  float64 `json:"strength"`   // The strength of the force (positive for attraction, negative for repulsion).
	Falloff   float64 `json:"falloff"`    // The rate at which the force's influence decays with distance.
}

type HumanoidInteractionOptions struct {
	// EnsureVisible, if true, will automatically scroll the element into view. Defaults to true.
	EnsureVisible *bool `json:"ensure_visible,omitempty"`
	// FieldSources defines a set of attractors/repulsors to create a potential field for mouse movement.
	FieldSources []HumanoidForceSource `json:"field_sources,omitempty"`
}

type HumanoidSequenceParams struct {
	Steps []HumanoidStep `json:"steps"`
	// Persona allows overriding the default browser fingerprint for this sequence,
	// enabling more flexible and realistic emulation.
	Persona *Persona `json:"persona,omitempty"`

	// --- ADDED FIELDS ---
	// TaintTemplate specifies which IAST taint tracking template to use (e.g., "strict", "permissive").
	TaintTemplate string `json:"taint_template,omitempty"`
	// TaintConfig allows passing a custom JSON configuration string for fine-grained control over taint sources and sinks.
	TaintConfig string `json:"taint_config,omitempty"`
}

type HumanoidStep struct {
	Action      HumanoidActionType          `json:"action"`                  // The type of action to perform.
	Selector    string                      `json:"selector,omitempty"`      // The CSS selector for the target element.
	EndSelector string                      `json:"end_selector,omitempty"`  // For DragDrop actions, the destination selector.
	Text        string                      `json:"text,omitempty"`          // For Type actions, the text to be typed.
	MeanScale   float64                     `json:"mean_scale,omitempty"`    // For Pause actions, scales the mean pause duration.
	StdDevScale float64                     `json:"std_dev_scale,omitempty"` // For Pause actions, scales the standard deviation of the pause duration.
	Options     *HumanoidInteractionOptions `json:"options,omitempty"`       // Advanced options for this specific step.
}

type IDORTaskParams struct {
	HTTPMethod  string            `json:"http_method"`  // The HTTP method to use for the request.
	HTTPBody    string            `json:"http_body"`    // The request body.
	HTTPHeaders map[string]string `json:"http_headers"` // The request headers.
}

type ImprovementAttemptProperties struct {
	GoalObjective string                 `json:"goal_objective"`       // The high-level goal being pursued.
	StrategyDesc  string                 `json:"strategy_description"` // The strategy devised to achieve the goal.
	ActionType    string                 `json:"action_type"`          // The specific type of action taken.
	ActionPayload map[string]interface{} `json:"action_payload"`       // The parameters and data used in the action.
	OutcomeOutput string                 `json:"outcome_output"`       // The result or output of the action.
}

type InteractionAction string

type InteractionConfig struct {
	MaxDepth                int               `json:"max_depth"`                   // Maximum depth for crawling links.
	MaxInteractionsPerDepth int               `json:"max_interactions_per_depth"`  // Max actions on a single page.
	InteractionDelayMs      int               `json:"interaction_delay_ms"`        // Delay between actions.
	PostInteractionWaitMs   int               `json:"post_interaction_wait_ms"`    // Wait time after an action for page load.
	CustomInputData         map[string]string `json:"custom_input_data,omitempty"` // Pre-filled data for forms.
	Steps                   []InteractionStep `json:"steps,omitempty"`             // A specific sequence of actions to perform.
}

type InteractionStep struct {
	Action       InteractionAction `json:"action"`                 // The type of action to perform.
	Selector     string            `json:"selector,omitempty"`     // CSS selector for targeting a DOM element.
	Value        string            `json:"value,omitempty"`        // The value to use (e.g., text to type, option to select).
	Milliseconds int               `json:"milliseconds,omitempty"` // Duration for wait actions.
	Direction    string            `json:"direction,omitempty"`    // Direction for scroll actions (e.g., "down", "up").
}

type JSFileTaskParams struct {
	FilePath string `json:"file_path"`         // The path or URL of the JavaScript file.
	Content  string `json:"content,omitempty"` // The content of the file, if already available.
}

type JWTTaskParams struct {
	Token string `json:"token"` // The JWT token to be analyzed.
}

type KeyEventData struct {
	// Key represents the main key being pressed (e.g., "a", "Enter", "Tab").
	// The value should be compatible with the strings expected by the Chrome
	// DevTools Protocol's `input.dispatchKeyEvent` command.
	Key string
	// Modifiers is a bitmask representing the combination of active modifier keys.
	Modifiers KeyModifier
}

type KeyModifier int

type KnowledgeGraphClient interface {
	// AddNode adds a new node to the knowledge graph.
	AddNode(ctx context.Context, node Node) error
	// AddEdge adds a new edge between two nodes in the knowledge graph.
	AddEdge(ctx context.Context, edge Edge) error
	// GetNode retrieves a node by its unique ID.
	GetNode(ctx context.Context, id string) (Node, error)
	// GetEdge retrieves an edge by its unique ID.
	GetEdge(ctx context.Context, id string) (Edge, error)
	// GetEdges retrieves all edges connected to a specific node.
	GetEdges(ctx context.Context, nodeID string) ([]Edge, error)
	// GetNeighbors retrieves all nodes directly connected to a specific node.
	GetNeighbors(ctx context.Context, nodeID string) ([]Node, error)
	// QueryImprovementHistory searches for past self-improvement attempts related
	// to a specific objective.
	QueryImprovementHistory(ctx context.Context, goalObjective string, limit int) ([]Node, error)
}

type KnowledgeGraphUpdate struct {
	NodesToAdd []NodeInput `json:"nodes_to_add"`
	EdgesToAdd []EdgeInput `json:"edges_to_add"`
}

type LLMClient interface {
	// Generate produces a text completion based on the provided request.
	Generate(ctx context.Context, req GenerationRequest) (string, error)
	// Close cleans up any resources held by the client (e.g., network connections, SDK resources).
	Close() error
}

type ModelTier string

type MouseButton string

type MouseEventData struct {
	Type       MouseEventType `json:"type"`       // The type of the mouse event.
	X          float64        `json:"x"`          // The x-coordinate of the event.
	Y          float64        `json:"y"`          // The y-coordinate of the event.
	Button     MouseButton    `json:"button"`     // The primary button associated with the event.
	Buttons    int64          `json:"buttons"`    // A bitmask of all buttons currently pressed.
	ClickCount int            `json:"clickCount"` // The number of consecutive clicks.
	DeltaX     float64        `json:"deltaX"`     // The horizontal scroll amount for wheel events.
	DeltaY     float64        `json:"deltaY"`     // The vertical scroll amount for wheel events.
}

type MouseEventType string

type NVPair struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

type Node struct {
	ID         string          `json:"id"`
	Type       NodeType        `json:"type"`
	Label      string          `json:"label"`
	Status     NodeStatus      `json:"status"`
	Properties json.RawMessage `json:"properties"` // Flexible JSONB field for type-specific data.
	CreatedAt  time.Time       `json:"created_at"`
	LastSeen   time.Time       `json:"last_seen"`
}

type NodeInput struct {
	ID         string          `json:"id"`
	Type       NodeType        `json:"type"`
	Label      string          `json:"label"`
	Status     NodeStatus      `json:"status"`
	Properties json.RawMessage `json:"properties"`
}

type NodeStatus string

type NodeType string

type OASTInteraction struct {
	Canary          string    // The unique canary token that triggered the interaction.
	Protocol        string    // The protocol of the interaction (e.g., "HTTP", "DNS").
	SourceIP        string    // The IP address from which the interaction originated.
	InteractionTime time.Time // The timestamp of the interaction.
	RawRequest      string    // The raw request data, if available.
}

type OASTProvider interface {
	// GetInteractions queries the OAST server for any interactions that match a
	// given list of canary tokens.
	GetInteractions(ctx context.Context, canaries []string) ([]OASTInteraction, error)
	// GetServerURL returns the public URL of the OAST server, which can be used
	// in payloads.
	GetServerURL() string
}

type ObservationType string

type Orchestrator interface {
	// StartScan initiates a new scan for a given set of targets and a unique scan ID.
	StartScan(ctx context.Context, targets []string, scanID string) error
}

type Page struct {
	StartedDateTime time.Time   `json:"startedDateTime"` // The timestamp when the page load started.
	ID              string      `json:"id"`              // A unique identifier for the page.
	Title           string      `json:"title"`           // The title of the page.
	PageTimings     PageTimings `json:"pageTimings"`     // Timings for page load events.
}

type PageTimings struct {
	OnContentLoad float64 `json:"onContentLoad"` // Time until the DOMContentLoaded event, in milliseconds.
	OnLoad        float64 `json:"onLoad"`        // Time until the page's load event, in milliseconds.
}

type Persona struct {
	UserAgent       string       `json:"userAgent"`
	Platform        string       `json:"platform"`
	Languages       []string     `json:"languages"`
	Width           int64        `json:"width"`
	Height          int64        `json:"height"`
	AvailWidth      int64        `json:"availWidth"`
	AvailHeight     int64        `json:"availHeight"`
	ColorDepth      int64        `json:"colorDepth"`
	PixelDepth      int64        `json:"pixelDepth"`
	Mobile          bool         `json:"mobile"`
	Timezone        string       `json:"timezoneId"`
	Locale          string       `json:"locale"`
	ClientHintsData *ClientHints `json:"clientHintsData,omitempty"`
	// WebGLVendor and WebGLRenderer are used to spoof canvas fingerprinting attempts.
	WebGLVendor   string `json:"webGLVendor,omitempty"`
	WebGLRenderer string `json:"webGLRenderer,omitempty"`
	NoiseSeed     int64  `json:"noiseSeed"`
}

type PostData struct {
	MimeType string   `json:"mimeType"` // The MIME type of the posted data.
	Text     string   `json:"text"`     // The raw text of the posted data.
	Params   []NVPair `json:"params"`   // A list of parameters for form-encoded data.
}

type ProbeType string

type RaceConditionParams struct {
	Method  string              `json:"method"`
	Headers map[string][]string `json:"headers"`
	Body    []byte              `json:"body"`
}

type RelationshipType string

type Request struct {
	Method      string      `json:"method"`
	URL         string      `json:"url"`
	HTTPVersion string      `json:"httpVersion"`
	Cookies     []HARCookie `json:"cookies"`
	Headers     []NVPair    `json:"headers"`
	QueryString []NVPair    `json:"queryString"`
	PostData    *PostData   `json:"postData,omitempty"`
	HeadersSize int64       `json:"headersSize"` // The size of the request headers in bytes.
	BodySize    int64       `json:"bodySize"`    // The size of the request body in bytes.
}

type Response struct {
	Status      int         `json:"status"`
	StatusText  string      `json:"statusText"`
	HTTPVersion string      `json:"httpVersion"`
	Cookies     []HARCookie `json:"cookies"`
	Headers     []NVPair    `json:"headers"`
	Content     Content     `json:"content"`
	RedirectURL string      `json:"redirectURL"`
	HeadersSize int64       `json:"headersSize"` // The size of the response headers in bytes.
	BodySize    int64       `json:"bodySize"`    // The size of the response body in bytes.
	// --- ADDED FIELDS ---
	// Custom fields for storing CDP network data for later analysis.
	// The underscore prefix indicates they are non-standard HAR fields.
	RemoteIPSpace   string `json:"_remoteIPAddressSpace,omitempty"` // The IP address space of the remote server.
	RemoteIPAddress string `json:"_remoteIPAddress,omitempty"`      // The IP address of the remote server.
}

type ResultEnvelope struct {
	ScanID    string                `json:"scan_id"`
	TaskID    string                `json:"task_id"`
	Timestamp time.Time             `json:"timestamp"`
	Findings  []Finding             `json:"findings"`
	KGUpdates *KnowledgeGraphUpdate `json:"kg_updates,omitempty"`
}

type SessionContext interface {
	ID() string                                                                  // Returns the unique ID of the session.
	Navigate(ctx context.Context, url string) error                              // Navigates the session to a new URL.
	Click(ctx context.Context, selector string) error                            // Clicks on an element matching the selector.
	Type(ctx context.Context, selector string, text string) error                // Types text into an element.
	Submit(ctx context.Context, selector string) error                           // Submits a form.
	ScrollPage(ctx context.Context, direction string) error                      // Scrolls the page up or down.
	WaitForAsync(ctx context.Context, milliseconds int) error                    // Waits for a specified period.
	ExposeFunction(ctx context.Context, name string, function interface{}) error // Exposes a Go function to the browser's JS context.
	InjectScriptPersistently(ctx context.Context, script string) error           // Injects a script that persists across navigations.
	Interact(ctx context.Context, config InteractionConfig) error                // Executes a complex sequence of interactions.
	Close(ctx context.Context) error                                             // Closes the browser session.
	CollectArtifacts(ctx context.Context) (*Artifacts, error)                    // Gathers all available data (HAR, DOM, etc.).
	AddFinding(ctx context.Context, finding Finding) error                       // Reports a new finding discovered in this session.
	Sleep(ctx context.Context, d time.Duration) error                            // Pauses execution for a duration.
	DispatchMouseEvent(ctx context.Context, data MouseEventData) error           // Dispatches a low-level mouse event.
	SendKeys(ctx context.Context, keys string) error                             // Sends a sequence of keystrokes.
	// DispatchStructuredKey sends a key press event with modifiers (e.g., Ctrl+C).
	DispatchStructuredKey(ctx context.Context, data KeyEventData) error
	GetElementGeometry(ctx context.Context, selector string) (*ElementGeometry, error)             // Gets the geometry of an element.
	ExecuteScript(ctx context.Context, script string, args []interface{}) (json.RawMessage, error) // Executes a JavaScript snippet.
}

type Severity string

type StorageState struct {
	Cookies        []*Cookie         `json:"cookies"`
	LocalStorage   map[string]string `json:"local_storage"`
	SessionStorage map[string]string `json:"session_storage"`
}

type Store interface {
	// PersistData saves a collection of findings and other results from a task
	// to the data store.
	PersistData(ctx context.Context, data *ResultEnvelope) error
	// GetFindingsByScanID retrieves all findings associated with a specific scan ID.
	GetFindingsByScanID(ctx context.Context, scanID string) ([]Finding, error)
}

type Subgraph struct {
	Nodes []Node `json:"nodes"`
	Edges []Edge `json:"edges"`
}

type TaintSink string

type TaintSource string

type Task struct {
	TaskID     string      `json:"task_id"`    // A unique identifier for this specific task instance.
	ScanID     string      `json:"scan_id"`    // The ID of the parent scan this task belongs to.
	Type       TaskType    `json:"type"`       // The type of the task, which determines which worker will handle it.
	TargetURL  string      `json:"target_url"` // The primary URL or resource target for the task.
	Parameters interface{} `json:"parameters"` // A flexible field for task-specific parameters.
}

type TaskEngine interface {
	// Start begins processing tasks from the provided channel.
	Start(ctx context.Context, taskChan <-chan Task)
	// Stop gracefully terminates the task execution engine.
	Stop()
}

type TaskType string

type Timings struct {
	Blocked float64 `json:"blocked"` // Time spent blocked before the request could be sent.
	DNS     float64 `json:"dns"`     // DNS lookup time.
	Connect float64 `json:"connect"` // TCP connection time.
	SSL     float64 `json:"ssl"`     // SSL/TLS handshake time.
	Send    float64 `json:"send"`    // Time spent sending the HTTP request.
	Wait    float64 `json:"wait"`    // Time spent waiting for the first byte of the response (TTFB).
	Receive float64 `json:"receive"` // Time spent receiving the response data.
}

type UserAgentBrandVersion struct {
	Brand   string `json:"brand"`
	Version string `json:"version"`
}