type Attributes map[string]any

type BucketRange struct {
	Min float64
	Max float64
}

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

type ClientOption func(*Client) error

type ContextualBanditAssignment struct {
	LeafId           int       `json:"leafId"`
	VariationWeights []float64 `json:"variationWeights"`
	BanditVersion    *int      `json:"banditVersion,omitempty"`
}

type ContextualBanditContext struct {
	// LeafId is nil when the payload's leafId is absent or not an integer;
	// such a leaf cannot be attributed and demotes to the fallback.
	LeafId    *int           `json:"leafId"`
	Condition condition.Base `json:"condition"`
	// Weights is nil when the payload's weights are absent or type-malformed.
	Weights []float64 `json:"weights"`
	// contains filtered or unexported fields
}

type ContextualBanditDefinition struct {
	BanditVersion *int                      `json:"banditVersion"`
	Contexts      []ContextualBanditContext `json:"contexts"`
	// contains filtered or unexported fields
}

type ContextualBanditDefinitions map[string]ContextualBanditDefinition

type DataSource interface {
	Start(context.Context) error
	Close() error
}

type EventLogger func(ctx context.Context, eventName string, properties EventProperties, userCtx *EventUserContext)

type EventLoggerPlugin interface {
	OnEvent(ctx context.Context, eventName string, properties EventProperties, userCtx *EventUserContext)
}

type EventProperties map[string]any

type EventUserContext = TrackingUserContext

type Experiment struct {
	// The globally unique identifier for the experiment
	Key string `json:"key"`
	// The different variations to choose between
	Variations []FeatureValue `json:"variations"`
	// How to weight traffic between variations. Must add to 1.
	Weights []float64 `json:"weights"`
	// Active determines if the experiment is running. If set to false, always return the control (first variation)
	// If nil (field missing in JSON), the experiment is considered active by default.
	Active *bool `json:"active"`
	// What percent of users should be included in the experiment (between 0 and 1, inclusive)
	Coverage *float64 `json:"coverage"`
	// Array of ranges, one per variation
	Ranges []BucketRange `json:"ranges"`
	// Optional targeting condition
	Condition condition.Base `json:"condition"`
	// Each item defines a prerequisite where a condition must evaluate against a parent feature's value (identified by id).
	ParentConditions []ParentCondition `json:"parentConditions"`
	// Adds the experiment to a namespace
	Namespace *Namespace `json:"namespace"`
	// All users included in the experiment will be forced into the specific variation index
	Force *int `json:"force"`
	// What user attribute should be used to assign variations (defaults to id)
	HashAttribute string `json:"hashAttribute"`
	// When using sticky bucketing, can be used as a fallback to assign variations
	FallbackAttribute string `json:"fallbackAttribute"`
	// The hash version to use (default to 1)
	HashVersion int `json:"hashVersion"`
	// Meta info about the variations
	Meta []VariationMeta `json:"meta"`
	// Array of filters to apply
	Filters []Filter `json:"filters"`
	// The hash seed to use
	Seed string `json:"seed"`
	// Human-readable name for the experiment
	Name string `json:"name"`
	// Id of the current experiment phase
	Phase string `json:"phase"`
	// If true, sticky bucketing will be disabled for this experiment.
	// (Note: sticky bucketing is only available if a StickyBucketingService is provided in the Context)
	DisableStickyBucketing bool `json:"disableStickyBucketing"`
	// An sticky bucket version number that can be used to force a re-bucketing of users (default to 0)
	BucketVersion int `json:"bucketVersion"`
	// Any users with a sticky bucket version less than this will be excluded from the experiment
	MinBucketVersion int `json:"minBucketVersion"`
	// URL patterns to restrict where the experiment runs. Empty means no URL restriction.
	URLPatterns []URLTarget `json:"urlPatterns"`
	// Legacy URL regex to restrict where the experiment runs. Empty means no URL restriction.
	URL string `json:"url"`
	// Legacy group names — user must belong to at least one matching group (Client.WithGroups).
	// Distinct from saved groups, which power $inGroup conditions.
	Groups []string `json:"groups"`
	// Status controls eval: "draft" is skipped unless qaMode/forced, "stopped" only honors Force, "running" is normal.
	Status ExperimentStatus `json:"status"`
	// ContextualBandit is set during evaluation when a contextual bandit
	// decided this experiment's weights.
	ContextualBandit *ContextualBanditAssignment `json:"contextualBandit,omitempty"`
}

type ExperimentCallback func(context.Context, *Experiment, *ExperimentResult, *TrackingUserContext, any)

