posthog

type APIError struct {
	// StatusCode is the HTTP status code returned by the PostHog API.
	StatusCode int
	// Message is the error message returned by or derived from the API response.
	Message string
}

type APIMessage interface{}

type Alias struct {
	// Type is reserved for SDK serialization and is overwritten by Enqueue.
	Type string
	// Uuid is an optional event UUID. If empty, Enqueue generates a random UUID.
	Uuid string

	// Alias is the alternate distinct ID to attach to DistinctId.
	Alias string
	// DistinctId is the existing user distinct ID that Alias should resolve to.
	DistinctId string
	// Timestamp is the event timestamp. If zero, Enqueue uses the current time.
	Timestamp time.Time
	// DisableGeoIP controls whether this alias event disables GeoIP lookup.
	// Enqueue overwrites it from Config.GetDisableGeoIP.
	DisableGeoIP bool
}

type AliasInApi struct {
	// Type is the message type sent to the batch API.
	Type string `json:"type"`
	// Uuid is the event UUID sent to the batch API.
	Uuid string `json:"uuid"`
	// Library is the SDK name sent to the batch API.
	Library string `json:"library"`
	// LibraryVersion is the SDK version sent to the batch API.
	LibraryVersion string `json:"library_version"`
	// Timestamp is the event timestamp sent to the batch API.
	Timestamp time.Time `json:"timestamp"`

	// Properties contains alias-specific event properties.
	Properties AliasInApiProperties `json:"properties"`

	// Event is always $create_alias for Alias messages.
	Event string `json:"event"`
}

type AliasInApiProperties struct {

	// DistinctId is the canonical user distinct ID.
	DistinctId string `json:"distinct_id"`
	// Alias is the alternate distinct ID being linked to DistinctId.
	Alias string `json:"alias"`
	// Lib is the SDK name sent as $lib.
	Lib string `json:"$lib"`
	// LibVersion is the SDK version sent as $lib_version.
	LibVersion string `json:"$lib_version"`
	// DisableGeoIP is sent as $geoip_disable when GeoIP lookup is disabled.
	DisableGeoIP bool `json:"$geoip_disable,omitempty"`
	// contains filtered or unexported fields
}

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

type Callback interface {

	// Success is called for every message that was successfully sent to the API.
	Success(APIMessage)

	// Failure is called for every message that failed to be sent to the API and
	// will be discarded by the client. The error describes the send or serialization failure.
	Failure(APIMessage, error)
}

type Capture struct {
	// Type is reserved for SDK serialization and is overwritten by Enqueue.
	Type string
	// Uuid is an optional event UUID. If empty, Enqueue generates a random UUID.
	// Set it only when you need idempotency, for example to prevent duplicate events.
	Uuid string
	// DistinctId identifies the user or entity that performed Event.
	// When using EnqueueWithContext, this can be inherited from RequestContext.
	DistinctId string
	// Event is the event name to capture. It must be non-empty.
	Event string
	// Timestamp is the event timestamp. If zero, Enqueue uses the current time.
	Timestamp time.Time
	// Properties are event properties. Enqueue merges request context properties
	// and Config.DefaultEventProperties into this map before sending.
	Properties Properties
	// Groups associates the event with group analytics groups.
	Groups Groups
	// SendFeatureFlags requests legacy feature flag enrichment on this event.
	// Deprecated: Prefer Client.EvaluateFlags and pass the returned snapshot via Flags.
	SendFeatureFlags SendFeatureFlagsValue
	// Flags, when set, attaches $feature/<key> and $active_feature_flags
	// properties from a snapshot returned by Client.EvaluateFlags. It is
	// preferred over SendFeatureFlags: the snapshot guarantees the event
	// carries the exact values the application branched on and avoids a
	// hidden /flags request on every capture. Flags takes precedence when
	// both are set.
	Flags *FeatureFlagEvaluations
}

type CaptureInApi struct {
	// Type is the message type sent to the batch API.
	Type string `json:"type"`
	// Uuid is the event UUID sent to the batch API.
	Uuid string `json:"uuid"`
	// Library is the SDK name sent to the batch API.
	Library string `json:"library"`
	// LibraryVersion is the SDK version sent to the batch API.
	LibraryVersion string `json:"library_version"`
	// Timestamp is the event timestamp sent to the batch API.
	Timestamp time.Time `json:"timestamp"`

	// DistinctId identifies the user or entity for the event.
	DistinctId string `json:"distinct_id"`
	// Event is the captured event name.
	Event string `json:"event"`
	// Properties contains event, SDK, system, group, and feature flag properties.
	Properties Properties `json:"properties"`
	// SendFeatureFlags carries the legacy send_feature_flags value for compatibility.
	SendFeatureFlags SendFeatureFlagsValue `json:"send_feature_flags"`
}

