core

type APIKeyHinter interface {
	APIKeyHint() string
}

type ASN struct {
	Number  string `json:"number,omitempty"`  // "AS13335"
	Org     string `json:"org,omitempty"`     // Holder name
	Country string `json:"country,omitempty"` // ISO 3166-1 alpha-2
}

type Adapter interface {
	// Name returns the adapter name (e.g., "sarif", "cyclonedx")
	Name() string

	// InputFormats returns supported input formats
	InputFormats() []string

	// OutputFormat returns the output format (usually "ctis")
	OutputFormat() string

	// CanConvert checks if the input can be converted
	CanConvert(input []byte) bool

	// Convert transforms input to CTIS Report
	Convert(ctx context.Context, input []byte, opts *AdapterOptions) (*ctis.Report, error)
}

type AdapterOptions struct {
	// Source information
	SourceName string `yaml:"source_name" json:"source_name"`
	SourceType string `yaml:"source_type" json:"source_type"`

	// Target repository/asset info
	Repository string `yaml:"repository" json:"repository"`
	Branch     string `yaml:"branch" json:"branch"`
	CommitSHA  string `yaml:"commit_sha" json:"commit_sha"`

	// Filtering
	MinSeverity string `yaml:"min_severity" json:"min_severity"`

	// Debug
	Verbose bool `yaml:"verbose" json:"verbose"`
}

type AssetResolver func(scanner, target string) (ctis.AssetType, string)

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

type AuthGateConfig struct {
	// BackoffBase is the first re-check delay after a rejection.
	BackoffBase time.Duration
	// BackoffMax caps the re-check delay.
	BackoffMax time.Duration
	// Logger receives the state changes. Nil logs to stderr with timestamps.
	Logger *log.Logger
}

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

type BaseCollectorConfig struct {
	Name       string            `yaml:"name" json:"name"`
	SourceType string            `yaml:"source_type" json:"source_type"`
	BaseURL    string            `yaml:"base_url" json:"base_url"`
	APIKey     string            `yaml:"api_key" json:"api_key"`
	Headers    map[string]string `yaml:"headers" json:"headers"`
	Timeout    time.Duration     `yaml:"timeout" json:"timeout"`
	Verbose    bool              `yaml:"verbose" json:"verbose"`
}

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

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

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

type BaseScannerConfig struct {
	Name         string            `yaml:"name" json:"name"`
	Version      string            `yaml:"version" json:"version"`
	Binary       string            `yaml:"binary" json:"binary"`
	DefaultArgs  []string          `yaml:"default_args" json:"default_args"`
	Timeout      time.Duration     `yaml:"timeout" json:"timeout"`
	OKExitCodes  []int             `yaml:"ok_exit_codes" json:"ok_exit_codes"`
	Capabilities []string          `yaml:"capabilities" json:"capabilities"`
	WorkDir      string            `yaml:"work_dir" json:"work_dir"`
	Env          map[string]string `yaml:"env" json:"env"`
	Verbose      bool              `yaml:"verbose" json:"verbose"`
	// MaxOutputBytes bounds the captured stdout; 0 means
	// DefaultMaxScannerOutput. A scanner that writes more is stopped and
	// Scan returns ErrScannerOutputTooLarge.
	MaxOutputBytes int64 `yaml:"max_output_bytes" json:"max_output_bytes"`
}

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

type BaseSensorConfig struct {
	Name    string `yaml:"name" json:"name"`
	Version string `yaml:"version" json:"version"`
	// ProductName, Commit and BuildTime describe the sensor binary on every
	// heartbeat ("sensor"); all optional. ProductName defaults to the name
	// given to useragent.SetProduct, then to the executable's name;
	// BuildTime is RFC 3339.
	ProductName       string        `yaml:"product_name" json:"product_name"`
	Commit            string        `yaml:"commit" json:"commit"`
	BuildTime         string        `yaml:"build_time" json:"build_time"`
	Region            string        `yaml:"region" json:"region"` // Deployment region (e.g., "us-east-1", "ap-southeast-1")
	ScanInterval      time.Duration `yaml:"scan_interval" json:"scan_interval"`
	CollectInterval   time.Duration `yaml:"collect_interval" json:"collect_interval"`
	HeartbeatInterval time.Duration `yaml:"heartbeat_interval" json:"heartbeat_interval"`
	Targets           []string      `yaml:"targets" json:"targets"`
	Verbose           bool          `yaml:"verbose" json:"verbose"`
}

type CVSSData struct {
	Source CVSSSource `json:"source"`
	Score  float64    `json:"score"`
	Vector string     `json:"vector"`
}

type CVSSSource string

type CacheStats struct {
	TemplateCount int            `json:"template_count"`
	TotalSize     int64          `json:"total_size"`
	TenantCount   map[string]int `json:"tenant_count"`
	TypeCount     map[string]int `json:"type_count"`
	OldestEntry   time.Time      `json:"oldest_entry"`
	NewestEntry   time.Time      `json:"newest_entry"`
}