type ExperimentResult struct {
	// Whether or not the user is part of the experiment
	InExperiment bool `json:"inExperiment"`
	// The array index of the assigned variation
	VariationId int `json:"variationId"`
	// The array value of the assigned variation
	Value FeatureValue `json:"value"`
	// If a hash was used to assign a variation
	HashUsed bool `json:"hashUsed"`
	// The user attribute used to assign a variation
	HashAttribute string `json:"hashAttribute"`
	// The value of hash attribute
	HashValue string `json:"hashValue"`
	// The id of the feature (if any) that the experiment came from
	FeatureId string `json:"featureId"`
	// The unique key for the assigned variation
	Key string `json:"key"`
	// The hash value used to assign a variation (float from 0 to 1)
	Bucket *float64 `json:"bucket"`
	// The human-readable name of the assigned variation
	Name string `json:"name"`
	// Used for holdout groups
	Passthrough bool `json:"passthrough"`
	// If sticky bucketing was used to assign a variation
	StickyBucketUsed bool `json:"stickyBucketUsed"`
	// The contextual bandit leaf used for this assignment
	LeafId *int `json:"leafId,omitempty"`
	// The variation weights the contextual bandit assigned with
	VariationWeights []float64 `json:"variationWeights,omitempty"`
	// The version of the contextual bandit definition used
	BanditVersion *int `json:"banditVersion,omitempty"`
}

type ExperimentStatus string

type ExperimentSubscriber func(ctx context.Context, exp *Experiment, result *ExperimentResult)

type Feature struct {
	// DefaultValue is optional default value
	DefaultValue FeatureValue `json:"defaultValue"`
	//Rules determine when and how the [DefaultValue] gets overridden
	Rules []FeatureRule `json:"rules"`
}

type FeatureApiResponse struct {
	Status                     int                         `json:"status"`
	Features                   FeatureMap                  `json:"features"`
	DateUpdated                time.Time                   `json:"dateUpdated"`
	SavedGroups                condition.SavedGroups       `json:"savedGroups"`
	EncryptedFeatures          string                      `json:"encryptedFeatures"`
	ContextualBandits          ContextualBanditDefinitions `json:"contextualBandits"`
	EncryptedContextualBandits string                      `json:"encryptedContextualBandits"`
	SseSupport                 bool
	Etag                       string
}

type FeatureMap map[string]*Feature

type FeatureResult struct {
	RuleId           string              `json:"ruleId"`
	Value            FeatureValue        `json:"value"`
	Source           FeatureResultSource `json:"source"`
	On               bool                `json:"on"`
	Off              bool                `json:"off"`
	Experiment       *Experiment         `json:"experiment"`
	ExperimentResult *ExperimentResult   `json:"experimentResult"`
}

type FeatureResultSource string

type FeatureRule struct {
	// Optional rule id, reserved for future use
	Id string `json:"id"`
	// Optional targeting condition
	Condition condition.Base `json:"condition"`
	// Each item defines a prerequisite where a condition must evaluate against a parent feature's value (identified by id).
	// If gate is true, then this is a blocking feature-level prerequisite; otherwise it applies to the current rule only.
	ParentConditions []ParentCondition `json:"parentConditions"`
	// What percent of users should be included in the experiment (between 0 and 1, inclusive)
	Coverage *float64 `json:"coverage"`
	// Immediately force a specific value (ignore every other option besides condition and coverage)
	Force FeatureValue `json:"force"`
	// Run an experiment (A/B test) and randomly choose between these variations
	Variations []FeatureValue `json:"variations"`
	// The globally unique tracking key for the experiment (default to the feature key)
	Key string `json:"key"`
	// How to weight traffic between variations. Must add to 1.
	Weights []float64 `json:"weights"`
	// Adds the experiment to a namespace
	Namespace *Namespace `json:"namespace"`
	// What user attribute should be used to assign variations (defaults to id)
	HashAttribute string `json:"hashAttribute"`
	// When using sticky bucketing, can be used as a fallback to assign variations
	FallbackAttribute string `json:"fallbackAttribute"`
	// If true, sticky bucketing will be disabled for this experiment.
	DisableStickyBucketing bool `json:"disableStickyBucketing"`
	// The hash version to use (default to 1)
	HashVersion int `json:"hashVersion"`
	// An sticky bucket version number that can be used to force a re-bucketing of users (default to 0)
	BucketVersion int `json:"bucketVersion"`
	// Any users with a sticky bucket version less than this will be excluded from the experiment
	MinBucketVersion int `json:"minBucketVersion"`
	// A more precise version of coverage
	Range *BucketRange `json:"range"`
	// Ranges for experiment variations
	Ranges []BucketRange `json:"ranges"`
	// Meta info about the experiment variations
	Meta []VariationMeta `json:"meta"`
	// Slice of filters to apply to the rule
	Filters []Filter `json:"filters"`
	// Seed to use for hashing
	Seed string `json:"seed"`
	//Human-readable name for the experiment
	Name string `json:"name"`
	// The phase id of the experiment
	Phase string `json:"phase"`
	// Reference to a contextual bandit definition in the payload
	ContextualBanditRef string `json:"contextualBanditRef"`
	// Variations for a contextual bandit rule, carried separately from
	// Variations so SDKs without bandit support skip the rule
	ContextualVariations []FeatureValue `json:"contextualVariations"`
	// Deprecated: ignored during evaluation. Feature rules never carried URL
	// targeting in the JS SDK; use Experiment.URLPatterns with RunExperiment.
	URLPatterns []URLTarget `json:"urlPatterns"`
	// Deprecated: ignored during evaluation. Feature rules never carried URL
	// targeting in the JS SDK; use Experiment.URL with RunExperiment.
	URL string `json:"url"`
	// Deprecated: ignored during evaluation. Feature rules never carried group
	// targeting in the JS SDK; use Experiment.Groups with RunExperiment.
	Groups []string `json:"groups"`
	// Deprecated: ignored during evaluation. Feature rules never carried a
	// status in the JS SDK; use Experiment.Status with RunExperiment.
	Status ExperimentStatus `json:"status"`
	// contains filtered or unexported fields
}