type Client interface {
	EnqueueClient

	// Close gracefully shuts down the client and flushes pending messages.
	// If Config.ShutdownTimeout is positive, Close uses it as the shutdown deadline;
	// otherwise it waits indefinitely. Repeated calls return ErrClosed.
	Close() error

	// IsFeatureEnabled evaluates one feature flag for a user and returns the same
	// value as GetFeatureFlag: a variant string for multivariate flags or a bool
	// for boolean flags. The FeatureFlagPayload parameter supplies the flag key,
	// distinct ID, optional groups/properties, and evaluation options.
	// Deprecated: Prefer EvaluateFlags for new code.
	IsFeatureEnabled(FeatureFlagPayload) (interface{}, error)

	// GetFeatureFlag evaluates one feature flag for a user. It returns a variant
	// string for multivariate flags, true or false for boolean flags, false with
	// nil error when the flag is missing/disabled, and an error for evaluation failures.
	// Deprecated: Prefer EvaluateFlags for new code.
	GetFeatureFlag(FeatureFlagPayload) (interface{}, error)

	// GetFeatureFlagResult evaluates one feature flag and returns its value and payload together.
	// Use this instead of calling GetFeatureFlag and GetFeatureFlagPayload separately.
	// It returns ErrFlagNotFound when the flag cannot be found or evaluated and
	// ErrNoPersonalAPIKey when OnlyEvaluateLocally is true without PersonalApiKey.
	GetFeatureFlagResult(FeatureFlagPayload) (*FeatureFlagResult, error)

	// GetFeatureFlagPayload returns the payload for the matching flag value, or an
	// empty string when no payload is configured or the flag is missing/disabled.
	// Deprecated: Use GetFeatureFlagResult instead, which returns both the flag value
	// and payload while properly tracking feature flag usage.
	GetFeatureFlagPayload(FeatureFlagPayload) (string, error)

	// GetRemoteConfigPayload returns the decrypted payload for a remote config flag key.
	// It requires Config.PersonalApiKey and returns ErrNoPersonalAPIKey when missing.
	GetRemoteConfigPayload(string) (string, error)

	// GetAllFlags evaluates all flags for a user. Returned values are booleans for
	// boolean flags and strings for multivariate variants. It returns ErrNoPersonalAPIKey
	// when OnlyEvaluateLocally is true without PersonalApiKey.
	GetAllFlags(FeatureFlagPayloadNoKey) (map[string]interface{}, error)

	// EvaluateFlags returns a snapshot of feature-flag evaluations for the
	// given distinct_id using at most one /flags request. Returns ErrNoDistinctID
	// if DistinctId is empty. Pass the returned snapshot to a Capture event via
	// Capture.Flags to attach $feature/<key> properties without another network call.
	// Calls to IsEnabled and GetFlag
	// on the snapshot fire deduped $feature_flag_called events; GetFlagPayload
	// does not.
	//
	// If the remote /flags request fails after some flags were resolved
	// locally, EvaluateFlags returns a non-nil snapshot containing the
	// locally-evaluated flags alongside the error so the caller can still
	// branch on what was resolved.
	// If OnlyEvaluateLocally is true and no PersonalApiKey is configured, returns ErrNoPersonalAPIKey.
	EvaluateFlags(EvaluateFlagsPayload) (*FeatureFlagEvaluations, error)

	// ReloadFeatureFlags forces a reload of feature flags.
	// If no PersonalApiKey is configured, returns ErrNoPersonalAPIKey.
	ReloadFeatureFlags() error

	// CloseWithContext gracefully shuts down the client with the provided context.
	// The context can be used to control the shutdown deadline.
	CloseWithContext(context.Context) error
}

type CommonResponseFields struct {
	// QuotaLimited lists quota-limited resources returned by the API.
	QuotaLimited []string `json:"quota_limited"`
	// RequestId is the API request identifier for tracing flag evaluation.
	RequestId string `json:"requestId"`
	// EvaluatedAt is the server evaluation timestamp, when returned.
	EvaluatedAt *int64 `json:"evaluatedAt"`
	// ErrorsWhileComputingFlags reports whether the server had errors computing any flags.
	ErrorsWhileComputingFlags bool `json:"errorsWhileComputingFlags"`
}

type CompressionMode uint8

