@setgo/sdk 1.0.1

package/dist/core/metrics-reporter.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Metrics Reporter - collects and sends usage metrics
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsReporter = void 0;
+const index_js_1 = require("../errors/index.js");
+class MetricsReporter {
+    metrics = new Map();
+    bucketStart;
+    sendInterval;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.bucketStart = this.getCurrentHourBucket();
+    }
+    /**
+     * Get the current hour bucket timestamp
+     */
+    getCurrentHourBucket() {
+        const now = new Date();
+        now.setMinutes(0, 0, 0);
+        return now;
+    }
+    /**
+     * Start the metrics reporting interval
+     */
+    start() {
+        if (this.config.disableMetrics)
+            return;
+        this.sendInterval = setInterval(() => {
+            void this.flush();
+        }, this.config.metricsInterval);
+        // Ensure the interval doesn't prevent Node.js from exiting
+        if (this.sendInterval.unref) {
+            this.sendInterval.unref();
+        }
+    }
+    /**
+     * Stop the metrics reporting interval
+     */
+    stop() {
+        if (this.sendInterval) {
+            clearInterval(this.sendInterval);
+            this.sendInterval = undefined;
+        }
+    }
+    /**
+     * Track a feature evaluation
+     */
+    track(featureName, enabled) {
+        if (this.config.disableMetrics)
+            return;
+        // Check if we need to rotate the bucket
+        const currentBucket = this.getCurrentHourBucket();
+        if (currentBucket.getTime() !== this.bucketStart.getTime()) {
+            // New hour, flush old metrics and start fresh
+            void this.flush();
+            this.bucketStart = currentBucket;
+        }
+        const existing = this.metrics.get(featureName) ?? { yes: 0, no: 0 };
+        if (enabled) {
+            existing.yes++;
+        }
+        else {
+            existing.no++;
+        }
+        this.metrics.set(featureName, existing);
+    }
+    /**
+     * Flush metrics to the server
+     */
+    async flush() {
+        if (this.config.disableMetrics)
+            return;
+        if (this.metrics.size === 0)
+            return;
+        const toggles = [];
+        for (const [featureName, data] of this.metrics.entries()) {
+            if (data.yes > 0 || data.no > 0) {
+                toggles.push({
+                    featureName,
+                    yes: data.yes,
+                    no: data.no,
+                });
+            }
+        }
+        if (toggles.length === 0)
+            return;
+        const payload = {
+            appName: this.config.appName,
+            instanceId: this.config.instanceId,
+            bucket: this.bucketStart.toISOString(),
+            toggles,
+        };
+        // Clear metrics before sending (to avoid losing new metrics during send)
+        this.metrics.clear();
+        try {
+            await this.sendMetrics(payload);
+        }
+        catch {
+            // Re-add metrics on failure (best effort)
+            for (const toggle of toggles) {
+                const existing = this.metrics.get(toggle.featureName) ?? { yes: 0, no: 0 };
+                existing.yes += toggle.yes;
+                existing.no += toggle.no;
+                this.metrics.set(toggle.featureName, existing);
+            }
+        }
+    }
+    /**
+     * Send metrics to the API
+     */
+    async sendMetrics(payload) {
+        const url = `${this.config.baseUrl}/client/metrics`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: this.config.token,
+                },
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new index_js_1.NetworkError(`Failed to send metrics: ${response.statusText}`, response.status);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new index_js_1.TimeoutError('Metrics request timed out');
+            }
+            if (error instanceof index_js_1.NetworkError) {
+                throw error;
+            }
+            throw new index_js_1.NetworkError(`Failed to send metrics: ${error instanceof Error ? error.message : 'Unknown error'}`, undefined, error instanceof Error ? error : undefined);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Get current metrics count (for testing/debugging)
+     */
+    getMetricsCount() {
+        return this.metrics.size;
+    }
+}
+exports.MetricsReporter = MetricsReporter;

package/dist/core/repository.d.ts

@@ -0,0 +1,37 @@
+/**
+ * In-memory feature repository
+ */
+import type { Feature, FeaturesResponse } from '../types/index.js';
+export declare class FeatureRepository {
+    private features;
+    private version;
+    /**
+     * Update the repository with new features
+     */
+    update(response: FeaturesResponse): void;
+    /**
+     * Get a specific feature by name
+     */
+    get(name: string): Feature | undefined;
+    /**
+     * Get all features
+     */
+    getAll(): Feature[];
+    /**
+     * Check if a feature exists
+     */
+    has(name: string): boolean;
+    /**
+     * Get current version
+     */
+    getVersion(): number;
+    /**
+     * Get the number of features
+     */
+    size(): number;
+    /**
+     * Clear all features
+     */
+    clear(): void;
+}
+//# sourceMappingURL=repository.d.ts.map

