api

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

type Action string

type Audience string

type AudienceAuthorizer interface {
	RequireScopes(context.Context, Audience, []string) error
	AuthenticateClient(context.Context, *http.Request, string) (context.Context, error)
}

type AudiencePolicy struct {
	Audience       Audience
	RequiredScopes []string
	ClientAudience string
}

type CollectionEnvelope[T any] struct {
	Data []T            `json:"data"`
	Meta PaginationMeta `json:"meta"`
}

type CollectionOutput[T any] struct {
	Body CollectionEnvelope[T]
}

type Config struct {
	Title                            string
	Version                          string
	BasePath                         string
	OpenAPIPath                      string
	DocsPath                         string
	SchemasPath                      string
	MaxBodyBytes                     int64
	RequestTransactionTimeout        time.Duration
	MaxConcurrentRequestTransactions int
}

type ErrorBody struct {
	Code      string              `json:"code"`
	Message   string              `json:"message"`
	RequestID string              `json:"request_id,omitempty"`
	Fields    map[string][]string `json:"fields,omitempty"`
}

type ErrorEnvelope struct {
	Error ErrorBody `json:"error"`
}

type Meta struct {
	RequestID string `json:"request_id"`
}

type Middleware func(http.Handler) http.Handler

type Option func(*settings)

type PaginationMeta struct {
	RequestID string `json:"request_id"`
	Page      int    `json:"page"`
	PerPage   int    `json:"per_page"`
	Total     int    `json:"total"`
	Pages     int    `json:"pages"`
}

type Registrar interface {
	Register(*Router, string) error
}

type RequestTransactionInfo struct {
	Request     *http.Request
	OperationID string
	Owner       string
	Audience    AudiencePolicy
	PathValues  map[string]string
}

type RequestTransactionInitializer func(context.Context, RequestTransactionInfo, database.LocalSettings) (context.Context, error)

type Resource[T, C, U, R any] struct {
	// contains filtered or unexported fields
}

type ResourceConfig[T, C, U, R any] struct {
	Name         string
	Repository   *repository.Repository[T]
	Serializer   serializer.Serializer[T, R]
	CreateEntity func(context.Context, C) (*T, error)
	UpdateEntity func(context.Context, *T, U) error
	Query        query.Definition
	Disabled     []Action
	Authorize    ResourceHook[T]
	// AuthorizeWrite validates the final mapped entity before create or update.
	// Engine resources with either action enabled must provide it unless they
	// explicitly opt into global access with AllowUnscoped.
	AuthorizeWrite ResourceHook[T]
	Before         ResourceHook[T]
	After          ResourceHook[T]
	Scope          func(context.Context, *bun.SelectQuery) *bun.SelectQuery
	// AllowUnscoped explicitly marks a resource as global. Engine resources
	// must set this or provide Scope or Authorize.
	AllowUnscoped   bool
	Audience        AudiencePolicy
	Audiences       map[Action]AudiencePolicy
	ModifyOperation map[Action]func(*huma.Operation)
}

type ResourceHook[T any] func(context.Context, Action, *T) error

type Route struct {
	Method         string
	Path           string
	OperationID    string
	Owner          string
	Tags           []string
	Audience       Audience
	RequiredScopes []string
	ClientAudience string
}

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

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

type StatusError struct {
	ErrorEnvelope
	// contains filtered or unexported fields
}

type SuccessEnvelope[T any] struct {
	Data T    `json:"data"`
	Meta Meta `json:"meta"`
}

type SuccessOutput[T any] struct {
	Body SuccessEnvelope[T]
}