Skip to content

Commit 7945e00

Browse files
EmilianoSanchezEmilianoSanchez
committed
Update ts test
1 parent 8075815 commit 7945e00

File tree

2 files changed

+113
-99
lines changed

2 files changed

+113
-99
lines changed

‎ts-tests/index.ts‎

Lines changed: 110 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -25,19 +25,19 @@ let trackPromise: Promise<boolean>;
2525
/**** Interfaces ****/
2626

2727
// Facade return interface
28-
let NodeSDK: SplitIO.INodeSDK;
29-
let AsyncSDK: SplitIO.INodeAsyncSDK;
30-
let BrowserSDK: SplitIO.ISDK;
28+
let SDK: SplitIO.ISDK;
29+
let AsyncSDK: SplitIO.IAsyncSDK;
30+
let BrowserSDK: SplitIO.IBrowserSDK;
3131
// Settings interfaces
3232
let nodeSettings: SplitIO.INodeSettings;
3333
let asyncSettings: SplitIO.INodeAsyncSettings;
3434
let browserSettings: SplitIO.IBrowserSettings;
3535
// Client & Manager APIs
36-
let nodeClient: SplitIO.INodeClient;
36+
let client: SplitIO.IClient;
3737
let manager: SplitIO.IManager;
38-
let nodeAsyncClient: SplitIO.INodeAsyncClient;
38+
let asyncClient: SplitIO.IAsyncClient;
3939
let asyncManager: SplitIO.IAsyncManager;
40-
let browserClient: SplitIO.IClient;
40+
let browserClient: SplitIO.IBrowserClient;
4141
// Utility interfaces
4242
let impressionListener: SplitIO.IImpressionListener;
4343

@@ -137,7 +137,7 @@ splitViewsAsync = splitViewsPromise;
137137
splitKey = 'someKey';
138138
splitKey = splitKeyObj;
139139

140-
/**** Tests for INodeSDK interface ****/
140+
/**** Tests for ISDK interface ****/
141141

142142
// For node with sync storage
143143
nodeSettings = {
@@ -162,8 +162,8 @@ browserSettings = {
162162
key: 'customer-key'
163163
}
164164
};
165-
// With sync settings should return INodeSDK, if settings have async storage it should return INodeAsyncSDK
166-
NodeSDK = SplitFactory(nodeSettings);
165+
// With sync settings should return ISDK, if settings have async storage it should return IAsyncSDK
166+
SDK = SplitFactory(nodeSettings);
167167
AsyncSDK = SplitFactory(asyncSettings);
168168
BrowserSDK = SplitFactory(browserSettings);
169169

@@ -173,38 +173,38 @@ const instantiatedSettingsCore: {
173173
key: SplitIO.SplitKey,
174174
labelsEnabled: boolean,
175175
IPAddressesEnabled: boolean
176-
} = NodeSDK.settings.core;
177-
const instantiatedSettingsMode: ('standalone' | 'consumer' | 'consumer_partial' | 'localhost') = NodeSDK.settings.mode;
178-
const instantiatedSettingsScheduler: { [key: string]: number } = NodeSDK.settings.scheduler;
179-
const instantiatedSettingsStartup: { [key: string]: number } = NodeSDK.settings.startup;
180-
const instantiatedSettingsStorage = NodeSDK.settings.storage as SplitIO.StorageOptions;
181-
const instantiatedSettingsUrls: { [key: string]: string } = NodeSDK.settings.urls;
182-
const instantiatedSettingsVersion: string = NodeSDK.settings.version;
183-
let instantiatedSettingsFeatures = NodeSDK.settings.features as SplitIO.MockedFeaturesMap;
176+
} = SDK.settings.core;
177+
const instantiatedSettingsMode: ('standalone' | 'consumer' | 'consumer_partial' | 'localhost') = SDK.settings.mode;
178+
const instantiatedSettingsScheduler: { [key: string]: number } = SDK.settings.scheduler;
179+
const instantiatedSettingsStartup: { [key: string]: number } = SDK.settings.startup;
180+
const instantiatedSettingsStorage = SDK.settings.storage as SplitIO.StorageOptions;
181+
const instantiatedSettingsUrls: { [key: string]: string } = SDK.settings.urls;
182+
const instantiatedSettingsVersion: string = SDK.settings.version;
183+
let instantiatedSettingsFeatures = SDK.settings.features as SplitIO.MockedFeaturesMap;
184184
// We should be able to write on features prop. The rest are readonly props.
185185
instantiatedSettingsFeatures.something = 'something';
186-
NodeSDK.settings.features = 'new_file_path'; // Node
187-
NodeSDK.settings.features = { 'split_x': 'on' }; // Browser
186+
SDK.settings.features = 'new_file_path'; // Node
187+
SDK.settings.features = { 'split_x': 'on' }; // Browser
188188

