farp

type AccessRule struct {
	// Path pattern (glob or regex)
	Path string `json:"path"`

	// HTTP methods
	Methods []string `json:"methods"`

	// Required roles
	Roles []string `json:"roles,omitempty"`

	// Required permissions
	Permissions []string `json:"permissions,omitempty"`

	// Allow anonymous access
	AllowAnonymous bool `json:"allow_anonymous,omitempty"`
}

type Application interface {
	// Name returns the application/service name
	Name() string

	// Version returns the application version
	Version() string

	// Routes returns route information for schema generation
	// The actual type depends on the framework (e.g., []forge.RouteInfo)
	Routes() any
}

type AsyncAPIMetadata struct {
	// Message broker type
	Protocol string `json:"protocol"` // "kafka", "amqp", "mqtt", "ws"

	// Channel bindings
	ChannelBindings map[string]any `json:"channel_bindings,omitempty"`

	// Message bindings
	MessageBindings map[string]any `json:"message_bindings,omitempty"`
}

type AuthConfig struct {
	// Authentication schemes supported by service
	Schemes []AuthScheme `json:"schemes"`

	// Required permissions/scopes
	RequiredScopes []string `json:"required_scopes,omitempty"`

	// Access control rules
	AccessControl []AccessRule `json:"access_control,omitempty"`

	// Token validation endpoint
	TokenValidationURL string `json:"token_validation_url,omitempty"`

	// Public (unauthenticated) routes
	PublicRoutes []string `json:"public_routes,omitempty"`
}

type AuthScheme struct {
	// Scheme type
	Type AuthType `json:"type"`

	// Scheme configuration (varies by type)
	Config map[string]any `json:"config,omitempty"`
}

type AuthType string

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

type BreakingChange struct {
	// Type of breaking change
	Type ChangeType `json:"type"`

	// Path in schema (e.g., "/paths/users/get", "User.email")
	Path string `json:"path"`

	// Human-readable description
	Description string `json:"description"`

	// Severity level
	Severity ChangeSeverity `json:"severity"`

	// Migration instructions
	Migration string `json:"migration,omitempty"`
}

type Capability string

type ChangeSeverity string

type ChangeType string

type CommunicationRoute struct {
	// Route identifier
	ID string `json:"id"`

	// Route path
	Path string `json:"path"`

	// HTTP method
	Method string `json:"method"`

	// Route purpose/type
	Type CommunicationRouteType `json:"type"`

	// Description
	Description string `json:"description,omitempty"`

	// Request schema (JSON Schema, OpenAPI schema, etc.)
	RequestSchema any `json:"request_schema,omitempty"`

	// Response schema
	ResponseSchema any `json:"response_schema,omitempty"`

	// Authentication required
	AuthRequired bool `json:"auth_required"`

	// Idempotent operation
	Idempotent bool `json:"idempotent"`

	// Expected timeout
	Timeout string `json:"timeout,omitempty"`
}

type CommunicationRouteType string

type CompatibilityMode string

type CompositionConfig struct {
	// Include this schema in merged/federated API documentation
	IncludeInMerged bool `json:"include_in_merged"`

	// Prefix for component schemas to avoid naming conflicts
	// If empty, defaults to service name
	ComponentPrefix string `json:"component_prefix,omitempty"`

	// Tag prefix for operation tags
	TagPrefix string `json:"tag_prefix,omitempty"`

	// Operation ID prefix to avoid conflicts
	OperationIDPrefix string `json:"operation_id_prefix,omitempty"`

	// Conflict resolution strategy when paths/components collide
	ConflictStrategy ConflictStrategy `json:"conflict_strategy"`

	// Whether to preserve x-extensions from this schema
	PreserveExtensions bool `json:"preserve_extensions"`

	// Custom servers to use in merged spec (overrides service defaults)
	CustomServers []OpenAPIServer `json:"custom_servers,omitempty"`
}

type ConflictStrategy string

type DataSensitivity string

type DeploymentMetadata struct {
	// Deployment ID
	DeploymentID string `json:"deployment_id"`

	// Deployment strategy
	Strategy DeploymentStrategy `json:"strategy"`

	// Traffic percentage (0-100)
	TrafficPercent int `json:"traffic_percent,omitempty"`

	// Deployment stage
	Stage string `json:"stage,omitempty"` // "canary", "rollout", "stable"

	// Deployment time
	DeployedAt int64 `json:"deployed_at"`
}

type DeploymentStrategy string

