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"`

	// 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"`
	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 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"`

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

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

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

	// 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"`

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

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

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

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

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

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

	// 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"`

	// 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      *struct {
		AgentId       int64 `json:"agent_id"`
		Authenticated bool  `json:"authenticated"`
	}
	JSON401 *ErrorObject
}

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)

	// 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)

	// 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 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 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      *struct {
		// ApiVersion The minimum accepted version of the API
		ApiVersion int `json:"api_version"`

		// BenchmarksNeeded Whether the agent needs to run benchmarks. False when the server already has valid benchmarks for this agent.
		BenchmarksNeeded bool `json:"benchmarks_needed"`

		// Config Advanced hashcat and agent configuration options
		Config AdvancedAgentConfiguration `json:"config"`
	}
	JSON401 *ErrorObject
}

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

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
}

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 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 TaskStatus) (*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 SendCrackJSONRequestBody = HashcatResult

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

type SendHeartbeat200State string

type SendHeartbeatJSONBody 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"`
}

type SendHeartbeatJSONRequestBody SendHeartbeatJSONBody

type SendHeartbeatResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *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 SendHeartbeat200State `json:"state"`
	}
	JSON401 *ErrorObject
}

type SendStatusJSONRequestBody = TaskStatus

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      *struct {
		State   *string `json:"state,omitempty"`
		Success *bool   `json:"success,omitempty"`
	}
	JSON401 *ErrorObject
	JSON404 *ErrorObject
	JSON422 *struct {
		Details *[]string `json:"details,omitempty"`
		Error   *string   `json:"error,omitempty"`
	}
}

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

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

type Severity = SubmitErrorAgentJSONBodySeverity

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

type SubmitBenchmarkJSONRequestBody SubmitBenchmarkJSONBody

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

type SubmitErrorAgentJSONBody 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 the error
	Metadata *struct {
		// ErrorDate The date of the error
		ErrorDate time.Time `json:"error_date"`

		// Other Other metadata
		Other *map[string]interface{} `json:"other"`
	} `json:"metadata"`

	// 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 SubmitErrorAgentJSONBodySeverity `json:"severity"`

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

type SubmitErrorAgentJSONBodySeverity string

type SubmitErrorAgentJSONRequestBody SubmitErrorAgentJSONBody

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

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"`

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

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

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

type TaskStatus 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 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 TaskStatus) (*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 UpdateAgentJSONBody 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 UpdateAgentJSONRequestBody UpdateAgentJSONBody

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