type CachedTemplateMetadata struct {
	ID           string    `json:"id"`
	Name         string    `json:"name"`
	TemplateType string    `json:"template_type"`
	ContentHash  string    `json:"content_hash"`
	TenantID     string    `json:"tenant_id"`
	FilePath     string    `json:"file_path"`
	Size         int64     `json:"size"`
	CachedAt     time.Time `json:"cached_at"`
	LastUsedAt   time.Time `json:"last_used_at"`
}

type CancelPusher interface {
	SendHeartbeatForCancels(ctx context.Context, status *SensorStatus) ([]string, error)
}

type CapabilityReport struct {
	// Tools is the tool inventory. nil reports nothing (the platform keeps
	// using its administrator's list); an empty, non-nil slice reports that
	// no tool is available.
	Tools []ToolInfo
	// Capabilities are the capability names the sensor serves ("validate",
	// a tool name, "sast"). nil reports nothing, as for Tools.
	Capabilities []string
	// MaxConcurrentJobs is the operator's ceiling on concurrent jobs
	// (SENSOR_MAX_JOBS, SetMaxConcurrentJobs); 0 reports none. It is not
	// what the sensor can run now: a sensor with a resource manager reports
	// that as its dynamic slots (SensorStatus.Capacity.SlotsTotal), always
	// at most this ceiling.
	MaxConcurrentJobs int
}

type CapabilityReporter interface {
	CapabilityReport(ctx context.Context) CapabilityReport
}

type CapabilityReporterFunc func(ctx context.Context) CapabilityReport

type CapabilityScanner interface {
	Scanner
	TakesCapabilityJobs() bool
}

type CollectCommandPayload struct {
	Collector    string                 `json:"collector"`
	SourceConfig map[string]interface{} `json:"source_config,omitempty"`
}

type CollectOptions struct {
	// Source configuration
	SourceURL string            `yaml:"source_url" json:"source_url"`
	APIKey    string            `yaml:"api_key" json:"api_key"`
	Headers   map[string]string `yaml:"headers" json:"headers"`
	Query     map[string]string `yaml:"query" json:"query"`

	// Filtering
	Since      int64    `yaml:"since" json:"since"` // Unix timestamp
	Repository string   `yaml:"repository" json:"repository"`
	Branches   []string `yaml:"branches" json:"branches"`

	// Pagination
	PageSize int `yaml:"page_size" json:"page_size"`
	MaxPages int `yaml:"max_pages" json:"max_pages"`
}

type CollectResult struct {
	// Source info
	SourceName string `json:"source_name"`
	SourceType string `json:"source_type"`

	// Collection timing
	CollectedAt int64 `json:"collected_at"`
	DurationMs  int64 `json:"duration_ms"`

	// Results
	Reports    []*ctis.Report `json:"reports"`
	TotalItems int            `json:"total_items"`
	ErrorItems int            `json:"error_items"`

	// Cursor for pagination
	NextCursor string `json:"next_cursor,omitempty"`
	HasMore    bool   `json:"has_more"`
}

type Collector interface {
	// Name returns the collector name
	Name() string

	// Type returns the source type (e.g., "github", "gitlab", "api")
	Type() string

	// Collect pulls data from the external source
	Collect(ctx context.Context, opts *CollectOptions) (*CollectResult, error)

	// TestConnection verifies the connection to the external source
	TestConnection(ctx context.Context) error
}

type Command struct {
	ID        string          `json:"id"`
	Type      string          `json:"type"`
	Priority  string          `json:"priority"`
	Payload   json.RawMessage `json:"payload"`
	CreatedAt time.Time       `json:"created_at"`
	ExpiresAt time.Time       `json:"expires_at"`
	// LeaseEpoch and LeaseExpiresAt are the command's lease as the poll
	// saw it (protocol v2, api RFC-035 D6): the claim that follows starts
	// a new epoch, which the client keeps and echoes on complete and fail.
	// Zero from a platform without leases.
	LeaseEpoch     int       `json:"lease_epoch,omitempty"`
	LeaseExpiresAt time.Time `json:"lease_expires_at,omitzero"`
	// SignedJob is the platform job signer's DSSE envelope for this
	// delivery ("signed_job" of a claim answer; api RFC-040 §5.6). It binds
	// Payload's exact bytes, so Payload must be kept as received.
	SignedJob json.RawMessage `json:"signed_job,omitempty"`
	// Claimed is true when the poll already claimed the command for this
	// sensor (claim-N, api RFC-046 §11). The poller still acknowledges it
	// (a replay) when it runs it, and releases it when it does not.
	Claimed bool `json:"-"`
	// contains filtered or unexported fields
}