type Deprecation struct {
	// Path in schema
	Path string `json:"path"`

	// Deprecation date (ISO 8601)
	DeprecatedAt string `json:"deprecated_at"`

	// Planned removal date (ISO 8601)
	RemovalDate string `json:"removal_date,omitempty"`

	// Replacement recommendation
	Replacement string `json:"replacement,omitempty"`

	// Migration guide
	Migration string `json:"migration,omitempty"`

	// Reason for deprecation
	Reason string `json:"reason,omitempty"`
}

type EventType string

type FederatedEntity struct {
	// Type name
	TypeName string `json:"type_name"`

	// Key fields for entity resolution
	KeyFields []string `json:"key_fields"`

	// Fields owned by this service
	Fields []string `json:"fields"`

	// Resolvable via this subgraph
	Resolvable bool `json:"resolvable"`
}

type FetchOptions struct {
	// UseCache indicates whether to use cache
	UseCache bool

	// ValidateChecksum verifies schema hash after fetch
	ValidateChecksum bool

	// ExpectedHash is the expected SHA256 hash (for validation)
	ExpectedHash string

	// Timeout for fetch operation (0 = no timeout)
	Timeout int64
}

type GRPCMetadata struct {
	// Reflection enabled
	ReflectionEnabled bool `json:"reflection_enabled"`

	// Package names
	Packages []string `json:"packages"`

	// Service names
	Services []string `json:"services"`

	// gRPC-Web support
	GRPCWebEnabled bool `json:"grpc_web_enabled,omitempty"`

	// gRPC-Web protocol
	GRPCWebProtocol string `json:"grpc_web_protocol,omitempty"` // "grpc-web", "grpc-web-text"

	// Server streaming support
	ServerStreamingEnabled bool `json:"server_streaming_enabled,omitempty"`

	// Client streaming support
	ClientStreamingEnabled bool `json:"client_streaming_enabled,omitempty"`

	// Bidirectional streaming support
	BidirectionalStreamingEnabled bool `json:"bidirectional_streaming_enabled,omitempty"`
}

type GraphQLFederation struct {
	// Federation version
	Version string `json:"version"` // "v1", "v2"

	// Subgraph name
	SubgraphName string `json:"subgraph_name"`

	// Entity types owned by this service
	Entities []FederatedEntity `json:"entities,omitempty"`

	// External types from other services
	Extends []string `json:"extends,omitempty"`

	// Provides relationships
	Provides []ProvidesRelation `json:"provides,omitempty"`

	// Requires relationships
	Requires []RequiresRelation `json:"requires,omitempty"`
}

type GraphQLMetadata struct {
	// Federation configuration
	Federation *GraphQLFederation `json:"federation,omitempty"`

	// Subscription support
	SubscriptionsEnabled bool `json:"subscriptions_enabled,omitempty"`

	// Subscription protocol
	SubscriptionProtocol string `json:"subscription_protocol,omitempty"` // "graphql-ws", "graphql-transport-ws"

	// Query complexity limits
	ComplexityLimit int `json:"complexity_limit,omitempty"`

	// Query depth limits
	DepthLimit int `json:"depth_limit,omitempty"`
}

type HTTPCommunicationRoutes struct {
	// Service exposes these routes for gateway to call
	ServiceRoutes []CommunicationRoute `json:"service_routes,omitempty"`

	// Gateway exposes these routes for service to call
	GatewayRoutes []CommunicationRoute `json:"gateway_routes,omitempty"`

	// Polling configuration if HTTP polling is used
	Polling *PollingConfig `json:"polling,omitempty"`
}

type InstanceMetadata struct {
	// Instance address (host:port)
	Address string `json:"address"`

	// Instance region/zone/datacenter
	Region string `json:"region,omitempty"`
	Zone   string `json:"zone,omitempty"`

	// Instance labels for selection
	Labels map[string]string `json:"labels,omitempty"`

	// Instance weight for load balancing (0-100, default: 100)
	Weight int `json:"weight,omitempty"`

	// Instance status
	Status InstanceStatus `json:"status"`

	// Instance role in deployment
	Role InstanceRole `json:"role,omitempty"`

	// Canary/blue-green deployment metadata
	Deployment *DeploymentMetadata `json:"deployment,omitempty"`

	// Instance start time
	StartedAt int64 `json:"started_at"` // Unix timestamp

	// Expected schema checksum (for validation)
	ExpectedSchemaChecksum string `json:"expected_schema_checksum,omitempty"`
}

type InstanceRole string

type InstanceStatus string

