@splitsoftware/openfeature-js-split-provider 1.1.0 → 1.3.0

package/src/lib/context.ts

@@ -0,0 +1,23 @@
+import type { EvaluationContext } from '@openfeature/server-sdk';
+import type { Consumer } from './types';
+import { DEFAULT_TRAFFIC_TYPE } from './types';
+
+/**
+ * Transforms OpenFeature evaluation context into the consumer shape used by the Split API:
+ * targeting key, traffic type (with default), and remaining attributes.
+ */
+export function transformContext(
+  context: EvaluationContext,
+  defaultTrafficType: string = DEFAULT_TRAFFIC_TYPE
+): Consumer {
+  const { targetingKey, trafficType: ttVal, ...attributes } = context;
+  const trafficType =
+    ttVal != null && typeof ttVal === 'string' && ttVal.trim() !== ''
+      ? ttVal
+      : defaultTrafficType;
+  return {
+    targetingKey,
+    trafficType,
+    attributes: JSON.parse(JSON.stringify(attributes)),
+  };
+}

package/src/lib/js-split-provider.ts

@@ -1,8 +1,9 @@
 import {
   EvaluationContext,
+  EventDetails,
   FlagNotFoundError,
-  InvalidContextError,
   JsonValue,
+  Logger,
   OpenFeatureEventEmitter,
   ParseError,
   Provider,
@@ -12,157 +13,159 @@ import {
   TargetingKeyMissingError,
   TrackingEventDetails
 } from '@openfeature/server-sdk';
-import { SplitFactory } from '@splitsoftware/splitio';
 import type SplitIO from '@splitsoftware/splitio/types/splitio';
+import { getSplitClient } from './client-resolver';
+import { transformContext } from './context';
+import { parseValidJsonObject, parseValidNumber } from './parsers';
+import { attachReadyEventHandlers, waitUntilReady } from './readiness';
+import {
+  CONTROL_TREATMENT,
+  CONTROL_VALUE_ERROR_MESSAGE,
+  DEFAULT_TRAFFIC_TYPE,
+  PROVIDER_NAME,
+  SplitProviderConstructorOptions,
+  type Consumer
+} from './types';
 
-type SplitProviderOptions = {
-  splitClient: SplitIO.IClient | SplitIO.IAsyncClient;
-}
-
-type Consumer = {
-  key: string | undefined;
-  attributes: SplitIO.Attributes;
-};
+export class OpenFeatureSplitProvider implements Provider {
+  readonly metadata = {
+    name: PROVIDER_NAME,
+  } as const;
 
-const CONTROL_VALUE_ERROR_MESSAGE = 'Received the "control" value from Split.';
-const CONTROL_TREATMENT = 'control';
+  readonly runsOn = 'server' as const;
 
-export class OpenFeatureSplitProvider implements Provider {
-  metadata = {
-    name: 'split',
-  };
-  private initialized: Promise<void>;
   private client: SplitIO.IClient | SplitIO.IAsyncClient;
-
+  private trafficType: string;
   public readonly events = new OpenFeatureEventEmitter();
 
-  private getSplitClient(options: SplitProviderOptions | string | SplitIO.ISDK | SplitIO.IAsyncSDK) {
-    if (typeof(options) === 'string') {
-      const splitFactory = SplitFactory({core: { authorizationKey: options } });
-      return splitFactory.client();
-    } 
-
-    let splitClient;
-    try {
-      splitClient = (options as SplitIO.ISDK | SplitIO.IAsyncSDK).client();
-    } catch {
-      splitClient = (options as SplitProviderOptions).splitClient
-    }
-
-    return splitClient;
-  }
-  
-  constructor(options: SplitProviderOptions | string | SplitIO.ISDK | SplitIO.IAsyncSDK) {
-
-    this.client = this.getSplitClient(options);
-
-    this.client.on(this.client.Event.SDK_UPDATE, () => {
-      this.events.emit(ProviderEvents.ConfigurationChanged)
-    });
-    this.initialized = new Promise((resolve) => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      if ((this.client as any).__getStatus().isReady) {
-        console.log(`${this.metadata.name} provider initialized`);
-        resolve();
-      } else {
-        this.client.on(this.client.Event.SDK_READY, () => {
-          console.log(`${this.metadata.name} provider initialized`);
-          resolve();
-        });
+  constructor(
+    options: SplitProviderConstructorOptions
+  ) {
+    this.trafficType = DEFAULT_TRAFFIC_TYPE;
+    this.client = getSplitClient(options);
+
+    attachReadyEventHandlers(this.client, this.events, this.metadata.name);
+
+    this.client.on(
+      this.client.Event.SDK_UPDATE,
+      (updateMetadata: SplitIO.SdkUpdateMetadata) => {
+        const eventDetails: EventDetails = {
+          providerName: this.metadata.name,
+          ...(updateMetadata
+            ? {
+                metadata: { type: updateMetadata.type },
+                flagsChanged: updateMetadata.names || [],
+              }
+            : {}),
+        };
+        this.events.emit(ProviderEvents.ConfigurationChanged, eventDetails);
       }
-    });
+    );
+  }
+
+  /**
+   * Called by the SDK after the provider is set. Waits for the Split client to be ready.
+   * When this promise resolves, the SDK emits ProviderEvents.Ready.
+   */
+  async initialize(_context?: EvaluationContext): Promise<void> {
+    void _context;
+    await waitUntilReady(this.client, this.events, this.metadata.name);
   }
 
-  async resolveBooleanEvaluation(
+  public async resolveBooleanEvaluation(
     flagKey: string,
     _: boolean,
-    context: EvaluationContext
+    context: EvaluationContext,
+    logger: Logger
   ): Promise<ResolutionDetails<boolean>> {
+    void logger;
     const details = await this.evaluateTreatment(
       flagKey,
-      this.transformContext(context)
+      transformContext(context, this.trafficType)
     );
     const treatment = details.value.toLowerCase();
 
-    if ( treatment === 'on' || treatment === 'true' ) {
+    if (treatment === 'on' || treatment === 'true') {
       return { ...details, value: true };
     }
-
-    if ( treatment === 'off' || treatment === 'false' ) {
+    if (treatment === 'off' || treatment === 'false') {
       return { ...details, value: false };
     }
 
     throw new ParseError(`Invalid boolean value for ${treatment}`);
   }
 
-  async resolveStringEvaluation(
+  public async resolveStringEvaluation(
     flagKey: string,
     _: string,
-    context: EvaluationContext
+    context: EvaluationContext,
+    logger: Logger
   ): Promise<ResolutionDetails<string>> {
-    const details = await this.evaluateTreatment(
+    void logger;
+    return this.evaluateTreatment(
       flagKey,
-      this.transformContext(context)
+      transformContext(context, this.trafficType)
     );
-    return details;
   }
 
-  async resolveNumberEvaluation(
+  public async resolveNumberEvaluation(
     flagKey: string,
     _: number,
-    context: EvaluationContext
+    context: EvaluationContext,
+    logger: Logger
   ): Promise<ResolutionDetails<number>> {
+    void logger;
     const details = await this.evaluateTreatment(
       flagKey,
-      this.transformContext(context)
+      transformContext(context, this.trafficType)
     );
-    return { ...details, value: this.parseValidNumber(details.value) };
+    return { ...details, value: parseValidNumber(details.value) };
   }
 
-  async resolveObjectEvaluation<U extends JsonValue>(
+  public async resolveObjectEvaluation<U extends JsonValue>(
     flagKey: string,
     _: U,
-    context: EvaluationContext
+    context: EvaluationContext,
+    logger: Logger
   ): Promise<ResolutionDetails<U>> {
+    void logger;
     const details = await this.evaluateTreatment(
       flagKey,
-      this.transformContext(context)
+      transformContext(context, this.trafficType)
     );
-    return { ...details, value: this.parseValidJsonObject(details.value) };
+    return { ...details, value: parseValidJsonObject<U>(details.value) };
   }
 
   private async evaluateTreatment(
     flagKey: string,
     consumer: Consumer
   ): Promise<ResolutionDetails<string>> {
-    if (!consumer.key) {
+    if (!consumer.targetingKey) {
       throw new TargetingKeyMissingError(
         'The Split provider requires a targeting key.'
       );
     }
     if (flagKey == null || flagKey === '') {
-      throw new FlagNotFoundError(
-        'flagKey must be a non-empty string'
-      );
+      throw new FlagNotFoundError('flagKey must be a non-empty string');
     }
 
-    await this.initialized;
-    const { treatment: value, config }: SplitIO.TreatmentWithConfig = await this.client.getTreatmentWithConfig(
-      consumer.key,
-      flagKey,
-      consumer.attributes
-    );
+    await waitUntilReady(this.client, this.events, this.metadata.name);
+    const { treatment: value, config }: SplitIO.TreatmentWithConfig =
+      await this.client.getTreatmentWithConfig(
+        consumer.targetingKey,
+        flagKey,
+        consumer.attributes
+      );
     if (value === CONTROL_TREATMENT) {
       throw new FlagNotFoundError(CONTROL_VALUE_ERROR_MESSAGE);
     }
-    const flagMetadata = { config: config ? config : '' };
-    const details: ResolutionDetails<string> = {
-      value: value,
+    const flagMetadata = Object.freeze({ config: config ?? '' });
+    return {
+      value,
       variant: value,
-      flagMetadata: flagMetadata,
+      flagMetadata,
       reason: StandardResolutionReasons.TARGETING_MATCH,
     };
-    return details;
   }
 
   async track(
@@ -170,26 +173,21 @@ export class OpenFeatureSplitProvider implements Provider {
     context: EvaluationContext,
     details: TrackingEventDetails
   ): Promise<void> {
-
-    // targetingKey is always required
-    const { targetingKey } = context;
-    if (targetingKey == null || targetingKey === '')
-      throw new TargetingKeyMissingError('Missing targetingKey, required to track');
-
-    // eventName is always required
-    if (trackingEventName == null || trackingEventName === '')
+    if (trackingEventName == null || trackingEventName === '') {
       throw new ParseError('Missing eventName, required to track');
+    }
 
-    // trafficType is always required
-    const ttVal = context['trafficType'];
-    const trafficType =
-      ttVal != null && typeof ttVal === 'string' && ttVal.trim() !== ''
-        ? ttVal
-        : null;
-    if (trafficType == null || trafficType === '')
-      throw new InvalidContextError('Missing trafficType variable, required to track');
+    const { targetingKey, trafficType } = transformContext(
+      context,
+      this.trafficType
+    );
+    if (targetingKey == null || targetingKey === '') {
+      throw new TargetingKeyMissingError(
+        'Missing targetingKey, required to track'
+      );
+    }
 
-    let value;
+    let value: number | undefined;
     let properties: SplitIO.Properties = {};
     if (details != null) {
       if (details.value != null) {
@@ -198,53 +196,18 @@ export class OpenFeatureSplitProvider implements Provider {
       if (details.properties != null) {
         properties = details.properties as SplitIO.Properties;
       }
-    } 
+    }
 
-    this.client.track(targetingKey, trafficType, trackingEventName, value, properties);
+    this.client.track(
+      targetingKey,
+      trafficType,
+      trackingEventName,
+      value,
+      properties
+    );
   }
 
-  async onClose?(): Promise<void> {
+  public async onClose?(): Promise<void> {
     return this.client.destroy();
   }
-
-  //Transform the context into an object useful for the Split API, an key string with arbitrary Split 'Attributes'.
-  private transformContext(context: EvaluationContext): Consumer {
-    const { targetingKey, ...attributes } = context;
-    return {
-      key: targetingKey,
-      // Stringify context objects include date.
-      attributes: JSON.parse(JSON.stringify(attributes)),
-    };
-  }
-
-  private parseValidNumber(stringValue: string | undefined) {
-    if (stringValue === undefined) {
-      throw new ParseError(`Invalid 'undefined' value.`);
-    }
-    const result = Number.parseFloat(stringValue);
-    if (Number.isNaN(result)) {
-      throw new ParseError(`Invalid numeric value ${stringValue}`);
-    }
-    return result;
-  }
-
-  private parseValidJsonObject<T extends JsonValue>(
-    stringValue: string | undefined
-  ): T {
-    if (stringValue === undefined) {
-      throw new ParseError(`Invalid 'undefined' JSON value.`);
-    }
-    // we may want to allow the parsing to be customized.
-    try {
-      const value = JSON.parse(stringValue);
-      if (typeof value !== 'object') {
-        throw new ParseError(
-          `Flag value ${stringValue} had unexpected type ${typeof value}, expected "object"`
-        );
-      }
-      return value;
-    } catch (err) {
-      throw new ParseError(`Error parsing ${stringValue} as JSON, ${err}`);
-    }
-  }
-}
+}

package/src/lib/parsers.ts

@@ -0,0 +1,32 @@
+import { ParseError } from '@openfeature/server-sdk';
+import type { JsonValue } from '@openfeature/server-sdk';
+
+export function parseValidNumber(stringValue: string | undefined): number {
+  if (stringValue === undefined) {
+    throw new ParseError(`Invalid 'undefined' value.`);
+  }
+  const result = Number.parseFloat(stringValue);
+  if (Number.isNaN(result)) {
+    throw new ParseError(`Invalid numeric value ${stringValue}`);
+  }
+  return result;
+}
+
+export function parseValidJsonObject<T extends JsonValue>(
+  stringValue: string | undefined
+): T {
+  if (stringValue === undefined) {
+    throw new ParseError(`Invalid 'undefined' JSON value.`);
+  }
+  try {
+    const value = JSON.parse(stringValue);
+    if (typeof value !== 'object') {
+      throw new ParseError(
+        `Flag value ${stringValue} had unexpected type ${typeof value}, expected "object"`
+      );
+    }
+    return value;
+  } catch (err) {
+    throw new ParseError(`Error parsing ${stringValue} as JSON, ${err}`);
+  }
+}

package/src/lib/readiness.ts

@@ -0,0 +1,103 @@
+import type { OpenFeatureEventEmitter } from '@openfeature/server-sdk';
+import { ProviderEvents } from '@openfeature/server-sdk';
+import type SplitIO from '@splitsoftware/splitio/types/splitio';
+import { PROVIDER_NAME } from './types';
+
+/**
+ * Builds OpenFeature Ready event details including Split SDK ready metadata.
+ * Handles Split SDK not passing metadata (e.g. in consumer/Redis mode).
+ */
+function buildReadyEventDetails(
+  providerName: string,
+  splitMetadata: SplitIO.SdkReadyMetadata | undefined,
+  readyFromCache: boolean
+) {
+  const metadata: Record<string, string | boolean | number> = {
+    readyFromCache,
+    initialCacheLoad: splitMetadata?.initialCacheLoad ?? false,
+  };
+  if (splitMetadata?.lastUpdateTimestamp != null) {
+    metadata.lastUpdateTimestamp = splitMetadata.lastUpdateTimestamp;
+  }
+  return {
+    providerName: providerName || PROVIDER_NAME,
+    metadata,
+  };
+}
+
+/**
+ * Registers Split SDK_READY and SDK_READY_FROM_CACHE listeners and forwards them
+ * as OpenFeature ProviderEvents.Ready with event metadata (initialCacheLoad, lastUpdateTimestamp, readyFromCache).
+ * If the client is already ready when attaching (e.g. localhost or reused client), emits Ready once
+ * with best-effort metadata so handlers always receive at least one Ready when the client is ready.
+ */
+export function attachReadyEventHandlers(
+  client: SplitIO.IClient | SplitIO.IAsyncClient,
+  events: OpenFeatureEventEmitter,
+  providerName: string = PROVIDER_NAME
+): void {
+  client.on(
+    client.Event.SDK_READY_FROM_CACHE,
+    (splitMetadata: SplitIO.SdkReadyMetadata) => {
+      events.emit(
+        ProviderEvents.Ready,
+        buildReadyEventDetails(providerName, splitMetadata, true)
+      );
+    }
+  );
+  client.on(client.Event.SDK_READY, (splitMetadata: SplitIO.SdkReadyMetadata) => {
+    events.emit(
+      ProviderEvents.Ready,
+      buildReadyEventDetails(providerName, splitMetadata, false)
+    );
+  });
+
+  const status = client.getStatus();
+  if (status.isReady) {
+    events.emit(
+      ProviderEvents.Ready,
+      buildReadyEventDetails(providerName, undefined, false)
+    );
+  }
+}
+
+/**
+ * Returns a promise that resolves when the Split client is ready (SDK_READY),
+ * or rejects if the client has timed out (SDK_READY_TIMED_OUT).
+ * Used to gate evaluations until the SDK has synchronized with the backend.
+ */
+export function waitUntilReady(
+  client: SplitIO.IClient | SplitIO.IAsyncClient,
+  events: OpenFeatureEventEmitter,
+  providerName: string = PROVIDER_NAME
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const status = client.getStatus();
+    if (status.isReady) {
+      emitReadyEvent(client, events, providerName);
+      resolve();
+      return;
+    }
+    if (status.hasTimedout) {
+      reject();
+      return;
+    }
+    client.on(client.Event.SDK_READY_TIMED_OUT, reject);
+    client.on(client.Event.SDK_READY, () => {
+      emitReadyEvent(client, events, providerName);
+      resolve();
+    });
+  });
+}
+
+export function emitReadyEvent(
+  client: SplitIO.IClient | SplitIO.IAsyncClient,
+  events: OpenFeatureEventEmitter,
+  providerName: string = PROVIDER_NAME
+): void {
+  events.emit(
+    ProviderEvents.Ready,
+    buildReadyEventDetails(providerName, undefined, false)
+  );
+}
+

package/src/lib/types.ts

@@ -0,0 +1,32 @@
+import type SplitIO from '@splitsoftware/splitio/types/splitio';
+
+/**
+ * Options when providing an existing Split client to the provider.
+ */
+export type SplitProviderOptions = {
+  splitClient: SplitIO.IClient | SplitIO.IAsyncClient;
+};
+
+/**
+ * Consumer representation used for Split API calls:
+ * targeting key, traffic type, and attributes.
+ */
+export type Consumer = {
+  targetingKey: string | undefined;
+  trafficType: string;
+  attributes: SplitIO.Attributes;
+};
+
+/**
+ * Union of all constructor argument types for the Split OpenFeature provider.
+ */
+export type SplitProviderConstructorOptions =
+  | SplitProviderOptions
+  | string
+  | SplitIO.ISDK
+  | SplitIO.IAsyncSDK;
+
+export const CONTROL_TREATMENT = 'control';
+export const CONTROL_VALUE_ERROR_MESSAGE = 'Received the "control" value from Split.';
+export const DEFAULT_TRAFFIC_TYPE = 'user';
+export const PROVIDER_NAME = 'split';

package/types/lib/client-resolver.d.ts

@@ -0,0 +1,7 @@
+import type SplitIO from '@splitsoftware/splitio/types/splitio';
+import type { SplitProviderConstructorOptions } from './types';
+/**
+ * Resolves the Split client from the various supported constructor option shapes.
+ * Supports: API key (string), Split SDK/AsyncSDK (factory), or pre-built splitClient.
+ */
+export declare function getSplitClient(options: SplitProviderConstructorOptions): SplitIO.IClient | SplitIO.IAsyncClient;

package/types/lib/context.d.ts

@@ -0,0 +1,7 @@
+import type { EvaluationContext } from '@openfeature/server-sdk';
+import type { Consumer } from './types';
+/**
+ * Transforms OpenFeature evaluation context into the consumer shape used by the Split API:
+ * targeting key, traffic type (with default), and remaining attributes.
+ */
+export declare function transformContext(context: EvaluationContext, defaultTrafficType?: string): Consumer;

package/types/lib/js-split-provider.d.ts

@@ -1,26 +1,24 @@
-import { EvaluationContext, JsonValue, OpenFeatureEventEmitter, Provider, ResolutionDetails, TrackingEventDetails } from '@openfeature/server-sdk';
-import type SplitIO from '@splitsoftware/splitio/types/splitio';
-type SplitProviderOptions = {
-    splitClient: SplitIO.IClient | SplitIO.IAsyncClient;
-};
+import { EvaluationContext, JsonValue, Logger, OpenFeatureEventEmitter, Provider, ResolutionDetails, TrackingEventDetails } from '@openfeature/server-sdk';
+import { SplitProviderConstructorOptions } from './types';
 export declare class OpenFeatureSplitProvider implements Provider {
-    metadata: {
-        name: string;
+    readonly metadata: {
+        readonly name: "split";
     };
-    private initialized;
+    readonly runsOn: "server";
     private client;
+    private trafficType;
     readonly events: OpenFeatureEventEmitter;
-    private getSplitClient;
-    constructor(options: SplitProviderOptions | string | SplitIO.ISDK | SplitIO.IAsyncSDK);
-    resolveBooleanEvaluation(flagKey: string, _: boolean, context: EvaluationContext): Promise<ResolutionDetails<boolean>>;
-    resolveStringEvaluation(flagKey: string, _: string, context: EvaluationContext): Promise<ResolutionDetails<string>>;
-    resolveNumberEvaluation(flagKey: string, _: number, context: EvaluationContext): Promise<ResolutionDetails<number>>;
-    resolveObjectEvaluation<U extends JsonValue>(flagKey: string, _: U, context: EvaluationContext): Promise<ResolutionDetails<U>>;
+    constructor(options: SplitProviderConstructorOptions);
+    /**
+     * Called by the SDK after the provider is set. Waits for the Split client to be ready.
+     * When this promise resolves, the SDK emits ProviderEvents.Ready.
+     */
+    initialize(_context?: EvaluationContext): Promise<void>;
+    resolveBooleanEvaluation(flagKey: string, _: boolean, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<boolean>>;
+    resolveStringEvaluation(flagKey: string, _: string, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<string>>;
+    resolveNumberEvaluation(flagKey: string, _: number, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<number>>;
+    resolveObjectEvaluation<U extends JsonValue>(flagKey: string, _: U, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<U>>;
     private evaluateTreatment;
     track(trackingEventName: string, context: EvaluationContext, details: TrackingEventDetails): Promise<void>;
     onClose?(): Promise<void>;
-    private transformContext;
-    private parseValidNumber;
-    private parseValidJsonObject;
 }
-export {};

package/types/lib/parsers.d.ts

@@ -0,0 +1,3 @@
+import type { JsonValue } from '@openfeature/server-sdk';
+export declare function parseValidNumber(stringValue: string | undefined): number;
+export declare function parseValidJsonObject<T extends JsonValue>(stringValue: string | undefined): T;

package/types/lib/readiness.d.ts

@@ -0,0 +1,16 @@
+import type { OpenFeatureEventEmitter } from '@openfeature/server-sdk';
+import type SplitIO from '@splitsoftware/splitio/types/splitio';
+/**
+ * Registers Split SDK_READY and SDK_READY_FROM_CACHE listeners and forwards them
+ * as OpenFeature ProviderEvents.Ready with event metadata (initialCacheLoad, lastUpdateTimestamp, readyFromCache).
+ * If the client is already ready when attaching (e.g. localhost or reused client), emits Ready once
+ * with best-effort metadata so handlers always receive at least one Ready when the client is ready.
+ */
+export declare function attachReadyEventHandlers(client: SplitIO.IClient | SplitIO.IAsyncClient, events: OpenFeatureEventEmitter, providerName?: string): void;
+/**
+ * Returns a promise that resolves when the Split client is ready (SDK_READY),
+ * or rejects if the client has timed out (SDK_READY_TIMED_OUT).
+ * Used to gate evaluations until the SDK has synchronized with the backend.
+ */
+export declare function waitUntilReady(client: SplitIO.IClient | SplitIO.IAsyncClient, events: OpenFeatureEventEmitter, providerName?: string): Promise<void>;
+export declare function emitReadyEvent(client: SplitIO.IClient | SplitIO.IAsyncClient, events: OpenFeatureEventEmitter, providerName?: string): void;

package/types/lib/types.d.ts

@@ -0,0 +1,24 @@
+import type SplitIO from '@splitsoftware/splitio/types/splitio';
+/**
+ * Options when providing an existing Split client to the provider.
+ */
+export type SplitProviderOptions = {
+    splitClient: SplitIO.IClient | SplitIO.IAsyncClient;
+};
+/**
+ * Consumer representation used for Split API calls:
+ * targeting key, traffic type, and attributes.
+ */
+export type Consumer = {
+    targetingKey: string | undefined;
+    trafficType: string;
+    attributes: SplitIO.Attributes;
+};
+/**
+ * Union of all constructor argument types for the Split OpenFeature provider.
+ */
+export type SplitProviderConstructorOptions = SplitProviderOptions | string | SplitIO.ISDK | SplitIO.IAsyncSDK;
+export declare const CONTROL_TREATMENT = "control";
+export declare const CONTROL_VALUE_ERROR_MESSAGE = "Received the \"control\" value from Split.";
+export declare const DEFAULT_TRAFFIC_TYPE = "user";
+export declare const PROVIDER_NAME = "split";