type CommandAdmission struct {
	// Total is how many targets the command named.
	Total int
	// Refused are the targets removed from the command (or, with an error,
	// the targets that made it refused), in payload order.
	Refused []RefusedTarget
}

type CommandCanceler interface {
	CancelCommands(ids ...string)
}

type CommandClaimer interface {
	ClaimCommand(ctx context.Context, id string) (*Command, error)
}

type CommandClient interface {
	GetCommands(ctx context.Context) (*GetCommandsResponse, error)
	AcknowledgeCommand(ctx context.Context, cmdID string) error
	StartCommand(ctx context.Context, cmdID string) error
	ReportCommandResult(ctx context.Context, cmdID string, result *CommandResult) error
	ReportCommandProgress(ctx context.Context, cmdID string, progress int, message string) error
}

type CommandExecutionResult struct {
	DurationMs    int64
	FindingsCount int
	ExitCode      int
	Metadata      map[string]interface{}
	// TargetOutcomes is how each of a scan job's targets ended, in job
	// order (target_outcomes.go); nil for other commands.
	TargetOutcomes []outcome.Target
}

type CommandExecutor interface {
	Execute(ctx context.Context, cmd *Command) (*CommandExecutionResult, error)
}

type CommandLogSink interface {
	// CommandLog adds one line (level: info, warn or error) to the log of
	// command commandID. It never blocks on the network.
	CommandLog(ctx context.Context, commandID, level, msg string, fields map[string]any)
	// FinishCommandLog sends what is left of the command's lines. Queued
	// (direct false), the lines are delivered by the outbox ahead of the
	// result reported after it. Direct, they are sent before it returns:
	// for a command about to be handed back, after which the platform no
	// longer takes this sensor's lines for it.
	FinishCommandLog(ctx context.Context, commandID string, direct bool)
}

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

type CommandPollerConfig struct {
	PollInterval  time.Duration `yaml:"poll_interval" json:"poll_interval"`
	MaxConcurrent int           `yaml:"max_concurrent" json:"max_concurrent"`
	AllowedTypes  []string      `yaml:"allowed_types" json:"allowed_types"`
	Verbose       bool          `yaml:"verbose" json:"verbose"`
	// DoorbellSafetyPoll is how often the poller still polls on its own
	// while the heartbeat doorbell is active. Default 5m.
	DoorbellSafetyPoll time.Duration `yaml:"doorbell_safety_poll" json:"doorbell_safety_poll"`
	// DrainGrace is how long a stopping poller lets running commands finish
	// before it cancels them and releases them to the platform. Default 30s.
	DrainGrace time.Duration `yaml:"drain_grace" json:"drain_grace"`
}

type CommandProgress struct {
	Done        int      `json:"done"`
	Total       int      `json:"total"`
	Finished    [][2]int `json:"finished,omitempty"`
	Records     int64    `json:"records,omitempty"`
	OutputBytes int64    `json:"output_bytes,omitempty"`
	CPUMs       int64    `json:"cpu_ms,omitempty"`
	// ReleasedKeys are the politeness keys the sensor freed because the
	// targets that needed them settled (politeness.Holding): the platform
	// stops counting them as held by the command, so other work on those
	// hosts can start before it ends. Sorted, at most politeness.MaxKeys.
	ReleasedKeys []string `json:"released_keys,omitempty"`
}

type CommandResult struct {
	Status        string                 `json:"status"`
	CompletedAt   time.Time              `json:"completed_at"`
	DurationMs    int64                  `json:"duration_ms"`
	ExitCode      int                    `json:"exit_code"`
	FindingsCount int                    `json:"findings_count"`
	Error         string                 `json:"error,omitempty"`
	Metadata      map[string]interface{} `json:"metadata,omitempty"`
	// Refusal is set when a policy refused the command (RefusalOf): it was
	// never run, or was stopped by the kill switch.
	Refusal *Refusal `json:"refusal,omitempty"`
	// TargetOutcomes is how each target of a completed scan command ended
	// (ctis outcome.ResultKey): the platform settles the targets with an
	// outcome and hands out only the unfinished ones again.
	TargetOutcomes []outcome.Target `json:"target_outcomes,omitempty"`
}

type ConfigCheck struct {
	ID       string                 `json:"id"`
	Status   string                 `json:"status"`
	Severity string                 `json:"severity"`
	Code     string                 `json:"code"`
	Params   map[string]ConfigParam `json:"params,omitempty"`
	Keys     []string               `json:"keys,omitempty"`
	Summary  string                 `json:"summary,omitempty"`
	Excerpt  string                 `json:"excerpt,omitempty"`
	Blocks   []string               `json:"blocks,omitempty"`
}

