api.connect.go

// Code generated by protoc-gen-connect-go. DO NOT EDIT.
//
// Source: api/api.proto

package apiconnect

import (
	context "context"
	errors "errors"
	connect_go "github.com/bufbuild/connect-go"
	api "github.com/nix-community/trustix/packages/trustix-proto/api"
	schema "github.com/nix-community/trustix/packages/trustix-proto/schema"
	http "net/http"
	strings "strings"
)

// This is a compile-time assertion to ensure that this generated file and the connect package are
// compatible. If you get a compiler error that this constant is not defined, this code was
// generated with a version of connect newer than the one compiled into your binary. You can fix the
// problem by either regenerating this code with an older version of connect or updating the connect
// version compiled into your binary.
const _ = connect_go.IsAtLeastVersion0_1_0

const (
	// NodeAPIName is the fully-qualified name of the NodeAPI service.
	NodeAPIName = "trustix_api.v1.NodeAPI"
	// LogAPIName is the fully-qualified name of the LogAPI service.
	LogAPIName = "trustix_api.v1.LogAPI"
)

// NodeAPIClient is a client for the trustix_api.v1.NodeAPI service.
type NodeAPIClient interface {
	// Get a list of all logs published by this node
	Logs(context.Context, *connect_go.Request[api.LogsRequest]) (*connect_go.Response[api.LogsResponse], error)
	// Get values by their content-address
	GetValue(context.Context, *connect_go.Request[api.ValueRequest]) (*connect_go.Response[api.ValueResponse], error)
}

// NewNodeAPIClient constructs a client for the trustix_api.v1.NodeAPI service. By default, it uses
// the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
// connect.WithGRPCWeb() options.
//
// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
// http://api.acme.com or https://acme.com/grpc).
func NewNodeAPIClient(httpClient connect_go.HTTPClient, baseURL string, opts ...connect_go.ClientOption) NodeAPIClient {
	baseURL = strings.TrimRight(baseURL, "/")
	return &nodeAPIClient{
		logs: connect_go.NewClient[api.LogsRequest, api.LogsResponse](
			httpClient,
			baseURL+"/trustix_api.v1.NodeAPI/Logs",
			opts...,
		),
		getValue: connect_go.NewClient[api.ValueRequest, api.ValueResponse](
			httpClient,
			baseURL+"/trustix_api.v1.NodeAPI/GetValue",
			opts...,
		),
	}
}

// nodeAPIClient implements NodeAPIClient.
type nodeAPIClient struct {
	logs     *connect_go.Client[api.LogsRequest, api.LogsResponse]
	getValue *connect_go.Client[api.ValueRequest, api.ValueResponse]
}

// Logs calls trustix_api.v1.NodeAPI.Logs.
func (c *nodeAPIClient) Logs(ctx context.Context, req *connect_go.Request[api.LogsRequest]) (*connect_go.Response[api.LogsResponse], error) {
	return c.logs.CallUnary(ctx, req)
}

// GetValue calls trustix_api.v1.NodeAPI.GetValue.
func (c *nodeAPIClient) GetValue(ctx context.Context, req *connect_go.Request[api.ValueRequest]) (*connect_go.Response[api.ValueResponse], error) {
	return c.getValue.CallUnary(ctx, req)
}

// NodeAPIHandler is an implementation of the trustix_api.v1.NodeAPI service.
type NodeAPIHandler interface {
	// Get a list of all logs published by this node
	Logs(context.Context, *connect_go.Request[api.LogsRequest]) (*connect_go.Response[api.LogsResponse], error)
	// Get values by their content-address
	GetValue(context.Context, *connect_go.Request[api.ValueRequest]) (*connect_go.Response[api.ValueResponse], error)
}

// NewNodeAPIHandler builds an HTTP handler from the service implementation. It returns the path on
// which to mount the handler and the handler itself.
//
// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
// and JSON codecs. They also support gzip compression.
func NewNodeAPIHandler(svc NodeAPIHandler, opts ...connect_go.HandlerOption) (string, http.Handler) {
	mux := http.NewServeMux()
	mux.Handle("/trustix_api.v1.NodeAPI/Logs", connect_go.NewUnaryHandler(
		"/trustix_api.v1.NodeAPI/Logs",
		svc.Logs,
		opts...,
	))
	mux.Handle("/trustix_api.v1.NodeAPI/GetValue", connect_go.NewUnaryHandler(
		"/trustix_api.v1.NodeAPI/GetValue",
		svc.GetValue,
		opts...,
	))
	return "/trustix_api.v1.NodeAPI/", mux
}

// UnimplementedNodeAPIHandler returns CodeUnimplemented from all methods.
type UnimplementedNodeAPIHandler struct{}