package/dist/core/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../src/core/repository.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAEnE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAmC;IACnD,OAAO,CAAC,OAAO,CAAa;IAE5B;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IASxC;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAItC;;OAEG;IACH,MAAM,IAAI,OAAO,EAAE;IAInB;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;OAEG;IACH,UAAU,IAAI,MAAM;IAIpB;;OAEG;IACH,IAAI,IAAI,MAAM;IAId;;OAEG;IACH,KAAK,IAAI,IAAI;CAId"}

package/dist/core/repository.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * In-memory feature repository
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureRepository = void 0;
+class FeatureRepository {
+    features = new Map();
+    version = 0;
+    /**
+     * Update the repository with new features
+     */
+    update(response) {
+        this.version = response.version;
+        this.features.clear();
+        for (const feature of response.features) {
+            this.features.set(feature.name, feature);
+        }
+    }
+    /**
+     * Get a specific feature by name
+     */
+    get(name) {
+        return this.features.get(name);
+    }
+    /**
+     * Get all features
+     */
+    getAll() {
+        return Array.from(this.features.values());
+    }
+    /**
+     * Check if a feature exists
+     */
+    has(name) {
+        return this.features.has(name);
+    }
+    /**
+     * Get current version
+     */
+    getVersion() {
+        return this.version;
+    }
+    /**
+     * Get the number of features
+     */
+    size() {
+        return this.features.size;
+    }
+    /**
+     * Clear all features
+     */
+    clear() {
+        this.features.clear();
+        this.version = 0;
+    }
+}
+exports.FeatureRepository = FeatureRepository;

package/dist/core/strategy-evaluator.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Strategy Evaluator - evaluates feature flag strategies locally
+ */
+import type { Strategy, FeatureContext } from '../types/index.js';
+export declare class StrategyEvaluator {
+    /**
+     * Evaluate a single strategy
+     */
+    evaluate(strategy: Strategy, context?: FeatureContext): boolean;
+    /**
+     * DEFAULT strategy - returns enabled status
+     */
+    private evaluateDefault;
+    /**
+     * GRADUAL_ROLLOUT - percentage-based rollout using hash
+     */
+    private evaluateGradualRollout;
+    /**
+     * USER_WITH_ID - check if userId is in the allowed list
+     */
+    private evaluateUserWithId;
+    /**
+     * FLEXIBLE_ROLLOUT - percentage with custom stickiness
+     */
+    private evaluateFlexibleRollout;
+    /**
+     * REMOTE_ADDRESS - check if IP matches allowed IPs/CIDRs
+     */
+    private evaluateRemoteAddress;
+    /**
+     * Check if context satisfies all constraints
+     */
+    private checkConstraints;
+    /**
+     * Check a single constraint
+     */
+    private checkConstraint;
+    /**
+     * Get value from context by name
+     */
+    private getContextValue;
+}
+//# sourceMappingURL=strategy-evaluator.d.ts.map

package/dist/core/strategy-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy-evaluator.d.ts","sourceRoot":"","sources":["../../src/core/strategy-evaluator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAIlE,qBAAa,iBAAiB;IAC5B;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO;IAiCnE;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAuC9B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAe1B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAqC/B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAe7B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAYxB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqDvB;;OAEG;IACH,OAAO,CAAC,eAAe;CAYxB"}