189189
// Client and Manager
190-
nodeClient = NodeSDK.client();
191-
manager = NodeSDK.manager();
190+
client = SDK.client();
191+
manager = SDK.manager();
192192
manager = BrowserSDK.manager();
193193
// Today async clients are only possible on Node. Shared client creation not available here.
194-
nodeAsyncClient = AsyncSDK.client();
194+
asyncClient = AsyncSDK.client();
195195
asyncManager = AsyncSDK.manager();
196196
// Browser client for attributes binding
197197
browserClient = BrowserSDK.client();
198198
browserClient = BrowserSDK.client('a customer key');
199199

200200
// Logger
201-
NodeSDK.Logger.enable();
202-
NodeSDK.Logger.setLogLevel(NodeSDK.Logger.LogLevel.DEBUG);
203-
NodeSDK.Logger.setLogLevel(NodeSDK.Logger.LogLevel.INFO);
204-
NodeSDK.Logger.setLogLevel(NodeSDK.Logger.LogLevel.WARN);
205-
NodeSDK.Logger.setLogLevel(NodeSDK.Logger.LogLevel.ERROR);
206-
NodeSDK.Logger.setLogLevel(NodeSDK.Logger.LogLevel.NONE);
207-
NodeSDK.Logger.disable();
201+
SDK.Logger.enable();
202+
SDK.Logger.setLogLevel(SDK.Logger.LogLevel.DEBUG);
203+
SDK.Logger.setLogLevel(SDK.Logger.LogLevel.INFO);
204+
SDK.Logger.setLogLevel(SDK.Logger.LogLevel.WARN);
205+
SDK.Logger.setLogLevel(SDK.Logger.LogLevel.ERROR);
206+
SDK.Logger.setLogLevel(SDK.Logger.LogLevel.NONE);
207+
SDK.Logger.disable();
208208

209209
AsyncSDK.Logger.enable();
210210
AsyncSDK.Logger.setLogLevel(AsyncSDK.Logger.LogLevel.DEBUG);
@@ -217,163 +217,163 @@ AsyncSDK.Logger.disable();
217217
/**** Tests for IClient interface ****/
218218

219219
// Events constants we get
220-
const eventConsts: { [key: string]: SplitIO.Event } = nodeClient.Event;
221-
splitEvent = nodeClient.Event.SDK_READY;
222-
splitEvent = nodeClient.Event.SDK_READY_FROM_CACHE;
223-
splitEvent = nodeClient.Event.SDK_READY_TIMED_OUT;
224-
splitEvent = nodeClient.Event.SDK_UPDATE;
220+
const eventConsts: { [key: string]: SplitIO.Event } = client.Event;
221+
splitEvent = client.Event.SDK_READY;
222+
splitEvent = client.Event.SDK_READY_FROM_CACHE;
223+
splitEvent = client.Event.SDK_READY_TIMED_OUT;
224+
splitEvent = client.Event.SDK_UPDATE;
225225

226226
// Client implements methods from NodeJS.Events. Testing a few.
227-
nodeClient = nodeClient.on(splitEvent, () => { });
228-
const a: boolean = nodeClient.emit(splitEvent);
229-
nodeClient = nodeClient.removeAllListeners(splitEvent);
230-
nodeClient = nodeClient.removeAllListeners();
231-
const b: number = nodeClient.listenerCount(splitEvent);
232-
let nodeEventEmitter: NodeJS.EventEmitter = nodeClient;
227+
client = client.on(splitEvent, () => { });
228+
const a: boolean = client.emit(splitEvent);
229+
client = client.removeAllListeners(splitEvent);
230+
client = client.removeAllListeners();
231+
const b: number = client.listenerCount(splitEvent);
232+
let nodeEventEmitter: NodeJS.EventEmitter = client;
233233

234234
// Ready, destroy and flush
235-
let promise: Promise<void> = nodeClient.ready();
236-
promise = nodeClient.destroy();
237-
promise = NodeSDK.destroy();
235+
let promise: Promise<void> = client.ready();
236+
promise = client.destroy();
237+
promise = SDK.destroy();
238238
// @TODO not public yet
239-
// promise = nodeClient.flush();
239+
// promise = client.flush();
240240