func (UnimplementedNodeAPIHandler) Logs(context.Context, *connect_go.Request[api.LogsRequest]) (*connect_go.Response[api.LogsResponse], error) {
	return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("trustix_api.v1.NodeAPI.Logs is not implemented"))
}

func (UnimplementedNodeAPIHandler) GetValue(context.Context, *connect_go.Request[api.ValueRequest]) (*connect_go.Response[api.ValueResponse], error) {
	return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("trustix_api.v1.NodeAPI.GetValue is not implemented"))
}

// LogAPIClient is a client for the trustix_api.v1.LogAPI service.
type LogAPIClient interface {
	// Get signed head
	GetHead(context.Context, *connect_go.Request[api.LogHeadRequest]) (*connect_go.Response[schema.LogHead], error)
	GetLogConsistencyProof(context.Context, *connect_go.Request[api.GetLogConsistencyProofRequest]) (*connect_go.Response[api.ProofResponse], error)
	GetLogAuditProof(context.Context, *connect_go.Request[api.GetLogAuditProofRequest]) (*connect_go.Response[api.ProofResponse], error)
	GetLogEntries(context.Context, *connect_go.Request[api.GetLogEntriesRequest]) (*connect_go.Response[api.LogEntriesResponse], error)
	GetMapValue(context.Context, *connect_go.Request[api.GetMapValueRequest]) (*connect_go.Response[api.MapValueResponse], error)
	GetMHLogConsistencyProof(context.Context, *connect_go.Request[api.GetLogConsistencyProofRequest]) (*connect_go.Response[api.ProofResponse], error)
	GetMHLogAuditProof(context.Context, *connect_go.Request[api.GetLogAuditProofRequest]) (*connect_go.Response[api.ProofResponse], error)
	GetMHLogEntries(context.Context, *connect_go.Request[api.GetLogEntriesRequest]) (*connect_go.Response[api.LogEntriesResponse], error)
}

// NewLogAPIClient constructs a client for the trustix_api.v1.LogAPI service. By default, it uses
// the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
// connect.WithGRPCWeb() options.
//
// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
// http://api.acme.com or https://acme.com/grpc).
func NewLogAPIClient(httpClient connect_go.HTTPClient, baseURL string, opts ...connect_go.ClientOption) LogAPIClient {
	baseURL = strings.TrimRight(baseURL, "/")
	return &logAPIClient{
		getHead: connect_go.NewClient[api.LogHeadRequest, schema.LogHead](
			httpClient,
			baseURL+"/trustix_api.v1.LogAPI/GetHead",
			opts...,
		),
		getLogConsistencyProof: connect_go.NewClient[api.GetLogConsistencyProofRequest, api.ProofResponse](
			httpClient,
			baseURL+"/trustix_api.v1.LogAPI/GetLogConsistencyProof",
			opts...,
		),
		getLogAuditProof: connect_go.NewClient[api.GetLogAuditProofRequest, api.ProofResponse](
			httpClient,
			baseURL+"/trustix_api.v1.LogAPI/GetLogAuditProof",
			opts...,
		),
		getLogEntries: connect_go.NewClient[api.GetLogEntriesRequest, api.LogEntriesResponse](
			httpClient,
			baseURL+"/trustix_api.v1.LogAPI/GetLogEntries",
			opts...,
		),
		getMapValue: connect_go.NewClient[api.GetMapValueRequest, api.MapValueResponse](
			httpClient,
			baseURL+"/trustix_api.v1.LogAPI/GetMapValue",
			opts...,
		),
		getMHLogConsistencyProof: connect_go.NewClient[api.GetLogConsistencyProofRequest, api.ProofResponse](
			httpClient,
			baseURL+"/trustix_api.v1.LogAPI/GetMHLogConsistencyProof",
			opts...,
		),
		getMHLogAuditProof: connect_go.NewClient[api.GetLogAuditProofRequest, api.ProofResponse](
			httpClient,
			baseURL+"/trustix_api.v1.LogAPI/GetMHLogAuditProof",
			opts...,
		),
		getMHLogEntries: connect_go.NewClient[api.GetLogEntriesRequest, api.LogEntriesResponse](
			httpClient,
			baseURL+"/trustix_api.v1.LogAPI/GetMHLogEntries",
			opts...,
		),
	}
}

// logAPIClient implements LogAPIClient.
type logAPIClient struct {
	getHead                  *connect_go.Client[api.LogHeadRequest, schema.LogHead]
	getLogConsistencyProof   *connect_go.Client[api.GetLogConsistencyProofRequest, api.ProofResponse]
	getLogAuditProof         *connect_go.Client[api.GetLogAuditProofRequest, api.ProofResponse]
	getLogEntries            *connect_go.Client[api.GetLogEntriesRequest, api.LogEntriesResponse]
	getMapValue              *connect_go.Client[api.GetMapValueRequest, api.MapValueResponse]
	getMHLogConsistencyProof *connect_go.Client[api.GetLogConsistencyProofRequest, api.ProofResponse]
	getMHLogAuditProof       *connect_go.Client[api.GetLogAuditProofRequest, api.ProofResponse]
	getMHLogEntries          *connect_go.Client[api.GetLogEntriesRequest, api.LogEntriesResponse]
}

