ts-client-lib 0.0.7

package/finance/TSTax.d.ts

@@ -0,0 +1,49 @@
+export interface TSTier {
+    rate: number;
+    floor: number;
+    ceiling: number;
+}
+export interface TSTaxTiers {
+    product: number;
+    deduct: any;
+    exciseRate: number;
+    tiers: TSTier[];
+}
+/**
+ * Colon-delimited `deduct` DSL (pairs: key, value, key, value, …), e.g. `"income:1:floor:1:bonus:1"`.
+ * Use for client-visible specs so users know which TSTax instructions apply before calling the backend.
+ */
+export declare function encodeDeductSpec(pairs: Record<string, string | number | boolean>): string;
+/** Parses a `deduct` string into key/value pairs (values are strings, matching `find()`). */
+export declare function decodeDeductSpec(s: string): Record<string, string>;
+/**
+ * Normalizes `tax.deduct` in place: `null`/`undefined` → `{}`, string → object via {@link decodeDeductSpec}.
+ * Idempotent for plain objects. Call before `outcome` / `income` when `find()` was not used.
+ */
+export declare function parseDeductInPlace(tax: TSTaxTiers): void;
+/**
+ * [{
+    product: 1,
+    deduct: "income:1:floor:1:bonus:1",
+    exciseRate: 10,
+    tiers: [ { rate: 15, floor: 0, ceiling: 0 } ]
+ * }]
+ */
+export declare class TSTax {
+    taxes: TSTaxTiers[];
+    constructor(taxes?: TSTaxTiers[]);
+    income(tax: TSTaxTiers, income: number): {
+        value: number;
+        percent: number;
+    };
+    outcome(tax: TSTaxTiers, { outcome, income, reward, max }: {
+        outcome: number;
+        income: number;
+        reward?: number;
+        max?: number;
+    }): {
+        value: number;
+        percent: number;
+    };
+    find(product: number): TSTaxTiers;
+}

package/finance/TSTax.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSTax = void 0;
+exports.encodeDeductSpec = encodeDeductSpec;
+exports.decodeDeductSpec = decodeDeductSpec;
+exports.parseDeductInPlace = parseDeductInPlace;
+var TSArray_1 = require("../utils/TSArray");
+/**
+ * Colon-delimited `deduct` DSL (pairs: key, value, key, value, …), e.g. `"income:1:floor:1:bonus:1"`.
+ * Use for client-visible specs so users know which TSTax instructions apply before calling the backend.
+ */
+function encodeDeductSpec(pairs) {
+    var keys = Object.keys(pairs).sort();
+    var parts = [];
+    for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+        var k = keys_1[_i];
+        parts.push(k, String(pairs[k]));
+    }
+    return parts.join(':');
+}
+/** Parses a `deduct` string into key/value pairs (values are strings, matching `find()`). */
+function decodeDeductSpec(s) {
+    var t = s.trim();
+    if (!t)
+        return {};
+    return TSArray_1.TSArray.toPair(t.split(':'));
+}
+/**
+ * Normalizes `tax.deduct` in place: `null`/`undefined` → `{}`, string → object via {@link decodeDeductSpec}.
+ * Idempotent for plain objects. Call before `outcome` / `income` when `find()` was not used.
+ */
+function parseDeductInPlace(tax) {
+    if (tax.deduct == null) {
+        tax.deduct = {};
+    }
+    else if (typeof tax.deduct === 'string') {
+        tax.deduct = tax.deduct ? decodeDeductSpec(tax.deduct) : {};
+    }
+}
+/** Caller must have run {@link parseDeductInPlace} on `tax` so `deduct` is an object. */
+function taxableWorth(outcome, income, reward, tax) {
+    var d = tax.deduct;
+    var skipIncome = (typeof reward === 'number') || (!d.income && typeof reward !== 'number');
+    return outcome - (skipIncome ? 0 : income);
+}
+function tierOutcomeIfMatch(tax, t, outcome, income, worth, max) {
+    if (worth < t.floor || (worth > t.ceiling && worth !== max))
+        return null;
+    var percent = t.rate;
+    var taxPrecent = percent / 100;
+    var d = tax.deduct;
+    if (d.floor) {
+        var value = (outcome - income - tax.tiers[0].floor > 0) ? (outcome - tax.tiers[0].floor) * -taxPrecent : 0;
+        return { value: value, percent: percent };
+    }
+    return { value: worth * -taxPrecent, percent: percent };
+}
+/**
+ * [{
+    product: 1,
+    deduct: "income:1:floor:1:bonus:1",
+    exciseRate: 10,
+    tiers: [ { rate: 15, floor: 0, ceiling: 0 } ]
+ * }]
+ */
+var TSTax = /** @class */ (function () {
+    function TSTax(taxes) {
+        if (taxes === void 0) { taxes = []; }
+        this.taxes = taxes;
+    }
+    TSTax.prototype.income = function (tax, income) {
+        parseDeductInPlace(tax);
+        if (!tax.exciseRate) {
+            return { value: 0, percent: 0 };
+        }
+        var percent = tax.exciseRate, value = income / (1 + (percent / 100));
+        return { value: value, percent: percent };
+    };
+    TSTax.prototype.outcome = function (tax, _a) {
+        var outcome = _a.outcome, income = _a.income, _b = _a.reward, reward = _b === void 0 ? undefined : _b, _c = _a.max, max = _c === void 0 ? Infinity : _c;
+        parseDeductInPlace(tax);
+        if (!tax.tiers || tax.tiers.length < 1) {
+            return { value: outcome - (typeof reward === 'number' ? 0 : income), percent: 0 };
+        }
+        if (!Number(tax.tiers[tax.tiers.length - 1].ceiling)) {
+            tax.tiers[tax.tiers.length - 1].ceiling = max;
+        }
+        var worth = taxableWorth(outcome, income, reward, tax);
+        for (var _i = 0, _d = tax.tiers; _i < _d.length; _i++) {
+            var t = _d[_i];
+            var hit = tierOutcomeIfMatch(tax, t, outcome, income, worth, max);
+            if (hit)
+                return hit;
+        }
+        return { value: 0, percent: 0 };
+    };
+    TSTax.prototype.find = function (product) {
+        var tax = this.taxes.find(function (t) { return t.product === product; });
+        if (!tax)
+            return {};
+        parseDeductInPlace(tax);
+        return tax;
+    };
+    return TSTax;
+}());
+exports.TSTax = TSTax;