type Config struct {

	// Endpoint is the PostHog API host used for event ingestion and feature flag requests.
	// If empty, it defaults to DefaultEndpoint.
	Endpoint string

	// PersonalApiKey enables local feature flag evaluation, remote config payloads,
	// and lower-latency flag APIs. If empty, feature flag methods fall back to the
	// /flags endpoint unless the method requires local-only behavior.
	// See https://posthog.com/docs/api/overview for how to create a personal API key.
	PersonalApiKey string

	// DisableGeoIP controls whether event and feature flag requests include
	// $geoip_disable/geoip_disable. Nil defaults to true because this SDK usually
	// runs server-side; set Ptr(false) to allow GeoIP lookup.
	DisableGeoIP *bool

	// Interval is the flush interval for queued messages. Messages are sent when
	// BatchSize is reached or when this timer fires. If zero, it defaults to
	// DefaultInterval.
	Interval time.Duration

	// DefaultFeatureFlagsPollingInterval is the interval for reloading local feature
	// flag definitions when PersonalApiKey is configured. If zero, it defaults to
	// DefaultFeatureFlagsPollingInterval.
	DefaultFeatureFlagsPollingInterval time.Duration

	// FeatureFlagRequestTimeout is the timeout for feature flag and remote config
	// HTTP requests. If zero, it defaults to DefaultFeatureFlagRequestTimeout.
	// Use time.Duration values such as 3 * time.Second.
	FeatureFlagRequestTimeout time.Duration

	// NextFeatureFlagsPollingTick optionally calculates the next local feature flag
	// polling delay. When set, it overrides DefaultFeatureFlagsPollingInterval.
	NextFeatureFlagsPollingTick func() time.Duration

	// HistoricalMigration marks captured batches as historical migration traffic.
	// See https://posthog.com/docs/migrate for migration guidance.
	HistoricalMigration bool

	// Transport is the HTTP transport used by the client. Set it to customize
	// low-level request behavior such as connection pooling or proxies. If nil,
	// the client uses a clone of http.DefaultTransport with SDK defaults.
	Transport http.RoundTripper

	// Logger receives informational, warning, and error messages from background
	// operations. If nil, the client logs to os.Stderr with the standard logger.
	Logger Logger

	// DefaultEventProperties are merged into every Capture event before sending.
	// They are useful for common metadata like service name or app version. On key
	// conflicts, values from DefaultEventProperties overwrite event properties.
	DefaultEventProperties Properties

	// Callback receives success or failure notifications for messages sent to the
	// PostHog batch API.
	Callback Callback

	// BatchSize is the maximum number of messages sent in one batch API call.
	// Messages are sent when BatchSize is reached or when Interval fires. If zero,
	// it defaults to DefaultBatchSize. The API still enforces a 500KB request limit.
	BatchSize int

	// Verbose enables more frequent and detailed debug logging through Logger.
	Verbose bool

	// RetryAfter returns the delay before retrying a failed batch upload. The int
	// argument is the retry attempt number. If nil, DefaultBackoff().Duration is used.
	RetryAfter func(int) time.Duration

	// MaxRetries is the maximum number of retries after the first send attempt.
	// It must be in [0,9]. If nil, it defaults to 9 retries (10 total attempts).
	MaxRetries *int

	// ShutdownTimeout is the maximum time Close waits for in-flight messages to be
	// sent. If zero or negative, Close waits indefinitely for backward compatibility.
	ShutdownTimeout time.Duration

	// BatchUploadTimeout is the timeout for uploading one batch to the /batch/
	// endpoint. If zero, it defaults to DefaultBatchUploadTimeout.
	BatchUploadTimeout time.Duration

	// BatchSubmitTimeout is the maximum time to wait when submitting a batch to the
	// worker pool while its queue is full. If zero, it defaults to
	// DefaultBatchSubmitTimeout. Set a negative duration for non-blocking behavior
	// that drops immediately when the queue is full.
	BatchSubmitTimeout time.Duration

	// MaxEnqueuedRequests is the maximum number of batches waiting for upload.
	// When the queue is full, new batches are dropped and the failure callback is
	// invoked. If zero, it defaults to DefaultMaxEnqueuedRequests.
	MaxEnqueuedRequests int

	// Compression selects the compression mode for batch payloads. CompressionGzip
	// compresses payloads and adds the appropriate headers/query params. If zero,
	// it defaults to CompressionNone.
	Compression CompressionMode
	// contains filtered or unexported fields
}

type ConfigError struct {

	// A human-readable message explaining why the configuration field's value
	// is invalid.
	Reason string

	// The name of the configuration field that was carrying an invalid value.
	Field string

	// The value of the configuration field that caused the error.
	Value interface{}
}

type DecideRequestData struct {
	// ApiKey is the PostHog project API key.
	ApiKey string `json:"api_key"`
	// DistinctId is the user distinct ID to evaluate flags for.
	DistinctId string `json:"distinct_id"`
	// Groups contains group identifiers for group-targeted flags.
	Groups Groups `json:"groups"`
	// PersonProperties overrides person properties for this evaluation.
	PersonProperties Properties `json:"person_properties"`
	// GroupProperties overrides group properties for this evaluation, keyed by group type.
	GroupProperties map[string]Properties `json:"group_properties"`
}

