overtime-live-trading-utils 2.1.17 → 2.1.19

package/src/tests/unit/sports.test.ts

@@ -1,58 +1,58 @@
-import {
-    getBetTypesForLeague,
-    getLeagueSpreadTypes,
-    getLeagueTotalTypes,
-    getLiveSupportedLeagues,
-} from '../../utils/sports';
-import { LeagueMocks } from '../mock/MockLeagueMap';
-
-describe('Sports', () => {
-    it('Should return all enabled leagues for LIVE', () => {
-        const supportedLeageus = getLiveSupportedLeagues(LeagueMocks.leagueInfoEnabledSpeadAndTotals);
-
-        expect(supportedLeageus).toContain(9806);
-    });
-
-    it('Should return all enabled bet types for league', () => {
-        const betTypes = getBetTypesForLeague(9806, LeagueMocks.leagueInfoEnabledAll);
-
-        expect(betTypes).toContain('Moneyline');
-        expect(betTypes).toContain('Goal Spread');
-        expect(betTypes).toContain('Total Goals');
-        expect(betTypes).toContain('Double Chance');
-        expect(betTypes).toContain('Correct Score');
-    });
-
-    it('Should return all enabled bet types for league, and not contain disabled ones (Totals)', () => {
-        const betTypes = getBetTypesForLeague(9806, LeagueMocks.leagueInfoEnabledSpreadDisabledTotals);
-
-        expect(betTypes).toContain('Moneyline');
-        expect(betTypes).toContain('Goal Spread');
-        expect(betTypes).not.toContain('Total Goals');
-    });
-
-    it('Should return all enabled bet types for league, and not contain disabled ones (Double Chance and Correct Score)', () => {
-        const betTypes = getBetTypesForLeague(9806, LeagueMocks.leagueInfoDisabledCorrectScoreAndDoubleChance);
-
-        expect(betTypes).toContain('Moneyline');
-        expect(betTypes).toContain('Goal Spread');
-        expect(betTypes).not.toContain('Double Chance');
-        expect(betTypes).not.toContain('Correct Score');
-    });
-
-    it('Should return all enabled spread bet types for league', () => {
-        const betTypes = getLeagueSpreadTypes(9806, LeagueMocks.leagueInfoEnabledSpeadAndTotals);
-
-        expect(betTypes).not.toContain('moneyline');
-        expect(betTypes).toContain('goal spread');
-        expect(betTypes).not.toContain('total goals');
-    });
-
-    it('Should return all enabled total bet types for league', () => {
-        const betTypes = getLeagueTotalTypes(9806, LeagueMocks.leagueInfoEnabledSpeadAndTotals);
-
-        expect(betTypes).not.toContain('moneyline');
-        expect(betTypes).not.toContain('goal spread');
-        expect(betTypes).toContain('total goals');
-    });
-});
+import {
+    getBetTypesForLeague,
+    getLeagueSpreadTypes,
+    getLeagueTotalTypes,
+    getLiveSupportedLeagues,
+} from '../../utils/sports';
+import { LeagueMocks } from '../mock/MockLeagueMap';
+
+describe('Sports', () => {
+    it('Should return all enabled leagues for LIVE', () => {
+        const supportedLeageus = getLiveSupportedLeagues(LeagueMocks.leagueInfoEnabledSpeadAndTotals);
+
+        expect(supportedLeageus).toContain(9806);
+    });
+
+    it('Should return all enabled bet types for league', () => {
+        const betTypes = getBetTypesForLeague(9806, LeagueMocks.leagueInfoEnabledAll);
+
+        expect(betTypes).toContain('Moneyline');
+        expect(betTypes).toContain('Goal Spread');
+        expect(betTypes).toContain('Total Goals');
+        expect(betTypes).toContain('Double Chance');
+        expect(betTypes).toContain('Correct Score');
+    });
+
+    it('Should return all enabled bet types for league, and not contain disabled ones (Totals)', () => {
+        const betTypes = getBetTypesForLeague(9806, LeagueMocks.leagueInfoEnabledSpreadDisabledTotals);
+
+        expect(betTypes).toContain('Moneyline');
+        expect(betTypes).toContain('Goal Spread');
+        expect(betTypes).not.toContain('Total Goals');
+    });
+
+    it('Should return all enabled bet types for league, and not contain disabled ones (Double Chance and Correct Score)', () => {
+        const betTypes = getBetTypesForLeague(9806, LeagueMocks.leagueInfoDisabledCorrectScoreAndDoubleChance);
+
+        expect(betTypes).toContain('Moneyline');
+        expect(betTypes).toContain('Goal Spread');
+        expect(betTypes).not.toContain('Double Chance');
+        expect(betTypes).not.toContain('Correct Score');
+    });
+
+    it('Should return all enabled spread bet types for league', () => {
+        const betTypes = getLeagueSpreadTypes(9806, LeagueMocks.leagueInfoEnabledSpeadAndTotals);
+
+        expect(betTypes).not.toContain('moneyline');
+        expect(betTypes).toContain('goal spread');
+        expect(betTypes).not.toContain('total goals');
+    });
+
+    it('Should return all enabled total bet types for league', () => {
+        const betTypes = getLeagueTotalTypes(9806, LeagueMocks.leagueInfoEnabledSpeadAndTotals);
+
+        expect(betTypes).not.toContain('moneyline');
+        expect(betTypes).not.toContain('goal spread');
+        expect(betTypes).toContain('total goals');
+    });
+});

