api

type APIClient interface {
	Tasks() TasksClient
	Attacks() AttacksClient
	Agents() AgentsClient
	Auth() AuthClient
}

type APIError struct {
	StatusCode int
	Message    string
	Body       string
}

type AdvancedAgentConfiguration struct {
	// AgentUpdateInterval The interval in seconds to check for agent updates
	AgentUpdateInterval *int `json:"agent_update_interval"`

	// BackendDevice The device to use for hashcat, separated by commas
	BackendDevice *string `json:"backend_device"`

	// EnableAdditionalHashTypes Causes hashcat to perform benchmark-all, rather than just benchmark
	EnableAdditionalHashTypes bool `json:"enable_additional_hash_types"`

	// OpenclDevices The OpenCL device types to use for hashcat, separated by commas
	OpenclDevices *string `json:"opencl_devices,omitempty"`

	// UseNativeHashcat Use the hashcat binary already installed on the client system
	UseNativeHashcat *bool `json:"use_native_hashcat"`
}

type Agent struct {
	// AdvancedConfiguration Advanced hashcat and agent configuration options
	AdvancedConfiguration AdvancedAgentConfiguration `json:"advanced_configuration"`

	// ClientSignature The signature of the client
	ClientSignature string `json:"client_signature"`

	// CurrentActivity Current agent activity state
	CurrentActivity *string  `json:"current_activity,omitempty"`
	Devices         []string `json:"devices"`

	// HostName The hostname of the agent
	HostName string `json:"host_name"`

	// Id The id of the agent
	Id int64 `json:"id"`

	// OperatingSystem The operating system of the agent
	OperatingSystem string `json:"operating_system"`

	// State The state of the agent
	State AgentState `json:"state"`
}

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

type AgentHeartbeatRequest struct {
	// Activity Current agent activity state. Known values: starting, benchmarking, updating, downloading, waiting, cracking, stopping. Future versions may support additional values.
	Activity *string `json:"activity,omitempty"`
}

type AgentState string

type AgentsClient interface {
	// SendHeartbeat sends a heartbeat to the server with the current activity state.
	SendHeartbeat(ctx context.Context, id int64, activity string) (*SendHeartbeatResponse, error)

	// UpdateAgent updates agent metadata.
	UpdateAgent(
		ctx context.Context,
		id int64,
		body UpdateAgentJSONRequestBody,
	) (*UpdateAgentResponse, error)

	// SubmitBenchmark submits benchmark results.
	SubmitBenchmark(
		ctx context.Context,
		id int64,
		body SubmitBenchmarkJSONRequestBody,
	) (*SubmitBenchmarkResponse, error)

	// SubmitErrorAgent reports an error to the server.
	SubmitErrorAgent(
		ctx context.Context,
		id int64,
		body SubmitErrorAgentJSONRequestBody,
	) (*SubmitErrorAgentResponse, error)

	// SetAgentShutdown notifies the server of agent shutdown.
	SetAgentShutdown(ctx context.Context, id int64) (*SetAgentShutdownResponse, error)
}

