featuremanagement

type ClientFilter struct {
	// Name is the identifier for this filter type
	Name string `json:"name"`
	// Parameters are the configuration values for the filter
	Parameters map[string]any `json:"parameters,omitempty"`
}

type Conditions struct {
	// RequirementType determines if any or all filters must be satisfied
	// Values: "Any" or "All"
	RequirementType RequirementType `json:"requirement_type,omitempty"`
	// ClientFilters are the filter conditions that must be evaluated by the client
	ClientFilters []ClientFilter `json:"client_filters,omitempty"`
}

type EvaluationResult struct {
	// Feature contains the evaluated feature flag
	Feature *FeatureFlag
	// Enabled indicates the final state of the feature after evaluation
	Enabled bool
	// TargetingID is the identifier used for consistent targeting
	TargetingID string
	// Variant is the selected variant (if any)
	Variant *Variant
	// VariantAssignmentReason explains why the variant was assigned
	VariantAssignmentReason VariantAssignmentReason
}

type FeatureFilter interface {
	// Name returns the identifier for this filter
	Name() string

	// Evaluate determines whether a feature should be enabled based on the provided contexts
	Evaluate(evalCtx FeatureFilterEvaluationContext, appCtx any) (bool, error)
}

type FeatureFilterEvaluationContext struct {
	// FeatureName is the name of the feature being evaluated
	FeatureName string

	// Parameters contains the filter-specific configuration parameters
	Parameters map[string]any
}

type FeatureFlag struct {
	// ID uniquely identifies the feature
	ID string `json:"id"`
	// Description provides details about the feature's purpose
	Description string `json:"description,omitempty"`
	// DisplayName is a human-friendly name for display purposes
	DisplayName string `json:"display_name,omitempty"`
	// Enabled indicates if the feature is on or off
	Enabled bool `json:"enabled"`
	// Conditions defines when the feature should be dynamically enabled
	Conditions *Conditions `json:"conditions,omitempty"`
	// Variants represents different configurations of this feature
	Variants []VariantDefinition `json:"variants,omitempty"`
	// Allocation determines how variants are assigned to users
	Allocation *VariantAllocation `json:"allocation,omitempty"`
	// Telemetry contains feature flag telemetry configuration
	Telemetry *Telemetry `json:"telemetry,omitempty"`
}

type FeatureFlagProvider interface {
	// GetFeatureFlag retrieves a specific feature flag by its name.
	//
	// Parameters:
	//   - name: The name of the feature flag to retrieve
	//
	// Returns:
	//   - FeatureFlag: The feature flag if found
	//   - error: An error if the feature flag cannot be found or retrieved
	GetFeatureFlag(name string) (FeatureFlag, error)

	// GetFeatureFlags retrieves all available feature flags.
	//
	// Returns:
	//   - []FeatureFlag: A slice of all available feature flags
	//   - error: An error if the feature flags cannot be retrieved
	GetFeatureFlags() ([]FeatureFlag, error)
}

type FeatureManagement struct {
	FeatureFlags []FeatureFlag `json:"feature_flags"`
}

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

type GroupAllocation struct {
	// Variant is the name of the variant to use
	Variant string `json:"variant"`
	// Groups is the collection of group IDs to apply this variant to
	Groups []string `json:"groups"`
}

type Options struct {
	// Filters is a list of custom feature filters that will be used during feature flag evaluation.
	// Each filter must implement the FeatureFilter interface.
	Filters []FeatureFilter
}

type PercentileAllocation struct {
	// Variant is the name of the variant to use
	Variant string `json:"variant"`
	// From is the lower end of the percentage range (0-100)
	From float64 `json:"from"`
	// To is the upper end of the percentage range (0-100)
	To float64 `json:"to"`
}

type RequirementType string

type StatusOverride string

type TargetingAudience struct {
	DefaultRolloutPercentage float64
	Users                    []string
	Groups                   []TargetingGroup
	Exclusion                *TargetingExclusion
}

type TargetingContext struct {
	// UserID is the identifier for targeting specific users
	UserID string

	// Groups are the groups the user belongs to for group targeting
	Groups []string
}

type TargetingExclusion struct {
	Users  []string
	Groups []string
}

type TargetingFilter struct{}

type TargetingFilterParameters struct {
	Audience TargetingAudience
}

type TargetingGroup struct {
	Name              string
	RolloutPercentage float64
}

type Telemetry struct {
	// Enabled indicates if telemetry is enabled for this feature
	Enabled bool `json:"enabled,omitempty"`
	// Metadata contains additional data to include with telemetry
	Metadata map[string]string `json:"metadata,omitempty"`
}

type TimeWindowFilter struct{}

type TimeWindowFilterParameters struct {
	Start string `json:"start,omitempty"`
	End   string `json:"end,omitempty"`
}

type UserAllocation struct {
	// Variant is the name of the variant to use
	Variant string `json:"variant"`
	// Users is the collection of user IDs to apply this variant to
	Users []string `json:"users"`
}

type Variant struct {
	// Name uniquely identifies this variant
	Name string

	// ConfigurationValue holds the value for this variant
	ConfigurationValue any
}

type VariantAllocation struct {
	// DefaultWhenDisabled specifies which variant to use when feature is disabled
	DefaultWhenDisabled string `json:"default_when_disabled,omitempty"`
	// DefaultWhenEnabled specifies which variant to use when feature is enabled
	DefaultWhenEnabled string `json:"default_when_enabled,omitempty"`
	// User defines variant assignments for specific users
	User []UserAllocation `json:"user,omitempty"`
	// Group defines variant assignments for user groups
	Group []GroupAllocation `json:"group,omitempty"`
	// Percentile defines variant assignments by percentage ranges
	Percentile []PercentileAllocation `json:"percentile,omitempty"`
	// Seed is used to ensure consistent percentile calculations across features
	Seed string `json:"seed,omitempty"`
}

type VariantAssignmentReason string

type VariantDefinition struct {
	// Name uniquely identifies this variant
	Name string `json:"name"`
	// ConfigurationValue holds the value for this variant
	ConfigurationValue any `json:"configuration_value,omitempty"`
	// StatusOverride overrides the enabled state of the feature when this variant is assigned
	// Values: "None", "Enabled", "Disabled"
	StatusOverride StatusOverride `json:"status_override,omitempty"`
}