type ConfigParam struct {
	Int     *int64   `json:"int,omitempty"`
	Bool    *bool    `json:"bool,omitempty"`
	Enum    string   `json:"enum,omitempty"`
	Path    string   `json:"path,omitempty"`
	Host    string   `json:"host,omitempty"`
	Version string   `json:"version,omitempty"`
	Name    string   `json:"name,omitempty"`
	Names   []string `json:"names,omitempty"`
}

type ConfigReport struct {
	Schema       int             `json:"schema"`
	ObservedAt   string          `json:"observed_at"`
	Trigger      string          `json:"trigger"`
	Runtime      ConfigRuntime   `json:"runtime"`
	ConfigHealth string          `json:"config_health"`
	Checks       []ConfigCheck   `json:"checks"`
	Settings     []ConfigSetting `json:"settings"`
	Truncated    bool            `json:"truncated"`
}

type ConfigReportAck struct {
	Digest  string
	Changed bool
	Ignored []ManifestIgnored
}

type ConfigReportPusher interface {
	PutConfigReport(ctx context.Context, r *ConfigReport) (*ConfigReportAck, error)
}

type ConfigReportSummary struct {
	Digest     string `json:"digest"`
	Health     string `json:"health"`
	Fail       int    `json:"fail"`
	Warn       int    `json:"warn"`
	ObservedAt string `json:"observed_at"`
}

type ConfigReporter interface {
	ConfigReport() *ConfigReport
}

type ConfigReporterFunc func() *ConfigReport

type ConfigRuntime struct {
	Kind string `json:"kind"`
}

type ConfigSetting struct {
	Name   string `json:"name"`
	Set    bool   `json:"set"`
	Source string `json:"source"`
	Secret bool   `json:"secret"`
	Valid  bool   `json:"valid"`
}

type Connector interface {
	// Name returns the connector name (e.g., "github", "gitlab")
	Name() string

	// Type returns the connector type (e.g., "scm", "cloud", "ticketing")
	Type() string

	// Connect establishes connection to the external system
	Connect(ctx context.Context) error

	// Close closes the connection
	Close() error

	// IsConnected returns true if connected
	IsConnected() bool

	// TestConnection verifies the connection is working
	TestConnection(ctx context.Context) error

	// HTTPClient returns the configured HTTP client (with auth headers)
	HTTPClient() *http.Client

	// RateLimited returns true if rate limiting is enabled
	RateLimited() bool

	// WaitForRateLimit blocks until rate limit allows next request
	WaitForRateLimit(ctx context.Context) error
}

type ConnectorConfig struct {
	// Authentication
	APIKey      string       `yaml:"api_key" json:"api_key"`
	Token       string       `yaml:"token" json:"token"`
	Username    string       `yaml:"username" json:"username"`
	Password    string       `yaml:"password" json:"password"`
	OAuthConfig *OAuthConfig `yaml:"oauth" json:"oauth,omitempty"`

	// Connection
	BaseURL string        `yaml:"base_url" json:"base_url"`
	Timeout time.Duration `yaml:"timeout" json:"timeout"`

	// Rate limiting
	RateLimit  int `yaml:"rate_limit" json:"rate_limit"`   // requests per hour
	BurstLimit int `yaml:"burst_limit" json:"burst_limit"` // burst size

	// Retry
	MaxRetries int           `yaml:"max_retries" json:"max_retries"`
	RetryDelay time.Duration `yaml:"retry_delay" json:"retry_delay"`

	// Debug
	Verbose bool `yaml:"verbose" json:"verbose"`
}

type ContentInfo struct {
	// Name is the content's name (ContentTrivyDB, ContentNucleiTemplates, ...).
	Name string `json:"name"`
	// Version identifies the content: a release tag for templates, the
	// build time for a database, a digest prefix for a rules bundle. Empty
	// when the sensor has none.
	Version string `json:"version,omitempty"`
	// UpdatedAt is when the content was published (the database's build
	// time, the templates' release date); the platform measures staleness
	// from it. nil when unknown.
	UpdatedAt *time.Time `json:"updated_at,omitempty"`
	// FetchedAt is when this sensor installed it.
	FetchedAt *time.Time `json:"fetched_at,omitempty"`
	// CheckedAt is when the sensor last confirmed with its source that this
	// is still the newest version (or the pinned one). Content that is old
	// because its publisher has released nothing newer is not stale: see
	// Stale.
	CheckedAt *time.Time `json:"checked_at,omitempty"`
	// Source is where it came from: a registry repository, a URL, "image"
	// for content baked into the sensor image, or the tool's own fetch.
	Source string `json:"source,omitempty"`
	// Digest is the content's digest ("sha256:..."): the OCI manifest digest
	// of a database, the archive digest of a template release.
	Digest string `json:"digest,omitempty"`
	// Managed is true when the sensor controls the content (it refreshes,
	// verifies and swaps it, and scans use exactly this version); false
	// when the tool fetches its content by itself.
	Managed bool `json:"managed"`
	// Error is the last refresh failure, if the last refresh failed (the
	// sensor keeps scanning with the version above). Short, no secrets.
	Error string `json:"error,omitempty"`
}