type DecideResponse struct {
	// FeatureFlags contains evaluated flag values keyed by flag key.
	FeatureFlags map[string]interface{} `json:"featureFlags"`
	// FeatureFlagPayloads contains raw payloads keyed by flag key.
	FeatureFlagPayloads map[string]json.RawMessage `json:"featureFlagPayloads"`
}

type DefaultStackTraceExtractor struct {
	// InAppDecider decides whether each runtime frame is application code.
	// Set it to SimpleInAppDecider or another non-nil function before use.
	InAppDecider InAppDecider
}

type DescriptionExtractor interface {
	// ExtractDescription returns the ExceptionItem.Value to use for a slog record.
	ExtractDescription(r slog.Record) string
}

type EnqueueClient interface {
	// Enqueue queues a message to be sent by the client when the conditions for a batch
	// upload are met.
	// This is the main method you'll be using, a typical flow would look like
	// this:
	//
	//	client := posthog.New(apiKey)
	//	...
	//	client.Enqueue(posthog.Capture{ ... })
	//	...
	//	client.Close()
	//
	// Enqueue returns an error if the message could not be queued, which happens
	// when the client is closed or the message is invalid.
	Enqueue(Message) error
}

type ErrorExtractor struct {
	// ErrorKeys are attribute keys to inspect for error values, case-insensitively.
	ErrorKeys []string
	// Fallback is returned when no matching error attribute is found.
	Fallback string
}

type EvaluateFlagsPayload struct {
	// DistinctId is the user distinct ID to evaluate flags for. It is required
	// unless EvaluateFlagsWithContext can read one from RequestContext.
	DistinctId string
	// DeviceId optionally provides a device_id for remote /flags requests and event deduplication.
	DeviceId *string
	// Groups supplies group identifiers for group-targeted flags.
	Groups Groups
	// PersonProperties overrides person properties used during flag evaluation.
	PersonProperties Properties
	// GroupProperties overrides group properties used during flag evaluation, keyed by group type.
	GroupProperties map[string]Properties
	// OnlyEvaluateLocally prevents fallback to remote /flags requests.
	OnlyEvaluateLocally bool
	// DisableGeoIP, when non-nil, overrides the client-level DisableGeoIP for
	// this evaluation only.
	DisableGeoIP *bool
	// FlagKeys, when non-empty, trims the network call by asking the server
	// to evaluate only the named flags (sent as flag_keys_to_evaluate).
	// This is server-side filtering; use FeatureFlagEvaluations.Only to do
	// client-side filtering of which flags are attached to events from an
	// existing snapshot.
	FlagKeys []string
}

type Exception struct {
	// Type is reserved for SDK serialization and is overwritten by Enqueue.
	Type string
	// Uuid is an optional event UUID. If empty, Enqueue generates a random UUID.
	Uuid string

	// DistinctId identifies the user or entity associated with the exception.
	// When using EnqueueWithContext, this can be inherited from RequestContext.
	DistinctId string
	// Timestamp is the event timestamp. If zero, Enqueue uses the current time.
	Timestamp time.Time
	// Properties are custom event properties flattened into the exception event.
	Properties Properties
	// DisableGeoIP controls whether this exception event disables GeoIP lookup.
	// Enqueue overwrites it from Config.GetDisableGeoIP.
	DisableGeoIP bool

	// ExceptionList is the list of exception items sent as $exception_list. It must be non-empty.
	ExceptionList []ExceptionItem
	// ExceptionFingerprint optionally overrides PostHog's default exception grouping fingerprint.
	ExceptionFingerprint *string
}

type ExceptionInApi struct {
	// Type is the message type sent to the batch API.
	Type string `json:"type"`
	// Uuid is the event UUID sent to the batch API.
	Uuid string `json:"uuid"`
	// Library is the SDK name sent to the batch API.
	Library string `json:"library"`
	// LibraryVersion is the SDK version sent to the batch API.
	LibraryVersion string `json:"library_version"`
	// Timestamp is the event timestamp sent to the batch API.
	Timestamp time.Time `json:"timestamp"`
	// Event is always $exception for Exception messages.
	Event string `json:"event"`
	// Properties contains built-in and custom exception properties.
	Properties ExceptionInApiProperties `json:"properties"`
}