type LatencyProfile struct {
	// Median latency
	P50 string `json:"p50,omitempty"` // e.g., "10ms"

	// 95th percentile
	P95 string `json:"p95,omitempty"` // e.g., "50ms"

	// 99th percentile
	P99 string `json:"p99,omitempty"` // e.g., "100ms"

	// 99.9th percentile
	P999 string `json:"p999,omitempty"` // e.g., "500ms"
}

type LocationType string

type ManifestChangeHandler func(event *ManifestEvent)

type ManifestDiff struct {
	// SchemasAdded are schemas present in new but not in old
	SchemasAdded []SchemaDescriptor

	// SchemasRemoved are schemas present in old but not in new
	SchemasRemoved []SchemaDescriptor

	// SchemasChanged are schemas present in both but with different hashes
	SchemasChanged []SchemaChangeDiff

	// CapabilitiesAdded are new capabilities
	CapabilitiesAdded []string

	// CapabilitiesRemoved are removed capabilities
	CapabilitiesRemoved []string

	// EndpointsChanged indicates if endpoints changed
	EndpointsChanged bool
}

type ManifestError struct {
	ServiceName string
	InstanceID  string
	Err         error
}

type ManifestEvent struct {
	// Type of event (added, updated, removed)
	Type EventType

	// The manifest that changed
	Manifest *SchemaManifest

	// Timestamp of the event (Unix timestamp)
	Timestamp int64
}

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

type MountStrategy string

type ORPCMetadata struct {
	// Batch operations supported
	BatchEnabled bool `json:"batch_enabled,omitempty"`

	// Streaming procedures
	StreamingProcedures []string `json:"streaming_procedures,omitempty"`
}

type OpenAPIMetadata struct {
	// x-extension fields to preserve
	Extensions map[string]any `json:"extensions,omitempty"`

	// Server variables for URL templating
	ServerVariables map[string]ServerVariable `json:"server_variables,omitempty"`

	// Default security schemes
	DefaultSecurity []string `json:"default_security,omitempty"`

	// Composition settings for schema merging
	Composition *CompositionConfig `json:"composition,omitempty"`
}

type OpenAPIServer struct {
	// Server URL
	URL string `json:"url"`

	// Server description
	Description string `json:"description,omitempty"`

	// Server variables
	Variables map[string]ServerVariable `json:"variables,omitempty"`
}

type PathRewrite struct {
	// Pattern to match (regex)
	Pattern string `json:"pattern"`

	// Replacement string
	Replacement string `json:"replacement"`
}

type PollingConfig struct {
	// Polling interval
	Interval string `json:"interval"` // Duration string

	// Polling timeout
	Timeout string `json:"timeout,omitempty"`

	// Long polling support
	LongPolling bool `json:"long_polling,omitempty"`

	// Long polling timeout
	LongPollingTimeout string `json:"long_polling_timeout,omitempty"`
}

type ProtocolMetadata struct {
	// GraphQL-specific metadata
	GraphQL *GraphQLMetadata `json:"graphql,omitempty"`

	// gRPC-specific metadata
	GRPC *GRPCMetadata `json:"grpc,omitempty"`

	// OpenAPI-specific metadata
	OpenAPI *OpenAPIMetadata `json:"openapi,omitempty"`

	// AsyncAPI-specific metadata
	AsyncAPI *AsyncAPIMetadata `json:"asyncapi,omitempty"`

	// oRPC-specific metadata
	ORPC *ORPCMetadata `json:"orpc,omitempty"`
}

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

type ProvidesRelation struct {
	// Field path
	Field string `json:"field"`

	// Provided fields
	Fields []string `json:"fields"`
}

type PublishOptions struct {
	// Compress indicates whether to compress the schema
	Compress bool

	// TTL is time-to-live in seconds (0 = no expiry)
	TTL int64

	// OverwriteExisting allows overwriting existing schemas
	OverwriteExisting bool
}

type RegistryConfig struct {
	// Backend type (consul, etcd, kubernetes, redis, memory)
	Backend string

	// Namespace/prefix for keys (optional)
	Namespace string

	// Backend-specific configuration (varies by implementation)
	BackendConfig map[string]any

	// Max schema size in bytes (default: 1MB)
	MaxSchemaSize int64

	// Enable compression for schemas > threshold
	CompressionThreshold int64

	// TTL for schemas (0 = no expiry)
	TTL int64
}

type RequiresRelation struct {
	// Field path
	Field string `json:"field"`

	// Required fields
	Fields []string `json:"fields"`
}