package/src/tests/unit/spread.test.ts

@@ -1,131 +1,131 @@
-import { ZERO_ODDS_AFTER_SPREAD_ADJUSTMENT } from '../../constants/errors';
-import { processMarket } from '../../utils/markets';
-import { mapOpticOddsApiFixtureOdds } from '../../utils/opticOdds';
-import { LeagueMocks } from '../mock/MockLeagueMap';
-import { MockAfterSpreadZeroOdds1, MockOnlyMoneylineFavorite, MockOpticSoccer } from '../mock/MockOpticSoccer';
-import { mockSoccer } from '../mock/MockSoccerRedis';
-
-describe('Spread configuration', () => {
-    it('Should return zero odds for quotes that sum up total probability above 1', () => {
-        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
-        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockAfterSpreadZeroOdds1));
-        const market = processMarket(
-            freshMockSoccer,
-            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
-            ['draftkings'],
-            [],
-            false,
-            undefined,
-            undefined,
-            LeagueMocks.leagueInfoEnabledSpeadAndTotals
-        );
-
-        const hasOdds = market.odds.some(
-            (odd: any) => odd.american !== 0 || odd.decimal !== 0 || odd.normalizedImplied !== 0
-        );
-
-        expect(hasOdds).toBe(false);
-        expect(market).toHaveProperty('errorMessage');
-        expect(market.errorMessage).toBe(ZERO_ODDS_AFTER_SPREAD_ADJUSTMENT); // should be no matching bookmakers mesage
-    });
-
-    it('Should have diff between odds equal to 3%', () => {
-        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
-        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOpticSoccer));
-        const market = JSON.parse(
-            JSON.stringify(
-                processMarket(
-                    freshMockSoccer,
-                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
-                    ['draftkings'],
-                    [],
-                    true,
-                    undefined,
-                    undefined,
-                    LeagueMocks.leagueInfoOnlyParent
-                )
-            )
-        );
-
-        const marketWithAddedSpread = JSON.parse(
-            JSON.stringify(
-                processMarket(
-                    freshMockSoccer,
-                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
-                    ['draftkings'],
-                    [],
-                    true,
-                    undefined,
-                    undefined,
-                    LeagueMocks.leagueInfoOnlyParentWithSpreadAdded
-                )
-            )
-        );
-
-        const diff1 =
-            ((market.odds[0].decimal - marketWithAddedSpread.odds[0].decimal) / marketWithAddedSpread.odds[0].decimal) *
-            100;
-
-        const diff2 =
-            ((market.odds[1].decimal - marketWithAddedSpread.odds[1].decimal) / marketWithAddedSpread.odds[1].decimal) *
-            100;
-
-        const diff3 =
-            ((market.odds[2].decimal - marketWithAddedSpread.odds[2].decimal) / marketWithAddedSpread.odds[2].decimal) *
-            100;
-
-        expect(Math.round(diff1)).toBe(3);
-        expect(Math.round(diff2)).toBe(3);
-        expect(Math.round(diff3)).toBe(3);
-    });
-
-    it('Should have diff between odds equal to 3%, and one odd should stay the same', () => {
-        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
-        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOnlyMoneylineFavorite));
-        const market = JSON.parse(
-            JSON.stringify(
-                processMarket(
-                    freshMockSoccer,
-                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
-                    ['draftkings'],
-                    [],
-                    true,
-                    undefined,
-                    undefined,
-                    LeagueMocks.leagueInfoOnlyParent
-                )
-            )
-        );
-
-        const marketWithAddedSpread = JSON.parse(
-            JSON.stringify(
-                processMarket(
-                    freshMockSoccer,
-                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
-                    ['draftkings'],
-                    [],
-                    true,
-                    undefined,
-                    undefined,
-                    LeagueMocks.leagueInfoOnlyParentWithSpreadAdded
-                )
-            )
-        );
-
-        const diff1 =
-            ((market.odds[0].decimal - marketWithAddedSpread.odds[0].decimal) / marketWithAddedSpread.odds[0].decimal) *
-            100;
-
-        const diff2 =
-            ((market.odds[1].decimal - marketWithAddedSpread.odds[1].decimal) / marketWithAddedSpread.odds[1].decimal) *
-            100;
-
-        const diff3 =
-            ((market.odds[2].decimal - marketWithAddedSpread.odds[2].decimal) / marketWithAddedSpread.odds[2].decimal) *
-            100;
-
-        expect(Math.round(diff1)).toBe(0);
-        expect(Math.round(diff2)).toBe(3);
-        expect(Math.round(diff3)).toBe(3);
-    });
-});
+import { ZERO_ODDS_AFTER_SPREAD_ADJUSTMENT } from '../../constants/errors';
+import { processMarket } from '../../utils/markets';
+import { mapOpticOddsApiFixtureOdds } from '../../utils/opticOdds';
+import { LeagueMocks } from '../mock/MockLeagueMap';
+import { MockAfterSpreadZeroOdds1, MockOnlyMoneylineFavorite, MockOpticSoccer } from '../mock/MockOpticSoccer';
+import { mockSoccer } from '../mock/MockSoccerRedis';
+
+describe('Spread configuration', () => {
+    it('Should return zero odds for quotes that sum up total probability above 1', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockAfterSpreadZeroOdds1));
+        const market = processMarket(
+            freshMockSoccer,
+            mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+            ['draftkings'],
+            [],
+            false,
+            undefined,
+            undefined,
+            LeagueMocks.leagueInfoEnabledSpeadAndTotals
+        );
+
+        const hasOdds = market.odds.some(
+            (odd: any) => odd.american !== 0 || odd.decimal !== 0 || odd.normalizedImplied !== 0
+        );
+
+        expect(hasOdds).toBe(false);
+        expect(market).toHaveProperty('errorMessage');
+        expect(market.errorMessage).toBe(ZERO_ODDS_AFTER_SPREAD_ADJUSTMENT); // should be no matching bookmakers mesage
+    });
+
+    it('Should have diff between odds equal to 3%', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOpticSoccer));
+        const market = JSON.parse(
+            JSON.stringify(
+                processMarket(
+                    freshMockSoccer,
+                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                    ['draftkings'],
+                    [],
+                    true,
+                    undefined,
+                    undefined,
+                    LeagueMocks.leagueInfoOnlyParent
+                )
+            )
+        );
+
+        const marketWithAddedSpread = JSON.parse(
+            JSON.stringify(
+                processMarket(
+                    freshMockSoccer,
+                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                    ['draftkings'],
+                    [],
+                    true,
+                    undefined,
+                    undefined,
+                    LeagueMocks.leagueInfoOnlyParentWithSpreadAdded
+                )
+            )
+        );
+
+        const diff1 =
+            ((market.odds[0].decimal - marketWithAddedSpread.odds[0].decimal) / marketWithAddedSpread.odds[0].decimal) *
+            100;
+
+        const diff2 =
+            ((market.odds[1].decimal - marketWithAddedSpread.odds[1].decimal) / marketWithAddedSpread.odds[1].decimal) *
+            100;
+
+        const diff3 =
+            ((market.odds[2].decimal - marketWithAddedSpread.odds[2].decimal) / marketWithAddedSpread.odds[2].decimal) *
+            100;
+
+        expect(Math.round(diff1)).toBe(3);
+        expect(Math.round(diff2)).toBe(3);
+        expect(Math.round(diff3)).toBe(3);
+    });
+
+    it('Should have diff between odds equal to 3%, and one odd should stay the same', () => {
+        const freshMockSoccer = JSON.parse(JSON.stringify(mockSoccer));
+        const freshMockOpticSoccer = JSON.parse(JSON.stringify(MockOnlyMoneylineFavorite));
+        const market = JSON.parse(
+            JSON.stringify(
+                processMarket(
+                    freshMockSoccer,
+                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                    ['draftkings'],
+                    [],
+                    true,
+                    undefined,
+                    undefined,
+                    LeagueMocks.leagueInfoOnlyParent
+                )
+            )
+        );
+
+        const marketWithAddedSpread = JSON.parse(
+            JSON.stringify(
+                processMarket(
+                    freshMockSoccer,
+                    mapOpticOddsApiFixtureOdds([freshMockOpticSoccer])[0],
+                    ['draftkings'],
+                    [],
+                    true,
+                    undefined,
+                    undefined,
+                    LeagueMocks.leagueInfoOnlyParentWithSpreadAdded
+                )
+            )
+        );
+
+        const diff1 =
+            ((market.odds[0].decimal - marketWithAddedSpread.odds[0].decimal) / marketWithAddedSpread.odds[0].decimal) *
+            100;
+
+        const diff2 =
+            ((market.odds[1].decimal - marketWithAddedSpread.odds[1].decimal) / marketWithAddedSpread.odds[1].decimal) *
+            100;
+
+        const diff3 =
+            ((market.odds[2].decimal - marketWithAddedSpread.odds[2].decimal) / marketWithAddedSpread.odds[2].decimal) *
+            100;
+
+        expect(Math.round(diff1)).toBe(0);
+        expect(Math.round(diff2)).toBe(3);
+        expect(Math.round(diff3)).toBe(3);
+    });
+});