type ExceptionInApiProperties struct {

	// Lib is the SDK name sent as $lib.
	Lib string `json:"$lib"`
	// LibVersion is the SDK version sent as $lib_version.
	LibVersion string `json:"$lib_version"`
	// DistinctId is the user distinct ID associated with the exception.
	DistinctId string `json:"distinct_id"`
	// DisableGeoIP is sent as $geoip_disable when GeoIP lookup is disabled.
	DisableGeoIP bool `json:"$geoip_disable,omitempty"`
	// ExceptionList is sent as $exception_list.
	ExceptionList []ExceptionItem `json:"$exception_list"`
	// ExceptionFingerprint is sent as $exception_fingerprint when provided.
	ExceptionFingerprint *string `json:"$exception_fingerprint,omitempty"`

	// Custom is flattened into the wire "properties" on marshal.
	// Typed fields win on collision.
	Custom Properties `json:"-"`
	// contains filtered or unexported fields
}

type ExceptionItem struct {
	// Type is rendered as the exception title in the PostHog UI.
	Type string `json:"type"`
	// Value is rendered as the exception description in the PostHog UI.
	Value string `json:"value"`
	// Mechanism describes how the exception was produced or handled.
	Mechanism *ExceptionMechanism `json:"mechanism,omitempty"`
	// Stacktrace contains stack frames for the exception. Use StackTraceExtractor to generate it.
	Stacktrace *ExceptionStacktrace `json:"stacktrace,omitempty"`
}

type ExceptionMechanism struct {
	// Handled reports whether the exception was handled by application code.
	Handled *bool `json:"handled,omitempty"`
	// Synthetic reports whether the exception was synthesized by instrumentation.
	Synthetic *bool `json:"synthetic,omitempty"`
}

type ExceptionStacktrace struct {
	// Type is the stack trace representation type. The default extractor uses "raw".
	Type string `json:"type"`
	// Frames is the ordered list of stack frames.
	Frames []StackFrame `json:"frames"`
}

type FeatureFlag struct {
	// Key is the feature flag key.
	Key string `json:"key"`
	// RolloutPercentage is the top-level rollout percentage, when configured.
	RolloutPercentage *float64 `json:"rollout_percentage"`
	// Active reports whether the flag is active.
	Active bool `json:"active"`
	// Filters contains matching conditions, variants, and payloads.
	Filters Filter `json:"filters"`
	// EnsureExperienceContinuity indicates that the flag requires server-side continuity checks.
	EnsureExperienceContinuity *bool `json:"ensure_experience_continuity"`
	// BucketingIdentifier optionally selects the property used for hash bucketing.
	BucketingIdentifier *string `json:"bucketing_identifier"`
}

type FeatureFlagCondition struct {
	// Properties are the targeting rules in this condition group.
	Properties []FlagProperty `json:"properties"`
	// RolloutPercentage is the rollout percentage for this condition group.
	RolloutPercentage *float64 `json:"rollout_percentage"`
	// Variant is the variant key forced by this condition group, when any.
	Variant *string `json:"variant"`
	// AggregationGroupTypeIndex identifies the group type for this condition group.
	AggregationGroupTypeIndex *uint8 `json:"aggregation_group_type_index"`
}

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

type FeatureFlagPayload struct {
	// Key is the feature flag key to evaluate. It is required.
	Key string
	// DistinctId is the user distinct ID to evaluate the flag for. It is required.
	DistinctId string
	// DeviceId optionally provides a device_id for remote /flags requests and event deduplication.
	DeviceId *string
	// Groups supplies group identifiers for group-targeted flags.
	Groups Groups
	// PersonProperties overrides person properties used during flag evaluation.
	PersonProperties Properties
	// GroupProperties overrides group properties used during flag evaluation, keyed by group type.
	GroupProperties map[string]Properties
	// OnlyEvaluateLocally prevents fallback to remote /flags requests.
	OnlyEvaluateLocally bool
	// SendFeatureFlagEvents controls whether $feature_flag_called is captured.
	// Nil defaults to true during validation.
	SendFeatureFlagEvents *bool
}

type FeatureFlagPayloadNoKey struct {
	// DistinctId is the user distinct ID to evaluate flags for. It is required.
	DistinctId string
	// DeviceId optionally provides a device_id for remote /flags requests and event deduplication.
	DeviceId *string
	// Groups supplies group identifiers for group-targeted flags.
	Groups Groups
	// PersonProperties overrides person properties used during flag evaluation.
	PersonProperties Properties
	// GroupProperties overrides group properties used during flag evaluation, keyed by group type.
	GroupProperties map[string]Properties
	// OnlyEvaluateLocally prevents fallback to remote /flags requests.
	OnlyEvaluateLocally bool
	// SendFeatureFlagEvents is reserved for parity with single-flag payloads.
	// Nil defaults to true during validation; GetAllFlags does not currently emit per-flag access events.
	SendFeatureFlagEvents *bool
}