type RetryConfig struct {
	// Maximum retry attempts
	MaxAttempts int `json:"max_attempts"`

	// Initial retry delay
	InitialDelay string `json:"initial_delay"` // Duration string

	// Maximum retry delay
	MaxDelay string `json:"max_delay"`

	// Backoff multiplier
	Multiplier float64 `json:"multiplier"`
}

type RouteMetadata struct {
	// Operation/route identifier
	OperationID string `json:"operation_id"`

	// Path pattern
	Path string `json:"path"`

	// HTTP method (for REST/OpenAPI)
	Method string `json:"method,omitempty"`

	// Is operation idempotent?
	Idempotent bool `json:"idempotent"`

	// Recommended timeout for this operation
	TimeoutHint string `json:"timeout_hint,omitempty"`

	// Operation cost/complexity (1-10 scale)
	Cost int `json:"cost,omitempty"`

	// Is result cacheable?
	Cacheable bool `json:"cacheable,omitempty"`

	// Cache TTL hint
	CacheTTL string `json:"cache_ttl,omitempty"`

	// Data sensitivity level
	Sensitivity DataSensitivity `json:"sensitivity,omitempty"`

	// Expected response size
	ResponseSize SizeHint `json:"response_size,omitempty"`

	// Rate limit hint (requests per second)
	RateLimitHint int `json:"rate_limit_hint,omitempty"`
}

type RoutingConfig struct {
	// Mounting strategy
	Strategy MountStrategy `json:"strategy"`

	// Base path for mounting (used with path-based strategies)
	BasePath string `json:"base_path,omitempty"`

	// Subdomain for mounting (used with subdomain strategy)
	Subdomain string `json:"subdomain,omitempty"`

	// Path rewriting rules
	Rewrite []PathRewrite `json:"rewrite,omitempty"`

	// Strip prefix before forwarding to service
	StripPrefix bool `json:"strip_prefix,omitempty"`

	// Priority for conflict resolution (higher = higher priority)
	Priority int `json:"priority,omitempty"`

	// Tags for route grouping and filtering
	Tags []string `json:"tags,omitempty"`
}

type ScalingProfile struct {
	// Auto-scaling enabled
	AutoScale bool `json:"auto_scale"`

	// Minimum instances
	MinInstances int `json:"min_instances,omitempty"`

	// Maximum instances
	MaxInstances int `json:"max_instances,omitempty"`

	// Target CPU utilization
	TargetCPU float64 `json:"target_cpu,omitempty"` // 0.0-1.0

	// Target memory utilization
	TargetMemory float64 `json:"target_memory,omitempty"` // 0.0-1.0
}

type SchemaCache interface {
	// Get retrieves a cached schema by hash
	Get(hash string) (any, bool)

	// Set stores a schema in cache with its hash
	Set(hash string, schema any) error

	// Delete removes a schema from cache
	Delete(hash string) error

	// Clear removes all cached schemas
	Clear() error

	// Size returns the number of cached schemas
	Size() int
}

type SchemaChangeDiff struct {
	Type    SchemaType
	OldHash string
	NewHash string
}

type SchemaChangeHandler func(event *SchemaEvent)

type SchemaCompatibility struct {
	// Compatibility mode
	Mode CompatibilityMode `json:"mode"`

	// Previous schema versions (for lineage tracking)
	PreviousVersions []string `json:"previous_versions,omitempty"`

	// Breaking changes from previous version
	BreakingChanges []BreakingChange `json:"breaking_changes,omitempty"`

	// Deprecation notices
	Deprecations []Deprecation `json:"deprecations,omitempty"`
}

type SchemaDescriptor struct {
	// Type of schema (openapi, asyncapi, grpc, graphql, etc.)
	Type SchemaType `json:"type"`

	// Specification version (e.g., "3.1.0" for OpenAPI, "3.0.0" for AsyncAPI)
	SpecVersion string `json:"spec_version"`

	// How to retrieve the schema
	Location SchemaLocation `json:"location"`

	// Content type (e.g., "application/json", "application/x-protobuf")
	ContentType string `json:"content_type"`

	// Optional: Inline schema for small schemas (< 100KB recommended)
	InlineSchema any `json:"inline_schema,omitempty"`

	// Integrity validation
	Hash string `json:"hash"` // SHA256 of schema content
	Size int64  `json:"size"` // Size in bytes

	// Schema compatibility metadata
	Compatibility *SchemaCompatibility `json:"compatibility,omitempty"`

	// Protocol-specific metadata
	Metadata *ProtocolMetadata `json:"metadata,omitempty"`
}

