configcat

type BoolEvaluationDetails struct {
	Data  EvaluationDetailsData
	Value bool
}

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

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

type Comparator uint8

type Condition struct {
	// UserCondition describes a condition that works with User Object attributes.
	UserCondition *UserCondition `json:"u"`
	// UserCondition describes a condition that works with a segment.
	SegmentCondition *SegmentCondition `json:"s"`
	// UserCondition describes a condition that works with a prerequisite flag.
	PrerequisiteFlagCondition *PrerequisiteFlagCondition `json:"p"`
}

type Config struct {
	// SDKKey holds the key for the SDK. This parameter
	// is mandatory.
	SDKKey string

	// Logger is used to log information about configuration evaluation
	// and issues. If it's nil, DefaultLogger() will be used.
	// It assumes that the logging level will not be increased
	// during the lifetime of the client.
	Logger Logger

	// LogLevel determines the logging verbosity.
	LogLevel LogLevel

	// Cache is used to cache configuration values.
	// If it's nil, no caching will be done.
	Cache ConfigCache

	// BaseURL holds the URL of the ConfigCat CDN server.
	// If this is empty, an appropriate URL will be chosen
	// based on the DataGovernance parameter.
	BaseURL string

	// Transport is used as the HTTP transport for
	// requests to the CDN. If it's nil, http.DefaultTransport
	// will be used.
	Transport http.RoundTripper

	// HTTPTimeout holds the timeout for HTTP requests
	// made by the client. If it's zero, DefaultHTTPTimeout
	// will be used. If it's negative, no timeout will be
	// used.
	HTTPTimeout time.Duration

	// PollingMode specifies how the configuration is refreshed.
	// The zero value (default) is AutoPoll.
	PollingMode PollingMode

	// NoWaitForRefresh specifies that a Client get method (GetBoolValue,
	// GetIntValue, GetFloatValue, GetStringValue) should never wait for a
	// configuration refresh to complete before returning.
	//
	// By default, when this is false, if PollingMode is AutoPoll,
	// the first request may block, and if PollingMode is Lazy, any
	// request may block.
	NoWaitForRefresh bool

	// PollInterval specifies how old a configuration can
	// be before it's considered stale. If this is less
	// than 1, DefaultPollInterval is used.
	//
	// This parameter is ignored when PollingMode is Manual.
	PollInterval time.Duration

	// DataGovernance specifies the data governance mode.
	// Set this parameter to be in sync with the Data Governance
	// preference on the Dashboard at
	// https://app.configcat.com/organization/data-governance
	// (only Organization Admins have access).
	// The default is Global.
	DataGovernance DataGovernance

	// DefaultUser holds the default user information to associate
	// with the Flagger, used whenever a nil User is passed.
	// This usually won't contain user-specific
	// information, but it may be useful when feature flags are dependent
	// on attributes of the current machine or similar. It's somewhat
	// more efficient to use DefaultUser=u than to call flagger.Snapshot(u)
	// on every feature flag evaluation.
	DefaultUser User

	// FlagOverrides holds the feature flag and setting overrides.
	FlagOverrides *FlagOverrides

	// Hooks controls the events sent by Client.
	Hooks *Hooks

	// Offline indicates whether the SDK should be initialized in offline mode or not.
	Offline bool
}

type ConfigCache interface {
	// Get reads the configuration from the cache.
	Get(ctx context.Context, key string) ([]byte, error)
	// Set writes the configuration into the cache.
	Set(ctx context.Context, key string, value []byte) error
}

type ConfigJson struct {
	// Settings is the map of the available feature flags and settings.
	Settings map[string]*Setting `json:"f"`
	// Segments is the list of available segments.
	Segments []*Segment `json:"s"`
	// Preferences contains additional metadata.
	Preferences *Preferences `json:"p"`
}

type DataGovernance int

type ErrConfigJsonMissing struct {
	Key string
}

type ErrKeyNotFound struct {
	Key           string
	AvailableKeys []string
}

type ErrSettingTypeMismatch struct {
	Key          string
	Value        interface{}
	ExpectedType string
}

type EvaluationDetails struct {
	Data  EvaluationDetailsData
	Value interface{}
}

type EvaluationDetailsData struct {
	Key                     string
	VariationID             string
	User                    User
	IsDefaultValue          bool
	Error                   error
	FetchTime               time.Time
	MatchedTargetingRule    *TargetingRule
	MatchedPercentageOption *PercentageOption
}

type Flag interface {
	// Key returns the flag's key.
	Key() string

	// GetValue returns the flag's value. It will always
	// return the appropriate type for the flag (never nil).
	GetValue(snap *Snapshot) interface{}

	// GetValueDetails returns the evaluation details
	// along with the flag's value. Its Value field always
	// have the appropriate type for the flag.
	GetValueDetails(snap *Snapshot) EvaluationDetails
}

type FlagOverrides struct {
	// Behavior describes how the overrides should behave. Default is LocalOnly.
	Behavior OverrideBehavior

	// Values is a map that contains the overrides.
	// Each value must be one of the following types: bool, int, float64, or string.
	Values map[string]interface{}

	// FilePath is the path to a JSON file that contains the overrides.
	// The supported JSON file formats are documented here: https://configcat.com/docs/sdk-reference/go/#json-file-structure
	FilePath string
	// contains filtered or unexported fields
}