type FeatureFlagResult struct {
	// Key is the feature flag key that was evaluated
	Key string

	// Enabled indicates whether the feature flag evaluation determined
	// the flag to be in an enabled state.
	Enabled bool

	// RawPayload is the serialized JSON payload associated with the flag variant.
	// Nil if no payload is configured.
	// Use GetPayloadAs to unmarshal the payload into a specific type.
	RawPayload *string

	// Variant is the variant key if this is a multivariate flag.
	// Nil for boolean flags.
	Variant *string
	// contains filtered or unexported fields
}

type FeatureFlagsPoller struct {

	// Logger receives poller warnings and errors.
	Logger Logger
	// Endpoint is the PostHog API host used by the poller.
	Endpoint string
	// contains filtered or unexported fields
}

type FeatureFlagsResponse struct {
	// Flags contains feature flag definitions for local evaluation.
	Flags []FeatureFlag `json:"flags"`
	// GroupTypeMapping maps group type indexes to group type names.
	GroupTypeMapping *map[string]string `json:"group_type_mapping"`
	// Cohorts contains cohort definitions referenced by local feature flags.
	Cohorts map[string]PropertyGroup `json:"cohorts"`
}

type FieldError struct {

	// The human-readable representation of the type of structure that wasn't
	// initialized properly.
	Type string

	// The name of the field that wasn't properly initialized.
	Name string

	// The value of the field that wasn't properly initialized.
	Value interface{}
}

type Filter struct {
	// AggregationGroupTypeIndex identifies the group type for group-targeted flags.
	AggregationGroupTypeIndex *uint8 `json:"aggregation_group_type_index"`
	// Groups contains the ordered condition groups to evaluate.
	Groups []FeatureFlagCondition `json:"groups"`
	// Multivariate contains variant definitions for multivariate flags.
	Multivariate *Variants `json:"multivariate"`
	// Payloads maps flag values or variant keys to raw JSON payloads.
	Payloads map[string]json.RawMessage `json:"payloads"`
	// DecodedPayloads holds pre-decoded string versions of Payloads.
	// Built once at flag load time to avoid per-evaluation json.Unmarshal / unquoting.
	DecodedPayloads map[string]string `json:"-"`
	// VariantLookupTable is pre-computed at flag load time to avoid per-evaluation
	// slice allocation for multivariate flags.
	VariantLookupTable []FlagVariantMeta `json:"-"`
}

type FlagDetail struct {
	// Key is the feature flag key.
	Key string `json:"key"`
	// Enabled reports whether the flag is enabled for the evaluated user.
	Enabled bool `json:"enabled"`
	// Variant is the matched variant key for multivariate flags, or nil for boolean flags.
	Variant *string `json:"variant"`
	// Reason explains why the flag matched or did not match, when provided by the API.
	Reason *FlagReason `json:"reason"`
	// Metadata contains IDs, version, payload, and optional flag description.
	Metadata FlagMetadata `json:"metadata"`
	// Failed is true when the API could not evaluate this flag due to a transient failure.
	Failed *bool `json:"failed,omitempty"`
}

type FlagMetadata struct {
	// ID is the numeric feature flag ID in PostHog.
	ID int `json:"id"`
	// Version is the feature flag version evaluated by the API.
	Version int `json:"version"`
	// Payload is the raw JSON payload associated with the matched flag value.
	Payload json.RawMessage `json:"payload"`
	// Description is the feature flag description, when returned by the API.
	Description *string `json:"description,omitempty"`
}

type FlagProperty struct {
	// Key is the property key to read.
	Key string `json:"key"`
	// Operator is the comparison operator, such as exact, is_not, or regex.
	Operator string `json:"operator"`
	// Value is the comparison value for Operator.
	Value interface{} `json:"value"`
	// Type is the property source. Supported values include "person", "group", "cohort", and "flag".
	Type string `json:"type"`
	// Negation inverts the property match when true.
	Negation bool `json:"negation"`
	// DependencyChain tracks feature flag dependencies while evaluating nested flag properties.
	DependencyChain []string `json:"dependency_chain"`
}

type FlagReason struct {
	// Code is the machine-readable reason code returned by the API.
	Code string `json:"code"`
	// Description is the human-readable reason returned by the API.
	Description string `json:"description"`
	// ConditionIndex is the matched condition index, when available.
	ConditionIndex *int `json:"condition_index"`
}

type FlagVariant struct {
	// Key is the stable variant key returned by flag evaluation.
	Key string `json:"key"`
	// Name is the display name for the variant.
	Name string `json:"name"`
	// RolloutPercentage is the percentage allocated to this variant.
	RolloutPercentage *float64 `json:"rollout_percentage"`
}

type FlagVariantMeta struct {
	// ValueMin is the inclusive lower bound of the normalized hash range.
	ValueMin float64
	// ValueMax is the exclusive upper bound of the normalized hash range.
	ValueMax float64
	// Key is the variant key for this hash range.
	Key string
}