type Attack struct {
	// AttackMode Attack mode name
	AttackMode AttackAttackMode `json:"attack_mode"`

	// AttackModeHashcat hashcat attack mode
	AttackModeHashcat int `json:"attack_mode_hashcat"`

	// ClassicMarkov Enable hashcat classic markov mode
	ClassicMarkov bool `json:"classic_markov"`

	// CustomCharset1 Custom charset 1 for hashcat mask attacks
	CustomCharset1 *string `json:"custom_charset_1,omitempty"`

	// CustomCharset2 Custom charset 2 for hashcat mask attacks
	CustomCharset2 *string `json:"custom_charset_2,omitempty"`

	// CustomCharset3 Custom charset 3 for hashcat mask attacks
	CustomCharset3 *string `json:"custom_charset_3,omitempty"`

	// CustomCharset4 Custom charset 4 for hashcat mask attacks
	CustomCharset4 *string `json:"custom_charset_4,omitempty"`

	// DisableMarkov Disable hashcat markov mode
	DisableMarkov bool `json:"disable_markov"`

	// HashListChecksum The MD5 checksum of the hash list
	HashListChecksum *[]byte `json:"hash_list_checksum"`

	// HashListId The id of the hash list
	HashListId int64 `json:"hash_list_id"`

	// HashListUrl The download URL for the hash list
	HashListUrl *string `json:"hash_list_url"`

	// HashMode The hashcat hash mode
	HashMode int `json:"hash_mode"`

	// Id The id of the attack
	Id int64 `json:"id"`

	// IncrementMaximum The end of the increment range
	IncrementMaximum int `json:"increment_maximum"`

	// IncrementMinimum The start of the increment range
	IncrementMinimum int `json:"increment_minimum"`

	// IncrementMode Enable hashcat increment mode
	IncrementMode bool `json:"increment_mode"`

	// LeftRule The left-hand rule for combinator attacks
	LeftRule *string `json:"left_rule,omitempty"`

	// MarkovThreshold The hashcat markov threshold
	MarkovThreshold *int `json:"markov_threshold,omitempty"`

	// Mask A hashcat mask string
	Mask *string `json:"mask,omitempty"`

	// MaskList A downloadable resource file (word list, rule list, or mask list) used by an attack
	MaskList *AttackResourceFile `json:"mask_list,omitempty"`

	// Optimized Enable hashcat optimized mode
	Optimized bool `json:"optimized"`

	// RightRule The right-hand rule for combinator attacks
	RightRule *string `json:"right_rule,omitempty"`

	// RuleList A downloadable resource file (word list, rule list, or mask list) used by an attack
	RuleList *AttackResourceFile `json:"rule_list,omitempty"`

	// SlowCandidateGenerators Enable hashcat slow candidate generators
	SlowCandidateGenerators bool `json:"slow_candidate_generators"`

	// Url The URL to the attack
	Url *string `json:"url"`

	// WordList A downloadable resource file (word list, rule list, or mask list) used by an attack
	WordList *AttackResourceFile `json:"word_list,omitempty"`

	// WorkloadProfile The hashcat workload profile
	WorkloadProfile int `json:"workload_profile"`
}

type AttackAttackMode string

type AttackResourceFile struct {
	// Checksum The MD5 checksum of the resource file
	Checksum []byte `json:"checksum"`

	// DownloadUrl The download URL of the resource file
	DownloadUrl string `json:"download_url"`

	// FileName The name of the resource file
	FileName string `json:"file_name"`

	// Id The id of the resource file
	Id int64 `json:"id"`
}

type AttacksClient interface {
	// GetAttack retrieves attack parameters by ID.
	GetAttack(ctx context.Context, id int64) (*GetAttackResponse, error)

	// GetHashList retrieves the hash list for an attack.
	GetHashList(ctx context.Context, id int64) (*GetHashListResponse, error)
}

type AuthClient interface {
	// Authenticate verifies agent credentials with the server.
	Authenticate(ctx context.Context) (*AuthenticateResponse, error)

	// GetConfiguration retrieves agent configuration from the server.
	GetConfiguration(ctx context.Context) (*GetConfigurationResponse, error)
}

type AuthenticateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *AuthenticationResponse
	JSON401      *ErrorObject
}

type AuthenticationResponse struct {
	AgentId       int64 `json:"agent_id"`
	Authenticated bool  `json:"authenticated"`
}

type BenchmarkReceipt struct {
	// FailedCount Number of benchmark entries rejected due to validation failures
	FailedCount int `json:"failed_count"`

	// Message Human-readable summary of the submission result
	Message *string `json:"message,omitempty"`

	// ProcessedCount Number of benchmark entries successfully stored
	ProcessedCount int `json:"processed_count"`

	// ReceivedCount Number of benchmark entries received in the request
	ReceivedCount int `json:"received_count"`
}

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

type CircuitTransport struct {
	Base    http.RoundTripper
	Breaker *CircuitBreaker
	Logger  *slog.Logger // Optional structured logger; nil disables logging.
}

type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}