type FeatureUsageCallback func(context.Context, string, *FeatureResult, any)

type FeatureValue any

type Filter struct {
	Seed        string        `json:"seed"`
	Ranges      []BucketRange `json:"ranges"`
	Attribute   string        `json:"attribute"`
	HashVersion int           `json:"hashVersion"`
}

type ForcedVariationsMap map[string]int

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

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

type Namespace struct {
	Id    string
	Start float64
	End   float64
}

type ParentCondition struct {
	Id        string         `json:"id"`
	Condition condition.Base `json:"condition"`
	Gate      bool           `json:"gate"`
}

type Plugin interface {
	// Init is called after the client is fully configured. The plugin
	// receives a reference to the client and may read configuration
	// from it (e.g., ClientKey). Returning an error marks the plugin
	// as failed; the client logs the error and continues. The client
	// will still call OnExperimentViewed, OnFeatureEvaluated, and
	// Close on a failed plugin.
	Init(client *Client) error

	// OnExperimentViewed is called when a user is included in an
	// experiment. Implementations should return quickly (e.g., by
	// enqueueing work). Panics are recovered by the caller.
	// Must be a no-op when Init returned an error.
	OnExperimentViewed(ctx context.Context, experiment *Experiment, result *ExperimentResult)

	// OnFeatureEvaluated is called every time a feature is evaluated.
	// Implementations should return quickly. Panics are recovered by
	// the caller.
	// Must be a no-op when Init returned an error.
	OnFeatureEvaluated(ctx context.Context, featureKey string, result *FeatureResult)

	// Close performs cleanup. For tracking plugins this means flushing
	// any remaining events. Close must be safe to call multiple times
	// and must be safe to call when Init returned an error.
	Close() error
}

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

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

type SseOption func(*SseDataSource)

type StickyBucketAssignmentData struct {
	Key     string
	Doc     *StickyBucketAssignmentDoc
	Changed bool
}

type StickyBucketAssignmentDoc struct {
	AttributeName  string            `json:"attributeName"`
	AttributeValue string            `json:"attributeValue"`
	Assignments    map[string]string `json:"assignments"`
}

type StickyBucketAssignments map[string]*StickyBucketAssignmentDoc

type StickyBucketAttributes map[string]string

type StickyBucketResult struct {
	Variation        int
	VersionIsBlocked bool
}

type StickyBucketService interface {
	GetAssignments(attributeName string, attributeValue string) (*StickyBucketAssignmentDoc, error)
	SaveAssignments(doc *StickyBucketAssignmentDoc) error
	GetAllAssignments(attributes map[string]string) (StickyBucketAssignments, error)
}

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

type TrackingData struct {
	Experiment *Experiment          `json:"experiment"`
	Result     *ExperimentResult    `json:"result"`
	User       *TrackingUserContext `json:"user,omitempty"`
}

type TrackingPluginConfig struct {
	// IngestorHost is the GrowthBook event ingestor endpoint.
	// Defaults to "https://us1.gb-ingest.com".
	IngestorHost string

	// BatchSize is the maximum number of events to accumulate before
	// flushing. Defaults to 100.
	BatchSize int

	// BatchTimeout is the maximum time to wait before flushing
	// accumulated events. Defaults to 10 seconds.
	BatchTimeout time.Duration

	// HTTPClient is used for sending events. If nil, the client's
	// HTTP client is used (which defaults to http.DefaultClient).
	HTTPClient *http.Client

	// Logger is used for error logging. If nil, the client's logger
	// is used.
	Logger *slog.Logger
}

type TrackingUserContext struct {
	Attributes Attributes `json:"attributes"`
	URL        string     `json:"url,omitempty"`
}

type URLTarget struct {
	Type    URLTargetType `json:"type"`
	Pattern string        `json:"pattern"`
	Include *bool         `json:"include"`
}

type URLTargetType string

type VariationMeta struct {
	// Key is a unique key for this variation.
	Key string `json:"key"`
	// Name is a human-readable name for this variation.
	Name string `json:"name"`
	// Passthrough used to implement holdout groups
	Passthrough bool `json:"passthrough"`
}