// GetHead calls trustix_api.v1.LogAPI.GetHead.
func (c *logAPIClient) GetHead(ctx context.Context, req *connect_go.Request[api.LogHeadRequest]) (*connect_go.Response[schema.LogHead], error) {
	return c.getHead.CallUnary(ctx, req)
}

// GetLogConsistencyProof calls trustix_api.v1.LogAPI.GetLogConsistencyProof.
func (c *logAPIClient) GetLogConsistencyProof(ctx context.Context, req *connect_go.Request[api.GetLogConsistencyProofRequest]) (*connect_go.Response[api.ProofResponse], error) {
	return c.getLogConsistencyProof.CallUnary(ctx, req)
}

// GetLogAuditProof calls trustix_api.v1.LogAPI.GetLogAuditProof.
func (c *logAPIClient) GetLogAuditProof(ctx context.Context, req *connect_go.Request[api.GetLogAuditProofRequest]) (*connect_go.Response[api.ProofResponse], error) {
	return c.getLogAuditProof.CallUnary(ctx, req)
}

// GetLogEntries calls trustix_api.v1.LogAPI.GetLogEntries.
func (c *logAPIClient) GetLogEntries(ctx context.Context, req *connect_go.Request[api.GetLogEntriesRequest]) (*connect_go.Response[api.LogEntriesResponse], error) {
	return c.getLogEntries.CallUnary(ctx, req)
}

// GetMapValue calls trustix_api.v1.LogAPI.GetMapValue.
func (c *logAPIClient) GetMapValue(ctx context.Context, req *connect_go.Request[api.GetMapValueRequest]) (*connect_go.Response[api.MapValueResponse], error) {
	return c.getMapValue.CallUnary(ctx, req)
}

// GetMHLogConsistencyProof calls trustix_api.v1.LogAPI.GetMHLogConsistencyProof.
func (c *logAPIClient) GetMHLogConsistencyProof(ctx context.Context, req *connect_go.Request[api.GetLogConsistencyProofRequest]) (*connect_go.Response[api.ProofResponse], error) {
	return c.getMHLogConsistencyProof.CallUnary(ctx, req)
}

// GetMHLogAuditProof calls trustix_api.v1.LogAPI.GetMHLogAuditProof.
func (c *logAPIClient) GetMHLogAuditProof(ctx context.Context, req *connect_go.Request[api.GetLogAuditProofRequest]) (*connect_go.Response[api.ProofResponse], error) {
	return c.getMHLogAuditProof.CallUnary(ctx, req)
}

// GetMHLogEntries calls trustix_api.v1.LogAPI.GetMHLogEntries.
func (c *logAPIClient) GetMHLogEntries(ctx context.Context, req *connect_go.Request[api.GetLogEntriesRequest]) (*connect_go.Response[api.LogEntriesResponse], error) {
	return c.getMHLogEntries.CallUnary(ctx, req)
}

// LogAPIHandler is an implementation of the trustix_api.v1.LogAPI service.
type LogAPIHandler interface {
	// Get signed head
	GetHead(context.Context, *connect_go.Request[api.LogHeadRequest]) (*connect_go.Response[schema.LogHead], error)
	GetLogConsistencyProof(context.Context, *connect_go.Request[api.GetLogConsistencyProofRequest]) (*connect_go.Response[api.ProofResponse], error)
	GetLogAuditProof(context.Context, *connect_go.Request[api.GetLogAuditProofRequest]) (*connect_go.Response[api.ProofResponse], error)
	GetLogEntries(context.Context, *connect_go.Request[api.GetLogEntriesRequest]) (*connect_go.Response[api.LogEntriesResponse], error)
	GetMapValue(context.Context, *connect_go.Request[api.GetMapValueRequest]) (*connect_go.Response[api.MapValueResponse], error)
	GetMHLogConsistencyProof(context.Context, *connect_go.Request[api.GetLogConsistencyProofRequest]) (*connect_go.Response[api.ProofResponse], error)
	GetMHLogAuditProof(context.Context, *connect_go.Request[api.GetLogAuditProofRequest]) (*connect_go.Response[api.ProofResponse], error)
	GetMHLogEntries(context.Context, *connect_go.Request[api.GetLogEntriesRequest]) (*connect_go.Response[api.LogEntriesResponse], error)
}