type FlagsRequestData struct {
	// ApiKey is the PostHog project API key.
	ApiKey string `json:"api_key"`
	// DistinctId is the user distinct ID to evaluate flags for.
	DistinctId string `json:"distinct_id"`
	// DeviceId optionally identifies the device for device-aware flag evaluation.
	DeviceId *string `json:"device_id,omitempty"`
	// Groups contains group identifiers for group-targeted flags.
	Groups Groups `json:"groups"`
	// PersonProperties overrides person properties for this evaluation.
	PersonProperties Properties `json:"person_properties"`
	// GroupProperties overrides group properties for this evaluation, keyed by group type.
	GroupProperties map[string]Properties `json:"group_properties"`
	// DisableGeoIP disables GeoIP enrichment for this flags request.
	DisableGeoIP bool `json:"geoip_disable,omitempty"`
	// FlagKeysToEvaluate asks the server to evaluate only these flag keys when non-empty.
	FlagKeysToEvaluate []string `json:"flag_keys_to_evaluate,omitempty"`
}

type FlagsResponse struct {
	// CommonResponseFields contains response metadata shared across formats.
	CommonResponseFields

	// Flags contains v4-format flag details keyed by flag key.
	Flags map[string]FlagDetail `json:"flags,omitempty"`

	// FeatureFlags contains legacy v3 flag values keyed by flag key.
	FeatureFlags map[string]interface{} `json:"featureFlags"`
	// FeatureFlagPayloads contains legacy v3 raw payloads keyed by flag key.
	FeatureFlagPayloads map[string]json.RawMessage `json:"featureFlagPayloads"`
}

type GroupIdentify struct {
	// Type is the group type, such as "company" or "organization".
	Type string
	// Key is the group key or ID within the group type.
	Key string
	// Uuid is an optional event UUID. If empty, Enqueue generates a random UUID.
	Uuid string

	// DistinctId is accepted for compatibility but the wire payload uses a generated group distinct ID.
	DistinctId string
	// Timestamp is the event timestamp. If zero, Enqueue uses the current time.
	Timestamp time.Time
	// Properties are sent as the $group_set properties for the group.
	Properties Properties
	// DisableGeoIP controls whether this group-identify event disables GeoIP lookup.
	// Enqueue overwrites it from Config.GetDisableGeoIP.
	DisableGeoIP bool
}

type GroupIdentifyInApi struct {
	// Uuid is the event UUID sent to the batch API.
	Uuid string `json:"uuid"`
	// Library is the SDK name sent to the batch API.
	Library string `json:"library"`
	// LibraryVersion is the SDK version sent to the batch API.
	LibraryVersion string `json:"library_version"`
	// Timestamp is the event timestamp sent to the batch API.
	Timestamp time.Time `json:"timestamp"`

	// Event is always $groupidentify for GroupIdentify messages.
	Event string `json:"event"`
	// DistinctId is the generated group distinct ID sent to PostHog.
	DistinctId string `json:"distinct_id"`
	// Properties contains SDK metadata, group identifiers, and $group_set properties.
	Properties Properties `json:"properties"`
}

type Groups map[string]interface{}

type Identify struct {
	// Type is reserved for SDK serialization and is overwritten by Enqueue.
	Type string
	// Uuid is an optional event UUID. If empty, Enqueue generates a random UUID.
	Uuid string

	// DistinctId is the user distinct ID whose person profile should be updated.
	DistinctId string
	// Timestamp is the event timestamp. If zero, Enqueue uses the current time.
	Timestamp time.Time
	// Properties are sent as the $set person properties for DistinctId.
	Properties Properties
	// DisableGeoIP controls whether this identify event disables GeoIP lookup.
	// Enqueue overwrites it from Config.GetDisableGeoIP.
	DisableGeoIP bool
}

type IdentifyInApi struct {
	// Type is the message type sent to the batch API.
	Type string `json:"type"`
	// Uuid is the event UUID sent to the batch API.
	Uuid string `json:"uuid"`
	// Library is the SDK name sent to the batch API.
	Library string `json:"library"`
	// LibraryVersion is the SDK version sent to the batch API.
	LibraryVersion string `json:"library_version"`
	// Timestamp is the event timestamp sent to the batch API.
	Timestamp time.Time `json:"timestamp"`

	// Event is always $identify for Identify messages.
	Event string `json:"event"`
	// DistinctId is the user distinct ID sent to PostHog.
	DistinctId string `json:"distinct_id"`
	// Properties contains SDK metadata and system context.
	Properties Properties `json:"properties"`
	// Set contains the person properties to update.
	Set Properties `json:"$set"`
}

type InAppDecider func(frame runtime.Frame) bool

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