type SchemaEndpoints struct {
	// Health check endpoint (required)
	// Example: "/health" or "/healthz"
	Health string `json:"health"`

	// Prometheus metrics endpoint (optional)
	// Example: "/metrics"
	Metrics string `json:"metrics,omitempty"`

	// OpenAPI spec endpoint (optional)
	// Example: "/openapi.json"
	OpenAPI string `json:"openapi,omitempty"`

	// AsyncAPI spec endpoint (optional)
	// Example: "/asyncapi.json"
	AsyncAPI string `json:"asyncapi,omitempty"`

	// Whether gRPC server reflection is enabled
	GRPCReflection bool `json:"grpc_reflection,omitempty"`

	// GraphQL introspection endpoint (optional)
	// Example: "/graphql"
	GraphQL string `json:"graphql,omitempty"`
}

type SchemaError struct {
	Type SchemaType
	Path string
	Err  error
}

type SchemaEvent struct {
	// Type of event (added, updated, removed)
	Type EventType

	// Path where the schema is stored
	Path string

	// The schema content (nil for removed events)
	Schema any

	// Timestamp of the event (Unix timestamp)
	Timestamp int64
}

type SchemaLocation struct {
	// Location type (http, registry, inline)
	Type LocationType `json:"type"`

	// HTTP URL (if Type == HTTP)
	// Example: "http://user-service:8080/openapi.json"
	URL string `json:"url,omitempty"`

	// Registry path in backend KV store (if Type == Registry)
	// Example: "/schemas/user-service/v1/openapi"
	RegistryPath string `json:"registry_path,omitempty"`

	// HTTP headers for authentication (if Type == HTTP)
	// Example: {"Authorization": "Bearer token"}
	Headers map[string]string `json:"headers,omitempty"`
}

type SchemaManifest struct {
	// Version of the FARP protocol (semver)
	Version string `json:"version"`

	// Service identity
	ServiceName    string `json:"service_name"`
	ServiceVersion string `json:"service_version"`
	InstanceID     string `json:"instance_id"`

	// Instance metadata
	Instance *InstanceMetadata `json:"instance,omitempty"`

	// Schemas exposed by this instance
	Schemas []SchemaDescriptor `json:"schemas"`

	// Capabilities/protocols supported (e.g., ["rest", "grpc", "websocket"])
	Capabilities []string `json:"capabilities"`

	// Endpoints for introspection and health
	Endpoints SchemaEndpoints `json:"endpoints"`

	// Routing configuration for gateway federation
	Routing RoutingConfig `json:"routing"`

	// Authentication configuration
	Auth AuthConfig `json:"auth,omitempty"`

	// Webhook for bidirectional communication
	Webhook WebhookConfig `json:"webhook,omitempty"`

	// Service operational hints (non-binding)
	Hints *ServiceHints `json:"hints,omitempty"`

	// Change tracking
	UpdatedAt int64  `json:"updated_at"` // Unix timestamp
	Checksum  string `json:"checksum"`   // SHA256 of all schemas combined
}

type SchemaProvider interface {
	// Type returns the schema type this provider generates
	Type() SchemaType

	// Generate generates a schema from the application
	// Returns the schema as interface{} (typically map[string]interface{} or struct)
	Generate(ctx context.Context, app Application) (any, error)

	// Validate validates a generated schema for correctness
	Validate(schema any) error

	// Hash calculates the SHA256 hash of a schema
	Hash(schema any) (string, error)

	// Serialize converts schema to bytes for storage/transmission
	Serialize(schema any) ([]byte, error)

	// Endpoint returns the HTTP endpoint where the schema is served
	// Returns empty string if not served via HTTP
	Endpoint() string

	// SpecVersion returns the specification version (e.g., "3.1.0" for OpenAPI)
	SpecVersion() string

	// ContentType returns the content type for the schema
	ContentType() string
}

