@azuro-org/toolkit 5.0.0-beta.2 → 5.0.0-beta.4

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 import { Environment } from './envs';
 import { type ChainData } from './global';
+export declare const MARGIN_DECIMALS = 12;
 export declare const ODDS_DECIMALS = 12;
 export declare const MIN_BET_AMOUNT = 1;
 export declare const CLIENT_DATA_TYPES: readonly [{

package/dist/docs/bets/gameBets.d.ts

@@ -50,5 +50,29 @@ export type GameBetsQuery = {
             };
         }>;
     }>;
+    v3Bets: Array<{
+        __typename?: 'V3_Bet';
+        rawAmount: string;
+        rawPotentialPayout: string;
+        result?: Types.BetResult | null;
+        isCashedOut: boolean;
+        selections: Array<{
+            __typename?: 'V3_Selection';
+            rawOdds: string;
+            outcome: {
+                __typename?: 'V3_Outcome';
+                outcomeId: string;
+                condition: {
+                    __typename?: 'V3_Condition';
+                    conditionId: string;
+                    gameId: string;
+                };
+            };
+        }>;
+        freebet?: {
+            __typename?: 'Freebet';
+            id: string;
+        } | null;
+    }>;
 };
 export declare const GameBetsDocument: import("graphql/language/ast").DocumentNode;

package/dist/docs/bets/{legacyPrematchBets.d.ts → legacyBets.d.ts}

@@ -1,12 +1,12 @@
 import * as Types from './types';
