import { a as renderOnce, t as ReferenceSyntaxError } from "./referenceSyntax-DYn3GIoP.js";

//#region src/vars/composition.d.ts
declare const MAX_COMPOSITION_DEPTH = 20;
interface ComposedReference {
  composedFrom?: ComposedReference[];
  error?: string;
  fatal: boolean;
  label?: string;
  name: string;
  reason: VariableResolutionReason;
  value?: string;
  version?: number;
}
interface FindReferencesAndErrorsResult {
  errors: ReferenceSyntaxError[];
  references: string[];
}
declare function hasReferences(value: unknown): boolean;
declare function findReferences(value: unknown): string[];
declare function findReferencesAndErrors(value: unknown): FindReferencesAndErrorsResult;
//#endregion
//#region src/vars/templateValidation.d.ts
interface TemplateFieldIssue {
  fieldName: string;
  foundInLabel?: string;
  foundInVariable: string;
  message: string;
  referencePath: string[];
  rootVariable: string;
}
//#endregion
//#region src/vars/errors.d.ts
declare class VariableCompositionError extends Error {
  override name: string;
}
declare class VariableCompositionCycleError extends VariableCompositionError {
  override name: string;
}
declare class VariableCompositionDepthError extends VariableCompositionError {
  override name: string;
}
declare class VariableRenderError extends Error {
  override name: string;
}
//#endregion
//#region src/vars/index.d.ts
type JsonSchema = Record<string, unknown>;
type ResolveFunction<T> = (targetingKey: string | undefined, attributes: Record<string, unknown>) => Promise<T> | T;
interface VariableCodec<T> {
  jsonSchema?: JsonSchema;
  parse(value: unknown): T;
  serialize?: (value: T) => string;
  typeName?: string;
}
interface VariableOptions<T> {
  codec?: VariableCodec<T>;
  default: ResolveFunction<T> | T;
  description?: string;
  templateInputsSchema?: JsonSchema;
}
type TemplateMismatchPolicy = "error" | "ignore" | "warn";
declare class TemplateInputsMismatchError extends Error {
  override name: string;
}
interface VariableDefinition {
  codec: Pick<VariableCodec<unknown>, "parse">;
  description: string | undefined;
  name: string;
  templateInputsSchema?: JsonSchema;
  toConfig(): VariableConfig;
}
interface VariableNameLike {
  name: string;
}
interface VariableGetOptions {
  attributes?: Record<string, unknown>;
  label?: string;
  targetingKey?: string;
}
interface ResolvedVariableInit<T> {
  composedFrom?: ComposedReference[];
  deserializer?: (serializedValue: string) => T;
  exception?: unknown;
  label?: string;
  name: string;
  reason: VariableResolutionReason;
  serializedValue?: string;
  value: T;
  version?: number;
}
type VariableResolutionReason = "code_default" | "context_override" | "missing_config" | "no_provider" | "other_error" | "resolved" | "unrecognized_variable" | "validation_error";
declare class ResolvedVariable<T> {
  composedFrom: ComposedReference[];
  private readonly deserializer;
  exception: unknown;
  label: string | undefined;
  name: string;
  reason: VariableResolutionReason;
  serializedValue: string | undefined;
  value: T;
  version: number | undefined;
  constructor(init: ResolvedVariableInit<T>);
  render(inputs?: Record<string, unknown>): T;
  withContext<R>(callback: () => Promise<R> | R): Promise<R>;
}
interface SerializedResolvedVariableInit {
  label?: string;
  name: string;
  reason: VariableResolutionReason;
  value: string | undefined;
  version?: number;
}
declare class SerializedResolvedVariable extends ResolvedVariable<string | undefined> {}
interface LabeledValue {
  serialized_value: string;
  version: number;
}
interface LabelRef {
  ref: string;
  version?: number | null;
}
interface LatestVersion {
  serialized_value: string;
  version: number;
}
interface Rollout {
  labels: Record<string, number>;
}
type Condition = KeyIsNotPresent | KeyIsPresent | ValueDoesNotEqual | ValueDoesNotMatchRegex | ValueEquals | ValueIsIn | ValueIsNotIn | ValueMatchesRegex;
interface ValueEquals {
  attribute: string;
  kind: "value-equals";
  value: unknown;
}
interface ValueDoesNotEqual {
  attribute: string;
  kind: "value-does-not-equal";
  value: unknown;
}
interface ValueIsIn {
  attribute: string;
  kind: "value-is-in";
  values: unknown[];
}
interface ValueIsNotIn {
  attribute: string;
  kind: "value-is-not-in";
  values: unknown[];
}
interface ValueMatchesRegex {
  attribute: string;
  kind: "value-matches-regex";
  pattern: string;
}
interface ValueDoesNotMatchRegex {
  attribute: string;
  kind: "value-does-not-match-regex";
  pattern: string;
}
interface KeyIsPresent {
  attribute: string;
  kind: "key-is-present";
}
interface KeyIsNotPresent {
  attribute: string;
  kind: "key-is-not-present";
}
interface RolloutOverride {
  conditions: Condition[];
  rollout: Rollout;
}
interface VariableConfig {
  aliases?: string[] | null;
  description?: string | null;
  example?: string | null;
  json_schema?: JsonSchema | null;
  labels: Record<string, LabelRef | LabeledValue>;
  latest_version?: LatestVersion | null;
  name: string;
  overrides: RolloutOverride[];
  rollout: Rollout;
  template_inputs_schema?: JsonSchema | null;
  type_name?: string | null;
}
interface VariablesConfig {
  variables: Record<string, VariableConfig>;
}
interface VariableTypeConfig {
  description?: string | null;
  json_schema: JsonSchema;
  name: string;
  source_hint?: string | null;
}
interface LabelValidationError {
  error: unknown;
  label: string | undefined;
  variableName: string;
}
interface DescriptionDifference {
  localDescription: string | undefined;
  serverDescription: string | undefined;
  variableName: string;
}
interface ValidationReport {
  descriptionDifferences: DescriptionDifference[];
  errors: LabelValidationError[];
  isValid: boolean;
  referenceCycles: string[];
  referenceErrors: string[];
  templateFieldIssues: TemplateFieldIssue[];
  variablesChecked: number;
  variablesNotOnServer: string[];
}
type VariablePushBlockReason = "incompatible_labels" | "incompatible_type_labels" | "reference_cycles" | "reference_errors" | "template_field_issues";
type MaybePromise<T> = T | Promise<T>;
interface VariableProvider {
  batchUpdate?(updates: Record<string, VariableConfig | undefined>): MaybePromise<void>;
  createVariable?(config: VariableConfig): MaybePromise<VariableConfig>;
  deleteVariable?(name: string): MaybePromise<void>;
  getAllVariablesConfig?(): MaybePromise<VariablesConfig>;
  getSerializedValue(variableName: string, targetingKey?: string, attributes?: Record<string, unknown>): MaybePromise<SerializedResolvedVariable>;
  getSerializedValueForLabel?(variableName: string, label: string): MaybePromise<SerializedResolvedVariable>;
  getVariableConfig?(name: string): MaybePromise<VariableConfig | undefined>;
  listVariableTypes?(): MaybePromise<Record<string, VariableTypeConfig>>;
  refresh?(force?: boolean): MaybePromise<void>;
  shutdown?(): MaybePromise<void>;
  start?(): void;
  updateVariable?(name: string, config: VariableConfig): MaybePromise<VariableConfig>;
  upsertVariableType?(config: VariableTypeConfig): MaybePromise<VariableTypeConfig>;
}
interface VariablesOptions {
  apiKey?: string;
  baseUrl?: string;
  blockBeforeFirstResolve?: boolean;
  fetch?: typeof fetch;
  includeBaggageInContext?: boolean;
  includeResourceAttributesInContext?: boolean;
  instrument?: boolean;
  polling?: boolean;
  pollingInterval?: number;
  sse?: boolean;
  timeoutMs?: number;
  templateMismatchPolicy?: TemplateMismatchPolicy;
}
interface LocalVariablesOptions {
  config: VariablesConfig;
  includeBaggageInContext?: boolean;
  includeResourceAttributesInContext?: boolean;
  instrument?: boolean;
  templateMismatchPolicy?: TemplateMismatchPolicy;
}
type VariablesConfigOptions = false | LocalVariablesOptions | VariablesOptions | undefined;
interface ConfigureVariablesRuntimeOptions {
  apiKey?: string;
  baseUrl?: string;
  resourceAttributes?: Record<string, unknown>;
}
interface VariablePushResult {
  blocked: boolean;
  blockedBy: VariablePushBlockReason[];
  changes: VariablePushChange[];
  dryRun: boolean;
}
interface VariablePushChange {
  action: "create" | "delete" | "update";
  name: string;
}
declare class VariableWriteError extends Error {
  override name: string;
}
declare class VariableNotFoundError extends VariableWriteError {
  override name: string;
}
declare class VariableAlreadyExistsError extends VariableWriteError {
  override name: string;
}
declare class NoOpVariableProvider implements VariableProvider {
  getSerializedValue(variableName: string): SerializedResolvedVariable;
  getVariableConfig(): VariableConfig | undefined;
  getAllVariablesConfig(): VariablesConfig;
}
declare class LocalVariableProvider implements VariableProvider {
  private config;
  constructor(config: VariablesConfig);
  getSerializedValue(variableName: string, targetingKey?: string, attributes?: Record<string, unknown>): SerializedResolvedVariable;
  getSerializedValueForLabel(variableName: string, label: string): SerializedResolvedVariable;
  getVariableConfig(name: string): VariableConfig | undefined;
  getAllVariablesConfig(): VariablesConfig;
  createVariable(config: VariableConfig): VariableConfig;
  updateVariable(name: string, config: VariableConfig): VariableConfig;
  deleteVariable(name: string): void;
  batchUpdate(updates: Record<string, VariableConfig | undefined>): void;
}
interface RemoteVariableProviderOptions extends VariablesOptions {
  apiKey: string;
  baseUrl: string;
}
declare class LogfireRemoteVariableProvider implements VariableProvider {
  private readonly apiKey;
  private readonly baseUrl;
  private readonly blockBeforeFirstResolve;
  private readonly fetchImpl;
  private readonly pollingEnabled;
  private readonly pollingIntervalMs;
  private readonly sseEnabled;
  private readonly timeoutMs;
  private readonly transport;
  private config;
  private hasAttemptedFetch;
  private lastFetchedAt;
  private pollingTimer;
  private queuedForcedRefreshPromise;
  private refreshPromise;
  private sseController;
  private shutdownRequested;
  private started;
  constructor(options: RemoteVariableProviderOptions);
  start(): void;
  shutdown(): void;
  refresh(force?: boolean): Promise<void>;
  private runQueuedForcedRefresh;
  getSerializedValue(variableName: string, targetingKey?: string, attributes?: Record<string, unknown>): Promise<SerializedResolvedVariable>;
  getSerializedValueForLabel(variableName: string, label: string): Promise<SerializedResolvedVariable>;
  getVariableConfig(name: string): VariableConfig | undefined;
  getAllVariablesConfig(): Promise<VariablesConfig>;
  createVariable(config: VariableConfig): Promise<VariableConfig>;
  updateVariable(name: string, config: VariableConfig): Promise<VariableConfig>;
  deleteVariable(name: string): Promise<void>;
  batchUpdate(updates: Record<string, VariableConfig | undefined>): Promise<void>;
  listVariableTypes(): Promise<Record<string, VariableTypeConfig>>;
  upsertVariableType(config: VariableTypeConfig): Promise<VariableTypeConfig>;
  private runSseLoop;
  private readSseStream;
}
declare class Variable<T> {
  codec: VariableCodec<T>;
  defaultValue: ResolveFunction<T> | T;
  description: string | undefined;
  name: string;
  templateInputsSchema?: JsonSchema;
  constructor(name: string, options: VariableOptions<T>);
  get(options?: VariableGetOptions): Promise<ResolvedVariable<T>>;
  refresh(force?: boolean): Promise<void>;
  override<R>(value: ResolveFunction<T> | T, callback: () => Promise<R> | R): Promise<R>;
  toConfig(): VariableConfig;
  private getWithSpan;
  private resolve;
  private resolveInner;
  private resolveContextOverride;
  private lookupSerialized;
  private tryResolveSerialized;
  private resolveCodeDefaultValue;
  private resolveRawCodeDefault;
  private getDefaultCached;
  private getSerializedDefault;
}
type TemplateVariableOptions<T, InputsT extends Record<string, unknown>> = InputsT extends Record<string, unknown> ? VariableOptions<T> & {
  templateMismatchPolicy?: TemplateMismatchPolicy;
} : never;
declare class TemplateVariable<T, InputsT extends Record<string, unknown>> extends Variable<T> {
  private readonly templateMismatchPolicy;
  constructor(name: string, options: TemplateVariableOptions<T, InputsT>);
  override get(inputs: InputsT, options?: VariableGetOptions): Promise<ResolvedVariable<T>>;
  private resolveRenderFallbackValue;
  private effectiveTemplateMismatchPolicy;
  private checkTemplateInputs;
}
declare function defineVar<T>(name: string, options: VariableOptions<T>): Variable<T>;
declare function defineTemplateVar<T, InputsT extends Record<string, unknown> = Record<string, unknown>>(name: string, options: TemplateVariableOptions<T, InputsT>): TemplateVariable<T, InputsT>;
declare function variablesClear(): void;
declare function variablesGet(): VariableDefinition[];
declare function variablesBuildConfig(variables?: VariableDefinition[]): VariablesConfig;
declare function variablesValidate(variables?: VariableDefinition[]): Promise<ValidationReport>;
declare function variablesPush(variables?: VariableDefinition[], options?: {
  dryRun?: boolean;
  strict?: boolean;
}): Promise<VariablePushResult>;
declare function variablesPushConfig(config: VariablesConfig, options?: {
  dryRun?: boolean;
  mode?: "merge" | "replace";
}): Promise<VariablePushResult>;
declare function variablesPullConfig(): Promise<VariablesConfig>;
declare function variablesPushTypes(types: VariableTypeConfig[], options?: {
  dryRun?: boolean;
  strict?: boolean;
}): Promise<VariablePushResult>;
declare function configureVariables(options?: VariablesConfigOptions, runtime?: ConfigureVariablesRuntimeOptions): void;
declare function shutdownVariables(): Promise<void>;
declare function getVariableProvider(): VariableProvider;
declare function targetingContext<R>(targetingKey: string, callbackOrOptions: (() => Promise<R> | R) | {
  variables?: VariableNameLike[];
}, maybeCallback?: () => Promise<R> | R): Promise<R>;
//#endregion
export { type ComposedReference, Condition, ConfigureVariablesRuntimeOptions, DescriptionDifference, JsonSchema, KeyIsNotPresent, KeyIsPresent, LabelRef, LabelValidationError, LabeledValue, LatestVersion, LocalVariableProvider, LocalVariablesOptions, LogfireRemoteVariableProvider, MAX_COMPOSITION_DEPTH, MaybePromise, NoOpVariableProvider, RemoteVariableProviderOptions, ResolveFunction, ResolvedVariable, ResolvedVariableInit, Rollout, RolloutOverride, SerializedResolvedVariable, SerializedResolvedVariableInit, type TemplateFieldIssue, TemplateInputsMismatchError, TemplateMismatchPolicy, TemplateVariable, TemplateVariableOptions, ValidationReport, ValueDoesNotEqual, ValueDoesNotMatchRegex, ValueEquals, ValueIsIn, ValueIsNotIn, ValueMatchesRegex, Variable, VariableAlreadyExistsError, VariableCodec, VariableCompositionCycleError, VariableCompositionDepthError, VariableCompositionError, VariableConfig, VariableDefinition, VariableGetOptions, VariableNameLike, VariableNotFoundError, VariableOptions, VariableProvider, VariablePushBlockReason, VariablePushChange, VariablePushResult, VariableRenderError, VariableResolutionReason, VariableTypeConfig, VariableWriteError, VariablesConfig, VariablesConfigOptions, VariablesOptions, configureVariables, defineTemplateVar, defineTemplateVar as templateVar, defineVar, defineVar as var, findReferences, findReferencesAndErrors, getVariableProvider, hasReferences, renderOnce, shutdownVariables, targetingContext, variablesBuildConfig, variablesClear, variablesGet, variablesPullConfig, variablesPush, variablesPushConfig, variablesPushTypes, variablesValidate };