type Logger interface {
	// Debugf is called by PostHog client to log debug messages about the
	// operations they perform. Messages logged by this method are usually
	// tagged with an `DEBUG` log level in common logging libraries.
	Debugf(format string, args ...interface{})

	// Logf is called by PostHog client to log regular messages about the
	// operations they perform. Messages logged by this method are usually
	// tagged with an `INFO` log level in common logging libraries.
	Logf(format string, args ...interface{})

	// Warnf is called by PostHog client to log warning messages about
	// the operations they perform. Messages logged by this method are usually
	// tagged with an `WARN` log level in common logging libraries.
	Warnf(format string, args ...interface{})

	// Errorf is called by PostHog clients call this method to log errors
	// they encounter while sending events to the backend servers.
	// Messages logged by this method are usually tagged with an `ERROR` log
	// level in common logging libraries.
	Errorf(format string, args ...interface{})
}

type Message interface {

	// Validate checks the internal structure of the message. It returns nil when
	// the message is valid or an error describing the invalid field.
	Validate() error
	// APIfy converts the message into its PostHog batch API representation.
	APIfy() APIMessage
	// contains filtered or unexported methods
}

type Properties map[string]interface{}

type PropertyGroup struct {
	// Type is the boolean operator joining Values, such as AND or OR.
	Type string `json:"type"`
	// Values contains nested PropertyGroup values or FlagProperty values.
	Values []any `json:"values"`
	// ParsedValues holds pre-parsed typed values from Values.
	// Built once at flag load time to avoid reconstructing FlagProperty/PropertyGroup
	// from map[string]any on every cohort evaluation.
	ParsedValues []parsedPropertyValue `json:"-"`
}

type RequestContext struct {
	// DistinctId is the request-scoped user distinct ID.
	DistinctId string
	// SessionId is the request-scoped PostHog session ID.
	SessionId string
	// Properties are request-scoped properties merged into capture and exception events.
	Properties Properties
}

type RequestContextOption func(*RequestContextOptions)

type RequestContextOptions struct {
	// CaptureTracingHeaders controls whether X-PostHog-Distinct-Id and X-PostHog-Session-Id
	// are read into request-scoped analytics context. It defaults to true in NewRequestContextMiddleware.
	// When disabled, the middleware still attaches request metadata to the request context.
	CaptureTracingHeaders bool

	// CapturePanics controls whether NewRequestContextMiddleware captures downstream panics as
	// PostHog exception events before re-panicking. It defaults to false.
	CapturePanics bool

	// PanicCaptureClient receives panic exception events when CapturePanics is enabled.
	PanicCaptureClient EnqueueClient
}

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

type SendFeatureFlagsBool bool

type SendFeatureFlagsOptions struct {
	// OnlyEvaluateLocally forces evaluation to use locally loaded flag definitions only.
	OnlyEvaluateLocally bool
	// DeviceId provides a device_id for remote flag evaluation requests.
	DeviceId *string
	// PersonProperties provides explicit person properties for flag evaluation.
	PersonProperties Properties
	// GroupProperties provides explicit group properties for flag evaluation.
	GroupProperties map[string]Properties
}

type SendFeatureFlagsValue interface {
	// ShouldSend reports whether Enqueue should attach feature flag values to the Capture event.
	ShouldSend() bool
	// GetOptions returns optional feature flag evaluation parameters, or nil for boolean-only values.
	GetOptions() *SendFeatureFlagsOptions
}

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

type SlogOption func(*captureConfig)

type StackFrame struct {
	// Filename is the source file path for the frame.
	Filename string `json:"filename"`
	// LineNo is the one-based source line number.
	LineNo int `json:"lineno"`
	// Function is the fully qualified function name.
	Function string `json:"function"`
	// InApp reports whether the frame is considered application code.
	InApp bool `json:"in_app"`
	// Synthetic reports whether the frame was synthesized by instrumentation.
	Synthetic bool `json:"synthetic"`
	// Platform identifies the runtime platform; Go frames use "go".
	Platform string `json:"platform"`
}

type StackTraceExtractor interface {
	// GetStackTrace returns a PostHog-compatible stack trace.
	//
	// The skip parameter controls how many leading frames to omit before
	// recording. Use it to drop extractor/logging internals and start at the
	// application call site. For example, a skip of 3–5 is typically enough to
	// hide wrapper layers when called from a slog handler.
	GetStackTrace(skip int) *ExceptionStacktrace
}

type Ticker struct {

	// C receives the time for each backoff tick and is closed after Stop.
	C <-chan time.Time
	// contains filtered or unexported fields
}

type Variants struct {
	// Variants is the ordered list of possible flag variants.
	Variants []FlagVariant `json:"variants"`
}