type ClientInterface interface {
	// GetAgent request
	GetAgent(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateAgentWithBody request with any body
	UpdateAgentWithBody(ctx context.Context, id int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateAgent(ctx context.Context, id int64, body UpdateAgentJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SendHeartbeatWithBody request with any body
	SendHeartbeatWithBody(ctx context.Context, id int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SendHeartbeat(ctx context.Context, id int64, body SendHeartbeatJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SetAgentShutdown request
	SetAgentShutdown(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SubmitBenchmarkWithBody request with any body
	SubmitBenchmarkWithBody(ctx context.Context, id int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SubmitBenchmark(ctx context.Context, id int64, body SubmitBenchmarkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SubmitErrorAgentWithBody request with any body
	SubmitErrorAgentWithBody(ctx context.Context, id int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SubmitErrorAgent(ctx context.Context, id int64, body SubmitErrorAgentJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetAttack request
	GetAttack(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetHashList request
	GetHashList(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// Authenticate request
	Authenticate(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetConfiguration request
	GetConfiguration(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetHealth request
	GetHealth(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetNewTask request
	GetNewTask(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetTask request
	GetTask(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SetTaskAbandoned request
	SetTaskAbandoned(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SetTaskAccepted request
	SetTaskAccepted(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SetTaskExhausted request
	SetTaskExhausted(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetTaskZaps request
	GetTaskZaps(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SendCrackWithBody request with any body
	SendCrackWithBody(ctx context.Context, id int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SendCrack(ctx context.Context, id int64, body SendCrackJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SendStatusWithBody request with any body
	SendStatusWithBody(ctx context.Context, id int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SendStatus(ctx context.Context, id int64, body SendStatusJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
}

type ClientOption func(*Client) error

type ClientWithResponses struct {
	ClientInterface
}

type ClientWithResponsesInterface interface {
	// GetAgentWithResponse request
	GetAgentWithResponse(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*GetAgentResponse, error)

	// UpdateAgentWithBodyWithResponse request with any body
	UpdateAgentWithBodyWithResponse(ctx context.Context, id int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateAgentResponse, error)

	UpdateAgentWithResponse(ctx context.Context, id int64, body UpdateAgentJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateAgentResponse, error)

	// SendHeartbeatWithBodyWithResponse request with any body
	SendHeartbeatWithBodyWithResponse(ctx context.Context, id int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SendHeartbeatResponse, error)

	SendHeartbeatWithResponse(ctx context.Context, id int64, body SendHeartbeatJSONRequestBody, reqEditors ...RequestEditorFn) (*SendHeartbeatResponse, error)

	// SetAgentShutdownWithResponse request
	SetAgentShutdownWithResponse(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*SetAgentShutdownResponse, error)

	// SubmitBenchmarkWithBodyWithResponse request with any body
	SubmitBenchmarkWithBodyWithResponse(ctx context.Context, id int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SubmitBenchmarkResponse, error)

	SubmitBenchmarkWithResponse(ctx context.Context, id int64, body SubmitBenchmarkJSONRequestBody, reqEditors ...RequestEditorFn) (*SubmitBenchmarkResponse, error)

	// SubmitErrorAgentWithBodyWithResponse request with any body
	SubmitErrorAgentWithBodyWithResponse(ctx context.Context, id int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SubmitErrorAgentResponse, error)

	SubmitErrorAgentWithResponse(ctx context.Context, id int64, body SubmitErrorAgentJSONRequestBody, reqEditors ...RequestEditorFn) (*SubmitErrorAgentResponse, error)

	// GetAttackWithResponse request
	GetAttackWithResponse(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*GetAttackResponse, error)

	// GetHashListWithResponse request
	GetHashListWithResponse(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*GetHashListResponse, error)

	// AuthenticateWithResponse request
	AuthenticateWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*AuthenticateResponse, error)

	// GetConfigurationWithResponse request
	GetConfigurationWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetConfigurationResponse, error)

	// GetHealthWithResponse request
	GetHealthWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetHealthResponse, error)

	// GetNewTaskWithResponse request
	GetNewTaskWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetNewTaskResponse, error)

	// GetTaskWithResponse request
	GetTaskWithResponse(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*GetTaskResponse, error)

	// SetTaskAbandonedWithResponse request
	SetTaskAbandonedWithResponse(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*SetTaskAbandonedResponse, error)

	// SetTaskAcceptedWithResponse request
	SetTaskAcceptedWithResponse(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*SetTaskAcceptedResponse, error)

	// SetTaskExhaustedWithResponse request
	SetTaskExhaustedWithResponse(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*SetTaskExhaustedResponse, error)

	// GetTaskZapsWithResponse request
	GetTaskZapsWithResponse(ctx context.Context, id int64, reqEditors ...RequestEditorFn) (*GetTaskZapsResponse, error)

	// SendCrackWithBodyWithResponse request with any body
	SendCrackWithBodyWithResponse(ctx context.Context, id int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SendCrackResponse, error)

	SendCrackWithResponse(ctx context.Context, id int64, body SendCrackJSONRequestBody, reqEditors ...RequestEditorFn) (*SendCrackResponse, error)

	// SendStatusWithBodyWithResponse request with any body
	SendStatusWithBodyWithResponse(ctx context.Context, id int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SendStatusResponse, error)

	SendStatusWithResponse(ctx context.Context, id int64, body SendStatusJSONRequestBody, reqEditors ...RequestEditorFn) (*SendStatusResponse, error)
}

type ConfigurationResponse struct {
	// ApiVersion The minimum accepted version of the API
	ApiVersion int `json:"api_version"`

	// BenchmarksNeeded Whether the agent needs to run benchmarks
	BenchmarksNeeded bool `json:"benchmarks_needed"`

	// Config Advanced hashcat and agent configuration options
	Config AdvancedAgentConfiguration `json:"config"`

	// RecommendedCircuitBreaker Recommended circuit breaker settings for agent connections
	RecommendedCircuitBreaker struct {
		// FailureThreshold Number of failures before circuit opens
		FailureThreshold int `json:"failure_threshold"`

		// Timeout Seconds before circuit half-opens for retry
		Timeout int `json:"timeout"`
	} `json:"recommended_circuit_breaker"`

	// RecommendedRetry Recommended retry settings for agent HTTP requests
	RecommendedRetry struct {
		// InitialDelay Initial retry delay in seconds
		InitialDelay int `json:"initial_delay"`

		// MaxAttempts Maximum number of retry attempts
		MaxAttempts int `json:"max_attempts"`

		// MaxDelay Maximum retry delay in seconds
		MaxDelay int `json:"max_delay"`
	} `json:"recommended_retry"`

	// RecommendedTimeouts Recommended timeout settings for agent HTTP connections
	RecommendedTimeouts struct {
		// ConnectTimeout TCP connect timeout in seconds
		ConnectTimeout int `json:"connect_timeout"`

		// ReadTimeout Read timeout in seconds
		ReadTimeout int `json:"read_timeout"`

		// RequestTimeout Overall request timeout in seconds
		RequestTimeout int `json:"request_timeout"`

		// WriteTimeout Write timeout in seconds
		WriteTimeout int `json:"write_timeout"`
	} `json:"recommended_timeouts"`
}

type DeviceStatus struct {
	// DeviceId The id of the device
	DeviceId int `json:"device_id"`

	// DeviceName The name of the device
	DeviceName string `json:"device_name"`

	// DeviceType The type of the device
	DeviceType DeviceStatusDeviceType `json:"device_type"`

	// Speed The speed of the device
	Speed int64 `json:"speed"`

	// Temperature The temperature of the device, or -1 if unmonitored.
	Temperature int `json:"temperature"`

	// Utilization The utilization of the device
	Utilization int `json:"utilization"`
}

type DeviceStatusDeviceType string

type ErrorMetadata struct {
	// ErrorDate The date of the error
	ErrorDate time.Time `json:"error_date"`

	// Other Structured error context from the agent
	Other *ErrorMetadata_Other `json:"other,omitempty"`
}

type ErrorMetadata_Other struct {
	// AffectedCount Number of hashes affected by the error
	AffectedCount *int `json:"affected_count,omitempty"`

	// Category Error category (e.g. hash_format, device, network)
	Category *string `json:"category,omitempty"`

	// ErrorType Machine-readable error type slug
	ErrorType *string `json:"error_type,omitempty"`

	// Retryable Whether the operation can be retried
	Retryable *bool `json:"retryable,omitempty"`

	// Terminal Whether the error is definitively unrecoverable
	Terminal *bool `json:"terminal,omitempty"`

	// TotalCount Total number of hashes in the hash list
	TotalCount           *int                   `json:"total_count,omitempty"`
	AdditionalProperties map[string]interface{} `json:"-"`
}

type ErrorObject struct {
	Err                  string         `json:"error"`
	AdditionalProperties map[string]any `json:"-"`
}

type GetAgentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Agent
	JSON401      *ErrorObject
}

type GetAttackResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Attack
	JSON401      *ErrorObject
	JSON404      *ErrorObject
}

type GetConfigurationResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ConfigurationResponse
	JSON401      *ErrorObject
}

type GetHashListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *ErrorObject
	JSON404      *ErrorObject
}

type GetHealthResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		// ApiVersion API version
		ApiVersion int `json:"api_version"`

		// Database Database health (healthy or unhealthy)
		Database string `json:"database"`

		// Status Overall health status (ok or degraded)
		Status string `json:"status"`

		// Timestamp Server timestamp
		Timestamp time.Time `json:"timestamp"`
	}
	JSON503 *struct {
		// ApiVersion API version
		ApiVersion int `json:"api_version"`

		// Database Database health (healthy or unhealthy)
		Database string `json:"database"`

		// Status Overall health status (ok or degraded)
		Status string `json:"status"`

		// Timestamp Server timestamp
		Timestamp time.Time `json:"timestamp"`
	}
}

type GetNewTaskResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Task
	JSON401      *ErrorObject
}

type GetTaskResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Task
	JSON401      *ErrorObject
	JSON404      *ErrorObject
}

type GetTaskZapsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *ErrorObject
	JSON404      *ErrorObject
	JSON422      *ErrorObject
}

type HashcatBenchmark struct {
	// Device The device used for the benchmark
	Device int `json:"device"`

	// HashSpeed The speed of the benchmark in hashes per second.
	HashSpeed float64 `json:"hash_speed"`

	// HashType The hashcat hash type
	HashType int `json:"hash_type"`

	// Runtime The runtime of the benchmark in milliseconds.
	Runtime int64 `json:"runtime"`
}

type HashcatGuess struct {
	// GuessBase The base value used for the guess (for example, the mask)
	GuessBase string `json:"guess_base"`

	// GuessBaseCount The number of times the base value was used
	GuessBaseCount int64 `json:"guess_base_count"`

	// GuessBaseOffset The offset of the base value
	GuessBaseOffset int64 `json:"guess_base_offset"`

	// GuessBasePercentage The percentage completion of the base value
	GuessBasePercentage float64 `json:"guess_base_percentage"`

	// GuessMod The modifier used for the guess (for example, the wordlist)
	GuessMod string `json:"guess_mod"`

	// GuessModCount The number of times the modifier was used
	GuessModCount int64 `json:"guess_mod_count"`

	// GuessModOffset The offset of the modifier
	GuessModOffset int64 `json:"guess_mod_offset"`

	// GuessModPercentage The percentage completion of the modifier
	GuessModPercentage float64 `json:"guess_mod_percentage"`

	// GuessMode The mode used for the guess
	GuessMode int `json:"guess_mode"`
}

type HashcatResult struct {
	// Hash The hash value
	Hash string `json:"hash"`

	// PlainText The plain text value
	PlainText string `json:"plain_text"`

	// Timestamp The time the hash was cracked
	Timestamp time.Time `json:"timestamp"`
}

type HashcatStatusUpdate struct {
	// DeviceStatuses The status of the devices used for the task
	DeviceStatuses []DeviceStatus `json:"device_statuses"`

	// EstimatedStop The estimated time of completion.
	EstimatedStop time.Time `json:"estimated_stop"`

	// HashcatGuess Current hashcat guess progress including base and modifier values
	HashcatGuess HashcatGuess `json:"hashcat_guess"`

	// OriginalLine The original line from hashcat
	OriginalLine string `json:"original_line"`

	// Progress The progress of the task
	Progress []int64 `json:"progress"`

	// RecoveredHashes The number of recovered hashes
	RecoveredHashes []int `json:"recovered_hashes"`

	// RecoveredSalts The number of recovered salts
	RecoveredSalts []int `json:"recovered_salts"`

	// Rejected The number of rejected guesses
	Rejected int64 `json:"rejected"`

	// RestorePoint The restore point of the task
	RestorePoint int64 `json:"restore_point"`

	// Session The session name
	Session string `json:"session"`

	// Status The status of the task
	Status int `json:"status"`

	// Target The target of the task
	Target string `json:"target"`

	// Time The time the status was received
	Time time.Time `json:"time"`

	// TimeStart The time the task started.
	TimeStart time.Time `json:"time_start"`
}

type HeartbeatResponse struct {
	// State The state of the agent:
	//                        * `pending` - The agent needs to perform the setup process again.
	//                        * `active` - The agent is ready to accept tasks, all is good.
	//                        * `error` - The agent has encountered an error and needs to be checked.
	//                        * `stopped` - The agent has been stopped by the user.
	//                        * `offline` - The agent has not checked in recently and is considered offline.
	State HeartbeatResponseState `json:"state"`
}

type HeartbeatResponseState string

type HttpRequestDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

type MockAgentsClient struct {
	SendHeartbeatFunc    func(ctx context.Context, id int64, activity string) (*SendHeartbeatResponse, error)
	UpdateAgentFunc      func(ctx context.Context, id int64, body UpdateAgentJSONRequestBody) (*UpdateAgentResponse, error)
	SubmitBenchmarkFunc  func(ctx context.Context, id int64, body SubmitBenchmarkJSONRequestBody) (*SubmitBenchmarkResponse, error)
	SubmitErrorAgentFunc func(ctx context.Context, id int64, body SubmitErrorAgentJSONRequestBody) (*SubmitErrorAgentResponse, error)
	SetAgentShutdownFunc func(ctx context.Context, id int64) (*SetAgentShutdownResponse, error)
}

type MockAttacksClient struct {
	GetAttackFunc   func(ctx context.Context, id int64) (*GetAttackResponse, error)
	GetHashListFunc func(ctx context.Context, id int64) (*GetHashListResponse, error)
}

type MockAuthClient struct {
	AuthenticateFunc     func(ctx context.Context) (*AuthenticateResponse, error)
	GetConfigurationFunc func(ctx context.Context) (*GetConfigurationResponse, error)
}

type MockClient struct {
	TasksImpl   TasksClient
	AttacksImpl AttacksClient
	AgentsImpl  AgentsClient
	AuthImpl    AuthClient
}

type MockTasksClient struct {
	GetNewTaskFunc       func(ctx context.Context) (*GetNewTaskResponse, error)
	SetTaskAcceptedFunc  func(ctx context.Context, id int64) (*SetTaskAcceptedResponse, error)
	SetTaskExhaustedFunc func(ctx context.Context, id int64) (*SetTaskExhaustedResponse, error)
	SetTaskAbandonedFunc func(ctx context.Context, id int64) (*SetTaskAbandonedResponse, error)
	SendStatusFunc       func(ctx context.Context, id int64, status HashcatStatusUpdate) (*SendStatusResponse, error)
	SendCrackFunc        func(ctx context.Context, id int64, result HashcatResult) (*SendCrackResponse, error)
	GetTaskZapsFunc      func(ctx context.Context, id int64) (*GetTaskZapsResponse, error)
}

type RequestEditorFn func(ctx context.Context, req *http.Request) error

type RetryTransport struct {
	Base         http.RoundTripper // Underlying transport
	MaxAttempts  int               // Total attempts (1 = no retry)
	InitialDelay time.Duration     // First retry delay
	MaxDelay     time.Duration     // Cap for exponential backoff
	Logger       *slog.Logger      // Optional structured logger; nil disables logging.
}

type SendCrackJSONRequestBody = HashcatResult

type SendCrackResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *ErrorObject
	JSON404      *ErrorObject
}

type SendHeartbeatJSONRequestBody = AgentHeartbeatRequest

type SendHeartbeatResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *HeartbeatResponse
	JSON401      *ErrorObject
}

type SendStatusJSONRequestBody = HashcatStatusUpdate

type SendStatusResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *ErrorObject
	JSON422      *ErrorObject
}

type SetAgentShutdownResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *ErrorObject
}

type SetTaskAbandonedError struct {
	Details []string `json:"details"`
	Error_  *string  `json:"error"` //nolint:revive // underscore avoids collision with Error() method
}

type SetTaskAbandonedResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *TaskAbandonResponse
	JSON401      *ErrorObject
	JSON404      *ErrorObject
	JSON422      *TaskAbandonError
}

type SetTaskAcceptedResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *ErrorObject
	JSON404      *ErrorObject
	JSON422      *ErrorObject
}

type SetTaskExhaustedResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *ErrorObject
	JSON404      *ErrorObject
}

type Severity = SubmitErrorRequestSeverity

type State = HeartbeatResponseState

type SubmitBenchmarkJSONRequestBody = SubmitBenchmarkRequest

type SubmitBenchmarkRequest struct {
	HashcatBenchmarks []HashcatBenchmark `json:"hashcat_benchmarks"`
}

type SubmitBenchmarkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *BenchmarkReceipt
	JSON400      *ErrorObject
	JSON401      *ErrorObject
	JSON422      *ErrorObject
}

type SubmitErrorAgentJSONRequestBody = SubmitErrorRequest

type SubmitErrorAgentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON401      *ErrorObject
}

type SubmitErrorRequest struct {
	// AgentId The agent that caused the error
	AgentId int64 `json:"agent_id"`

	// Message The error message
	Message string `json:"message"`

	// Metadata Additional metadata about an agent error
	Metadata *ErrorMetadata `json:"metadata,omitempty"`

	// Severity The severity of the error:
	//                        * `info` - Informational message, no action required.
	//                        * `warning` - Non-critical error, no action required. Anticipated, but not necessarily problematic.
	//                        * `minor` - Minor error, no action required. Should be investigated, but the task can continue.
	//                        * `major` - Major error, action required. The task should be investigated and possibly restarted.
	//                        * `critical` - Critical error, action required. The task should be stopped and investigated.
	//                         * `fatal` - Fatal error, action required. The agent cannot continue with the task and should not be reattempted.
	Severity SubmitErrorRequestSeverity `json:"severity"`

	// TaskId The task that caused the error, if any
	TaskId *int64 `json:"task_id,omitempty"`
}

type SubmitErrorRequestSeverity string

type Task struct {
	// AttackId The id of the attack
	AttackId int64 `json:"attack_id"`

	// Id The id of the task
	Id int64 `json:"id"`

	// Limit The limit of the keyspace
	Limit *int64 `json:"limit,omitempty"`

	// Skip The offset of the keyspace
	Skip *int64 `json:"skip,omitempty"`

	// StartDate The time the task was started
	StartDate time.Time `json:"start_date"`

	// Status The status of the task
	Status TaskStatus `json:"status"`
}

type TaskAbandonError struct {
	Details *[]string `json:"details,omitempty"`
	Error   *string   `json:"error,omitempty"`
}

type TaskAbandonResponse struct {
	State   *string `json:"state,omitempty"`
	Success *bool   `json:"success,omitempty"`
}

type TaskStatus string

type TasksClient interface {
	// GetNewTask retrieves a new task from the server.
	GetNewTask(ctx context.Context) (*GetNewTaskResponse, error)

	// SetTaskAccepted marks a task as accepted.
	SetTaskAccepted(ctx context.Context, id int64) (*SetTaskAcceptedResponse, error)

	// SetTaskExhausted marks a task as exhausted (keyspace fully searched).
	SetTaskExhausted(ctx context.Context, id int64) (*SetTaskExhaustedResponse, error)

	// SetTaskAbandoned marks a task as abandoned.
	SetTaskAbandoned(ctx context.Context, id int64) (*SetTaskAbandonedResponse, error)

	// SendStatus sends a status update for a running task.
	SendStatus(ctx context.Context, id int64, status HashcatStatusUpdate) (*SendStatusResponse, error)

	// SendCrack sends a cracked hash result.
	SendCrack(ctx context.Context, id int64, result HashcatResult) (*SendCrackResponse, error)

	// GetTaskZaps retrieves previously cracked hashes for a task.
	GetTaskZaps(ctx context.Context, id int64) (*GetTaskZapsResponse, error)
}

type TransportConfig struct {
	ConnectTimeout time.Duration // TCP dial timeout
	ReadTimeout    time.Duration // TLS handshake + response header timeout
	RequestTimeout time.Duration // Overall per-request timeout on http.Client

	MaxAttempts       int           // Total attempts (1 = no retry)
	RetryInitialDelay time.Duration // First retry backoff delay
	RetryMaxDelay     time.Duration // Cap for exponential backoff

	CircuitBreakerFailureThreshold int           // Consecutive failures before opening
	CircuitBreakerTimeout          time.Duration // Duration before half-open probe

	Logger *slog.Logger // Optional; nil disables transport logging

	// BaseTransport overrides the default http.Transport when set.
	// Used by tests to inject httpmock's transport into the chain.
	BaseTransport http.RoundTripper

	// CircuitBreaker reuses an existing circuit breaker when set.
	// This preserves failure history across client rebuilds (e.g., after server config reload).
	// When nil, a new circuit breaker is created.
	CircuitBreaker *CircuitBreaker
}

type UpdateAgentJSONRequestBody = UpdateAgentRequest

type UpdateAgentRequest struct {
	// ClientSignature The signature of the client
	ClientSignature string   `json:"client_signature"`
	Devices         []string `json:"devices"`

	// HostName The hostname of the agent
	HostName string `json:"host_name"`

	// Id The id of the agent
	Id int64 `json:"id"`

	// OperatingSystem The operating system of the agent
	OperatingSystem string `json:"operating_system"`
}

type UpdateAgentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Agent
	JSON401      *ErrorObject
}