package/finance/bonus-money.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Bonus amounts + **TSMoney** — semantics and strict DTO helpers.
+ *
+ * **Semantics (align with `BonusEligibility.calculateValue`)**
+ * - **`fixed`**: `value` is an integer in **minor units** (same as `TSMoney.amount`).
+ * - **`percentage`**: `value` is a percent (e.g. `10` → 10%). `depositAmount` / `activityAmount` are in
+ *   **major (display) units** (e.g. dollars). Optional **`maxValue`** caps the result in those same units.
+ * - **`tiered` / `dynamic`**: same numeric rules as `calculateValue`; money output uses `fromDecimal`
+ *   where the computed value is fractional.
+ *
+ * Optional **`valueMoney` / `maxValueMoney` / `minDepositMoney`** mirror the legacy fields for strict
+ * transport (GraphQL/JSON). If present, they must match — use `assertCoherentMoneyFields`.
+ */
+import { TSMoney } from '../entities/TSMoney';
+import { type CurrencyCode } from '../entities/TSCurrencies';
+export type TSMoneyJSON = {
+    amount: number;
+    currency: CurrencyCode;
+};
+export interface BonusMoneyFields {
+    currency: CurrencyCode;
+    valueType: 'fixed' | 'percentage' | 'tiered' | 'dynamic';
+    value: number;
+    valueMoney?: TSMoneyJSON;
+    maxValueMoney?: TSMoneyJSON;
+    minDepositMoney?: TSMoneyJSON;
+}
+export declare function parseMoneyJSON(input: TSMoneyJSON): TSMoney;
+export declare function toMoneyJSON(m: TSMoney): TSMoneyJSON;
+/**
+ * Ensures optional money DTO fields agree with `currency` / `value` (fixed).
+ */
+export declare function assertCoherentMoneyFields(t: BonusMoneyFields): void;
+/**
+ * Fail fast if template references an unknown ISO/registry currency.
+ */
+export declare function assertKnownCurrenciesOnTemplate(template: {
+    currency: CurrencyCode;
+    supportedCurrencies?: readonly CurrencyCode[];
+}): void;
+export declare function hasCurrencyCode(code: string): boolean;