241241
// We can call getTreatment with or without a key.
242-
treatment = nodeClient.getTreatment(splitKey, 'mySplit');
242+
treatment = client.getTreatment(splitKey, 'mySplit');
243243
treatment = browserClient.getTreatment('mySplit');
244244
// Attributes parameter is optional on both signatures.
245-
treatment = nodeClient.getTreatment(splitKey, 'mySplit', attributes);
245+
treatment = client.getTreatment(splitKey, 'mySplit', attributes);
246246
treatment = browserClient.getTreatment('mySplit', attributes);
247247

248248
// We can call getTreatments with or without a key.
249-
treatments = nodeClient.getTreatments(splitKey, ['mySplit']);
249+
treatments = client.getTreatments(splitKey, ['mySplit']);
250250
treatments = browserClient.getTreatments(['mySplit']);
251251
// Attributes parameter is optional on both signatures.
252-
treatments = nodeClient.getTreatments(splitKey, ['mySplit'], attributes);
252+
treatments = client.getTreatments(splitKey, ['mySplit'], attributes);
253253
treatments = browserClient.getTreatments(['mySplit'], attributes);
254254

255255
// We can call getTreatmentWithConfig with or without a key.
256-
treatmentWithConfig = nodeClient.getTreatmentWithConfig(splitKey, 'mySplit');
256+
treatmentWithConfig = client.getTreatmentWithConfig(splitKey, 'mySplit');
257257
treatmentWithConfig = browserClient.getTreatmentWithConfig('mySplit');
258258
// Attributes parameter is optional on both signatures.
259-
treatmentWithConfig = nodeClient.getTreatmentWithConfig(splitKey, 'mySplit', attributes);
259+
treatmentWithConfig = client.getTreatmentWithConfig(splitKey, 'mySplit', attributes);
260260
treatmentWithConfig = browserClient.getTreatmentWithConfig('mySplit', attributes);
261261

262262
// We can call getTreatmentsWithConfig with or without a key.
263-
treatmentsWithConfig = nodeClient.getTreatmentsWithConfig(splitKey, ['mySplit']);
263+
treatmentsWithConfig = client.getTreatmentsWithConfig(splitKey, ['mySplit']);
264264
treatmentsWithConfig = browserClient.getTreatmentsWithConfig(['mySplit']);
265265
// Attributes parameter is optional on both signatures.
266-
treatmentsWithConfig = nodeClient.getTreatmentsWithConfig(splitKey, ['mySplit'], attributes);
266+
treatmentsWithConfig = client.getTreatmentsWithConfig(splitKey, ['mySplit'], attributes);
267267
treatmentsWithConfig = browserClient.getTreatmentsWithConfig(['mySplit'], attributes);
268268

269269
// We can call getTreatmentsByFlagSet with or without a key.
270-
treatments = nodeClient.getTreatmentsByFlagSet(splitKey, 'set_a');
270+
treatments = client.getTreatmentsByFlagSet(splitKey, 'set_a');
271271
treatments = browserClient.getTreatmentsByFlagSet('set_a');
272272
// Attributes parameter is optional.
273-
treatments = nodeClient.getTreatmentsByFlagSet(splitKey, 'set_a', attributes);
273+
treatments = client.getTreatmentsByFlagSet(splitKey, 'set_a', attributes);
274274
treatments = browserClient.getTreatmentsByFlagSet('set_a', attributes);
275275

276276
// We can call getTreatmentsByFlagSets with or without a key.
277-
treatments = nodeClient.getTreatmentsByFlagSets(splitKey, ['set_a']);
277+
treatments = client.getTreatmentsByFlagSets(splitKey, ['set_a']);
278278
treatments = browserClient.getTreatmentsByFlagSets(['set_a']);
279279
// Attributes parameter is optional.
280-
treatments = nodeClient.getTreatmentsByFlagSets(splitKey, ['set_a'], attributes);
280+
treatments = client.getTreatmentsByFlagSets(splitKey, ['set_a'], attributes);
281281
treatments = browserClient.getTreatmentsByFlagSets(['set_a'], attributes);
282282