type FloatEvaluationDetails struct {
	Data  EvaluationDetailsData
	Value float64
}

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

type Hooks struct {
	// OnFlagEvaluated is called each time when the SDK evaluates a feature flag or setting.
	OnFlagEvaluated func(details *EvaluationDetails)

	// OnError is called when an error occurs inside the ConfigCat SDK.
	OnError func(err error)

	// OnConfigChanged is called, when a new config.json has downloaded.
	OnConfigChanged func()
}

type IntEvaluationDetails struct {
	Data  EvaluationDetailsData
	Value int
}

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

type LogLevel int

type Logger interface {
	Debugf(format string, args ...interface{})
	Infof(format string, args ...interface{})
	Warnf(format string, args ...interface{})
	Errorf(format string, args ...interface{})
}

type OverrideBehavior int

type PercentageOption struct {
	// Value is the served value of the percentage option.
	Value *SettingValue `json:"v"`
	// Percentage is a number between 0 and 100 that represents a randomly allocated fraction of the users.
	Percentage int64 `json:"p"`
	// VariationID of the percentage option.
	VariationID string `json:"i"`
	// contains filtered or unexported fields
}

type PollingMode int

type Preferences struct {
	// Salt is used to hash sensitive comparison values.
	Salt     string           `json:"s"`
	URL      string           `json:"u"`
	Redirect *RedirectionKind `json:"r"` // NoRedirect, ShouldRedirect or ForceRedirect
	// contains filtered or unexported fields
}

type PrerequisiteComparator uint8

type PrerequisiteFlagCondition struct {
	// FlagKey is the key of the prerequisite flag that the condition is based on.
	FlagKey string `json:"f"`
	// Comparator is the operator which defines the relation between the evaluated value of the prerequisite flag and the comparison value.
	Comparator PrerequisiteComparator `json:"c"`
	// Value that the evaluated value of the prerequisite flag is compared to.
	Value *settingValueJson `json:"v"`
	// contains filtered or unexported fields
}

type RedirectionKind uint8

type Segment struct {
	// Name is the first 4 characters of the Segment's name
	Name string `json:"n"`
	// Conditions is the list of segment rule conditions (has a logical AND relation between the items).
	Conditions []*UserCondition `json:"r"`
	// contains filtered or unexported fields
}

type SegmentComparator uint8

type SegmentCondition struct {
	// Index identifies the segment that the condition is based on.
	Index int `json:"s"`
	// Comparator is the operator which defines the expected result of the evaluation of the segment.
	Comparator SegmentComparator `json:"c"`
	// contains filtered or unexported fields
}

type ServedValue struct {
	// Value is the value associated with the targeting rule or nil if the targeting rule has percentage options THEN part.
	Value *SettingValue `json:"v"`
	// VariationID of the targeting rule.
	VariationID string `json:"i"`
	// contains filtered or unexported fields
}

type Setting struct {
	// PercentageOptionsAttribute is the User Object attribute which serves as the basis of percentage options evaluation.
	PercentageOptionsAttribute string `json:"a"`
	// VariationID is the variation ID.
	VariationID string `json:"i"`
	// Value holds the setting's default value used when no targeting rules are matching during an evaluation process.
	Value *SettingValue `json:"v"`
	// Type describes the setting's type. It can be BoolSetting, StringSetting, IntSetting, FloatSetting
	Type SettingType `json:"t"`
	// TargetingRules is the list of targeting rules (where there is a logical OR relation between the items).
	TargetingRules []*TargetingRule `json:"r"`
	// PercentageOptions is the list of percentage options.
	PercentageOptions []*PercentageOption `json:"p"`
	// contains filtered or unexported fields
}

type SettingType int8

type SettingValue struct {
	// Value holds the feature flag's value.
	Value interface{}
	// contains filtered or unexported fields
}

type SimplifiedConfig struct {
	Flags map[string]interface{} `json:"flags"`
}

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

type StringEvaluationDetails struct {
	Data  EvaluationDetailsData
	Value string
}

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

type TargetingRule struct {
	// ServedValue is the value associated with the targeting rule or nil if the targeting rule has percentage options THEN part.
	ServedValue *ServedValue `json:"s"`
	// Conditions is the list of conditions that are combined with the AND logical operator.
	Conditions []*Condition `json:"c"`
	// PercentageOptions is the list of percentage options associated with the targeting rule or nil if the targeting rule has a served value THEN part.
	PercentageOptions []*PercentageOption `json:"p"`
}

type User interface{}

type UserAttributes interface {
	GetAttribute(attr string) interface{}
}

type UserCondition struct {
	// ComparisonAttribute is a User Object attribute that the condition is based on. Can be "Identifier", "Email", "Country" or any custom attribute.
	ComparisonAttribute string `json:"a"`
	// StringValue is a value in text format that the User Object attribute is compared to.
	StringValue *string `json:"s"`
	// DoubleValue is a value in numeric format that the User Object attribute is compared to.
	DoubleValue *float64 `json:"d"`
	// StringArrayValue is a value in text array format that the User Object attribute is compared to.
	StringArrayValue []string `json:"l"`
	// Comparator is the operator which defines the relation between the comparison attribute and the comparison value.
	Comparator Comparator `json:"c"`
}

type UserData struct {
	Identifier string
	Email      string
	Country    string
	Custom     map[string]interface{}
}