package/finance/bonus-money.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Bonus amounts + **TSMoney** — semantics and strict DTO helpers.
+ *
+ * **Semantics (align with `BonusEligibility.calculateValue`)**
+ * - **`fixed`**: `value` is an integer in **minor units** (same as `TSMoney.amount`).
+ * - **`percentage`**: `value` is a percent (e.g. `10` → 10%). `depositAmount` / `activityAmount` are in
+ *   **major (display) units** (e.g. dollars). Optional **`maxValue`** caps the result in those same units.
+ * - **`tiered` / `dynamic`**: same numeric rules as `calculateValue`; money output uses `fromDecimal`
+ *   where the computed value is fractional.
+ *
+ * Optional **`valueMoney` / `maxValueMoney` / `minDepositMoney`** mirror the legacy fields for strict
+ * transport (GraphQL/JSON). If present, they must match — use `assertCoherentMoneyFields`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMoneyJSON = parseMoneyJSON;
+exports.toMoneyJSON = toMoneyJSON;
+exports.assertCoherentMoneyFields = assertCoherentMoneyFields;
+exports.assertKnownCurrenciesOnTemplate = assertKnownCurrenciesOnTemplate;
+exports.hasCurrencyCode = hasCurrencyCode;
+var TSMoney_1 = require("../entities/TSMoney");
+var TSCurrencies_1 = require("../entities/TSCurrencies");
+function parseMoneyJSON(input) {
+    return TSMoney_1.TSMoney.fromInteger(input.amount, input.currency);
+}
+function toMoneyJSON(m) {
+    return m.toJSON();
+}
+/**
+ * Ensures optional money DTO fields agree with `currency` / `value` (fixed).
+ */
+function assertCoherentMoneyFields(t) {
+    if (t.valueMoney) {
+        if (t.valueMoney.currency !== t.currency) {
+            throw new TypeError('valueMoney.currency must match template.currency');
+        }
+        if (t.valueType === 'fixed' && t.valueMoney.amount !== t.value) {
+            throw new TypeError('valueMoney.amount must equal value for fixed valueType');
+        }
+    }
+    if (t.maxValueMoney && t.maxValueMoney.currency !== t.currency) {
+        throw new TypeError('maxValueMoney.currency must match template.currency');
+    }
+    if (t.minDepositMoney && t.minDepositMoney.currency !== t.currency) {
+        throw new TypeError('minDepositMoney.currency must match template.currency');
+    }
+}
+/**
+ * Fail fast if template references an unknown ISO/registry currency.
+ */
+function assertKnownCurrenciesOnTemplate(template) {
+    var _a;
+    (0, TSCurrencies_1.resolveCurrency)(String(template.currency));
+    for (var _i = 0, _b = (_a = template.supportedCurrencies) !== null && _a !== void 0 ? _a : []; _i < _b.length; _i++) {
+        var c = _b[_i];
+        (0, TSCurrencies_1.resolveCurrency)(String(c));
+    }
+}
+function hasCurrencyCode(code) {
+    return (0, TSCurrencies_1.hasCurrency)(code);
+}

package/games/TSBetSlip.d.ts