// NewLogAPIHandler builds an HTTP handler from the service implementation. It returns the path on
// which to mount the handler and the handler itself.
//
// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
// and JSON codecs. They also support gzip compression.
func NewLogAPIHandler(svc LogAPIHandler, opts ...connect_go.HandlerOption) (string, http.Handler) {
	mux := http.NewServeMux()
	mux.Handle("/trustix_api.v1.LogAPI/GetHead", connect_go.NewUnaryHandler(
		"/trustix_api.v1.LogAPI/GetHead",
		svc.GetHead,
		opts...,
	))
	mux.Handle("/trustix_api.v1.LogAPI/GetLogConsistencyProof", connect_go.NewUnaryHandler(
		"/trustix_api.v1.LogAPI/GetLogConsistencyProof",
		svc.GetLogConsistencyProof,
		opts...,
	))
	mux.Handle("/trustix_api.v1.LogAPI/GetLogAuditProof", connect_go.NewUnaryHandler(
		"/trustix_api.v1.LogAPI/GetLogAuditProof",
		svc.GetLogAuditProof,
		opts...,
	))
	mux.Handle("/trustix_api.v1.LogAPI/GetLogEntries", connect_go.NewUnaryHandler(
		"/trustix_api.v1.LogAPI/GetLogEntries",
		svc.GetLogEntries,
		opts...,
	))
	mux.Handle("/trustix_api.v1.LogAPI/GetMapValue", connect_go.NewUnaryHandler(
		"/trustix_api.v1.LogAPI/GetMapValue",
		svc.GetMapValue,
		opts...,
	))
	mux.Handle("/trustix_api.v1.LogAPI/GetMHLogConsistencyProof", connect_go.NewUnaryHandler(
		"/trustix_api.v1.LogAPI/GetMHLogConsistencyProof",
		svc.GetMHLogConsistencyProof,
		opts...,
	))
	mux.Handle("/trustix_api.v1.LogAPI/GetMHLogAuditProof", connect_go.NewUnaryHandler(
		"/trustix_api.v1.LogAPI/GetMHLogAuditProof",
		svc.GetMHLogAuditProof,
		opts...,
	))
	mux.Handle("/trustix_api.v1.LogAPI/GetMHLogEntries", connect_go.NewUnaryHandler(
		"/trustix_api.v1.LogAPI/GetMHLogEntries",
		svc.GetMHLogEntries,
		opts...,
	))
	return "/trustix_api.v1.LogAPI/", mux
}

// UnimplementedLogAPIHandler returns CodeUnimplemented from all methods.
type UnimplementedLogAPIHandler struct{}

func (UnimplementedLogAPIHandler) GetHead(context.Context, *connect_go.Request[api.LogHeadRequest]) (*connect_go.Response[schema.LogHead], error) {
	return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("trustix_api.v1.LogAPI.GetHead is not implemented"))
}

func (UnimplementedLogAPIHandler) GetLogConsistencyProof(context.Context, *connect_go.Request[api.GetLogConsistencyProofRequest]) (*connect_go.Response[api.ProofResponse], error) {
	return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("trustix_api.v1.LogAPI.GetLogConsistencyProof is not implemented"))
}

func (UnimplementedLogAPIHandler) GetLogAuditProof(context.Context, *connect_go.Request[api.GetLogAuditProofRequest]) (*connect_go.Response[api.ProofResponse], error) {
	return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("trustix_api.v1.LogAPI.GetLogAuditProof is not implemented"))
}

func (UnimplementedLogAPIHandler) GetLogEntries(context.Context, *connect_go.Request[api.GetLogEntriesRequest]) (*connect_go.Response[api.LogEntriesResponse], error) {
	return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("trustix_api.v1.LogAPI.GetLogEntries is not implemented"))
}

func (UnimplementedLogAPIHandler) GetMapValue(context.Context, *connect_go.Request[api.GetMapValueRequest]) (*connect_go.Response[api.MapValueResponse], error) {
	return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("trustix_api.v1.LogAPI.GetMapValue is not implemented"))
}

func (UnimplementedLogAPIHandler) GetMHLogConsistencyProof(context.Context, *connect_go.Request[api.GetLogConsistencyProofRequest]) (*connect_go.Response[api.ProofResponse], error) {
	return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("trustix_api.v1.LogAPI.GetMHLogConsistencyProof is not implemented"))
}

func (UnimplementedLogAPIHandler) GetMHLogAuditProof(context.Context, *connect_go.Request[api.GetLogAuditProofRequest]) (*connect_go.Response[api.ProofResponse], error) {
	return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("trustix_api.v1.LogAPI.GetMHLogAuditProof is not implemented"))
}

func (UnimplementedLogAPIHandler) GetMHLogEntries(context.Context, *connect_go.Request[api.GetLogEntriesRequest]) (*connect_go.Response[api.LogEntriesResponse], error) {
	return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("trustix_api.v1.LogAPI.GetMHLogEntries is not implemented"))
}