mgmtapi

type BFD struct {
	// DesiredMinimumTxInterval The minimum interval between transmission of BFD control packets that the operator desires. This value is advertised to the peer, however the actual interval used is specified by taking the maximum of desired-minimum-tx-interval and the value of the remote required-minimum-receive interval value.
	DesiredMinimumTxInterval string `json:"desired_minimum_tx_interval"`

	// DetectionMultiplier The number of packets that must be missed to declare this session as down. The detection interval for the BFD session is calculated by multiplying the value of the negotiated transmission interval by this value.
	DetectionMultiplier int `json:"detection_multiplier"`

	// Enabled Indication of whether BFD is enabled and configured on this interface.
	Enabled bool `json:"enabled"`

	// RequiredMinimumReceive The minimum interval between received BFD control packets that this system should support. This value is advertised to the remote peer to indicate the maximum frequency (i.e., minimum inter-packet interval) between BFD control packets that is acceptable to the local system.
	RequiredMinimumReceive string `json:"required_minimum_receive"`
}

type BadRequest = StandardError

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

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 {
	// GetConfig request
	GetConfig(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

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

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

	SetLogLevel(ctx context.Context, body SetLogLevelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
}

type ClientOption func(*Client) error

type ClientWithResponses struct {
	ClientInterface
}

type ClientWithResponsesInterface interface {
	// GetConfigWithResponse request
	GetConfigWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetConfigResponse, error)

	// GetInfoWithResponse request
	GetInfoWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetInfoResponse, error)

	// GetInterfacesWithResponse request
	GetInterfacesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetInterfacesResponse, error)

	// GetLogLevelWithResponse request
	GetLogLevelWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetLogLevelResponse, error)

	// SetLogLevelWithBodyWithResponse request with any body
	SetLogLevelWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SetLogLevelResponse, error)

	SetLogLevelWithResponse(ctx context.Context, body SetLogLevelJSONRequestBody, reqEditors ...RequestEditorFn) (*SetLogLevelResponse, error)
}

type GetConfigResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *BadRequest
}

type GetInfoResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *BadRequest
}

type GetInterfacesResponse struct {
	Body                      []byte
	HTTPResponse              *http.Response
	JSON200                   *InterfacesResponse
	ApplicationproblemJSON400 *Problem
}

type GetLogLevelResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *LogLevel
	JSON400      *BadRequest
}

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

type Interface struct {
	Bfd BFD `json:"bfd"`

	// InterfaceId SCION interface identifier.
	InterfaceId int `json:"interface_id"`

	// InternalInterface The address of internal SCION interface of the router.
	InternalInterface string            `json:"internal_interface"`
	Neighbor          InterfaceNeighbor `json:"neighbor"`
	Relationship      LinkRelationship  `json:"relationship"`

	// ScionMtu The maximum transmission unit in bytes for SCION packets. This represents the protocol data unit (PDU) of the SCION layer and is usually calculated as maximum Ethernet payload - IP Header - UDP Header.
	ScionMtu ScionMTU  `json:"scion_mtu"`
	State    LinkState `json:"state"`
}

type InterfaceNeighbor struct {
	// Address UDP/IP underlay address of the SCION Interface.
	Address string `json:"address"`
	IsdAs   IsdAs  `json:"isd_as"`
}

type InterfacesResponse struct {
	Interfaces        *[]Interface        `json:"interfaces,omitempty"`
	SiblingInterfaces *[]SiblingInterface `json:"sibling_interfaces,omitempty"`
}

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

type IsdAs = string

type LinkRelationship string

type LinkState string

type LogLevel struct {
	// Level Logging level
	Level LogLevelLevel `json:"level"`
}

type LogLevelLevel string

type MiddlewareFunc func(http.Handler) http.Handler

type Problem struct {
	// Detail A human readable explanation specific to this occurrence of the problem that is helpful to locate the problem and give advice on how to proceed. Written in English and readable for engineers, usually not suited for non technical stakeholders and not localized.
	Detail *string `json:"detail,omitempty"`

	// Instance A URI reference that identifies the specific occurrence of the problem, e.g. by adding a fragment identifier or sub-path to the problem type. May be used to locate the root of this problem in the source code.
	Instance *string `json:"instance,omitempty"`

	// Status The HTTP status code generated by the origin server for this occurrence of the problem.
	Status int `json:"status"`

	// Title A short summary of the problem type. Written in English and readable for engineers, usually not suited for non technical stakeholders and not localized.
	Title string `json:"title"`

	// Type A URI reference that uniquely identifies the problem type only in the context of the provided API. Opposed to the specification in RFC-7807, it is neither recommended to be dereferencable and point to a human-readable documentation nor globally unique for the problem type.
	Type *string `json:"type,omitempty"`
}

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

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

type RequiredParamError struct {
	ParamName string
}

type ScionMTU = int

type Server struct {
	Config    http.HandlerFunc
	Info      http.HandlerFunc
	LogLevel  http.HandlerFunc
	Dataplane control.ObservableDataplane
}

type ServerInterface interface {
	// Prints the TOML configuration file.
	// (GET /config)
	GetConfig(w http.ResponseWriter, r *http.Request)
	// Basic information page about the control service process.
	// (GET /info)
	GetInfo(w http.ResponseWriter, r *http.Request)
	// List the SCION interfaces
	// (GET /interfaces)
	GetInterfaces(w http.ResponseWriter, r *http.Request)
	// Get logging level
	// (GET /log/level)
	GetLogLevel(w http.ResponseWriter, r *http.Request)
	// Set logging level
	// (PUT /log/level)
	SetLogLevel(w http.ResponseWriter, r *http.Request)
}

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

type SetLogLevelJSONRequestBody = LogLevel

type SetLogLevelResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *LogLevel
	JSON400      *BadRequest
}

type SiblingInterface struct {
	// InterfaceId SCION interface identifier.
	InterfaceId int `json:"interface_id"`

	// InternalInterface Internal address of the local router.
	InternalInterface string           `json:"internal_interface"`
	Neighbor          SiblingNeighbor  `json:"neighbor"`
	Relationship      LinkRelationship `json:"relationship"`

	// ScionMtu The maximum transmission unit in bytes for SCION packets. This represents the protocol data unit (PDU) of the SCION layer and is usually calculated as maximum Ethernet payload - IP Header - UDP Header.
	ScionMtu ScionMTU  `json:"scion_mtu"`
	State    LinkState `json:"state"`
}

type SiblingNeighbor struct {
	IsdAs IsdAs `json:"isd_as"`
}

type StandardError struct {
	// Error Error message
	Error string `json:"error"`
}

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

type Unimplemented struct{}

type UnmarshalingParamError struct {
	ParamName string
	Err       error
}