283283
// We can call getTreatmentsWithConfigByFlagSet with or without a key.
284-
treatmentsWithConfig = nodeClient.getTreatmentsWithConfigByFlagSet(splitKey, 'set_a');
284+
treatmentsWithConfig = client.getTreatmentsWithConfigByFlagSet(splitKey, 'set_a');
285285
treatmentsWithConfig = browserClient.getTreatmentsWithConfigByFlagSet('set_a');
286286
// Attributes parameter is optional.
287-
treatmentsWithConfig = nodeClient.getTreatmentsWithConfigByFlagSet(splitKey, 'set_a', attributes);
287+
treatmentsWithConfig = client.getTreatmentsWithConfigByFlagSet(splitKey, 'set_a', attributes);
288288
treatmentsWithConfig = browserClient.getTreatmentsWithConfigByFlagSet('set_a', attributes);
289289

290290
// We can call getTreatmentsWithConfigByFlagSets with or without a key.
291-
treatmentsWithConfig = nodeClient.getTreatmentsWithConfigByFlagSets(splitKey, ['set_a']);
291+
treatmentsWithConfig = client.getTreatmentsWithConfigByFlagSets(splitKey, ['set_a']);
292292
treatmentsWithConfig = browserClient.getTreatmentsWithConfigByFlagSets(['set_a']);
293293
// Attributes parameter is optional.
294-
treatmentsWithConfig = nodeClient.getTreatmentsWithConfigByFlagSets(splitKey, ['set_a'], attributes);
294+
treatmentsWithConfig = client.getTreatmentsWithConfigByFlagSets(splitKey, ['set_a'], attributes);
295295
treatmentsWithConfig = browserClient.getTreatmentsWithConfigByFlagSets(['set_a'], attributes);
296296

297297
// We can call track with or without a key.
298-
tracked = nodeClient.track(splitKey, 'myTrafficType', 'myEventType'); // all params
298+
tracked = client.track(splitKey, 'myTrafficType', 'myEventType'); // all params
299299
tracked = browserClient.track('myTrafficType', 'myEventType'); // key bound, tt provided.
300300
// Value parameter is optional on all signatures.
301-
tracked = nodeClient.track(splitKey, 'myTrafficType', 'myEventType', 10);
301+
tracked = client.track(splitKey, 'myTrafficType', 'myEventType', 10);
302302
tracked = browserClient.track('myTrafficType', 'myEventType', 10);
303303
// Properties parameter is optional on all signatures.
304-
tracked = nodeClient.track(splitKey, 'myTrafficType', 'myEventType', 10, { prop1: 1, prop2: '2', prop3: false, prop4: null });
304+
tracked = client.track(splitKey, 'myTrafficType', 'myEventType', 10, { prop1: 1, prop2: '2', prop3: false, prop4: null });
305305
tracked = browserClient.track('myTrafficType', 'myEventType', undefined, { prop1: 1, prop2: '2', prop3: false, prop4: null });
306306

307307
/*** Repeating tests for Async Client ***/
308308

309309
// Events constants we get (same as for sync client, just for interface checking)
310-
const eventConstsAsync: { [key: string]: SplitIO.Event } = nodeAsyncClient.Event;
311-
splitEvent = nodeAsyncClient.Event.SDK_READY;
312-
splitEvent = nodeAsyncClient.Event.SDK_READY_FROM_CACHE;
313-
splitEvent = nodeAsyncClient.Event.SDK_READY_TIMED_OUT;
314-
splitEvent = nodeAsyncClient.Event.SDK_UPDATE;
310+
const eventConstsAsync: { [key: string]: SplitIO.Event } = asyncClient.Event;
311+
splitEvent = asyncClient.Event.SDK_READY;
312+
splitEvent = asyncClient.Event.SDK_READY_FROM_CACHE;
313+
splitEvent = asyncClient.Event.SDK_READY_TIMED_OUT;
314+
splitEvent = asyncClient.Event.SDK_UPDATE;
315315

316316
// Client implements methods from NodeJS.Events. (same as for sync client, just for interface checking)
317-
nodeAsyncClient = nodeAsyncClient.on(splitEvent, () => { });
318-
const a1: boolean = nodeAsyncClient.emit(splitEvent);
319-
nodeAsyncClient = nodeAsyncClient.removeAllListeners(splitEvent);
320-
nodeAsyncClient = nodeAsyncClient.removeAllListeners();
321-
const b1: number = nodeAsyncClient.listenerCount(splitEvent);
322-
nodeEventEmitter = nodeAsyncClient;
317+
asyncClient = asyncClient.on(splitEvent, () => { });
318+
const a1: boolean = asyncClient.emit(splitEvent);
319+
asyncClient = asyncClient.removeAllListeners(splitEvent);
320+
asyncClient = asyncClient.removeAllListeners();
321+
const b1: number = asyncClient.listenerCount(splitEvent);
322+
nodeEventEmitter = asyncClient;
323323