-export type LegacyPrematchBetsQueryVariables = Types.Exact<{
+export type LegacyBetsQueryVariables = Types.Exact<{
     first?: Types.InputMaybe<Types.Scalars['Int']['input']>;
     skip?: Types.InputMaybe<Types.Scalars['Int']['input']>;
     where: Types.Bet_Filter;
     orderBy?: Types.InputMaybe<Types.Bet_OrderBy>;
     orderDirection?: Types.InputMaybe<Types.OrderDirection>;
 }>;
-export type LegacyPrematchBetsQuery = {
+export type LegacyBetsQuery = {
     __typename?: 'Query';
     bets: Array<{
         __typename?: 'Bet';
@@ -88,5 +88,50 @@ export type LegacyPrematchBetsQuery = {
             payout: string;
         } | null;
     }>;
+    liveBets: Array<{
+        __typename?: 'LiveBet';
+        id: string;
+        amount: string;
+        status: Types.BetStatus;
+        potentialPayout: string;
+        payout?: string | null;
+        result?: Types.BetResult | null;
+        odds: string;
+        settledOdds?: string | null;
+        affiliate?: string | null;
+        isRedeemed: boolean;
+        isRedeemable: boolean;
+        isCashedOut: boolean;
+        tokenId: string;
+        createdAt: string;
+        txHash: string;
+        core: {
+            __typename?: 'CoreContract';
+            address: string;
+            liquidityPool: {
+                __typename?: 'LiquidityPoolContract';
+                address: string;
+            };
+        };
+        selections: Array<{
+            __typename?: 'LiveSelection';
+            odds: string;
+            result?: Types.SelectionResult | null;
+            outcome: {
+                __typename?: 'LiveOutcome';
+                outcomeId: string;
+                condition: {
+                    __typename?: 'LiveCondition';
+                    conditionId: string;
+                    status: Types.ConditionStatus;
+                    gameId: string;
+                };
+            };
+        }>;
+        cashout?: {
+            __typename?: 'Cashout';
+            payout: string;
+        } | null;
+    }>;
 };
-export declare const LegacyPrematchBetsDocument: import("graphql/language/ast").DocumentNode;
+export declare const LegacyBetsDocument: import("graphql/language/ast").DocumentNode;

package/dist/docs/bets/types.d.ts

@@ -7578,12 +7578,12 @@ export type V3_Bet = {
     odds: Scalars['BigDecimal']['output'];
     owner: Scalars['String']['output'];
     payout?: Maybe<Scalars['BigDecimal']['output']>;
-    payoutLimit: Scalars['BigDecimal']['output'];
+    potentialLossLimit: Scalars['BigDecimal']['output'];
     potentialPayout: Scalars['BigDecimal']['output'];
     rawAmount: Scalars['BigInt']['output'];
     rawOdds: Scalars['BigInt']['output'];
     rawPayout?: Maybe<Scalars['BigInt']['output']>;
-    rawPayoutLimit: Scalars['BigInt']['output'];
+    rawPotentialLossLimit: Scalars['BigInt']['output'];
     rawPotentialPayout: Scalars['BigInt']['output'];
     rawSettledOdds?: Maybe<Scalars['BigInt']['output']>;
     redeemedBlockNumber?: Maybe<Scalars['BigInt']['output']>;
@@ -7928,14 +7928,6 @@ export type V3_Bet_Filter = {
     owner_starts_with?: InputMaybe<Scalars['String']['input']>;
     owner_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
     payout?: InputMaybe<Scalars['BigDecimal']['input']>;
-    payoutLimit?: InputMaybe<Scalars['BigDecimal']['input']>;
-    payoutLimit_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
-    payoutLimit_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
-    payoutLimit_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
-    payoutLimit_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
-    payoutLimit_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
-    payoutLimit_not?: InputMaybe<Scalars['BigDecimal']['input']>;
-    payoutLimit_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
     payout_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
     payout_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
     payout_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
@@ -7943,6 +7935,14 @@ export type V3_Bet_Filter = {
     payout_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
     payout_not?: InputMaybe<Scalars['BigDecimal']['input']>;
     payout_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    potentialLossLimit?: InputMaybe<Scalars['BigDecimal']['input']>;
+    potentialLossLimit_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    potentialLossLimit_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    potentialLossLimit_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    potentialLossLimit_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    potentialLossLimit_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    potentialLossLimit_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    potentialLossLimit_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
     potentialPayout?: InputMaybe<Scalars['BigDecimal']['input']>;
     potentialPayout_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
     potentialPayout_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
@@ -7968,14 +7968,6 @@ export type V3_Bet_Filter = {
     rawOdds_not?: InputMaybe<Scalars['BigInt']['input']>;
     rawOdds_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
     rawPayout?: InputMaybe<Scalars['BigInt']['input']>;
-    rawPayoutLimit?: InputMaybe<Scalars['BigInt']['input']>;
-    rawPayoutLimit_gt?: InputMaybe<Scalars['BigInt']['input']>;
-    rawPayoutLimit_gte?: InputMaybe<Scalars['BigInt']['input']>;
-    rawPayoutLimit_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
-    rawPayoutLimit_lt?: InputMaybe<Scalars['BigInt']['input']>;
-    rawPayoutLimit_lte?: InputMaybe<Scalars['BigInt']['input']>;
-    rawPayoutLimit_not?: InputMaybe<Scalars['BigInt']['input']>;
-    rawPayoutLimit_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
     rawPayout_gt?: InputMaybe<Scalars['BigInt']['input']>;
     rawPayout_gte?: InputMaybe<Scalars['BigInt']['input']>;
     rawPayout_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
@@ -7983,6 +7975,14 @@ export type V3_Bet_Filter = {
     rawPayout_lte?: InputMaybe<Scalars['BigInt']['input']>;
     rawPayout_not?: InputMaybe<Scalars['BigInt']['input']>;
     rawPayout_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    rawPotentialLossLimit?: InputMaybe<Scalars['BigInt']['input']>;
+    rawPotentialLossLimit_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    rawPotentialLossLimit_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    rawPotentialLossLimit_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    rawPotentialLossLimit_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    rawPotentialLossLimit_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    rawPotentialLossLimit_not?: InputMaybe<Scalars['BigInt']['input']>;
+    rawPotentialLossLimit_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
     rawPotentialPayout?: InputMaybe<Scalars['BigInt']['input']>;
     rawPotentialPayout_gt?: InputMaybe<Scalars['BigInt']['input']>;
     rawPotentialPayout_gte?: InputMaybe<Scalars['BigInt']['input']>;
@@ -8124,12 +8124,12 @@ export declare enum V3_Bet_OrderBy {
     Odds = "odds",
     Owner = "owner",
     Payout = "payout",
-    PayoutLimit = "payoutLimit",
+    PotentialLossLimit = "potentialLossLimit",
     PotentialPayout = "potentialPayout",
     RawAmount = "rawAmount",
     RawOdds = "rawOdds",
     RawPayout = "rawPayout",
-    RawPayoutLimit = "rawPayoutLimit",
+    RawPotentialLossLimit = "rawPotentialLossLimit",
     RawPotentialPayout = "rawPotentialPayout",
     RawSettledOdds = "rawSettledOdds",
     RedeemedBlockNumber = "redeemedBlockNumber",

package/dist/docs/feed/condition.d.ts

@@ -13,6 +13,7 @@ export type ConditionQuery = {
         isExpressForbidden: boolean;
         isPrematchEnabled: boolean;
         isLiveEnabled: boolean;
+        margin: string;
         outcomes: Array<{
             __typename?: 'Outcome';
             title?: string | null;

package/dist/docs/feed/conditions.d.ts

@@ -16,6 +16,7 @@ export type ConditionsQuery = {
         isExpressForbidden: boolean;
         isPrematchEnabled: boolean;
         isLiveEnabled: boolean;
+        margin: string;
         outcomes: Array<{
             __typename?: 'Outcome';
             title?: string | null;

package/dist/docs/feed/fragments/condition.d.ts

@@ -8,6 +8,7 @@ export type ConditionFragment = {
     isExpressForbidden: boolean;
     isPrematchEnabled: boolean;
     isLiveEnabled: boolean;
+    margin: string;
     outcomes: Array<{
         __typename?: 'Outcome';
         title?: string | null;

package/dist/docs/feed/fragments/gameInfo.d.ts

@@ -6,6 +6,7 @@ export type GameInfoFragment = {
     title: string;
     startsAt: string;
     state: Types.GameState;
+    turnover: string;
     sport: {
         __typename?: 'Sport';
         sportId: string;

package/dist/docs/feed/game.d.ts

@@ -11,6 +11,7 @@ export type GameQuery = {
         title: string;
         startsAt: string;
         state: Types.GameState;
+        turnover: string;
         sport: {
             __typename?: 'Sport';
             sportId: string;

package/dist/docs/feed/games.d.ts

@@ -15,6 +15,7 @@ export type GamesQuery = {
         title: string;
         startsAt: string;
         state: Types.GameState;
+        turnover: string;
         sport: {
             __typename?: 'Sport';
             sportId: string;

package/dist/docs/feed/sports.d.ts

@@ -16,6 +16,7 @@ export type SportsQuery = {
         slug: string;
         name: string;
         sportId: string;
+        turnover: string;
         countries: Array<{
             __typename?: 'Country';
             slug: string;
@@ -28,12 +29,12 @@ export type SportsQuery = {
                 turnover: string;
                 games: Array<{
                     __typename?: 'Game';
-                    turnover: string;
                     id: string;
                     gameId: string;
                     title: string;
                     startsAt: string;
                     state: Types.GameState;
+                    turnover: string;
                     sport: {
                         __typename?: 'Sport';
                         sportId: string;

package/dist/docs/feed/types.d.ts

@@ -76,6 +76,9 @@ export type Block_Height = {
 };
 export type Condition = {
     __typename?: 'Condition';
+    _isCustomSettings: Scalars['Boolean']['output'];
+    _maxLiveConditionPotentialLoss?: Maybe<Scalars['BigDecimal']['output']>;
+    _maxLiveOutcomePotentialLoss?: Maybe<Scalars['BigDecimal']['output']>;
     _updatedAt: Scalars['BigInt']['output'];
     conditionId: Scalars['BigInt']['output'];
     createdBlockNumber: Scalars['BigInt']['output'];
@@ -88,6 +91,7 @@ export type Condition = {
     isExpressForbidden: Scalars['Boolean']['output'];
     isLiveEnabled: Scalars['Boolean']['output'];
     isPrematchEnabled: Scalars['Boolean']['output'];
+    margin: Scalars['BigDecimal']['output'];
     maxConditionPotentialLoss: Scalars['BigDecimal']['output'];
     maxOutcomePotentialLoss: Scalars['BigDecimal']['output'];
     outcomes: Array<Outcome>;
@@ -129,6 +133,26 @@ export declare enum ConditionState {
 export type Condition_Filter = {
     /** Filter for the block changed event. */
     _change_block?: InputMaybe<BlockChangedFilter>;
+    _isCustomSettings?: InputMaybe<Scalars['Boolean']['input']>;
+    _isCustomSettings_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+    _isCustomSettings_not?: InputMaybe<Scalars['Boolean']['input']>;
+    _isCustomSettings_not_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+    _maxLiveConditionPotentialLoss?: InputMaybe<Scalars['BigDecimal']['input']>;
+    _maxLiveConditionPotentialLoss_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    _maxLiveConditionPotentialLoss_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    _maxLiveConditionPotentialLoss_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    _maxLiveConditionPotentialLoss_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    _maxLiveConditionPotentialLoss_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    _maxLiveConditionPotentialLoss_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    _maxLiveConditionPotentialLoss_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    _maxLiveOutcomePotentialLoss?: InputMaybe<Scalars['BigDecimal']['input']>;
+    _maxLiveOutcomePotentialLoss_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    _maxLiveOutcomePotentialLoss_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    _maxLiveOutcomePotentialLoss_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    _maxLiveOutcomePotentialLoss_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    _maxLiveOutcomePotentialLoss_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    _maxLiveOutcomePotentialLoss_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    _maxLiveOutcomePotentialLoss_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
     _updatedAt?: InputMaybe<Scalars['BigInt']['input']>;
     _updatedAt_gt?: InputMaybe<Scalars['BigInt']['input']>;
     _updatedAt_gte?: InputMaybe<Scalars['BigInt']['input']>;
@@ -231,6 +255,14 @@ export type Condition_Filter = {
     isPrematchEnabled_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
     isPrematchEnabled_not?: InputMaybe<Scalars['Boolean']['input']>;
     isPrematchEnabled_not_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+    margin?: InputMaybe<Scalars['BigDecimal']['input']>;
+    margin_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    margin_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    margin_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    margin_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    margin_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    margin_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    margin_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
     maxConditionPotentialLoss?: InputMaybe<Scalars['BigDecimal']['input']>;
     maxConditionPotentialLoss_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
     maxConditionPotentialLoss_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
@@ -358,6 +390,9 @@ export type Condition_Filter = {
     wonOutcomes_not_contains_nocase?: InputMaybe<Array<Scalars['String']['input']>>;
 };
 export declare enum Condition_OrderBy {
+    IsCustomSettings = "_isCustomSettings",
+    MaxLiveConditionPotentialLoss = "_maxLiveConditionPotentialLoss",
+    MaxLiveOutcomePotentialLoss = "_maxLiveOutcomePotentialLoss",
     UpdatedAt = "_updatedAt",
     ConditionId = "conditionId",
     CreatedBlockNumber = "createdBlockNumber",
@@ -369,6 +404,7 @@ export declare enum Condition_OrderBy {
     IsExpressForbidden = "isExpressForbidden",
     IsLiveEnabled = "isLiveEnabled",
     IsPrematchEnabled = "isPrematchEnabled",
+    Margin = "margin",
     MaxConditionPotentialLoss = "maxConditionPotentialLoss",
     MaxOutcomePotentialLoss = "maxOutcomePotentialLoss",
     Outcomes = "outcomes",
@@ -695,6 +731,7 @@ export type Game = {
     __typename?: 'Game';
     _providerTitle?: Maybe<Scalars['String']['output']>;
     _updatedAt: Scalars['BigInt']['output'];
+    activeAndStoppedConditionsCount: Scalars['Int']['output'];
     activeConditionsCount: Scalars['Int']['output'];
     conditions: Array<Condition>;
     conditionsCount: Scalars['Int']['output'];
@@ -773,6 +810,14 @@ export type Game_Filter = {
     _updatedAt_lte?: InputMaybe<Scalars['BigInt']['input']>;
     _updatedAt_not?: InputMaybe<Scalars['BigInt']['input']>;
     _updatedAt_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    activeAndStoppedConditionsCount?: InputMaybe<Scalars['Int']['input']>;
+    activeAndStoppedConditionsCount_gt?: InputMaybe<Scalars['Int']['input']>;
+    activeAndStoppedConditionsCount_gte?: InputMaybe<Scalars['Int']['input']>;
+    activeAndStoppedConditionsCount_in?: InputMaybe<Array<Scalars['Int']['input']>>;
+    activeAndStoppedConditionsCount_lt?: InputMaybe<Scalars['Int']['input']>;
+    activeAndStoppedConditionsCount_lte?: InputMaybe<Scalars['Int']['input']>;
+    activeAndStoppedConditionsCount_not?: InputMaybe<Scalars['Int']['input']>;
+    activeAndStoppedConditionsCount_not_in?: InputMaybe<Array<Scalars['Int']['input']>>;
     activeConditionsCount?: InputMaybe<Scalars['Int']['input']>;
     activeConditionsCount_gt?: InputMaybe<Scalars['Int']['input']>;
     activeConditionsCount_gte?: InputMaybe<Scalars['Int']['input']>;
@@ -1036,6 +1081,7 @@ export type Game_Filter = {
 export declare enum Game_OrderBy {
     ProviderTitle = "_providerTitle",
     UpdatedAt = "_updatedAt",
+    ActiveAndStoppedConditionsCount = "activeAndStoppedConditionsCount",
     ActiveConditionsCount = "activeConditionsCount",
     Conditions = "conditions",
     ConditionsCount = "conditionsCount",
@@ -1253,91 +1299,6 @@ export declare enum League_OrderBy {
     TotalTurnover = "totalTurnover",
     Turnover = "turnover"
 }
-export type OffchainEvent = {
-    __typename?: 'OffchainEvent';
-    block: Scalars['BigInt']['output'];
-    data: Scalars['String']['output'];
-    id: Scalars['ID']['output'];
-    name?: Maybe<Scalars['String']['output']>;
-    timestamp: Scalars['BigInt']['output'];
-};
-export type OffchainEvent_Filter = {
-    /** Filter for the block changed event. */
-    _change_block?: InputMaybe<BlockChangedFilter>;
-    and?: InputMaybe<Array<InputMaybe<OffchainEvent_Filter>>>;
-    block?: InputMaybe<Scalars['BigInt']['input']>;
-    block_gt?: InputMaybe<Scalars['BigInt']['input']>;
-    block_gte?: InputMaybe<Scalars['BigInt']['input']>;
-    block_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
-    block_lt?: InputMaybe<Scalars['BigInt']['input']>;
-    block_lte?: InputMaybe<Scalars['BigInt']['input']>;
-    block_not?: InputMaybe<Scalars['BigInt']['input']>;
-    block_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
-    data?: InputMaybe<Scalars['String']['input']>;
-    data_contains?: InputMaybe<Scalars['String']['input']>;
-    data_contains_nocase?: InputMaybe<Scalars['String']['input']>;
-    data_ends_with?: InputMaybe<Scalars['String']['input']>;
-    data_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
-    data_gt?: InputMaybe<Scalars['String']['input']>;
-    data_gte?: InputMaybe<Scalars['String']['input']>;
-    data_in?: InputMaybe<Array<Scalars['String']['input']>>;
-    data_lt?: InputMaybe<Scalars['String']['input']>;
-    data_lte?: InputMaybe<Scalars['String']['input']>;
-    data_not?: InputMaybe<Scalars['String']['input']>;
-    data_not_contains?: InputMaybe<Scalars['String']['input']>;
-    data_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
-    data_not_ends_with?: InputMaybe<Scalars['String']['input']>;
-    data_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
-    data_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
-    data_not_starts_with?: InputMaybe<Scalars['String']['input']>;
-    data_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
-    data_starts_with?: InputMaybe<Scalars['String']['input']>;
-    data_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
-    id?: InputMaybe<Scalars['ID']['input']>;
-    id_gt?: InputMaybe<Scalars['ID']['input']>;
-    id_gte?: InputMaybe<Scalars['ID']['input']>;
-    id_in?: InputMaybe<Array<Scalars['ID']['input']>>;
-    id_lt?: InputMaybe<Scalars['ID']['input']>;
-    id_lte?: InputMaybe<Scalars['ID']['input']>;
-    id_not?: InputMaybe<Scalars['ID']['input']>;
-    id_not_in?: InputMaybe<Array<Scalars['ID']['input']>>;
-    name?: InputMaybe<Scalars['String']['input']>;
-    name_contains?: InputMaybe<Scalars['String']['input']>;
-    name_contains_nocase?: InputMaybe<Scalars['String']['input']>;
-    name_ends_with?: InputMaybe<Scalars['String']['input']>;
-    name_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
-    name_gt?: InputMaybe<Scalars['String']['input']>;
-    name_gte?: InputMaybe<Scalars['String']['input']>;
-    name_in?: InputMaybe<Array<Scalars['String']['input']>>;
-    name_lt?: InputMaybe<Scalars['String']['input']>;
-    name_lte?: InputMaybe<Scalars['String']['input']>;
-    name_not?: InputMaybe<Scalars['String']['input']>;
-    name_not_contains?: InputMaybe<Scalars['String']['input']>;
-    name_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
-    name_not_ends_with?: InputMaybe<Scalars['String']['input']>;
-    name_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
-    name_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
-    name_not_starts_with?: InputMaybe<Scalars['String']['input']>;
-    name_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
-    name_starts_with?: InputMaybe<Scalars['String']['input']>;
-    name_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
-    or?: InputMaybe<Array<InputMaybe<OffchainEvent_Filter>>>;
-    timestamp?: InputMaybe<Scalars['BigInt']['input']>;
-    timestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
-    timestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
-    timestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
-    timestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
-    timestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
-    timestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
-    timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
-};
-export declare enum OffchainEvent_OrderBy {
-    Block = "block",
-    Data = "data",
-    Id = "id",
-    Name = "name",
-    Timestamp = "timestamp"
-}
 /** Defines the order direction, either ascending or descending */
 export declare enum OrderDirection {
     Asc = "asc",
@@ -1623,8 +1584,6 @@ export type Query = {
     games: Array<Game>;
     league?: Maybe<League>;
     leagues: Array<League>;
-    offchainEvent?: Maybe<OffchainEvent>;
-    offchainEvents: Array<OffchainEvent>;
     outcome?: Maybe<Outcome>;
     outcomes: Array<Outcome>;
     participant?: Maybe<Participant>;
@@ -1711,20 +1670,6 @@ export type QueryLeaguesArgs = {
     subgraphError?: _SubgraphErrorPolicy_;
     where?: InputMaybe<League_Filter>;
 };
-export type QueryOffchainEventArgs = {
-    block?: InputMaybe<Block_Height>;
-    id: Scalars['ID']['input'];
-    subgraphError?: _SubgraphErrorPolicy_;
-};
-export type QueryOffchainEventsArgs = {
-    block?: InputMaybe<Block_Height>;
-    first?: InputMaybe<Scalars['Int']['input']>;
-    orderBy?: InputMaybe<OffchainEvent_OrderBy>;
-    orderDirection?: InputMaybe<OrderDirection>;
-    skip?: InputMaybe<Scalars['Int']['input']>;
-    subgraphError?: _SubgraphErrorPolicy_;
-    where?: InputMaybe<OffchainEvent_Filter>;
-};
 export type QueryOutcomeArgs = {
     block?: InputMaybe<Block_Height>;
     id: Scalars['ID']['input'];
@@ -2156,8 +2101,6 @@ export type Subscription = {
     games: Array<Game>;
     league?: Maybe<League>;
     leagues: Array<League>;
-    offchainEvent?: Maybe<OffchainEvent>;
-    offchainEvents: Array<OffchainEvent>;
     outcome?: Maybe<Outcome>;
     outcomes: Array<Outcome>;
     participant?: Maybe<Participant>;
@@ -2244,20 +2187,6 @@ export type SubscriptionLeaguesArgs = {
     subgraphError?: _SubgraphErrorPolicy_;
     where?: InputMaybe<League_Filter>;
 };
-export type SubscriptionOffchainEventArgs = {
-    block?: InputMaybe<Block_Height>;
-    id: Scalars['ID']['input'];
-    subgraphError?: _SubgraphErrorPolicy_;
-};
-export type SubscriptionOffchainEventsArgs = {
-    block?: InputMaybe<Block_Height>;
-    first?: InputMaybe<Scalars['Int']['input']>;
-    orderBy?: InputMaybe<OffchainEvent_OrderBy>;
-    orderDirection?: InputMaybe<OrderDirection>;
-    skip?: InputMaybe<Scalars['Int']['input']>;
-    subgraphError?: _SubgraphErrorPolicy_;
-    where?: InputMaybe<OffchainEvent_Filter>;
-};
 export type SubscriptionOutcomeArgs = {
     block?: InputMaybe<Block_Height>;
     id: Scalars['ID']['input'];

package/dist/docs/index.d.ts

@@ -3,8 +3,7 @@ export * from './bets/fragments/legacyLiveBet';
 export * from './bets/fragments/legacyPrematchBet';
 export * from './bets/fragments/bet';
 export * from './bets/bettors';
-export * from './bets/legacyLiveBets';
-export * from './bets/legacyPrematchBets';
+export * from './bets/legacyBets';
 export * from './bets/gameBets';
 export * from './bets/bets';
 export * from './feed/fragments/condition';
@@ -17,5 +16,6 @@ export * from './feed/games';
 export * from './feed/navigation';
 export * from './feed/sports';
 export * from './feed/sportsNavigation';
+export * from './legacy-live-feed/games';
 export { BetResult, Bet_OrderBy as Legacy_Bet_OrderBy, GameStatus as LegacyGameStatus, SelectionResult, BetStatus as GraphBetStatus, V3_Bet_OrderBy as Bet_OrderBy, ConditionStatus as BetConditionStatus, } from './bets/types';
 export { type Condition_Filter, Game_OrderBy, ConditionState, OrderDirection, GameState, Condition_OrderBy, } from './feed/types';

package/dist/docs/legacy-live-feed/games.d.ts

@@ -0,0 +1,41 @@
+import * as Types from './types';
+export type LegacyLiveGamesQueryVariables = Types.Exact<{
+    first?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    skip?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    where: Types.Game_Filter;
+    orderBy?: Types.InputMaybe<Types.Game_OrderBy>;
+    orderDirection?: Types.InputMaybe<Types.OrderDirection>;
+}>;
+export type LegacyLiveGamesQuery = {
+    __typename?: 'Query';
+    games: Array<{
+        __typename?: 'Game';
+        id: string;
+        gameId: string;
+        title?: string | null;
+        startsAt: string;
+        status: Types.GameStatus;
+        sport: {
+            __typename?: 'Sport';
+            sportId: string;
+            slug: string;
+            name: string;
+        };
+        league: {
+            __typename?: 'League';
+            slug: string;
+            name: string;
+            country: {
+                __typename?: 'Country';
+                slug: string;
+                name: string;
+            };
+        };
+        participants: Array<{
+            __typename?: 'Participant';
+            image?: string | null;
+            name: string;
+        }>;
+    }>;
+};
+export declare const LegacyLiveGamesDocument: import("graphql/language/ast").DocumentNode;