@@ -0,0 +1,72 @@
+export interface TSBSSelection {
+    k: string;
+    m: string;
+    o: number;
+    id: string;
+    sk?: string;
+    s?: string;
+}
+export interface TSBSEventSelection {
+    k: string;
+    e: any;
+    s: TSBSSelection;
+}
+export type TSBSCallback = (stake: number, odd: number, keys: (string | number)[], group?: number | string) => {
+    payout: number;
+    stake: number;
+};
+export type TSBSResult = {
+    numberOfBets: number;
+    totalStake: number;
+    totalOdds: number;
+    minPayOut?: number;
+    maxPayOut: number;
+};
+export type TSBSMode = 'single' | 'multiple' | 'multiple+' | 'system';
+export declare class TSBetSlip {
+    static get modes(): Array<TSBSMode>;
+    static initModes({ modes, multiplePlus }: {
+        modes?: TSBSMode[] | TSBSMode;
+        multiplePlus?: string;
+    }): Array<TSBSMode>;
+    static filterMode(modes: Array<TSBSMode> | TSBSMode): Array<TSBSMode> | TSBSMode;
+    static accumulator(selections: TSBSSelection[], data: Record<string, number | string>, cb?: TSBSCallback): TSBSResult;
+    static multiplicator(selections: TSBSSelection[], data: number, cb?: TSBSCallback): TSBSResult;
+    static aggregator(selections: Record<string, TSBSSelection>, data: Record<string, unknown> & {
+        _?: unknown[][];
+    }, cb?: TSBSCallback): TSBSResult;
+    /** Combined odds and selection keys for one system row; `null` if row is invalid. */
+    private static aggregatorRowOddsAndKeys;
+    static cb(stake: number, odd: number, _keys: (string | number)[], _group?: number | string): {
+        payout: number;
+        stake: number;
+    };
+    static rules({ minBet, maxBet, maxPayout, minSelection, maxSelection }?: {
+        minBet?: number | undefined;
+        maxBet?: number | undefined;
+        maxPayout?: number | undefined;
+        minSelection?: number | undefined;
+        maxSelection?: number | undefined;
+    }, overrides?: Record<string, unknown>): {
+        stake: {
+            min: number;
+            max: number;
+        };
+        payout: {
+            max: number;
+        };
+        selection: {
+            min: number;
+            max: number;
+        };
+    };
+    static isValid({ rules, selection, stake, balance, payout }: {
+        rules?: ReturnType<typeof TSBetSlip.rules>;
+        selection: number;
+        stake: number;
+        balance: number;
+        payout: number;
+    }): unknown[];
+    static validate(rules: Record<string, unknown>, data: Record<string, unknown>, prefix: (p: string | number) => string): unknown[];
+    static areDuplicate(selections: TSBSSelection[], separator?: string): boolean;
+}

package/games/TSBetSlip.js