324324
// Ready, destroy and flush (same as for sync client, just for interface checking)
325-
promise = nodeAsyncClient.ready();
326-
promise = nodeAsyncClient.destroy();
325+
promise = asyncClient.ready();
326+
promise = asyncClient.destroy();
327327
promise = AsyncSDK.destroy();
328328
// @TODO not public yet
329-
// promise = nodeAsyncClient.flush();
329+
// promise = asyncClient.flush();
330330

331331
// We can call getTreatment but always with a key.
332-
asyncTreatment = nodeAsyncClient.getTreatment(splitKey, 'mySplit');
332+
asyncTreatment = asyncClient.getTreatment(splitKey, 'mySplit');
333333
// Attributes parameter is optional
334-
asyncTreatment = nodeAsyncClient.getTreatment(splitKey, 'mySplit', attributes);
334+
asyncTreatment = asyncClient.getTreatment(splitKey, 'mySplit', attributes);
335335

336336
// We can call getTreatments but always with a key.
337-
asyncTreatments = nodeAsyncClient.getTreatments(splitKey, ['mySplit']);
337+
asyncTreatments = asyncClient.getTreatments(splitKey, ['mySplit']);
338338
// Attributes parameter is optional
339-
asyncTreatments = nodeAsyncClient.getTreatments(splitKey, ['mySplit'], attributes);
339+
asyncTreatments = asyncClient.getTreatments(splitKey, ['mySplit'], attributes);
340340

341341
// We can call getTreatmentWithConfig but always with a key.
342-
asyncTreatmentWithConfig = nodeAsyncClient.getTreatmentWithConfig(splitKey, 'mySplit');
342+
asyncTreatmentWithConfig = asyncClient.getTreatmentWithConfig(splitKey, 'mySplit');
343343
// Attributes parameter is optional
344-
asyncTreatmentWithConfig = nodeAsyncClient.getTreatmentWithConfig(splitKey, 'mySplit', attributes);
344+
asyncTreatmentWithConfig = asyncClient.getTreatmentWithConfig(splitKey, 'mySplit', attributes);
345345

346346
// We can call getTreatments but always with a key.
347-
asyncTreatmentsWithConfig = nodeAsyncClient.getTreatmentsWithConfig(splitKey, ['mySplit']);
347+
asyncTreatmentsWithConfig = asyncClient.getTreatmentsWithConfig(splitKey, ['mySplit']);
348348
// Attributes parameter is optional
349-
asyncTreatmentsWithConfig = nodeAsyncClient.getTreatmentsWithConfig(splitKey, ['mySplit'], attributes);
349+
asyncTreatmentsWithConfig = asyncClient.getTreatmentsWithConfig(splitKey, ['mySplit'], attributes);
350350

351351
// We can call getTreatmentsByFlagSet
352-
asyncTreatments = nodeAsyncClient.getTreatmentsByFlagSet(splitKey, 'set_a');
352+
asyncTreatments = asyncClient.getTreatmentsByFlagSet(splitKey, 'set_a');
353353
// Attributes parameter is optional
354-
asyncTreatments = nodeAsyncClient.getTreatmentsByFlagSet(splitKey, 'set_a', attributes);
354+
asyncTreatments = asyncClient.getTreatmentsByFlagSet(splitKey, 'set_a', attributes);
355355

356356
// We can call getTreatmentsByFlagSets
357-
asyncTreatments = nodeAsyncClient.getTreatmentsByFlagSets(splitKey, ['set_a']);
357+
asyncTreatments = asyncClient.getTreatmentsByFlagSets(splitKey, ['set_a']);
358358
// Attributes parameter is optional
359-
asyncTreatments = nodeAsyncClient.getTreatmentsByFlagSets(splitKey, ['set_a'], attributes);
359+
asyncTreatments = asyncClient.getTreatmentsByFlagSets(splitKey, ['set_a'], attributes);
360360

