funcie

type Application struct {
	// Name is the name of the application.
	Name string `json:"name"`
	// Endpoint is the address to send requests to.
	Endpoint Endpoint `json:"endpoint"`
}

type ApplicationRegistry interface {
	// Register registers the given application.
	Register(ctx context.Context, application *Application) error
	// Unregister unregisters the application with the given name.
	Unregister(ctx context.Context, applicationName string) error
	// GetApplication gets the application with the given name.
	// If no application is registered with the given name, ErrApplicationNotFound is returned.
	GetApplication(ctx context.Context, applicationName string) (*Application, error)
}

type Closable interface {
	Close() error
}

type Consumer interface {
	Connect(ctx context.Context) error
	Consume(ctx context.Context) error
	Subscribe(ctx context.Context, applicationId string, handler Handler) error
	Unsubscribe(ctx context.Context, applicationId string) error
}

type Endpoint struct {
	// Scheme is the protocol scheme of the endpoint.
	// This is usually "http" or "https".
	Scheme string `json:"protocol"`
	// Host is the host name or IP address of the endpoint.
	// This does not include the protocol or port.
	Host string `json:"host"`
	// Port is the port number of the endpoint.
	Port int `json:"port"`
}

type Handler func(ctx context.Context, message *Message) (*Response, error)

type Message = MessageBase[json.RawMessage]

type MessageBase[T any] struct {
	// ID is the unique identifier for this message.
	ID string `json:"id"`
	// Kind is the type of message that is being sent.
	Kind MessageKind `json:"kind"`
	// Application is the name of the application that this message is for.
	Application string `json:"application"`
	// Payload is the actual message payload.
	Payload T `json:"payload"`
	// Created is the time the message was created.
	Created time.Time `json:"created"`
}

type MessageKind string

type Pinger interface {
	Ping(app Application) error
}

type ProxyError struct {
	// Message is the error message.
	Message string `json:"message,omitempty"`
}

type Publisher interface {
	// Publish publishes a message to the tunnel, synchronously waiting for a response from the other side.
	// If no consumer is active, ErrNoConsumerActive is returned.
	Publish(ctx context.Context, message *Message) (*Response, error)
}

type Response = ResponseBase[json.RawMessage]

type ResponseBase[T any] struct {
	// ID is the unique identifier for this message.
	ID string `json:"id"`
	// Data is the actual message payload, or nil if an error occurred.
	// Exactly one of Data or Error are not nil.
	Data *T `json:"data,omitempty"`
	// Error is the error that occurred, or nil if no error occurred.
	// Exactly one of Data or Error are not nil.
	Error *ProxyError `json:"error,omitempty"`
	// Received is the time the response was received.
	Received time.Time `json:"received"`
}

type Tunnel interface {
	// Start starts the tunnel. This function never returns.
	// The handler is the handler that will be invoked when a request is received.
	// It is subject to the same restrictions as the handler for the serverless function provider (such as lambda.Start).
	Start()
}