type ContentPin struct {
	// MaxAgeHours: content older than this is stale. The sensor refreshes
	// it on its next check and the platform reports the sensor degraded
	// while it stays stale. 0: no limit.
	MaxAgeHours int `json:"max_age_hours,omitempty"`
	// Version pins the content: an OCI digest ("sha256:...") for a
	// database, a release tag ("v10.4.9") for templates. Empty: the
	// newest the source has.
	Version string `json:"version,omitempty"`
	// Rulesets (semgrep-rules only) are the registry rulesets the sensor
	// fetches, verifies and pins ("p/default"). Empty: semgrep fetches its
	// rules itself on every scan (--config auto).
	Rulesets []string `json:"rulesets,omitempty"`
}

type ContentPolicy struct {
	// RefreshIntervalHours is how often the sensor checks for new content;
	// 0 leaves the sensor's own setting.
	RefreshIntervalHours int `json:"refresh_interval_hours,omitempty"`
	// Content is the per-content policy, keyed by content name.
	Content map[string]ContentPin `json:"content,omitempty"`
}

type ControlStats struct {
	// IntervalSeconds is the heartbeat interval the sensor follows now: the
	// platform's advice, else its own setting.
	IntervalSeconds float64 `json:"interval_s"`
	// GapSeconds is the time since the previous delivered heartbeat, when
	// this one is sent (0 on the first).
	GapSeconds float64 `json:"gap_s,omitempty"`
	// LagMs is how late this heartbeat started against its schedule: the
	// time the sensor waited for the CPU.
	LagMs int64 `json:"lag_ms"`
	// BuildMs is the time spent building this heartbeat's report (load
	// snapshot, tool inventory, manifest).
	BuildMs int64 `json:"build_ms"`
	// RTTMs is the round trip of the previous delivered heartbeat.
	RTTMs int64 `json:"rtt_ms,omitempty"`
	// Failures is the heartbeats that failed since the previous delivered
	// one.
	Failures int `json:"failures,omitempty"`
}

type DNSRecord struct {
	Host       string   `json:"host"`                  // Hostname
	RecordType string   `json:"record_type"`           // A, AAAA, CNAME, MX, NS, TXT, SOA
	Values     []string `json:"values"`                // Record values
	TTL        int      `json:"ttl,omitempty"`         // Time to live
	Resolver   string   `json:"resolver,omitempty"`    // Resolver used
	StatusCode string   `json:"status_code,omitempty"` // NOERROR, NXDOMAIN, etc.
}

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

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

type DiscoveredURL struct {
	URL        string `json:"url"`              // Full URL
	Method     string `json:"method,omitempty"` // HTTP method (GET, POST, etc.)
	Source     string `json:"source,omitempty"` // Discovery source (crawl, js, archive)
	StatusCode int    `json:"status_code,omitempty"`
	Depth      int    `json:"depth,omitempty"`     // Crawl depth
	Parent     string `json:"parent,omitempty"`    // Parent URL
	Type       string `json:"type,omitempty"`      // endpoint, form, api, static
	Extension  string `json:"extension,omitempty"` // File extension
}

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

type DoorbellConfig struct {
	// OnRotateKey is called (in its own goroutine) when the platform sends
	// rotate_key, e.g. platform.KeyRenewManager.RenewNow. Nil: rotate_key is
	// logged and otherwise ignored.
	OnRotateKey func()
	// Logger receives the doorbell's state changes. Nil logs to stderr with
	// timestamps.
	Logger *log.Logger
	// Verbose also logs every heartbeat's hints.
	Verbose bool
}

type DoorbellPusher interface {
	SendHeartbeatWithHints(ctx context.Context, status *SensorStatus) (*HeartbeatHints, error)
}

type EmbeddedTemplate struct {
	ID           string `json:"id"`
	Name         string `json:"name"`
	TemplateType string `json:"template_type"` // nuclei, semgrep, betterleaks
	Content      string `json:"content"`       // Base64-encoded template content (YAML/TOML)
	ContentHash  string `json:"content_hash"`  // SHA256 hash of decoded content for verification
}

type Enricher interface {
	// Name returns the enricher name (e.g., "epss", "kev", "nvd")
	Name() string

	// Enrich adds threat intel to a single finding
	Enrich(ctx context.Context, finding *ctis.Finding) (*ctis.Finding, error)

	// EnrichBatch adds threat intel to multiple findings
	EnrichBatch(ctx context.Context, findings []ctis.Finding) ([]ctis.Finding, error)
}

