routeusagev1

type BatchProblemCode string

type BatchResult struct {
	Accepted bool              `json:"accepted"`
	Code     *BatchProblemCode `json:"code,omitempty"`
	ItemId   string            `json:"item_id"`
}

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 {

	// IngestRouteUsageBucketReportsWithBody Ingest route usage bucket reports
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/routes/usage-bucket-reports (the `IngestRouteUsageBucketReports` operationId).
	IngestRouteUsageBucketReportsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// IngestRouteUsageBucketReports Ingest route usage bucket reports
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/routes/usage-bucket-reports (the `IngestRouteUsageBucketReports` operationId).
	IngestRouteUsageBucketReports(ctx context.Context, body IngestRouteUsageBucketReportsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
}

type ClientOption func(*Client) error

type ClientWithResponses struct {
	ClientInterface
}

type ClientWithResponsesInterface interface {

	// IngestRouteUsageBucketReportsWithBodyWithResponse Ingest route usage bucket reports
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/routes/usage-bucket-reports (the `IngestRouteUsageBucketReports` operationId).
	IngestRouteUsageBucketReportsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*IngestRouteUsageBucketReportsResponse, error)

	// IngestRouteUsageBucketReportsWithResponse Ingest route usage bucket reports
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/routes/usage-bucket-reports (the `IngestRouteUsageBucketReports` operationId).
	IngestRouteUsageBucketReportsWithResponse(ctx context.Context, body IngestRouteUsageBucketReportsJSONRequestBody, reqEditors ...RequestEditorFn) (*IngestRouteUsageBucketReportsResponse, error)
}

type DurationHistogram struct {
	Count            PositiveInteger   `json:"count"`
	CumulativeCounts []UnsignedInteger `json:"cumulative_counts"`
	SumNanoseconds   UnsignedInteger   `json:"sum_nanoseconds"`
}

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

type IdentityID = ResourceID

type IngestRouteUsageBucketReportsJSONRequestBody = RouteUsageBucketReportBatch

type IngestRouteUsageBucketReportsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *RouteUsageBucketReportBatchResponse
	// ApplicationproblemJSON400 the response for an HTTP 400 `application/problem+json` response
	ApplicationproblemJSON400 *Problem
	// ApplicationproblemJSON401 the response for an HTTP 401 `application/problem+json` response
	ApplicationproblemJSON401 *Problem
	// ApplicationproblemJSON404 the response for an HTTP 404 `application/problem+json` response
	ApplicationproblemJSON404 *Problem
	// ApplicationproblemJSON409 the response for an HTTP 409 `application/problem+json` response
	ApplicationproblemJSON409 *Problem
	// ApplicationproblemJSON413 the response for an HTTP 413 `application/problem+json` response
	ApplicationproblemJSON413 *Problem
	// ApplicationproblemJSON415 the response for an HTTP 415 `application/problem+json` response
	ApplicationproblemJSON415 *Problem
	// ApplicationproblemJSONDefault the response for an HTTP default `application/problem+json` response
	ApplicationproblemJSONDefault *Problem
}

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

type MiddlewareFunc func(http.Handler) http.Handler

type PositiveInteger = string

type Problem struct {
	Code      ProblemCode            `json:"code"`
	Details   map[string]interface{} `json:"details"`
	RequestId string                 `json:"request_id"`
	Status    int                    `json:"status"`
	Title     string                 `json:"title"`
	Type      string                 `json:"type"`
}

type ProblemCode string

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

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

type RequiredParamError struct {
	ParamName string
}

type ResourceID = string

type RouteID = ResourceID

