client

type APIKey struct {
	Active                     *bool     `json:"active,omitempty"`
	CreationDate               *string   `json:"creation_date,omitempty"`
	DetectionCategoriesEnabled *[]string `json:"detection_categories_enabled,omitempty"`
	LastSeenDate               *string   `json:"last_seen_date,omitempty"`
	Tags                       *[]string `json:"tags,omitempty"`
}

type AccountInfo struct {
	Balance          *float32           `json:"balance,omitempty"`
	BillingEmail     *string            `json:"billing_email,omitempty"`
	CreationDate     *string            `json:"creation_date,omitempty"`
	Keys             *map[string]APIKey `json:"keys,omitempty"`
	ModificationDate *string            `json:"modification_date,omitempty"`
	Name             *string            `json:"name,omitempty"`
	StartingBalance  *float32           `json:"starting_balance,omitempty"`
	Subscription     *string            `json:"subscription,omitempty"`
	Users            *map[string]User   `json:"users,omitempty"`
}

type AccountResult struct {
	Response
	Account *AccountInfo
}

type AuthToken struct {
	CreationDate   *string `json:"creation_date,omitempty"`
	ExpirationDate *string `json:"expiration_date,omitempty"`
	ID             *string `json:"id,omitempty"`
}

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

type ClientOption func(*Client) error

type CreateTokenResult struct {
	Response
	Token *AuthToken
}

type DeleteFileResult struct {
	Response
}

type DeleteFileTraceResult struct {
	Response
}

type ErrorResponse struct {
	Error    *string            `json:"error,omitempty"`
	ID       *string            `json:"id,omitempty"`
	Metadata *map[string]string `json:"metadata,omitempty"`
}

type PingResult struct {
	Response
	Message string `json:"message"`
	Key     string `json:"key"`
}

type ProcessFileAsyncResult struct {
	Response
	Pending *ProcessingPendingResponse
	Error   *ErrorResponse
}

type ProcessFileFetchResult struct {
	Response
	Pending *ProcessingPendingResponse
	Error   *ErrorResponse
}

type ProcessFileResult struct {
	Response
	Result *ProcessingResponse
	Error  *ErrorResponse
}

type ProcessingPendingResponse struct {
	ID *string `json:"id,omitempty"`
}

type ProcessingResponse struct {
	Checksum      *string            `json:"checksum,omitempty"`
	ContentLength *float32           `json:"content_length,omitempty"`
	ContentType   *string            `json:"content_type,omitempty"`
	CreationDate  *string            `json:"creation_date,omitempty"`
	Error         *string            `json:"error,omitempty"`
	Findings      *[]string          `json:"findings,omitempty"`
	ID            *string            `json:"id,omitempty"`
	Metadata      *map[string]string `json:"metadata,omitempty"`
}

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

type Response struct {
	StatusCode int
	Header     http.Header
	// Timings is the wall-clock breakdown of the exchange that produced this
	// response.
	Timings Timings
}

type RetrieveFileResult struct {
	Response
	Result *ProcessingResponse
}

type RetrieveTokenResult struct {
	Response
	Token *AuthToken
}

type RetrieveTraceResult struct {
	Response
	Trace *TraceResponse
	Error *ErrorResponse
}

type Timings struct {
	// DNS is the time spent resolving the host name.
	DNS time.Duration

	// Connect is the time spent opening the TCP connection.
	Connect time.Duration

	// TLS is the time spent on the TLS handshake.
	TLS time.Duration

	// RequestTransfer is the time from having a usable connection to the last
	// byte of the request being written. For a file upload that is the upload
	// itself — near enough, anyway: the write finishes at the socket rather than
	// at the far end, so up to a send buffer's worth of it is still in flight.
	RequestTransfer time.Duration

	// ServerProcessing is the time between the last request byte going out and
	// the first response byte coming back. That covers the API's own work — for
	// a file scan, the scan — but also the round trip carrying the question
	// there and the answer back, and nothing on this side can see where the one
	// ends and the other begins. Expect it to read higher than whatever the
	// server reports for the same request, by about one round trip.
	//
	// It is zero when the API answered before the request finished going out, as
	// it does when it rejects an oversized upload part way through.
	ServerProcessing time.Duration

	// ResponseTransfer is the time from the first byte of the response to the
	// last byte of its body.
	ResponseTransfer time.Duration

	// Total is the wall clock for the whole exchange, from the request being
	// handed to the transport to the response body being fully read.
	Total time.Duration

	// Reused reports whether the exchange rode on a pooled connection, which is
	// why the phases that establish one can legitimately read as zero.
	Reused bool

	// Complete reports whether the exchange reached the API and its response was
	// read. It is a flag rather than something inferred from the durations,
	// because every one of them can legitimately be zero: a phase that finishes
	// inside the clock's resolution measures as no time at all, and Windows
	// resolves time in milliseconds.
	Complete bool
}

type TraceEvent struct {
	Message   *string `json:"message,omitempty"`
	Timestamp *string `json:"timestamp,omitempty"`
}

type TraceResponse struct {
	Events *[]TraceEvent `json:"events,omitempty"`
	ID     *string       `json:"id,omitempty"`
}

type User struct {
	CreationDate *string `json:"creation_date,omitempty"`
	LastLogin    *string `json:"last_login,omitempty"`
}