@@ -0,0 +1,179 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSBetSlip = void 0;
+var TSObject_1 = require("../utils/TSObject");
+var TSString_1 = require("../utils/TSString");
+var TSValidator_1 = require("../utils/TSValidator");
+var TSBetSlip = /** @class */ (function () {
+    function TSBetSlip() {
+    }
+    Object.defineProperty(TSBetSlip, "modes", {
+        get: function () {
+            return ['single', 'multiple', 'multiple+', 'system'];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TSBetSlip.initModes = function (_a) {
+        var modes = _a.modes, multiplePlus = _a.multiplePlus;
+        var modesArr;
+        if (!modes) {
+            modesArr = __spreadArray([], TSBetSlip.modes, true);
+        }
+        else {
+            var filtered = TSBetSlip.filterMode(modes);
+            modesArr = Array.isArray(filtered) ? filtered : [filtered];
+        }
+        // multiplePlus = tab | multiple
+        if (multiplePlus !== 'tab') {
+            var mpIndex = modesArr.indexOf('multiple+');
+            if (mpIndex !== -1) {
+                modesArr.splice(mpIndex, 1);
+            }
+        }
+        return modesArr;
+    };
+    TSBetSlip.filterMode = function (modes) {
+        var _a;
+        if (Array.isArray(modes)) {
+            return modes.filter(function (m) { return TSBetSlip.modes.indexOf(m) > -1; });
+        }
+        return (_a = TSBetSlip.modes.find(function (m) { return m === modes; })) !== null && _a !== void 0 ? _a : modes;
+    };
+    TSBetSlip.accumulator = function (selections, data, cb) {
+        if (cb === void 0) { cb = TSBetSlip.cb; }
+        var result = { numberOfBets: 0, totalStake: 0, totalOdds: 0, minPayOut: Infinity, maxPayOut: 0 };
+        selections.forEach(function (s) {
+            var _a, _b;
+            var sk = (_a = s.sk) !== null && _a !== void 0 ? _a : '';
+            var stakeSelection = Number(data[sk]) || 0, odd = Number(s.o) || 0;
+            if (stakeSelection) {
+                result.numberOfBets++;
+                var _c = cb(stakeSelection, odd, [sk], sk), payout = _c.payout, stake = _c.stake;
+                var minP = (_b = result.minPayOut) !== null && _b !== void 0 ? _b : Infinity;
+                if (payout < minP) {
+                    result.minPayOut = payout;
+                }
+                result.totalStake += stake;
+                result.maxPayOut += payout;
+                result.totalOdds += odd;
+            }
+        });
+        return result;
+    };
+    TSBetSlip.multiplicator = function (selections, data, cb) {
+        if (cb === void 0) { cb = TSBetSlip.cb; }
+        var result = { numberOfBets: 0, totalStake: 0, totalOdds: 1, maxPayOut: 0 }, keys = [];
+        selections.forEach(function (s) { var _a; return (keys.push((_a = s.sk) !== null && _a !== void 0 ? _a : ''), result.totalOdds *= Number(s.o) || 1); });
+        if (data) {
+            result.numberOfBets = 1;
+        }
+        var _a = cb(data, result.totalOdds, keys), payout = _a.payout, stake = _a.stake;
+        result.maxPayOut = payout;
+        result.totalStake = stake;
+        return result;
+    };
+    TSBetSlip.aggregator = function (selections, data, cb) {
+        var _a, _b;
+        if (cb === void 0) { cb = TSBetSlip.cb; }
+        var result = { numberOfBets: 0, totalStake: 0, totalOdds: 0, minPayOut: Infinity, maxPayOut: 0 };
+        var indexGroups = (_a = data._) !== null && _a !== void 0 ? _a : [];
+        for (var k in data) {
+            if (k === '_')
+                continue;
+            var selectionIndexs = indexGroups[parseInt(k, 10)];
+            if (!data[k] || !selectionIndexs)
+                continue;
+            if (!Array.isArray(selectionIndexs))
+                return result;
+            result.numberOfBets += selectionIndexs.length;
+            for (var i in selectionIndexs) {
+                var row = selectionIndexs[i];
+                var rowOutcome = TSBetSlip.aggregatorRowOddsAndKeys(selections, row);
+                if (rowOutcome === null)
+                    return result;
+                var _c = cb(Number(data[k]), rowOutcome.odds, rowOutcome.keys, "".concat(k, "_").concat(i)), payout = _c.payout, stake = _c.stake;
+                var minP = (_b = result.minPayOut) !== null && _b !== void 0 ? _b : Infinity;
+                if (payout < minP)
+                    result.minPayOut = payout;
+                result.totalOdds += rowOutcome.odds;
+                result.maxPayOut += payout;
+                result.totalStake += stake;
+            }
+        }
+        return result;
+    };
+    /** Combined odds and selection keys for one system row; `null` if row is invalid. */
+    TSBetSlip.aggregatorRowOddsAndKeys = function (selections, row) {
+        if (!row || typeof row[Symbol.iterator] !== 'function')
+            return null;
+        var odds = 1;
+        var keys = [];
+        for (var _i = 0, row_1 = row; _i < row_1.length; _i++) {
+            var j = row_1[_i];
+            var key = String(j);
+            var sel = selections[key];
+            if (!sel)
+                continue;
+            odds *= Number(sel.o);
+            keys.push(key);
+        }
+        return { odds: odds, keys: keys };
+    };
+    TSBetSlip.cb = function (stake, odd, _keys, _group) {
+        return { payout: stake * odd, stake: stake };
+    };
+    TSBetSlip.rules = function (_a, overrides) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.minBet, minBet = _c === void 0 ? 0.3 : _c, _d = _b.maxBet, maxBet = _d === void 0 ? 999999999 : _d, _e = _b.maxPayout, maxPayout = _e === void 0 ? 999999999 : _e, _f = _b.minSelection, minSelection = _f === void 0 ? 1 : _f, _g = _b.maxSelection, maxSelection = _g === void 0 ? 99 : _g;
+        if (overrides === void 0) { overrides = {}; }
+        var rules = {
+            stake: { min: minBet, max: maxBet }, payout: { max: maxPayout }, selection: { min: minSelection, max: maxSelection }
+        };
+        TSObject_1.TSObject.forOwn(rules, function (r, k) {
+            var o = overrides[String(k)];
+            if (o) {
+                Object.assign(r, o);
+            }
+        });
+        return rules;
+    };
+    TSBetSlip.isValid = function (_a) {
+        var _b = _a.rules, rules = _b === void 0 ? TSBetSlip.rules() : _b, selection = _a.selection, stake = _a.stake, balance = _a.balance, payout = _a.payout;
+        return TSBetSlip.validate(rules, {
+            selection: { amount: selection }, stake: { amount: stake, balance: balance }, payout: { amount: payout }
+        }, function (prefix) { return 'BSE' + TSString_1.TSString.cfChar(String(prefix)); });
+    };
+    TSBetSlip.validate = function (rules, data, prefix) {
+        var validations = [];
+        TSObject_1.TSObject.forOwn(rules, function (r, k) {
+            validations = validations.concat(new TSValidator_1.TSValidator(__assign(__assign({}, r), data[String(k)])).compare(prefix(k)));
+        });
+        return validations;
+    };
+    TSBetSlip.areDuplicate = function (selections, separator) {
+        if (separator === void 0) { separator = '@'; }
+        return new Set(selections.map(function (s) { var _a; return ((_a = s.sk) !== null && _a !== void 0 ? _a : '').toString().split(separator)[0]; })).size != selections.length;
+    };
+    return TSBetSlip;
+}());
+exports.TSBetSlip = TSBetSlip;

package/games/TSBetSystem.d.ts

@@ -0,0 +1,4 @@
+export declare class TSBetSystem {
+    static generate(selectionKeys: string[], cut?: number, max?: number, banker?: string[]): string[][][];
+    static combine(selections: string[], size: number, banker?: string[]): string[][];
+}

package/games/TSBetSystem.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSBetSystem = void 0;
+var TSBetSystem = /** @class */ (function () {
+    function TSBetSystem() {
+    }
+    TSBetSystem.generate = function (selectionKeys, cut, max, banker) {
+        var _a;
+        if (cut === void 0) { cut = 1; }
+        if (max === void 0) { max = 9; }
+        if (banker === void 0) { banker = []; }
+        var results = [];
+        if (selectionKeys.length > max && cut === 1) {
+            return results;
+        }
+        for (var i = cut; i < selectionKeys.length && i < max; i++) {
+            var c = TSBetSystem.combine(selectionKeys, i, banker);
+            if ((_a = c === null || c === void 0 ? void 0 : c[0]) === null || _a === void 0 ? void 0 : _a.length) {
+                results.push(c);
+            }
+        }
+        return results;
+    };
+    TSBetSystem.combine = function (selections, size, banker) {
+        if (banker === void 0) { banker = []; }
+        var combinations = [], combine = function (current, start) {
+            if (current.length === size) {
+                combinations.push(current.slice());
+                return;
+            }
+            var _loop_1 = function (i) {
+                var currentNumber = e(selections[i]);
+                if (currentNumber != null && current.indexOf(currentNumber) === -1 && current.every(function (n) { return e(n) !== currentNumber; })) {
+                    current.push(selections[i]);
+                    combine(current, i + 1);
+                    current.pop();
+                }
+            };
+            for (var i = start; i < selections.length; i++) {
+                _loop_1(i);
+            }
+        }, e = function (s) { return (s === null || s === void 0 ? void 0 : s.substring(0, 24)) || null; };
+        combine(banker, 0);
+        return combinations;
+    };
+    return TSBetSystem;
+}());
+exports.TSBetSystem = TSBetSystem;

package/games/TSLotto.d.ts

@@ -0,0 +1,35 @@
+export interface ITSLotto {
+    max: number;
+    pick: number;
+    extra: number;
+    tickets: number;
+    sort?: boolean;
+    randomize?: boolean;
+}
+export declare class TSLotto {
+    options: ITSLotto;
+    numbers: Array<number>;
+    selections: Array<Array<number>>;
+    bonus: Array<Array<number>>;
+    get render(): {
+        numbers: number[];
+        selections: number[][];
+        bonus: number[][];
+        lines: number[][];
+        options: ITSLotto;
+    };
+    set lotto(data: any);
+    constructor(options?: ITSLotto);
+    fillLine(line: Array<number>, existingLine?: Array<number>): void;
+    randomLine(index: number): void;
+    addLine(line?: Array<number>): number;
+    shufleLines(): void;
+    adjustLines(tickets: number): void;
+    clearLine(index: number): void;
+    deleteLine(index: number): void;
+    emptyLine(length: number): number[];
+    validateLine(index: number): boolean;
+    clear(): void;
+    toggle(line: number, index: number): void;
+    isComplete(index?: number): boolean;
+}