type EnricherConfig struct {
	// API endpoint (optional, for custom sources)
	Endpoint string `yaml:"endpoint" json:"endpoint"`

	// Cache duration
	CacheTTL time.Duration `yaml:"cache_ttl" json:"cache_ttl"`

	// Rate limiting
	RateLimit int `yaml:"rate_limit" json:"rate_limit"`

	// Debug
	Verbose bool `yaml:"verbose" json:"verbose"`
}

type EnvelopeSignature struct {
	KeyID string `json:"keyid"`
	Sig   []byte `json:"sig"`
}

type ExecConfig struct {
	Binary  string            // Scanner binary path
	Args    []string          // Command arguments
	WorkDir string            // Working directory
	Env     map[string]string // Extra environment variables (added to the allowlisted base, see ScannerEnviron)
	Timeout time.Duration     // Execution timeout
	Verbose bool              // Stream output to logs
	// MaxOutputBytes bounds the captured stdout; 0 means
	// DefaultMaxScannerOutput. A scanner that writes more is stopped and the
	// call returns ErrScannerOutputTooLarge.
	MaxOutputBytes int64
	// WritePaths are paths the scanner may write besides its private task
	// directory, when the task sandbox is on (pkg/sensorkit/executor): an output
	// file's directory, a cache the scanner owns. Everything else is
	// read-only to it.
	WritePaths []string
	// Limits override the sandbox's default resource limits (zero fields:
	// the defaults).
	Limits executor.Limits
}

type ExecResult struct {
	ExitCode   int
	Stdout     []byte
	Stderr     []byte
	DurationMs int64
	Error      error
	// Sandbox is the protection the scanner ran under (pkg/sensorkit/executor).
	Sandbox executor.Status
}

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

type GetCommandsResponse struct {
	Commands            []*Command `json:"commands"`
	PollIntervalSeconds int        `json:"poll_interval_seconds,omitempty"`
}

type GitHubAlertInstance struct {
	Ref      string              `json:"ref"`
	State    string              `json:"state"`
	Location GitHubAlertLocation `json:"location"`
	Message  GitHubAlertMessage  `json:"message"`
}

type GitHubAlertLocation struct {
	Path        string `json:"path"`
	StartLine   int    `json:"start_line"`
	EndLine     int    `json:"end_line"`
	StartColumn int    `json:"start_column"`
	EndColumn   int    `json:"end_column"`
}

type GitHubAlertMessage struct {
	Text string `json:"text"`
}

type GitHubAlertRule struct {
	ID                    string   `json:"id"`
	Severity              string   `json:"severity"`
	SecuritySeverityLevel string   `json:"security_severity_level"`
	Description           string   `json:"description"`
	Tags                  []string `json:"tags"`
}

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

type GitHubCodeScanningAlert struct {
	Number             int                 `json:"number"`
	State              string              `json:"state"`
	HTMLURL            string              `json:"html_url"`
	Rule               GitHubAlertRule     `json:"rule"`
	Tool               GitHubAlertTool     `json:"tool"`
	MostRecentInstance GitHubAlertInstance `json:"most_recent_instance"`
	CreatedAt          string              `json:"created_at"`
}

type GitHubCollector struct {
	*BaseCollector
	// contains filtered or unexported fields
}

type GitHubCollectorConfig struct {
	Token   string `yaml:"token" json:"token"`
	Owner   string `yaml:"owner" json:"owner"`
	Repo    string `yaml:"repo" json:"repo"`
	Verbose bool   `yaml:"verbose" json:"verbose"`
}

type HeartbeatAction string

type HeartbeatHints struct {
	// Present is true when the response carried at least one doorbell field.
	// A server that knows the doorbell answers every heartbeat of a
	// doorbell-aware sensor with at least next_heartbeat_seconds.
	Present bool
	// PendingJobs is the number of jobs this sensor could claim now (0..100).
	PendingJobs int
	// NextHeartbeat is the advised delay before the next heartbeat, already
	// clamped to [MinDoorbellHeartbeatInterval, MaxDoorbellHeartbeatInterval].
	// Zero when not advised.
	NextHeartbeat time.Duration
	// Actions are the actions the server sent, unfiltered. Doorbell.Handle
	// acts only on the known ones.
	Actions []HeartbeatAction
	// ConfigVersion is the opaque version of what the platform governs about
	// this sensor, or "" when absent or malformed.
	ConfigVersion string
	// CancelCommandIDs are commands the platform canceled that this sensor
	// may hold (cancel_command_ids, api RFC-030 §5.4): the poller stops
	// them and releases them.
	CancelCommandIDs []string
	// StopCommandIDs are held commands the platform asks the sensor to stop
	// and complete with what they finished (stop_command_ids: the task
	// stalled). See ErrStoppedByPlatform.
	StopCommandIDs []string
}

type JSONParser struct{}

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