type SchemaRegistry interface {

	// RegisterManifest registers a new schema manifest
	RegisterManifest(ctx context.Context, manifest *SchemaManifest) error

	// GetManifest retrieves a schema manifest by instance ID
	GetManifest(ctx context.Context, instanceID string) (*SchemaManifest, error)

	// UpdateManifest updates an existing schema manifest
	UpdateManifest(ctx context.Context, manifest *SchemaManifest) error

	// DeleteManifest removes a schema manifest
	DeleteManifest(ctx context.Context, instanceID string) error

	// ListManifests lists all manifests for a service name
	// Returns empty slice if serviceName is empty (list all services)
	ListManifests(ctx context.Context, serviceName string) ([]*SchemaManifest, error)

	// PublishSchema stores a schema in the registry
	// path is the registry path (e.g., "/schemas/user-service/v1/openapi")
	// schema is the schema content (typically map[string]interface{} or struct)
	PublishSchema(ctx context.Context, path string, schema any) error

	// FetchSchema retrieves a schema from the registry
	// Returns the schema as interface{} (must be type-asserted by caller)
	FetchSchema(ctx context.Context, path string) (any, error)

	// DeleteSchema removes a schema from the registry
	DeleteSchema(ctx context.Context, path string) error

	// WatchManifests watches for manifest changes for a service
	// onChange is called when a manifest is added, updated, or removed
	// Returns an error if watch setup fails
	// The watch continues until context is cancelled
	WatchManifests(ctx context.Context, serviceName string, onChange ManifestChangeHandler) error

	// WatchSchemas watches for schema changes at a specific path
	// onChange is called when the schema at path changes
	WatchSchemas(ctx context.Context, path string, onChange SchemaChangeHandler) error

	// Close closes the registry and cleans up resources
	Close() error

	// Health checks if the registry backend is healthy
	Health(ctx context.Context) error
}

type SchemaType string

type ServerVariable struct {
	// Default value
	Default string `json:"default"`

	// Enum values
	Enum []string `json:"enum,omitempty"`

	// Description
	Description string `json:"description,omitempty"`
}

type ServiceDependency struct {
	// Service name
	ServiceName string `json:"service_name"`

	// Schema type
	SchemaType SchemaType `json:"schema_type"`

	// Version requirement (semver range)
	VersionRange string `json:"version_range,omitempty"`

	// Is dependency critical for operation?
	Critical bool `json:"critical"`

	// Types/operations used from dependency
	UsedOperations []string `json:"used_operations,omitempty"`
}

type ServiceHints struct {
	// Recommended timeout for operations
	RecommendedTimeout string `json:"recommended_timeout,omitempty"`

	// Expected latency profile
	ExpectedLatency *LatencyProfile `json:"expected_latency,omitempty"`

	// Scaling characteristics
	Scaling *ScalingProfile `json:"scaling,omitempty"`

	// Dependencies on other services
	Dependencies []ServiceDependency `json:"dependencies,omitempty"`
}

type SizeHint string

type StorageBackend interface {
	// Put stores a value at the given key
	Put(ctx context.Context, key string, value []byte) error

	// Get retrieves a value by key
	// Returns ErrSchemaNotFound if key doesn't exist
	Get(ctx context.Context, key string) ([]byte, error)

	// Delete removes a key
	Delete(ctx context.Context, key string) error

	// List lists all keys with the given prefix
	List(ctx context.Context, prefix string) ([]string, error)

	// Watch watches for changes to keys with the given prefix
	// Returns a channel that receives change events
	Watch(ctx context.Context, prefix string) (<-chan StorageEvent, error)

	// Close closes the backend connection
	Close() error
}

type StorageEvent struct {
	// Type of event
	Type EventType

	// Key that changed
	Key string

	// Value (nil for delete events)
	Value []byte
}

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

type ValidationError struct {
	Field   string
	Message string
}

type VersionInfo struct {
	// Version is the full semver string
	Version string `json:"version"`

	// Major version number
	Major int `json:"major"`

	// Minor version number
	Minor int `json:"minor"`

	// Patch version number
	Patch int `json:"patch"`
}

type WebhookConfig struct {
	// Webhook endpoint on service for gateway notifications
	ServiceWebhook string `json:"service_webhook,omitempty"`

	// Webhook endpoint on gateway for service notifications
	GatewayWebhook string `json:"gateway_webhook,omitempty"`

	// Webhook secret for HMAC signature verification
	Secret string `json:"secret,omitempty"`

	// Event types service wants to receive from gateway
	SubscribeEvents []WebhookEventType `json:"subscribe_events,omitempty"`

	// Event types service will send to gateway
	PublishEvents []WebhookEventType `json:"publish_events,omitempty"`

	// Retry configuration
	Retry RetryConfig `json:"retry,omitempty"`

	// HTTP-based communication routes (alternative to push webhooks)
	HTTPRoutes *HTTPCommunicationRoutes `json:"http_routes,omitempty"`
}

type WebhookEventType string