package/src/types/missing-types.d.ts

@@ -1,2 +1,2 @@
-declare module 'oddslib';
-declare module 'bytes32';
+declare module 'oddslib';
+declare module 'bytes32';

package/src/types/odds.ts

@@ -1,61 +1,61 @@
-export type Fixture = {
-    gameId: string;
-    startDate: number;
-    homeTeam: string;
-    awayTeam: string;
-};
-
-export type Odds = [
-    {
-        id: string;
-        sportsBookName: string;
-        name: string;
-        price: number;
-        timestamp: number;
-        points: number;
-        isMain: boolean;
-        isLive: boolean;
-        marketName: string;
-        playerId: string;
-        selection: string;
-        selectionLine: string;
-    }
-];
-
-export type OddsObject = {
-    gameId: string;
-    startDate: number;
-    homeTeam: string;
-    awayTeam: string;
-    isLive: boolean;
-    status: string;
-    sport: string;
-    league: string;
-    odds: Odds;
-};
-
-export type ScoresObject = {
-    gameId: string;
-    sport: string;
-    league: string;
-    status: string;
-    isLive: boolean;
-    clock: string;
-    period: string;
-    homeTeam: string;
-    awayTeam: string;
-    homeTotal: string;
-    awayTotal: string;
-    homePeriod1: string;
-    awayPeriod1: string;
-    homePeriod2: string;
-    awayPeriod2: string;
-    homePeriod3: string;
-    awayPeriod3: string;
-    homePeriod4: string;
-    awayPeriod4: string;
-    homePeriod5: string;
-    awayPeriod5: string;
-};
-
-export type HomeAwayTeams = { homeTeam: string; awayTeam: string };
+export type Fixture = {
+    gameId: string;
+    startDate: number;
+    homeTeam: string;
+    awayTeam: string;
+};
+
+export type Odds = [
+    {
+        id: string;
+        sportsBookName: string;
+        name: string;
+        price: number;
+        timestamp: number;
+        points: number;
+        isMain: boolean;
+        isLive: boolean;
+        marketName: string;
+        playerId: string;
+        selection: string;
+        selectionLine: string;
+    }
+];
+
+export type OddsObject = {
+    gameId: string;
+    startDate: number;
+    homeTeam: string;
+    awayTeam: string;
+    isLive: boolean;
+    status: string;
+    sport: string;
+    league: string;
+    odds: Odds;
+};
+
+export type ScoresObject = {
+    gameId: string;
+    sport: string;
+    league: string;
+    status: string;
+    isLive: boolean;
+    clock: string;
+    period: string;
+    homeTeam: string;
+    awayTeam: string;
+    homeTotal: string;
+    awayTotal: string;
+    homePeriod1: string;
+    awayPeriod1: string;
+    homePeriod2: string;
+    awayPeriod2: string;
+    homePeriod3: string;
+    awayPeriod3: string;
+    homePeriod4: string;
+    awayPeriod4: string;
+    homePeriod5: string;
+    awayPeriod5: string;
+};
+
+export type HomeAwayTeams = { homeTeam: string; awayTeam: string };