package/dist/core/strategy-evaluator.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Strategy Evaluator - evaluates feature flag strategies locally
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategyEvaluator = void 0;
+const murmurhash_js_1 = require("../utils/murmurhash.js");
+const ip_matcher_js_1 = require("../utils/ip-matcher.js");
+class StrategyEvaluator {
+    /**
+     * Evaluate a single strategy
+     */
+    evaluate(strategy, context = {}) {
+        if (!strategy.enabled) {
+            return false;
+        }
+        // Check constraints first (if any)
+        if (strategy.constraints && strategy.constraints.length > 0) {
+            if (!this.checkConstraints(strategy.constraints, context)) {
+                return false;
+            }
+        }
+        switch (strategy.type) {
+            case 'DEFAULT':
+                return this.evaluateDefault(strategy);
+            case 'GRADUAL_ROLLOUT':
+                return this.evaluateGradualRollout(strategy, context);
+            case 'USER_WITH_ID':
+                return this.evaluateUserWithId(strategy, context);
+            case 'FLEXIBLE_ROLLOUT':
+                return this.evaluateFlexibleRollout(strategy, context);
+            case 'REMOTE_ADDRESS':
+                return this.evaluateRemoteAddress(strategy, context);
+            default:
+                return false;
+        }
+    }
+    /**
+     * DEFAULT strategy - returns enabled status
+     */
+    evaluateDefault(strategy) {
+        return strategy.enabled;
+    }
+    /**
+     * GRADUAL_ROLLOUT - percentage-based rollout using hash
+     */
+    evaluateGradualRollout(strategy, context) {
+        const params = strategy.parameters;
+        const percentage = params?.percentage ?? 0;
+        if (percentage <= 0)
+            return false;
+        if (percentage >= 100)
+            return true;
+        const stickiness = params?.stickiness ?? 'userId';
+        const groupId = params?.groupId ?? strategy.name;
+        let identifier;
+        switch (stickiness) {
+            case 'userId':
+                identifier = context.userId;
+                break;
+            case 'sessionId':
+                identifier = context.sessionId;
+                break;
+            case 'random':
+                identifier = Math.random().toString();
+                break;
+        }
+        if (!identifier) {
+            // If no identifier available, use random for this evaluation
+            identifier = Math.random().toString();
+        }
+        const hash = (0, murmurhash_js_1.normalizedHash)(groupId, identifier, 100);
+        return hash <= percentage;
+    }
+    /**
+     * USER_WITH_ID - check if userId is in the allowed list
+     */
+    evaluateUserWithId(strategy, context) {
+        if (!context.userId)
+            return false;
+        const params = strategy.parameters;
+        const userIds = params?.userIds ?? [];
+        if (userIds.length === 0)
+            return false;
+        return userIds.includes(context.userId);
+    }
+    /**
+     * FLEXIBLE_ROLLOUT - percentage with custom stickiness
+     */
+    evaluateFlexibleRollout(strategy, context) {
+        const params = strategy.parameters;
+        const rollout = params?.rollout ?? 0;
+        if (rollout <= 0)
+            return false;
+        if (rollout >= 100)
+            return true;
+        const stickiness = params?.stickiness ?? 'default';
+        const groupId = params?.groupId ?? strategy.name;
+        let identifier;
+        if (stickiness === 'default' || stickiness === 'userId') {
+            identifier = context.userId ?? context.sessionId;
+        }
+        else if (stickiness === 'sessionId') {
+            identifier = context.sessionId;
+        }
+        else if (stickiness === 'random') {
+            identifier = Math.random().toString();
+        }
+        else if (context.properties && stickiness in context.properties) {
+            const value = context.properties[stickiness];
+            identifier = value?.toString();
+        }
+        if (!identifier) {
+            identifier = Math.random().toString();
+        }
+        const hash = (0, murmurhash_js_1.normalizedHash)(groupId, identifier, 100);
+        return hash <= rollout;
+    }
+    /**
+     * REMOTE_ADDRESS - check if IP matches allowed IPs/CIDRs
+     */
+    evaluateRemoteAddress(strategy, context) {
+        if (!context.remoteAddress)
+            return false;
+        const params = strategy.parameters;
+        const ips = params?.ips ?? [];
+        if (ips.length === 0)
+            return false;
+        return (0, ip_matcher_js_1.matchIPList)(context.remoteAddress, ips);
+    }
+    /**
+     * Check if context satisfies all constraints
+     */
+    checkConstraints(constraints, context) {
+        for (const constraint of constraints) {
+            if (!this.checkConstraint(constraint, context)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check a single constraint
+     */
+    checkConstraint(constraint, context) {
+        const contextName = constraint['contextName'];
+        const operator = constraint['operator'];
+        const values = constraint['values'];
+        if (!contextName || !operator)
+            return true;
+        const contextValue = this.getContextValue(contextName, context);
+        switch (operator) {
+            case 'IN':
+                return values?.includes(contextValue) ?? false;
+            case 'NOT_IN':
+                return !(values?.includes(contextValue) ?? false);
+            case 'STR_ENDS_WITH':
+                if (typeof contextValue !== 'string' || !values)
+                    return false;
+                return values.some((v) => typeof v === 'string' && contextValue.endsWith(v));
+            case 'STR_STARTS_WITH':
+                if (typeof contextValue !== 'string' || !values)
+                    return false;
+                return values.some((v) => typeof v === 'string' && contextValue.startsWith(v));
+            case 'STR_CONTAINS':
+                if (typeof contextValue !== 'string' || !values)
+                    return false;
+                return values.some((v) => typeof v === 'string' && contextValue.includes(v));
+            case 'NUM_EQ':
+                if (typeof contextValue !== 'number' || !values?.[0])
+                    return false;
+                return contextValue === Number(values[0]);
+            case 'NUM_GT':
+                if (typeof contextValue !== 'number' || !values?.[0])
+                    return false;
+                return contextValue > Number(values[0]);
+            case 'NUM_GTE':
+                if (typeof contextValue !== 'number' || !values?.[0])
+                    return false;
+                return contextValue >= Number(values[0]);
+            case 'NUM_LT':
+                if (typeof contextValue !== 'number' || !values?.[0])
+                    return false;
+                return contextValue < Number(values[0]);
+            case 'NUM_LTE':
+                if (typeof contextValue !== 'number' || !values?.[0])
+                    return false;
+                return contextValue <= Number(values[0]);
+            default:
+                return true;
+        }
+    }
+    /**
+     * Get value from context by name
+     */
+    getContextValue(name, context) {
+        switch (name) {
+            case 'userId':
+                return context.userId;
+            case 'sessionId':
+                return context.sessionId;
+            case 'remoteAddress':
+                return context.remoteAddress;
+            default:
+                return context.properties?.[name];
+        }
+    }
+}
+exports.StrategyEvaluator = StrategyEvaluator;

package/dist/errors/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * SetGo SDK Error Classes
+ */
+export declare class SetGoError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare class NetworkError extends SetGoError {
+    readonly statusCode?: number | undefined;
+    readonly cause?: Error | undefined;
+    constructor(message: string, statusCode?: number | undefined, cause?: Error | undefined);
+}
+export declare class ConfigurationError extends SetGoError {
+    constructor(message: string);
+}
+export declare class AuthenticationError extends SetGoError {
+    constructor(message?: string);
+}
+export declare class TimeoutError extends SetGoError {
+    constructor(message?: string);
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,qBAAa,UAAW,SAAQ,KAAK;aAGjB,IAAI,EAAE,MAAM;gBAD5B,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,MAAM;CAM/B;AAED,qBAAa,YAAa,SAAQ,UAAU;aAGxB,UAAU,CAAC,EAAE,MAAM;aACnB,KAAK,CAAC,EAAE,KAAK;gBAF7B,OAAO,EAAE,MAAM,EACC,UAAU,CAAC,EAAE,MAAM,YAAA,EACnB,KAAK,CAAC,EAAE,KAAK,YAAA;CAMhC;AAED,qBAAa,kBAAmB,SAAQ,UAAU;gBACpC,OAAO,EAAE,MAAM;CAK5B;AAED,qBAAa,mBAAoB,SAAQ,UAAU;gBACrC,OAAO,GAAE,MAAuC;CAK7D;AAED,qBAAa,YAAa,SAAQ,UAAU;gBAC9B,OAAO,GAAE,MAA4B;CAKlD"}

package/dist/errors/index.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * SetGo SDK Error Classes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = exports.AuthenticationError = exports.ConfigurationError = exports.NetworkError = exports.SetGoError = void 0;
+class SetGoError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'SetGoError';
+        Object.setPrototypeOf(this, SetGoError.prototype);
+    }
+}
+exports.SetGoError = SetGoError;
+class NetworkError extends SetGoError {
+    statusCode;
+    cause;
+    constructor(message, statusCode, cause) {
+        super(message, 'NETWORK_ERROR');
+        this.statusCode = statusCode;
+        this.cause = cause;
+        this.name = 'NetworkError';
+        Object.setPrototypeOf(this, NetworkError.prototype);
+    }
+}
+exports.NetworkError = NetworkError;
+class ConfigurationError extends SetGoError {
+    constructor(message) {
+        super(message, 'CONFIGURATION_ERROR');
+        this.name = 'ConfigurationError';
+        Object.setPrototypeOf(this, ConfigurationError.prototype);
+    }
+}
+exports.ConfigurationError = ConfigurationError;
+class AuthenticationError extends SetGoError {
+    constructor(message = 'Invalid or expired API token') {
+        super(message, 'AUTHENTICATION_ERROR');
+        this.name = 'AuthenticationError';
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class TimeoutError extends SetGoError {
+    constructor(message = 'Request timed out') {
+        super(message, 'TIMEOUT_ERROR');
+        this.name = 'TimeoutError';
+        Object.setPrototypeOf(this, TimeoutError.prototype);
+    }
+}
+exports.TimeoutError = TimeoutError;

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * SetGo SDK - Feature Flag Management
+ *
+ * @example
+ * ```typescript
+ * import { SetGoClient } from '@setgo/sdk';
+ *
+ * const client = new SetGoClient({
+ *   baseUrl: process.env.SETGO_URL,
+ *   token: process.env.SETGO_TOKEN,
+ *   appName: 'my-app',
+ * });
+ *
+ * await client.start();
+ *
+ * if (client.isEnabled('dark-mode', { userId: '123' })) {
+ *   // Feature is enabled
+ * }
+ * ```
+ */
+export { SetGoClient } from './core/index.js';
+export type { SetGoConfig, ResolvedSetGoConfig, FeatureContext, Feature, Strategy, StrategyType, FeaturesResponse, SetGoEventType, SetGoEventHandler, SetGoReadyEvent, SetGoUpdateEvent, SetGoErrorEvent, SetGoEvent, FeatureMetric, MetricsPayload, RegisterPayload, SetGoModuleAsyncOptions, } from './types/index.js';
+export { SetGoError, NetworkError, ConfigurationError, AuthenticationError, TimeoutError, } from './errors/index.js';
+export { FeatureRepository, StrategyEvaluator, MetricsReporter } from './core/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9C,YAAY,EACV,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,aAAa,EACb,cAAc,EACd,eAAe,EACf,uBAAuB,GACxB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,UAAU,EACV,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACnB,YAAY,GACb,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * SetGo SDK - Feature Flag Management
+ *
+ * @example
+ * ```typescript
+ * import { SetGoClient } from '@setgo/sdk';
+ *
+ * const client = new SetGoClient({
+ *   baseUrl: process.env.SETGO_URL,
+ *   token: process.env.SETGO_TOKEN,
+ *   appName: 'my-app',
+ * });
+ *
+ * await client.start();
+ *
+ * if (client.isEnabled('dark-mode', { userId: '123' })) {
+ *   // Feature is enabled
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsReporter = exports.StrategyEvaluator = exports.FeatureRepository = exports.TimeoutError = exports.AuthenticationError = exports.ConfigurationError = exports.NetworkError = exports.SetGoError = exports.SetGoClient = void 0;
+// Main client
+var index_js_1 = require("./core/index.js");
+Object.defineProperty(exports, "SetGoClient", { enumerable: true, get: function () { return index_js_1.SetGoClient; } });
+// Errors
+var index_js_2 = require("./errors/index.js");
+Object.defineProperty(exports, "SetGoError", { enumerable: true, get: function () { return index_js_2.SetGoError; } });
+Object.defineProperty(exports, "NetworkError", { enumerable: true, get: function () { return index_js_2.NetworkError; } });
+Object.defineProperty(exports, "ConfigurationError", { enumerable: true, get: function () { return index_js_2.ConfigurationError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return index_js_2.AuthenticationError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return index_js_2.TimeoutError; } });
+// Internal (for advanced usage)
+var index_js_3 = require("./core/index.js");
+Object.defineProperty(exports, "FeatureRepository", { enumerable: true, get: function () { return index_js_3.FeatureRepository; } });
+Object.defineProperty(exports, "StrategyEvaluator", { enumerable: true, get: function () { return index_js_3.StrategyEvaluator; } });
+Object.defineProperty(exports, "MetricsReporter", { enumerable: true, get: function () { return index_js_3.MetricsReporter; } });

package/dist/nestjs/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * SetGo NestJS Module Exports
+ */
+export { SetGoModule } from './setgo.module.js';
+export { SetGoService } from './setgo.service.js';
+export { SETGO_CONFIG, SETGO_CLIENT } from './setgo.constants.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/nestjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/nestjs/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/nestjs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * SetGo NestJS Module Exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SETGO_CLIENT = exports.SETGO_CONFIG = exports.SetGoService = exports.SetGoModule = void 0;
+var setgo_module_js_1 = require("./setgo.module.js");
+Object.defineProperty(exports, "SetGoModule", { enumerable: true, get: function () { return setgo_module_js_1.SetGoModule; } });
+var setgo_service_js_1 = require("./setgo.service.js");
+Object.defineProperty(exports, "SetGoService", { enumerable: true, get: function () { return setgo_service_js_1.SetGoService; } });
+var setgo_constants_js_1 = require("./setgo.constants.js");
+Object.defineProperty(exports, "SETGO_CONFIG", { enumerable: true, get: function () { return setgo_constants_js_1.SETGO_CONFIG; } });
+Object.defineProperty(exports, "SETGO_CLIENT", { enumerable: true, get: function () { return setgo_constants_js_1.SETGO_CLIENT; } });