type JobsPosture struct {
	// Signed is JobsSignedRequired, JobsSignedVerifiedWhenPresent or
	// JobsSignedOff.
	Signed string `json:"signed"`
	// Root is the pinned job-signing root key id; "" when none is pinned.
	Root string `json:"root,omitempty"`
	// KeySetVersion and KeySetExpiresAt describe the accepted key set of
	// the pinned root (absent without one): the sensor refuses every signed
	// job once it expires, until the platform deploys a new one.
	KeySetVersion   uint64     `json:"keyset_version,omitempty"`
	KeySetExpiresAt *time.Time `json:"keyset_expires_at,omitempty"`
}

type LimitedCommandClient interface {
	GetCommandsLimit(ctx context.Context, limit int) (*GetCommandsResponse, error)
}

type LiveHost struct {
	URL           string   `json:"url"`                      // Full URL (https://example.com)
	Host          string   `json:"host"`                     // Hostname
	IP            string   `json:"ip,omitempty"`             // Resolved IP
	Port          int      `json:"port,omitempty"`           // Port number
	Scheme        string   `json:"scheme"`                   // http or https
	StatusCode    int      `json:"status_code"`              // HTTP status code
	ContentLength int64    `json:"content_length,omitempty"` // Response size
	Title         string   `json:"title,omitempty"`          // Page title
	WebServer     string   `json:"web_server,omitempty"`     // Server header
	ContentType   string   `json:"content_type,omitempty"`   // Content-Type header
	Technologies  []string `json:"technologies,omitempty"`   // Detected technologies
	CDN           string   `json:"cdn,omitempty"`            // CDN provider
	TLSVersion    string   `json:"tls_version,omitempty"`    // TLS version
	Redirect      string   `json:"redirect,omitempty"`       // Final redirect URL
	ResponseTime  int64    `json:"response_time_ms"`         // Response time in ms

	// What the probe learned about the server (all optional; the values are
	// chosen by the scanned server and bounded by ctis.ConvertReconToCTIS).
	CDNType     string   `json:"cdn_type,omitempty"`     // cdn, waf or cloud
	TLS         *TLSLeaf `json:"tls,omitempty"`          // Leaf certificate of the TLS handshake
	FaviconMMH3 string   `json:"favicon_mmh3,omitempty"` // mmh3 favicon hash (signed 32-bit decimal)
	JARM        string   `json:"jarm,omitempty"`         // JARM TLS server fingerprint
	ASN         *ASN     `json:"asn,omitempty"`          // Autonomous system of the host's address
}

type LoadReporter interface {
	ActiveJobs() int
	MaxJobs() int
}

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

type LocalPolicyError struct {
	// Layer is the policy layer that refused (RefusalLayer*); "" is the
	// local policy.
	Layer  string
	Rule   string
	Detail string
}

type LocalPolicyOptions struct {
	// Path is the policy file (a sensor's flag). "" reads EnvLocalPolicy,
	// then DefaultPath when that file exists. A path given here or in the
	// environment must exist.
	Path string
	// DefaultPath replaces DefaultLocalPolicyPath (tests).
	DefaultPath string
	// LookupEnv reads the environment (nil: os.LookupEnv).
	LookupEnv func(string) (string, bool)
	// LookupIP resolves host names for target checks (nil:
	// net.DefaultResolver).
	LookupIP func(ctx context.Context, host string) ([]net.IP, error)
	// Required makes a sensor without a policy fail closed (see
	// LocalPolicy.Required). EnvRequireLocalPolicy, when set, wins.
	Required bool
}

type LocalPolicyReport struct {
	// State is LocalPolicyStateEnforced or LocalPolicyStateAbsent.
	State string `json:"state"`
	// Required is true when the sensor requires a local policy (new
	// installs): absent, it refuses every job with network targets. State
	// absent with Required false is a legacy install that admits any
	// target outside the built-in deny list. Always sent; an SDK that
	// predates it sends none, which reads as false.
	Required bool `json:"required"`
	// Source is LocalPolicySourceFile or LocalPolicySourceEnv ("" when
	// absent).
	Source string `json:"source,omitempty"`
	// Digest is the policy's sha256 digest ("" when absent).
	Digest string `json:"digest,omitempty"`
	// KillSwitch is true while the sensor owner has stopped every job.
	KillSwitch bool `json:"kill_switch,omitempty"`
	// Summary is set when a policy is enforced.
	Summary *LocalPolicySummary `json:"summary,omitempty"`
	// Warnings are the operator warnings (see LocalPolicy.Warnings).
	Warnings []string `json:"warnings,omitempty"`
	// Schema is the policy file's schema version ("v1", "v2"); "" without
	// a file.
	Schema string `json:"schema,omitempty"`
	// Schemas are the schema versions this sensor reads
	// (LocalPolicySchemas): the platform generates a recommended policy
	// only in one of them.
	Schemas []string `json:"schemas,omitempty"`
}