package/src/types/resolution.ts

@@ -0,0 +1,96 @@
+export type PeriodScores = {
+    [key: string]: { home: number; away: number };
+};
+
+export type PeriodResolutionData = {
+    completedPeriods: number[];
+    readyForResolution: boolean;
+    periodScores: PeriodScores;
+    currentPeriod?: number;
+};
+
+/**
+ * OpticOdds Event type from their API response
+ * Uses 'any' for flexibility as API structure may vary
+ */
+export type OpticOddsEvent = any;
+
+/**
+ * Sport period structure types
+ * Different sports have different period structures that affect how typeIds are resolved
+ */
+export enum SportPeriodType {
+    /** Sports with 2 halves (Soccer, NCAAB) */
+    HALVES_BASED = 'halves_based',
+    /** Sports with 4 quarters (NFL, NBA) */
+    QUARTERS_BASED = 'quarters_based',
+    /** Sports with 9+ innings (MLB, NPB, KBO, College Baseball, etc.) */
+    INNINGS_BASED = 'innings_based',
+    /** Sports with 9 periods without halves or secondary moneyline types */
+    PERIOD_BASED = 'period_based',
+}
+
+/**
+ * Halves-based sports period-to-typeId mapping (Soccer, NCAAB)
+ * Period 1 = 1st half
+ * Period 2 = 2nd half
+ */
+export const HALVES_PERIOD_TYPE_ID_MAPPING: { [period: number]: number[] } = {
+    1: [10021, 10031, 10041, 10051, 10061, 10071, 10081, 10111, 10112, 10121, 10163], // 1st half
+    2: [10022, 10032, 10042, 10052, 10062, 10072, 10082, 10211, 10212, 10122], // 2nd half
+};
+
+/**
+ * Quarters-based sports period-to-typeId mapping (NFL, NBA)
+ * Period 1 = 1st quarter
+ * Period 2 = 2nd quarter (also completes 1st half - typeId 10051)
+ * Period 3 = 3rd quarter
+ * Period 4 = 4th quarter (also completes 2nd half - typeId 10052)
+ * Period 5+ = Overtime
+ */
+export const QUARTERS_PERIOD_TYPE_ID_MAPPING: { [period: number]: number[] } = {
+    1: [10021, 10031, 10041, 10061, 10071, 10081, 10111, 10112, 10121, 10163], // 1st quarter
+    2: [10022, 10032, 10042, 10051, 10062, 10072, 10082, 10211, 10212, 10122], // 2nd quarter + 1st half
+    3: [10023, 10033, 10043, 10063, 10073, 10083, 10311, 10312, 10123], // 3rd quarter
+    4: [10024, 10034, 10044, 10052, 10064, 10074, 10084, 10411, 10412, 10124], // 4th quarter + 2nd half
+    5: [10025, 10035, 10045, 10055, 10065, 10075, 10085, 10511, 10512], // Overtime/5th period
+};
+
+/**
+ * Innings-based sports period-to-typeId mapping (MLB, NPB, KBO, College Baseball)
+ * Period 1-5 = Innings 1-5 (period 5 completes 1st half - typeId 10051)
+ * Period 6-9 = Innings 6-9 (period 9 completes 2nd half - typeId 10052)
+ */
+export const INNINGS_PERIOD_TYPE_ID_MAPPING: { [period: number]: number[] } = {
+    1: [10021, 10031, 10041, 10061, 10071, 10081, 10111, 10112, 10121, 10163], // 1st inning
+    2: [10022, 10032, 10042, 10062, 10072, 10082, 10211, 10212, 10122], // 2nd inning
+    3: [10023, 10033, 10043, 10063, 10073, 10083, 10311, 10312, 10123], // 3rd inning
+    4: [10024, 10034, 10044, 10064, 10074, 10084, 10411, 10412, 10124], // 4th inning
+    5: [10025, 10035, 10045, 10051, 10065, 10075, 10085, 10511, 10512], // 5th inning + 1st half
+    6: [10026, 10036, 10046, 10056, 10066, 10076, 10086, 10611, 10612], // 6th inning
+    7: [10027, 10037, 10047, 10057, 10067, 10077, 10087, 10711, 10712], // 7th inning
+    8: [10028, 10038, 10048, 10058, 10068, 10078, 10088, 10811, 10812], // 8th inning
+    9: [10029, 10039, 10049, 10052, 10069, 10079, 10089], // 9th inning + 2nd half
+};
+
+/**
+ * Period-based sports period-to-typeId mapping (9 periods)
+ * Excludes halves types (10051, 10052) and secondary moneyline types (ending in 11/12)
+ */
+export const PERIOD_BASED_TYPE_ID_MAPPING: { [period: number]: number[] } = {
+    1: [10021, 10031, 10041, 10061, 10071, 10081, 10121, 10163], // 1st period
+    2: [10022, 10032, 10042, 10062, 10072, 10082, 10122], // 2nd period
+    3: [10023, 10033, 10043, 10063, 10073, 10083, 10123], // 3rd period
+    4: [10024, 10034, 10044, 10064, 10074, 10084, 10124], // 4th period
+    5: [10025, 10035, 10045, 10065, 10075, 10085], // 5th period
+    6: [10026, 10036, 10046, 10056, 10066, 10076, 10086], // 6th period
+    7: [10027, 10037, 10047, 10057, 10067, 10077, 10087], // 7th period
+    8: [10028, 10038, 10048, 10058, 10068, 10078, 10088], // 8th period
+    9: [10029, 10039, 10049, 10069, 10079, 10089], // 9th period
+};
+
+/**
+ * Full game type IDs that should NOT be resolved during live games
+ * These can only be resolved when the game status is "completed"
+ */
+export const FULL_GAME_TYPE_IDS: number[] = [0, 10001, 10002, 10003, 10004, 10010, 10011, 10012];

package/src/types/sports.ts

@@ -1,19 +1,19 @@
-
-export type LeagueConfigInfo = {
-    sportId: number;
-    typeId: number;
-    marketName: string;
-    type: string;
-    enabled: string;
-    minOdds: number;
-    maxOdds: number;
-    addedSpread?: number;
-};
-
-export type ChildMarket = {
-    leagueId: number;
-    typeId: number;
-    type: string;
-    line: number;
-    odds: Array<number>;
-};
+
+export type LeagueConfigInfo = {
+    sportId: number;
+    typeId: number;
+    marketName: string;
+    type: string;
+    enabled: string;
+    minOdds: number;
+    maxOdds: number;
+    addedSpread?: number;
+};
+
+export type ChildMarket = {
+    leagueId: number;
+    typeId: number;
+    type: string;
+    line: number;
+    odds: Array<number>;
+};