type RouteUsageBucketReport struct {
	// ActingIdentityId Acting identity recorded when this route version was created.
	ActingIdentityId IdentityID `json:"acting_identity_id"`
	BucketStart      time.Time  `json:"bucket_start"`

	// CapacityDenials Matched attempts rejected by the route connection limit.
	CapacityDenials UnsignedInteger `json:"capacity_denials"`

	// Complete Whether accounting covers the entire bucket without a missing ingress report.
	Complete bool `json:"complete"`

	// ConnectionAttempts Connections counted after a route match and before policy and capacity checks.
	ConnectionAttempts UnsignedInteger `json:"connection_attempts"`

	// ConnectionNanoseconds Elapsed time for successful streams, divided among the buckets in which the time passed.
	ConnectionNanoseconds UnsignedInteger `json:"connection_nanoseconds"`

	// EgressBytes Bytes successfully forwarded from publishers to visitors.
	EgressBytes UnsignedInteger `json:"egress_bytes"`

	// IngressBytes Bytes successfully forwarded from visitors to publishers.
	IngressBytes UnsignedInteger `json:"ingress_bytes"`
	ItemId       string          `json:"item_id"`

	// ObservedThrough Latest time covered by this bucket. Equals the bucket end when complete is true.
	ObservedThrough time.Time `json:"observed_through"`

	// PolicyDenials Matched attempts rejected by route access policy.
	PolicyDenials  UnsignedInteger                  `json:"policy_denials"`
	ReportRevision PositiveInteger                  `json:"report_revision"`
	Resolution     RouteUsageBucketReportResolution `json:"resolution"`
	RouteId        RouteID                          `json:"route_id"`

	// RouteVersion Route version measured by this report.
	RouteVersion PositiveInteger `json:"route_version"`

	// SuccessfulConnectionDuration Total time for a successful visitor stream. The value is recorded when the stream closes. The field is absent, rather than zero, when the bucket has no observations.
	SuccessfulConnectionDuration *DurationHistogram `json:"successful_connection_duration,omitempty"`

	// SuccessfulStreams Visitor streams that entered bidirectional forwarding.
	SuccessfulStreams UnsignedInteger `json:"successful_streams"`

	// TeamId Team recorded when this route version was created.
	TeamId TeamID `json:"team_id"`

	// TimeToFirstPublisherByte Time from a route match until the first publisher byte reaches the visitor. The value is recorded when that byte is written. The field is absent, rather than zero, when the bucket has no observations.
	TimeToFirstPublisherByte *DurationHistogram `json:"time_to_first_publisher_byte,omitempty"`

	// VisitorNetworkEstimate Precision-12 HyperLogLog estimate of distinct visitor networks for this route and bucket. All route versions share the same sketch, so do not add estimates from reports for the same route and bucket.
	VisitorNetworkEstimate UnsignedInteger `json:"visitor_network_estimate"`

	// VisitorNetworkHll Versioned precision-12 HyperLogLog data. After base64 decoding, the bytes start with version 1, precision 12, and an encoding byte. Sparse encoding 0 then contains a big-endian uint16 entry count and sorted entries of a big-endian uint16 register index followed by a uint8 value. Dense encoding 1 contains 4096 uint8 registers. Inputs are visitor IPv4 /32 or IPv6 /64 networks HMACed with a route-scoped secret that changes daily. No source address is included. When combining reports, merge each register by its maximum value instead of adding estimates.
	VisitorNetworkHll []byte `json:"visitor_network_hll"`

	// VisitorStreamOpenFailures Attempts for which opening a visitor stream failed.
	VisitorStreamOpenFailures UnsignedInteger `json:"visitor_stream_open_failures"`

	// VisitorStreamOpenLatency Time taken to open a visitor stream, including failed attempts. The value is recorded when the attempt ends. The field is absent, rather than zero, when the bucket has no observations.
	VisitorStreamOpenLatency *DurationHistogram `json:"visitor_stream_open_latency,omitempty"`
}

type RouteUsageBucketReportBatch struct {
	Items []RouteUsageBucketReport `json:"items"`
}

type RouteUsageBucketReportBatchResponse struct {
	Results []BatchResult `json:"results"`
}

type RouteUsageBucketReportResolution string

type ServeMux interface {
	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
	http.Handler
}

type ServerInterface interface {
	// IngestRouteUsageBucketReports Ingest route usage bucket reports
	// (POST /v1/routes/usage-bucket-reports)
	IngestRouteUsageBucketReports(w http.ResponseWriter, r *http.Request)
}

type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandlerFunc   func(w http.ResponseWriter, r *http.Request, err error)
}

type StdHTTPServerOptions struct {
	BaseURL          string
	BaseRouter       ServeMux
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

type TeamID = ResourceID

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

type UnmarshalingParamError struct {
	ParamName string
	Err       error
}

type UnsignedInteger = string