type LocalPolicySummary struct {
	// TargetsAllow is the number of targets.allow entries; -1 when the
	// policy sets no allow list (any target outside the deny lists).
	TargetsAllow int `json:"targets_allow"`
	// TargetsDeny is the number of targets.deny entries.
	TargetsDeny int `json:"targets_deny"`
	// AllowPrivate: private ranges may be scanned (the policy and the
	// private-range switch agree).
	AllowPrivate bool `json:"allow_private"`
	// Ports is ports.allow ("" = any port).
	Ports string `json:"ports,omitempty"`
	// Tools and Checks are tools.allow and checks.allow (absent = any).
	Tools  []string `json:"tools,omitempty"`
	Checks []string `json:"checks,omitempty"`
	// AllowCustomTemplates and AllowInteractsh are the policy's switches.
	AllowCustomTemplates bool `json:"allow_custom_templates"`
	AllowInteractsh      bool `json:"allow_interactsh"`
	// MaxRPS and MaxJobSeconds are rate.max_rps and rate.max_job_seconds
	// (0 = not set).
	MaxRPS        int `json:"max_rps,omitempty"`
	MaxJobSeconds int `json:"max_job_seconds,omitempty"`
	// ManagedAccept is managed.accept (v2): false when the sensor owner
	// refuses platform-managed policy documents.
	ManagedAccept bool `json:"managed_accept"`
	// HTTPUserAgent is http.user_agent (v3): the User-Agent forced on
	// every tool ("" none). AllowInsecureTLS is http.allow_insecure_tls.
	HTTPUserAgent    string `json:"http_user_agent,omitempty"`
	AllowInsecureTLS bool   `json:"allow_insecure_tls"`
}

type LogLevel int

type Logger interface {
	// Debug logs a debug message
	Debug(format string, args ...interface{})

	// Info logs an info message
	Info(format string, args ...interface{})

	// Warn logs a warning message
	Warn(format string, args ...interface{})

	// Error logs an error message
	Error(format string, args ...interface{})
}

type Manifest struct {
	Schema       int                  `json:"schema"`
	Sensor       *SensorBuild         `json:"sensor,omitempty"`
	SDK          *SDKInfo             `json:"sdk,omitempty"`
	Platform     *ManifestPlatform    `json:"platform,omitempty"`
	Resources    *ManifestResources   `json:"resources,omitempty"`
	Concurrency  *ManifestConcurrency `json:"concurrency,omitempty"`
	Capabilities []string             `json:"capabilities,omitempty"`
	Tools        []ManifestTool       `json:"tools"`
	// LocalPolicy is the sensor-local policy's state, digest and summary
	// (api RFC-040 §5.7), without the live kill switch (the heartbeat
	// carries that). The API client sends it only to a platform that lists
	// the "local_policy" feature.
	LocalPolicy *LocalPolicyReport `json:"local_policy,omitempty"`
	// Posture is the sensor's platform TLS pin and tool sandbox
	// (SensorPosture; BaseSensor.SetPosture). The API client sends it only
	// to a platform that lists the "posture" feature.
	Posture *SensorPosture `json:"posture,omitempty"`
	// Network is the sensor's network self-description (netctx.Report:
	// declared and detected facts, fingerprint, internet mode;
	// BaseSensor.SetNetworkReporter). The API client sends it only to a
	// platform that lists the "network" feature.
	Network *netctx.Report `json:"network,omitempty"`
}

type ManifestAck struct {
	// Digest is what the platform stored; heartbeats echo it.
	Digest string
	// Changed is false when the platform already had it.
	Changed bool
	// AcceptedTools and AcceptedCapabilities are what the platform kept.
	AcceptedTools        []string
	AcceptedCapabilities []string
	// Ignored lists what it dropped and why.
	Ignored []ManifestIgnored
	// Policy is what the platform lets the sensor run (api RFC-033 §6.12);
	// nil from a platform that does not say. The BaseSensor refuses
	// commands for tools outside it (CommandToolGate).
	Policy *ManifestPolicy
	// OmitInventory: heartbeats that echo Digest may leave the tool
	// inventory out and carry only each tool's content freshness.
	OmitInventory bool
}

type ManifestConcurrency struct {
	Ceiling int    `json:"ceiling"`
	Model   string `json:"model,omitempty"`
}

type ManifestContent struct {
	Name    string `json:"name"`
	Version string `json:"version,omitempty"`
	Digest  string `json:"digest,omitempty"`
	Source  string `json:"source,omitempty"`
	Managed bool   `json:"managed"`
}

type ManifestIgnored struct {
	Path   string `json:"path"`
	Value  string `json:"value,omitempty"`
	Reason string `json:"reason"`
}

type ManifestPlatform struct {
	OS   string `json:"os,omitempty"`
	Arch string `json:"arch,omitempty"`
}

type ManifestPolicy struct {
	AllowedTools        []string
	AllowedCapabilities []string
	MaxJobs             int
}