361361
// We can call getTreatmentsWithConfigByFlagSet
362-
asyncTreatmentsWithConfig = nodeAsyncClient.getTreatmentsWithConfigByFlagSet(splitKey, 'set_a');
362+
asyncTreatmentsWithConfig = asyncClient.getTreatmentsWithConfigByFlagSet(splitKey, 'set_a');
363363
// Attributes parameter is optional
364-
asyncTreatmentsWithConfig = nodeAsyncClient.getTreatmentsWithConfigByFlagSet(splitKey, 'set_a', attributes);
364+
asyncTreatmentsWithConfig = asyncClient.getTreatmentsWithConfigByFlagSet(splitKey, 'set_a', attributes);
365365

366366
// We can call getTreatmentsByFlagSets but always with a key.
367-
asyncTreatmentsWithConfig = nodeAsyncClient.getTreatmentsWithConfigByFlagSets(splitKey, ['set_a']);
367+
asyncTreatmentsWithConfig = asyncClient.getTreatmentsWithConfigByFlagSets(splitKey, ['set_a']);
368368
// Attributes parameter is optional
369-
asyncTreatmentsWithConfig = nodeAsyncClient.getTreatmentsWithConfigByFlagSets(splitKey, ['set_a'], attributes);
369+
asyncTreatmentsWithConfig = asyncClient.getTreatmentsWithConfigByFlagSets(splitKey, ['set_a'], attributes);
370370

371371
// We can call track only with a key.
372-
trackPromise = nodeAsyncClient.track(splitKey, 'myTrafficType', 'myEventType'); // all required params
372+
trackPromise = asyncClient.track(splitKey, 'myTrafficType', 'myEventType'); // all required params
373373
// Value parameter is optional.
374-
trackPromise = nodeAsyncClient.track(splitKey, 'myTrafficType', 'myEventType', 10);
374+
trackPromise = asyncClient.track(splitKey, 'myTrafficType', 'myEventType', 10);
375375
// Properties parameter is optional
376-
trackPromise = nodeAsyncClient.track(splitKey, 'myTrafficType', 'myEventType', 10, { prop1: 1, prop2: '2', prop3: true, prop4: null });
376+
trackPromise = asyncClient.track(splitKey, 'myTrafficType', 'myEventType', 10, { prop1: 1, prop2: '2', prop3: true, prop4: null });
377377

378378
/**** Tests for IManager interface ****/
379379

@@ -594,9 +594,23 @@ let fullAsyncSettings: SplitIO.INodeAsyncSettings = {
594594
labelsEnabled: false,
595595
IPAddressesEnabled: false
596596
},
597+
scheduler: {
598+
featuresRefreshRate: 1,
599+
impressionsRefreshRate: 1,
600+
impressionsQueueSize: 1,
601+
metricsRefreshRate: 1,
602+
telemetryRefreshRate: 1,
603+
segmentsRefreshRate: 1,
604+
offlineRefreshRate: 1,
605+
eventsPushRate: 1,
606+
eventsQueueSize: 1
607+
},
597608
startup: {
598609
readyTimeout: 1,
610+
requestTimeoutBeforeReady: 1,
611+
retriesOnFailureBeforeReady: 1
599612
},
613+
features: mockedFeaturesPath,
600614
storage: {
601615
type: 'REDIS',
602616
options: {

‎types/index.d.ts‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -12,17 +12,17 @@ declare module JsSdk {
1212
* The settings parameter should be an object that complies with the SplitIO.INodeAsyncSettings.
1313
* For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#configuration}
1414
*/
15-
export function SplitFactory(settings: SplitIO.INodeAsyncSettings): SplitIO.INodeAsyncSDK;
15+
export function SplitFactory(settings: SplitIO.INodeAsyncSettings): SplitIO.IAsyncSDK;
1616
/**
1717
* Split.io SDK factory function.
1818
* The settings parameter should be an object that complies with the SplitIO.INodeSettings.
1919
* For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#configuration}
2020
*/
21-
export function SplitFactory(settings: SplitIO.INodeSettings): SplitIO.INodeSDK;
21+
export function SplitFactory(settings: SplitIO.INodeSettings): SplitIO.ISDK;
2222
/**
2323
* Split.io SDK factory function.
2424
* The settings parameter should be an object that complies with the SplitIO.IBrowserSettings.
2525
* For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#configuration}
2626
*/
27-
export function SplitFactory(settings: SplitIO.IBrowserSettings): SplitIO.ISDK;
27+
export function SplitFactory(settings: SplitIO.IBrowserSettings): SplitIO.IBrowserSDK;
2828
}

0 commit comments

Comments
 (0)