@azuro-org/toolkit 5.2.0-beta.1 → 6.0.0-beta.0

package/dist/index.js

@@ -5844,6 +5844,7 @@ const isDevChain = (chainId) => {
         chainId === baseSepolia.id ||
         chainId === bscTestnet.id);
 };
+/** @deprecated Use REST API instead */
 const getFeedGraphqlEndpoint = (chainId) => (`https://thegraph-1.chainfeedon.com/subgraphs/name/azuro-protocol/azuro-data-feed-${endpointNameByChainId[chainId]}`);
 const getBetsGraphqlEndpoint = (chainId) => (`https://thegraph.chainfeedon.com/subgraphs/name/azuro-protocol/azuro-api-${endpointNameByChainId[chainId]}-v3`);
 /**
@@ -6233,15 +6234,47 @@ const chainsDataByEnv = {
     [Environment.BaseSepoliaWETH]: baseSepoliaData,
     [Environment.BscDevUSDT]: bscTestnetData,
     [Environment.BscUSDT]: bscData,
-};var BetState;
-(function (BetState) {
-    BetState["Created"] = "Created";
-    BetState["Pending"] = "Pending";
-    BetState["Sent"] = "Sent";
-    BetState["Accepted"] = "Accepted";
-    BetState["Rejected"] = "Rejected";
-    BetState["Canceled"] = "Canceled";
-})(BetState || (BetState = {}));
+};var BetOrderState;
+(function (BetOrderState) {
+    BetOrderState["Created"] = "Created";
+    BetOrderState["Placed"] = "Placed";
+    BetOrderState["Sent"] = "Sent";
+    BetOrderState["Pending"] = "Pending";
+    BetOrderState["Accepted"] = "Accepted";
+    BetOrderState["Rejected"] = "Rejected";
+    BetOrderState["PendingCancel"] = "PendingCancel";
+    BetOrderState["Canceled"] = "Canceled";
+    BetOrderState["CancelFailed"] = "CancelFailed";
+    BetOrderState["Settled"] = "Settled";
+})(BetOrderState || (BetOrderState = {}));
+var BetOrderResult;
+(function (BetOrderResult) {
+    BetOrderResult["Won"] = "Won";
+    BetOrderResult["Lost"] = "Lost";
+    BetOrderResult["Canceled"] = "Canceled";
+})(BetOrderResult || (BetOrderResult = {}));
+var GameState;
+(function (GameState) {
+    GameState["Finished"] = "Finished";
+    GameState["Live"] = "Live";
+    GameState["Prematch"] = "Prematch";
+    GameState["Stopped"] = "Stopped";
+    GameState["Canceled"] = "Canceled";
+})(GameState || (GameState = {}));
+var ConditionState;
+(function (ConditionState) {
+    ConditionState["Active"] = "Active";
+    ConditionState["Canceled"] = "Canceled";
+    ConditionState["Removed"] = "Removed";
+    ConditionState["Resolved"] = "Resolved";
+    ConditionState["Stopped"] = "Stopped";
+})(ConditionState || (ConditionState = {}));
+/** Defines the order direction, either ascending or descending */
+var OrderDirection$1;
+(function (OrderDirection) {
+    OrderDirection["Asc"] = "asc";
+    OrderDirection["Desc"] = "desc";
+})(OrderDirection$1 || (OrderDirection$1 = {}));
 var BonusType;
 (function (BonusType) {
     BonusType["FreeBet"] = "FreeBet";
@@ -6292,6 +6325,7 @@ var EventRestrictionState;
   resolvedAt: resolvedBlockTimestamp
   txHash: createdTxHash
   redeemedTxHash
+  redeemedAt: redeemedBlockTimestamp
   affiliate
   isRedeemed
   isRedeemable
@@ -6335,6 +6369,7 @@ var EventRestrictionState;
   resolvedAt: resolvedBlockTimestamp
   txHash: createdTxHash
   redeemedTxHash
+  redeemedAt: redeemedBlockTimestamp
   affiliate
   isRedeemed
   isRedeemable
@@ -6397,55 +6432,6 @@ var EventRestrictionState;
   cashout {
     payout
   }
-}
-    `;const BetFragmentDoc = gql `
-    fragment Bet on V3_Bet {
-  id
-  tokenId: betId
-  actor
-  amount
-  status
-  potentialPayout
-  payout
-  result
-  odds
-  settledOdds
-  createdAt: createdBlockTimestamp
-  resolvedAt: resolvedBlockTimestamp
-  txHash: createdTxHash
-  redeemedTxHash
-  affiliate
-  isRedeemed
-  isRedeemable
-  isCashedOut
-  core {
-    address
-    liquidityPool {
-      address
-    }
-  }
-  selections {
-    odds
-    result
-    conditionKind
-    outcome {
-      outcomeId
-      title
-      condition {
-        conditionId
-        title
-        status
-        gameId
-        wonOutcomeIds
-      }
-    }
-  }
-  freebetId
-  isFreebetAmountReturnable
-  paymasterContractAddress
-  cashout {
-    payout
-  }
 }
     `;const BettorsDocument = gql `
     query Bettors($where: Bettor_filter!) {
@@ -6536,207 +6522,6 @@ ${LegacyLiveBetFragmentDoc}`;const GameBetsDocument = gql `
       id
     }
   }
-}
-    `;const BetsDocument = gql `
-    query Bets($first: Int, $skip: Int, $where: V3_Bet_filter!, $orderBy: V3_Bet_orderBy, $orderDirection: OrderDirection) {
-  v3Bets(
-    first: $first
-    skip: $skip
-    where: $where
-    orderBy: $orderBy
-    orderDirection: $orderDirection
-    subgraphError: allow
-  ) {
-    ...Bet
-  }
-}
-    ${BetFragmentDoc}`;const ConditionFragmentDoc = gql `
-    fragment Condition on Condition {
-  id
-  conditionId
-  state
-  title
-  isExpressForbidden
-  isPrematchEnabled
-  isLiveEnabled
-  margin
-  outcomes {
-    title
-    outcomeId
-    odds: currentOdds
-  }
-  game {
-    gameId
-    sport {
-      sportId
-    }
-  }
-}
-    `;const GameInfoFragmentDoc = gql `
-    fragment GameInfo on Game {
-  id
-  gameId
-  slug
-  title
-  startsAt
-  state
-  turnover
-  sport {
-    sportId
-    slug
-    name
-    sporthub {
-      id
-      slug
-    }
-  }
-  league {
-    id
-    slug
-    name
-  }
-  country {
-    id
-    slug
-    name
-  }
-  participants {
-    image
-    name
-  }
-}
-    `;const ConditionDocument = gql `
-    query Condition($id: ID!) {
-  condition(id: $id, subgraphError: allow) {
-    ...Condition
-  }
-}
-    ${ConditionFragmentDoc}`;const ConditionsDocument = gql `
-    query Conditions($where: Condition_filter!, $orderBy: Condition_orderBy, $orderDirection: OrderDirection) {
-  conditions(
-    where: $where
-    first: 1000
-    orderBy: $orderBy
-    orderDirection: $orderDirection
-    subgraphError: allow
-  ) {
-    ...Condition
-    wonOutcomeIds
-  }
-}
-    ${ConditionFragmentDoc}`;const ConditionsBatchDocument = gql `
-    query ConditionsBatch($conditionFilter: Condition_filter) {
-  conditions(where: $conditionFilter, first: 1000, subgraphError: allow) {
-    state
-    conditionId
-    outcomes {
-      id
-      outcomeId
-      odds: currentOdds
-    }
-  }
-}
-    `;const GameDocument = gql `
-    query Game($id: ID!) {
-  game(id: $id, subgraphError: allow) {
-    ...GameInfo
-  }
-}
-    ${GameInfoFragmentDoc}`;const GamesDocument = gql `
-    query Games($first: Int, $skip: Int, $where: Game_filter!, $orderBy: Game_orderBy, $orderDirection: OrderDirection) {
-  games(
-    first: $first
-    skip: $skip
-    where: $where
-    orderBy: $orderBy
-    orderDirection: $orderDirection
-    subgraphError: allow
-  ) {
-    ...GameInfo
-  }
-}
-    ${GameInfoFragmentDoc}`;const NavigationDocument = gql `
-    query Navigation($sportFilter: Sport_filter, $countryFilter: Country_filter, $leagueFilter: League_filter) {
-  sports(where: $sportFilter, subgraphError: allow) {
-    id
-    slug
-    name
-    sportId
-    sporthub {
-      id
-      slug
-    }
-    activeGamesCount
-    activeLiveGamesCount
-    activePrematchGamesCount
-    countries(where: $countryFilter) {
-      id
-      slug
-      name
-      turnover
-      activeGamesCount
-      activeLiveGamesCount
-      activePrematchGamesCount
-      leagues(where: $leagueFilter) {
-        id
-        slug
-        name
-        turnover
-        activeGamesCount
-        activeLiveGamesCount
-        activePrematchGamesCount
-      }
-    }
-  }
-}
-    `;const SportsDocument = gql `
-    query Sports($first: Int, $sportFilter: Sport_filter, $countryFilter: Country_filter, $leagueFilter: League_filter, $gameFilter: Game_filter, $gameOrderBy: Game_orderBy, $gameOrderDirection: OrderDirection) {
-  sports(
-    where: $sportFilter
-    orderBy: turnover
-    orderDirection: desc
-    subgraphError: allow
-  ) {
-    id
-    slug
-    name
-    sportId
-    turnover
-    countries(where: $countryFilter, orderBy: turnover, orderDirection: desc) {
-      slug
-      name
-      turnover
-      leagues(where: $leagueFilter, orderBy: turnover, orderDirection: desc) {
-        slug
-        name
-        turnover
-        games(
-          where: $gameFilter
-          first: $first
-          orderBy: $gameOrderBy
-          orderDirection: $gameOrderDirection
-        ) {
-          ...GameInfo
-        }
-      }
-    }
-  }
-}
-    ${GameInfoFragmentDoc}`;const SportsNavigationDocument = gql `
-    query SportsNavigation($sportFilter: Sport_filter) {
-  sports(where: $sportFilter, subgraphError: allow) {
-    id
-    slug
-    name
-    sportId
-    sporthub {
-      id
-      slug
-    }
-    activeGamesCount
-    activeLiveGamesCount
-    activePrematchGamesCount
-  }
 }
     `;const LegacyLiveGamesDocument = gql `
     query LegacyLiveGames($first: Int, $skip: Int, $where: Game_filter!, $orderBy: Game_orderBy, $orderDirection: OrderDirection) {
@@ -6788,11 +6573,11 @@ ${LegacyLiveBetFragmentDoc}`;const GameBetsDocument = gql `
     AffiliateMonthly_OrderBy["Month"] = "month";
     AffiliateMonthly_OrderBy["Year"] = "year";
 })(AffiliateMonthly_OrderBy || (AffiliateMonthly_OrderBy = {}));
-var Aggregation_Interval$1;
+var Aggregation_Interval;
 (function (Aggregation_Interval) {
     Aggregation_Interval["Day"] = "day";
     Aggregation_Interval["Hour"] = "hour";
-})(Aggregation_Interval$1 || (Aggregation_Interval$1 = {}));
+})(Aggregation_Interval || (Aggregation_Interval = {}));
 var AzuroBetContract_OrderBy;
 (function (AzuroBetContract_OrderBy) {
     AzuroBetContract_OrderBy["Address"] = "address";
@@ -6977,7 +6762,7 @@ var ConditionStatus;
     ConditionStatus["Paused"] = "Paused";
     ConditionStatus["Resolved"] = "Resolved";
 })(ConditionStatus || (ConditionStatus = {}));
-var Condition_OrderBy$1;
+var Condition_OrderBy;
 (function (Condition_OrderBy) {
     Condition_OrderBy["OutcomesKey"] = "_outcomesKey";
     Condition_OrderBy["UpdatedAt"] = "_updatedAt";
@@ -7006,7 +6791,7 @@ var Condition_OrderBy$1;
     Condition_OrderBy["Turnover"] = "turnover";
     Condition_OrderBy["WonOutcomeIds"] = "wonOutcomeIds";
     Condition_OrderBy["WonOutcomes"] = "wonOutcomes";
-})(Condition_OrderBy$1 || (Condition_OrderBy$1 = {}));
+})(Condition_OrderBy || (Condition_OrderBy = {}));
 var CoreContract_OrderBy;
 (function (CoreContract_OrderBy) {
     CoreContract_OrderBy["Address"] = "address";
@@ -7014,7 +6799,7 @@ var CoreContract_OrderBy;
     CoreContract_OrderBy["LiquidityPool"] = "liquidityPool";
     CoreContract_OrderBy["Type"] = "type";
 })(CoreContract_OrderBy || (CoreContract_OrderBy = {}));
-var Country_OrderBy$1;
+var Country_OrderBy;
 (function (Country_OrderBy) {
     Country_OrderBy["ActiveLeaguesEntityIds"] = "activeLeaguesEntityIds";
     Country_OrderBy["HasActiveLeagues"] = "hasActiveLeagues";
@@ -7024,8 +6809,8 @@ var Country_OrderBy$1;
     Country_OrderBy["Slug"] = "slug";
     Country_OrderBy["Sport"] = "sport";
     Country_OrderBy["Turnover"] = "turnover";
-})(Country_OrderBy$1 || (Country_OrderBy$1 = {}));
-var EventName$1;
+})(Country_OrderBy || (Country_OrderBy = {}));
+var EventName;
 (function (EventName) {
     EventName["AzuroBetTransfer"] = "AzuroBetTransfer";
     EventName["BetCashedOut"] = "BetCashedOut";
@@ -7061,8 +6846,8 @@ var EventName$1;
     EventName["V3ConditionResolved"] = "V3_ConditionResolved";
     EventName["V3FreebetRedeemed"] = "V3_FreebetRedeemed";
     EventName["V3NewBet"] = "V3_NewBet";
-})(EventName$1 || (EventName$1 = {}));
-var Event_OrderBy$1;
+})(EventName || (EventName = {}));
+var Event_OrderBy;
 (function (Event_OrderBy) {
     Event_OrderBy["Affiliate"] = "affiliate";
     Event_OrderBy["BetId"] = "betId";
@@ -7082,7 +6867,7 @@ var Event_OrderBy$1;
     Event_OrderBy["SortOrder"] = "sortOrder";
     Event_OrderBy["TransactionIndex"] = "transactionIndex";
     Event_OrderBy["TxHash"] = "txHash";
-})(Event_OrderBy$1 || (Event_OrderBy$1 = {}));
+})(Event_OrderBy || (Event_OrderBy = {}));
 var ExpressPrematchRelation_OrderBy;
 (function (ExpressPrematchRelation_OrderBy) {
     ExpressPrematchRelation_OrderBy["Id"] = "id";
@@ -7137,7 +6922,7 @@ var GameStatus;
     GameStatus["Paused"] = "Paused";
     GameStatus["Resolved"] = "Resolved";
 })(GameStatus || (GameStatus = {}));
-var Game_OrderBy$1;
+var Game_OrderBy;
 (function (Game_OrderBy) {
     Game_OrderBy["ActiveConditionsEntityIds"] = "_activeConditionsEntityIds";
     Game_OrderBy["CanceledConditionsEntityIds"] = "_canceledConditionsEntityIds";
@@ -7169,8 +6954,8 @@ var Game_OrderBy$1;
     Game_OrderBy["Status"] = "status";
     Game_OrderBy["Title"] = "title";
     Game_OrderBy["Turnover"] = "turnover";
-})(Game_OrderBy$1 || (Game_OrderBy$1 = {}));
-var League_OrderBy$1;
+})(Game_OrderBy || (Game_OrderBy = {}));
+var League_OrderBy;
 (function (League_OrderBy) {
     League_OrderBy["ActiveGamesEntityIds"] = "activeGamesEntityIds";
     League_OrderBy["Country"] = "country";
@@ -7180,7 +6965,7 @@ var League_OrderBy$1;
     League_OrderBy["Name"] = "name";
     League_OrderBy["Slug"] = "slug";
     League_OrderBy["Turnover"] = "turnover";
-})(League_OrderBy$1 || (League_OrderBy$1 = {}));
+})(League_OrderBy || (League_OrderBy = {}));
 var LiquidityPoolContractType;
 (function (LiquidityPoolContractType) {
     LiquidityPoolContractType["V1"] = "V1";
@@ -7361,17 +7146,17 @@ var LiveSelection_OrderBy;
     LiveSelection_OrderBy["Result"] = "result";
 })(LiveSelection_OrderBy || (LiveSelection_OrderBy = {}));
 /** Defines the order direction, either ascending or descending */
-var OrderDirection$1;
+var OrderDirection;
 (function (OrderDirection) {
     OrderDirection["Asc"] = "asc";
     OrderDirection["Desc"] = "desc";
-})(OrderDirection$1 || (OrderDirection$1 = {}));
-var OutcomeResult$1;
+})(OrderDirection || (OrderDirection = {}));
+var OutcomeResult;
 (function (OutcomeResult) {
     OutcomeResult["Lost"] = "Lost";
     OutcomeResult["Won"] = "Won";
-})(OutcomeResult$1 || (OutcomeResult$1 = {}));
-var Outcome_OrderBy$1;
+})(OutcomeResult || (OutcomeResult = {}));
+var Outcome_OrderBy;
 (function (Outcome_OrderBy) {
     Outcome_OrderBy["BetsEntityIds"] = "_betsEntityIds";
     Outcome_OrderBy["UpdatedAt"] = "_updatedAt";
@@ -7386,20 +7171,20 @@ var Outcome_OrderBy$1;
     Outcome_OrderBy["Selections"] = "selections";
     Outcome_OrderBy["SortOrder"] = "sortOrder";
     Outcome_OrderBy["Title"] = "title";
-})(Outcome_OrderBy$1 || (Outcome_OrderBy$1 = {}));
+})(Outcome_OrderBy || (Outcome_OrderBy = {}));
 var OutcomesKeyConditionRelation_OrderBy;
 (function (OutcomesKeyConditionRelation_OrderBy) {
     OutcomesKeyConditionRelation_OrderBy["ConditionEntityId"] = "conditionEntityId";
     OutcomesKeyConditionRelation_OrderBy["Id"] = "id";
 })(OutcomesKeyConditionRelation_OrderBy || (OutcomesKeyConditionRelation_OrderBy = {}));
-var Participant_OrderBy$1;
+var Participant_OrderBy;
 (function (Participant_OrderBy) {
     Participant_OrderBy["Game"] = "game";
     Participant_OrderBy["Id"] = "id";
     Participant_OrderBy["Image"] = "image";
     Participant_OrderBy["Name"] = "name";
     Participant_OrderBy["SortOrder"] = "sortOrder";
-})(Participant_OrderBy$1 || (Participant_OrderBy$1 = {}));
+})(Participant_OrderBy || (Participant_OrderBy = {}));
 var SelectionResult;
 (function (SelectionResult) {
     SelectionResult["Lost"] = "Lost";
@@ -7418,14 +7203,14 @@ var Selection_OrderBy;
     Selection_OrderBy["RawOdds"] = "rawOdds";
     Selection_OrderBy["Result"] = "result";
 })(Selection_OrderBy || (Selection_OrderBy = {}));
-var SportHub_OrderBy$1;
+var SportHub_OrderBy;
 (function (SportHub_OrderBy) {
     SportHub_OrderBy["Id"] = "id";
     SportHub_OrderBy["Name"] = "name";
     SportHub_OrderBy["Slug"] = "slug";
     SportHub_OrderBy["Sports"] = "sports";
-})(SportHub_OrderBy$1 || (SportHub_OrderBy$1 = {}));
-var Sport_OrderBy$1;
+})(SportHub_OrderBy || (SportHub_OrderBy = {}));
+var Sport_OrderBy;
 (function (Sport_OrderBy) {
     Sport_OrderBy["Countries"] = "countries";
     Sport_OrderBy["Games"] = "games";
@@ -7434,7 +7219,7 @@ var Sport_OrderBy$1;
     Sport_OrderBy["Slug"] = "slug";
     Sport_OrderBy["SportId"] = "sportId";
     Sport_OrderBy["Sporthub"] = "sporthub";
-})(Sport_OrderBy$1 || (Sport_OrderBy$1 = {}));
+})(Sport_OrderBy || (Sport_OrderBy = {}));
 var V3_BetMetadata_OrderBy;
 (function (V3_BetMetadata_OrderBy) {
     V3_BetMetadata_OrderBy["FreebetId"] = "freebetId";
@@ -7561,234 +7346,25 @@ var V3_Selection_OrderBy;
     V3_Selection_OrderBy["Result"] = "result";
     V3_Selection_OrderBy["SettledMargin"] = "settledMargin";
 })(V3_Selection_OrderBy || (V3_Selection_OrderBy = {}));
-var _SubgraphErrorPolicy_$1;
-(function (_SubgraphErrorPolicy_) {
-    /** Data will be returned even if the subgraph has indexing errors */
-    _SubgraphErrorPolicy_["Allow"] = "allow";
-    /** If the subgraph has indexing errors, data will be omitted. The default. */
-    _SubgraphErrorPolicy_["Deny"] = "deny";
-})(_SubgraphErrorPolicy_$1 || (_SubgraphErrorPolicy_$1 = {}));var Aggregation_Interval;
-(function (Aggregation_Interval) {
-    Aggregation_Interval["Day"] = "day";
-    Aggregation_Interval["Hour"] = "hour";
-})(Aggregation_Interval || (Aggregation_Interval = {}));
-var ConditionState;
-(function (ConditionState) {
-    ConditionState["Active"] = "Active";
-    ConditionState["Canceled"] = "Canceled";
-    ConditionState["Removed"] = "Removed";
-    ConditionState["Resolved"] = "Resolved";
-    ConditionState["Stopped"] = "Stopped";
-})(ConditionState || (ConditionState = {}));
-var Condition_OrderBy;
-(function (Condition_OrderBy) {
-    Condition_OrderBy["IsCustomSettings"] = "_isCustomSettings";
-    Condition_OrderBy["MaxLiveConditionPotentialLoss"] = "_maxLiveConditionPotentialLoss";
-    Condition_OrderBy["MaxLiveOutcomePotentialLoss"] = "_maxLiveOutcomePotentialLoss";
-    Condition_OrderBy["UpdatedAt"] = "_updatedAt";
-    Condition_OrderBy["ConditionId"] = "conditionId";
-    Condition_OrderBy["CreatedBlockNumber"] = "createdBlockNumber";
-    Condition_OrderBy["CreatedBlockTimestamp"] = "createdBlockTimestamp";
-    Condition_OrderBy["CurrentConditionPotentialLoss"] = "currentConditionPotentialLoss";
-    Condition_OrderBy["Description"] = "description";
-    Condition_OrderBy["Game"] = "game";
-    Condition_OrderBy["Id"] = "id";
-    Condition_OrderBy["IsCashoutEnabled"] = "isCashoutEnabled";
-    Condition_OrderBy["IsExpressForbidden"] = "isExpressForbidden";
-    Condition_OrderBy["IsLiveEnabled"] = "isLiveEnabled";
-    Condition_OrderBy["IsPrematchEnabled"] = "isPrematchEnabled";
-    Condition_OrderBy["Margin"] = "margin";
-    Condition_OrderBy["MaxConditionPotentialLoss"] = "maxConditionPotentialLoss";
-    Condition_OrderBy["MaxOutcomePotentialLoss"] = "maxOutcomePotentialLoss";
-    Condition_OrderBy["Outcomes"] = "outcomes";
-    Condition_OrderBy["OutcomesIds"] = "outcomesIds";
-    Condition_OrderBy["RawCurrentConditionPotentialLoss"] = "rawCurrentConditionPotentialLoss";
-    Condition_OrderBy["RawMaxConditionPotentialLoss"] = "rawMaxConditionPotentialLoss";
-    Condition_OrderBy["RawMaxOutcomePotentialLoss"] = "rawMaxOutcomePotentialLoss";
-    Condition_OrderBy["RawTurnover"] = "rawTurnover";
-    Condition_OrderBy["SettledBlockNumber"] = "settledBlockNumber";
-    Condition_OrderBy["SettledBlockTimestamp"] = "settledBlockTimestamp";
-    Condition_OrderBy["State"] = "state";
-    Condition_OrderBy["Title"] = "title";
-    Condition_OrderBy["Turnover"] = "turnover";
-    Condition_OrderBy["WinningOutcomesCount"] = "winningOutcomesCount";
-    Condition_OrderBy["WonOutcomeIds"] = "wonOutcomeIds";
-    Condition_OrderBy["WonOutcomes"] = "wonOutcomes";
-})(Condition_OrderBy || (Condition_OrderBy = {}));
-var Country_OrderBy;
-(function (Country_OrderBy) {
-    Country_OrderBy["ActiveGamesCount"] = "activeGamesCount";
-    Country_OrderBy["ActiveLeaguesCount"] = "activeLeaguesCount";
-    Country_OrderBy["ActiveLiveGamesCount"] = "activeLiveGamesCount";
-    Country_OrderBy["ActiveLiveLeaguesCount"] = "activeLiveLeaguesCount";
-    Country_OrderBy["ActivePrematchGamesCount"] = "activePrematchGamesCount";
-    Country_OrderBy["ActivePrematchLeaguesCount"] = "activePrematchLeaguesCount";
-    Country_OrderBy["Games"] = "games";
-    Country_OrderBy["Id"] = "id";
-    Country_OrderBy["Leagues"] = "leagues";
-    Country_OrderBy["Name"] = "name";
-    Country_OrderBy["RawTotalTurnover"] = "rawTotalTurnover";
-    Country_OrderBy["RawTurnover"] = "rawTurnover";
-    Country_OrderBy["Slug"] = "slug";
-    Country_OrderBy["Sport"] = "sport";
-    Country_OrderBy["TotalTurnover"] = "totalTurnover";
-    Country_OrderBy["Turnover"] = "turnover";
-})(Country_OrderBy || (Country_OrderBy = {}));
-var EventName;
-(function (EventName) {
-    EventName["ConditionCreated"] = "ConditionCreated";
-    EventName["ConditionUpdated"] = "ConditionUpdated";
-    EventName["GameCreated"] = "GameCreated";
-    EventName["GameUpdated"] = "GameUpdated";
-})(EventName || (EventName = {}));
-var Event_OrderBy;
-(function (Event_OrderBy) {
-    Event_OrderBy["BlockNumber"] = "blockNumber";
-    Event_OrderBy["BlockTimestamp"] = "blockTimestamp";
-    Event_OrderBy["ConditionId"] = "conditionId";
-    Event_OrderBy["GameId"] = "gameId";
-    Event_OrderBy["Id"] = "id";
-    Event_OrderBy["Name"] = "name";
-})(Event_OrderBy || (Event_OrderBy = {}));
-var GameState;
-(function (GameState) {
-    GameState["Finished"] = "Finished";
-    GameState["Live"] = "Live";
-    GameState["Prematch"] = "Prematch";
-    GameState["Stopped"] = "Stopped";
-})(GameState || (GameState = {}));
-var Game_OrderBy;
-(function (Game_OrderBy) {
-    Game_OrderBy["ProviderTitle"] = "_providerTitle";
-    Game_OrderBy["UpdatedAt"] = "_updatedAt";
-    Game_OrderBy["ActiveAndStoppedConditionsCount"] = "activeAndStoppedConditionsCount";
-    Game_OrderBy["ActiveConditionsCount"] = "activeConditionsCount";
-    Game_OrderBy["Conditions"] = "conditions";
-    Game_OrderBy["ConditionsCount"] = "conditionsCount";
-    Game_OrderBy["Country"] = "country";
-    Game_OrderBy["CreatedBlockNumber"] = "createdBlockNumber";
-    Game_OrderBy["CreatedBlockTimestamp"] = "createdBlockTimestamp";
-    Game_OrderBy["Description"] = "description";
-    Game_OrderBy["FinishedBlockNumber"] = "finishedBlockNumber";
-    Game_OrderBy["FinishedBlockTimestamp"] = "finishedBlockTimestamp";
-    Game_OrderBy["GameId"] = "gameId";
-    Game_OrderBy["Id"] = "id";
-    Game_OrderBy["League"] = "league";
-    Game_OrderBy["Participants"] = "participants";
-    Game_OrderBy["RawTotalTurnover"] = "rawTotalTurnover";
-    Game_OrderBy["RawTurnover"] = "rawTurnover";
-    Game_OrderBy["SettledBlockNumber"] = "settledBlockNumber";
-    Game_OrderBy["SettledBlockTimestamp"] = "settledBlockTimestamp";
-    Game_OrderBy["SettledConditionsCount"] = "settledConditionsCount";
-    Game_OrderBy["Slug"] = "slug";
-    Game_OrderBy["Sport"] = "sport";
-    Game_OrderBy["StartsAt"] = "startsAt";
-    Game_OrderBy["State"] = "state";
-    Game_OrderBy["Title"] = "title";
-    Game_OrderBy["TotalTurnover"] = "totalTurnover";
-    Game_OrderBy["Turnover"] = "turnover";
-})(Game_OrderBy || (Game_OrderBy = {}));
-var League_OrderBy;
-(function (League_OrderBy) {
-    League_OrderBy["ActiveGamesCount"] = "activeGamesCount";
-    League_OrderBy["ActiveLiveGamesCount"] = "activeLiveGamesCount";
-    League_OrderBy["ActivePrematchGamesCount"] = "activePrematchGamesCount";
-    League_OrderBy["Country"] = "country";
-    League_OrderBy["Games"] = "games";
-    League_OrderBy["Id"] = "id";
-    League_OrderBy["Name"] = "name";
-    League_OrderBy["RawTotalTurnover"] = "rawTotalTurnover";
-    League_OrderBy["RawTurnover"] = "rawTurnover";
-    League_OrderBy["Slug"] = "slug";
-    League_OrderBy["Sport"] = "sport";
-    League_OrderBy["TotalTurnover"] = "totalTurnover";
-    League_OrderBy["Turnover"] = "turnover";
-})(League_OrderBy || (League_OrderBy = {}));
-/** Defines the order direction, either ascending or descending */
-var OrderDirection;
-(function (OrderDirection) {
-    OrderDirection["Asc"] = "asc";
-    OrderDirection["Desc"] = "desc";
-})(OrderDirection || (OrderDirection = {}));
-var OutcomeResult;
-(function (OutcomeResult) {
-    OutcomeResult["Lost"] = "Lost";
-    OutcomeResult["Won"] = "Won";
-})(OutcomeResult || (OutcomeResult = {}));
-var Outcome_OrderBy;
-(function (Outcome_OrderBy) {
-    Outcome_OrderBy["IsCustomPrice"] = "_isCustomPrice";
-    Outcome_OrderBy["UpdatedAt"] = "_updatedAt";
-    Outcome_OrderBy["Condition"] = "condition";
-    Outcome_OrderBy["CurrentOdds"] = "currentOdds";
-    Outcome_OrderBy["Id"] = "id";
-    Outcome_OrderBy["OutcomeId"] = "outcomeId";
-    Outcome_OrderBy["PotentialLoss"] = "potentialLoss";
-    Outcome_OrderBy["RawCurrentOdds"] = "rawCurrentOdds";
-    Outcome_OrderBy["RawPotentialLoss"] = "rawPotentialLoss";
-    Outcome_OrderBy["RawTurnover"] = "rawTurnover";
-    Outcome_OrderBy["Result"] = "result";
-    Outcome_OrderBy["SortOrder"] = "sortOrder";
-    Outcome_OrderBy["Title"] = "title";
-    Outcome_OrderBy["Turnover"] = "turnover";
-})(Outcome_OrderBy || (Outcome_OrderBy = {}));
-var Participant_OrderBy;
-(function (Participant_OrderBy) {
-    Participant_OrderBy["Game"] = "game";
-    Participant_OrderBy["Id"] = "id";
-    Participant_OrderBy["Image"] = "image";
-    Participant_OrderBy["Name"] = "name";
-    Participant_OrderBy["SortOrder"] = "sortOrder";
-})(Participant_OrderBy || (Participant_OrderBy = {}));
-var SportHub_OrderBy;
-(function (SportHub_OrderBy) {
-    SportHub_OrderBy["Id"] = "id";
-    SportHub_OrderBy["Name"] = "name";
-    SportHub_OrderBy["Slug"] = "slug";
-    SportHub_OrderBy["Sports"] = "sports";
-})(SportHub_OrderBy || (SportHub_OrderBy = {}));
-var Sport_OrderBy;
-(function (Sport_OrderBy) {
-    Sport_OrderBy["ActiveCountriesCount"] = "activeCountriesCount";
-    Sport_OrderBy["ActiveGamesCount"] = "activeGamesCount";
-    Sport_OrderBy["ActiveLeaguesCount"] = "activeLeaguesCount";
-    Sport_OrderBy["ActiveLiveCountriesCount"] = "activeLiveCountriesCount";
-    Sport_OrderBy["ActiveLiveGamesCount"] = "activeLiveGamesCount";
-    Sport_OrderBy["ActiveLiveLeaguesCount"] = "activeLiveLeaguesCount";
-    Sport_OrderBy["ActivePrematchCountriesCount"] = "activePrematchCountriesCount";
-    Sport_OrderBy["ActivePrematchGamesCount"] = "activePrematchGamesCount";
-    Sport_OrderBy["ActivePrematchLeaguesCount"] = "activePrematchLeaguesCount";
-    Sport_OrderBy["Countries"] = "countries";
-    Sport_OrderBy["Games"] = "games";
-    Sport_OrderBy["Id"] = "id";
-    Sport_OrderBy["Leagues"] = "leagues";
-    Sport_OrderBy["Name"] = "name";
-    Sport_OrderBy["RawTotalTurnover"] = "rawTotalTurnover";
-    Sport_OrderBy["RawTurnover"] = "rawTurnover";
-    Sport_OrderBy["Slug"] = "slug";
-    Sport_OrderBy["SportId"] = "sportId";
-    Sport_OrderBy["Sporthub"] = "sporthub";
-    Sport_OrderBy["TotalTurnover"] = "totalTurnover";
-    Sport_OrderBy["Turnover"] = "turnover";
-})(Sport_OrderBy || (Sport_OrderBy = {}));
-var VirtualCondition_OrderBy;
-(function (VirtualCondition_OrderBy) {
-    VirtualCondition_OrderBy["Data"] = "data";
-    VirtualCondition_OrderBy["Game"] = "game";
-    VirtualCondition_OrderBy["Id"] = "id";
-})(VirtualCondition_OrderBy || (VirtualCondition_OrderBy = {}));
-var VirtualGame_OrderBy;
-(function (VirtualGame_OrderBy) {
-    VirtualGame_OrderBy["Conditions"] = "conditions";
-    VirtualGame_OrderBy["Id"] = "id";
-})(VirtualGame_OrderBy || (VirtualGame_OrderBy = {}));
-var _SubgraphErrorPolicy_;
+var _SubgraphErrorPolicy_;
 (function (_SubgraphErrorPolicy_) {
     /** Data will be returned even if the subgraph has indexing errors */
     _SubgraphErrorPolicy_["Allow"] = "allow";
     /** If the subgraph has indexing errors, data will be omitted. The default. */
     _SubgraphErrorPolicy_["Deny"] = "deny";
 })(_SubgraphErrorPolicy_ || (_SubgraphErrorPolicy_ = {}));const CONDITION_PROVIDER_LENGTH = 3;
+/**
+ * Extracts the provider ID from a condition ID string.
+ * The provider ID is encoded in characters 2-4 of the condition ID.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/getProviderFromId
+ *
+ * @example
+ * import { getProviderFromId } from '@azuro-org/toolkit'
+ *
+ * const providerId = getProviderFromId('C001234567890')
+ * console.log(providerId) // 001
+ * */
 const getProviderFromId = (id) => {
     return +(id.slice(1, 1 + CONDITION_PROVIDER_LENGTH));
 };const formatToFixed = (value, digitsCount) => {
@@ -7797,70 +7373,102 @@ const getProviderFromId = (id) => {
         return +value;
     }
     const [int, digits] = value.split('.');
-    return +`${int}.${digits.substr(0, digitsCount)}`;
+    if (!digitsCount || digitsCount < 0 || !digits?.length || digits.length < digitsCount) {
+        return +(int || 0);
+    }
+    return +`${int}.${digits.slice(0, digitsCount)}`;
 };const adjustSubBetOdds = (value) => Math.ceil(+value / ODDS_COMBO_FEE_MODIFIER * 100) / 100;
-const calcMindOdds = (props) => {
+/**
+ * Calculates the minimum acceptable odds considering slippage for single or combo bets.
+ * For combo bets, applies fee modifiers and multiplies individual odds to calculate total odds.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/calcMinOdds
+ *
+ * @example
+ * import { calcMindOdds } from '@azuro-org/toolkit'
+ *
+ * // Single bet with 5% slippage
+ * const minOdds = calcMindOdds({ odds: 1.5, slippage: 5 })
+ *
+ * // Combo bet with multiple odds
+ * const comboMinOdds = calcMindOdds({ odds: [1.5, 2.0, 1.8], slippage: 5 })
+ * */
+const calcMinOdds = (props) => {
+    if (props.slippage && props.slippage >= 100) {
+        return (1).toFixed(ODDS_DECIMALS);
+    }
     let totalOdds;
     if (typeof props.odds === 'number') {
-        totalOdds = props.odds;
+        totalOdds = formatToFixed(props.odds, 2);
     }
     else {
         const comboOdds = props.odds.reduce((acc, odds) => acc * adjustSubBetOdds(odds), 1);
         totalOdds = formatToFixed(comboOdds * ODDS_COMBO_FEE_MODIFIER, 2);
     }
+    if (!props.slippage) {
+        return totalOdds.toFixed(ODDS_DECIMALS);
+    }
     const minOdds = formatToFixed(1 + (totalOdds - 1) * (100 - props.slippage) / 100, 2);
     return minOdds.toFixed(ODDS_DECIMALS);
-};const getIsPendingResolution = ({ state, startsAt }) => {
+};/**
+ * Normalize events timestamp (ISO String, unix time in seconds or ms) to milliseconds.
+ *
+ * As a reasonable threshold for whether to count the number in seconds or milliseconds,
+ * it takes the value 32_503_680_000 (which equals January 12, 1971 in ms and Jan 01, 3000 in seconds).
+ *
+ * So it isn't applicable to dates before January 12, 1971.
+ * */
+const normalizeTimestampToMs = (timestamp) => {
+    if (typeof timestamp === 'string' && isNaN(+timestamp)) {
+        return Date.parse(timestamp);
+    }
+    const numericValue = +timestamp;
+    // If the value is less than a reasonable milliseconds threshold,
+    // treat it as seconds, otherwise as milliseconds
+    return numericValue < 32_503_680_000 ? numericValue * 1000 : numericValue;
+};/**
+ * Determines if a game is pending resolution after completion.
+ * Returns true if the game is in Live state but has exceeded the expected resolution window (100 minutes after start).
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/getIsPendingResolution
+ *
+ * @example
+ * import { getIsPendingResolution, GameState } from '@azuro-org/toolkit'
+ *
+ * const isPending = getIsPendingResolution({
+ *   state: GameState.Live,
+ *   startsAt: '1640000000'
+ * })
+ * */
+const getIsPendingResolution = ({ state, startsAt }) => {
     if (state !== GameState.Live) {
         return false;
     }
-    const startDate = +startsAt * 1000;
+    const startDate = normalizeTimestampToMs(startsAt);
     const now = Date.now();
     const isStarted = startDate < now;
     const pendingResolutionDate = startDate + 6000000;
     return isStarted && pendingResolutionDate < now;
-};var BetStatus;
-(function (BetStatus) {
-    BetStatus[BetStatus["Accepted"] = 0] = "Accepted";
-    BetStatus[BetStatus["Live"] = 1] = "Live";
-    BetStatus[BetStatus["PendingResolution"] = 2] = "PendingResolution";
-    BetStatus[BetStatus["Resolved"] = 3] = "Resolved";
-    BetStatus[BetStatus["Canceled"] = 4] = "Canceled";
-})(BetStatus || (BetStatus = {}));
-const getExpressIsPendingResolution = (games) => {
-    const lastStartDate = Math.max(...games.map(({ startsAt }) => +startsAt));
-    const lastGames = games.filter(({ startsAt }) => +startsAt === lastStartDate);
-    return lastGames.some((game) => {
-        return getIsPendingResolution(game);
-    });
-};
-const getBetStatus = (props) => {
-    const { games, graphStatus } = props;
-    if (graphStatus === BetStatus$1.Canceled) {
-        return BetStatus.Canceled;
-    }
-    if (graphStatus === BetStatus$1.Resolved) {
-        return BetStatus.Resolved;
-    }
-    const isExpress = games.length > 1;
-    const isPendingResolution = isExpress
-        ? getExpressIsPendingResolution(games)
-        : getIsPendingResolution(games[0]);
-    if (isPendingResolution) {
-        return BetStatus.PendingResolution;
-    }
-    const isLive = games.some(game => game.state === GameState.Live);
-    if (isLive) {
-        return BetStatus.Live;
-    }
-    return BetStatus.Accepted;
-};const getBetFee = async (chainId) => {
-    const api = getApiEndpoint(chainId);
-    const environment = environments[chainId];
-    const response = await fetch(`${api}/bet/gas-info?environment=${environment}`);
-    const data = await response.json();
-    return data;
-};const groupConditionsByMarket = (conditions) => {
+};/**
+ * Groups game conditions by their market types and sorts them according to sport-specific ordering.
+ * It processes outcomes to include selection names, handles duplicate conditions, and organizes data for display.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/groupConditionsByMarket
+ *
+ * @example
+ * import { groupConditionsByMarket } from '@azuro-org/toolkit'
+ *
+ * const conditions = await getConditionsByGameIds({ gameIds: ['123'] })
+ * const markets = groupConditionsByMarket(conditions)
+ *
+ * markets.forEach(market => {
+ *   console.log(market.name) // e.g., "Match Winner", "Total Goals"
+ *   market.conditions.forEach(condition => {
+ *     console.log(condition.outcomes) // outcomes with odds and selection names
+ *   })
+ * })
+ * */
+const groupConditionsByMarket = (conditions) => {
     const sportId = conditions[0].game.sport.sportId;
     const markets = {};
     const stateByOutcomeIds = {};
@@ -7978,7 +7586,119 @@ const getBetStatus = (props) => {
         }
         return 0;
     });
-};const getBetTypedData = (props) => {
+};var BetStatus;
+(function (BetStatus) {
+    BetStatus[BetStatus["Accepted"] = 0] = "Accepted";
+    BetStatus[BetStatus["Live"] = 1] = "Live";
+    BetStatus[BetStatus["PendingResolution"] = 2] = "PendingResolution";
+    BetStatus[BetStatus["Resolved"] = 3] = "Resolved";
+    BetStatus[BetStatus["Canceled"] = 4] = "Canceled";
+    BetStatus[BetStatus["Preparing"] = 5] = "Preparing";
+    BetStatus[BetStatus["Rejected"] = 6] = "Rejected";
+})(BetStatus || (BetStatus = {}));
+const filterLastGames = (games) => {
+    const lastStartDate = Math.max(...games.map(({ startsAt }) => +startsAt));
+    return games.filter(({ startsAt }) => +startsAt === lastStartDate);
+};
+/**
+ * Determines the current status of a bet based on order state, on-chain status, and game states.
+ * Returns a unified bet status that combines API order state and blockchain data.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/bet/getBetStatus
+ *
+ * @example
+ * import { getBetStatus, BetStatus } from '@azuro-org/toolkit'
+ *
+ * const games = [
+ *   { state: GameState.Live, startsAt: '1234567890' },
+ * ]
+ * const orderState = BetOrderState.Sent
+ * const graphStatus = GraphBetStatus.Accepted
+ *
+ * const status = getBetStatus({ games, orderState, graphStatus })
+ *
+ * if (status === BetStatus.Live) {
+ *   console.log('Bet is live!')
+ * }
+ * */
+const getBetStatus = (props) => {
+    const { games, graphStatus, orderState } = props;
+    if ((!orderState && !graphStatus)
+        || orderState === BetOrderState.Pending
+        || orderState === BetOrderState.Created
+        || orderState === BetOrderState.Placed
+        || (orderState === BetOrderState.Sent && !graphStatus)) {
+        return BetStatus.Preparing;
+    }
+    if (orderState === BetOrderState.Rejected) {
+        return BetStatus.Rejected;
+    }
+    if (graphStatus === BetStatus$1.Canceled
+        || orderState === BetOrderState.Canceled) {
+        return BetStatus.Canceled;
+    }
+    if (graphStatus === BetStatus$1.Resolved) {
+        return BetStatus.Resolved;
+    }
+    const lastGames = filterLastGames(games);
+    if (lastGames.every((game) => game.state === GameState.Finished)
+        || lastGames.some((game) => getIsPendingResolution(game))) {
+        return BetStatus.PendingResolution;
+    }
+    const isLive = games.some(game => game.state === GameState.Live);
+    if (isLive) {
+        return BetStatus.Live;
+    }
+    return BetStatus.Accepted;
+};/**
+ * Retrieves the current relayer fee information for placing bets on a specific chain.
+ * Returns gas price, bet token rate, and calculated relayer fee amount.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/bet/getBetFee
+ *
+ * @example
+ * import { getBetFee } from '@azuro-org/toolkit'
+ *
+ * const chainId = 137
+ *
+ * const feeInfo = await getBetFee(chainId)
+ *
+ * console.log('Relayer fee:', feeInfo.beautyRelayerFeeAmount, feeInfo.symbol)
+ * console.log('Gas limit:', feeInfo.gasLimit)
+ * */
+const getBetFee = async (chainId) => {
+    const api = getApiEndpoint(chainId);
+    const environment = environments[chainId];
+    const response = await fetch(`${api}/bet/gas-info?environment=${environment}`);
+    if (!response.ok) {
+        throw new Error(`Status ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+};/**
+ * Generates EIP-712 typed data for signing a single (ordinary) bet.
+ * This typed data is used with wallet signing methods to create a bet signature.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/bet/getBetTypedData
+ *
+ * @example
+ * import { getBetTypedData } from '@azuro-org/toolkit'
+ * import { signTypedData } from 'viem/actions'
+ *
+ * const account = '0x...'
+ * const clientData = { chainId: 137, core: '0x...', ... }
+ * const bet = {
+ *   conditionId: '1',
+ *   outcomeId: '1',
+ *   minOdds: '1500000000000',
+ *   amount: '1000000',
+ *   nonce: '1',
+ * }
+ *
+ * const typedData = getBetTypedData({ account, clientData, bet })
+ * const signature = await signTypedData(walletClient, typedData)
+ * */
+const getBetTypedData = (props) => {
     const { account, clientData, bet } = props;
     const { chainId, core } = clientData;
     const EIP712Domain = {
@@ -8015,7 +7735,34 @@ const getBetStatus = (props) => {
             ],
         },
     };
-};const getComboBetTypedData = (props) => {
+};/**
+ * Generates EIP-712 typed data for signing a combo (parlay) bet.
+ * This typed data is used with wallet signing methods to create a combo bet signature.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/bet/getComboBetTypedData
+ *
+ * @example
+ * import { getComboBetTypedData } from '@azuro-org/toolkit'
+ * import { signTypedData } from 'viem/actions'
+ *
+ * const account = '0x...'
+ * const clientData = { chainId: 137, core: '0x...', ... }
+ * const bets = [
+ *   { conditionId: '1', outcomeId: '1' },
+ *   { conditionId: '2', outcomeId: '2' },
+ * ]
+ *
+ * const typedData = getComboBetTypedData({
+ *   account,
+ *   clientData,
+ *   bets,
+ *   amount: '1000000',
+ *   minOdds: '3000000000000',
+ *   nonce: '1',
+ * })
+ * const signature = await signTypedData(walletClient, typedData)
+ * */
+const getComboBetTypedData = (props) => {
     const { account, amount, minOdds, nonce, clientData, bets } = props;
     const { chainId, core } = clientData;
     const EIP712Domain = {
@@ -8050,7 +7797,29 @@ const getBetStatus = (props) => {
             })),
         },
     };
-};const createBet = async (props) => {
+};/**
+ * Creates a single (ordinary) bet by submitting signed bet data to the Azuro API.
+ * This function sends the bet order to the relayer which will then place the bet on-chain.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/bet/createBet
+ *
+ * @example
+ * import { createBet } from '@azuro-org/toolkit'
+ *
+ * const account = '0x...'
+ * const clientData = { chainId: 137, core: '0x...', ... }
+ * const bet = {
+ *   conditionId: '1',
+ *   outcomeId: '1',
+ *   minOdds: '1500000000000',
+ *   amount: '1000000',
+ *   nonce: '1',
+ * }
+ * const signature = '0x...'
+ *
+ * const result = await createBet({ account, clientData, bet, signature })
+ * */
+const createBet = async (props) => {
     const { account, clientData, bet, signature, bonusId } = props;
     const { chainId } = clientData;
     const { api, environment } = chainsData[chainId];
@@ -8079,9 +7848,6 @@ const getBetStatus = (props) => {
         },
         body: JSON.stringify(signedBet),
     });
-    if (response.status === 404) {
-        return null;
-    }
     const data = await response.json();
     if (!response.ok) {
         const error = new Error(data?.errorMessage || `Status: ${response.status}`);
@@ -8091,7 +7857,34 @@ const getBetStatus = (props) => {
         throw error;
     }
     return data;
-};const createComboBet = async (props) => {
+};/**
+ * Creates a combo (parlay) bet by submitting signed bet data to the Azuro API.
+ * This function sends the combo bet order to the relayer which will then place the bet on-chain.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/bet/createComboBet
+ *
+ * @example
+ * import { createComboBet } from '@azuro-org/toolkit'
+ *
+ * const account = '0x...'
+ * const clientData = { chainId: 137, core: '0x...', ... }
+ * const bets = [
+ *   { conditionId: '1', outcomeId: '1' },
+ *   { conditionId: '2', outcomeId: '2' },
+ * ]
+ * const signature = '0x...'
+ *
+ * const result = await createComboBet({
+ *   account,
+ *   clientData,
+ *   bets,
+ *   amount: '1000000',
+ *   minOdds: '3000000000000',
+ *   nonce: '1',
+ *   signature,
+ * })
+ * */
+const createComboBet = async (props) => {
     const { account, amount, minOdds, nonce, clientData, bets, signature, bonusId } = props;
     const { chainId } = clientData;
     const { api, environment } = chainsData[chainId];
@@ -8120,9 +7913,6 @@ const getBetStatus = (props) => {
         },
         body: JSON.stringify(signedBet),
     });
-    if (response.status === 404) {
-        return null;
-    }
     const data = await response.json();
     if (!response.ok) {
         const error = new Error(data?.errorMessage || `Status: ${response.status}`);
@@ -8132,7 +7922,26 @@ const getBetStatus = (props) => {
         throw error;
     }
     return data;
-};const getBet = async ({ chainId, orderId }) => {
+};/**
+ * Retrieves bet order data by order ID from the Azuro API.
+ * Returns null if the bet order is not found.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/bet/getBet
+ *
+ * @example
+ * import { getBet } from '@azuro-org/toolkit'
+ *
+ * const orderId = '0x123...'
+ * const chainId = 137
+ *
+ * const bet = await getBet({ chainId, orderId })
+ *
+ * if (bet) {
+ *   console.log('Bet state:', bet.state)
+ *   console.log('Bet result:', bet.result)
+ * }
+ * */
+const getBet = async ({ chainId, orderId }) => {
     const { api } = chainsData[chainId];
     const response = await fetch(`${api}/bet/orders/${orderId}`);
     if (response.status === 404) {
@@ -8143,38 +7952,12 @@ const getBetStatus = (props) => {
     }
     const data = await response.json();
     return data;
-};/** @deprecated use `getBetCalculation` instead */
-const getMaxBet = async (props) => {
-    const { chainId, selections } = props;
-    const { api, environment } = chainsData[chainId];
-    const response = await fetch(`${api}/bet/calculation`, {
-        method: 'POST',
-        headers: {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            bets: selections.map(({ conditionId, outcomeId }) => ({
-                conditionId,
-                outcomeId: +outcomeId,
-            })),
-            environment,
-        }),
-    });
-    if (response.status === 404) {
-        return null;
-    }
-    if (!response.ok) {
-        throw new Error(`Status ${response.status}: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return data.response;
 };/**
  * Calculates the minimum and maximum bet amount for given selections.
  * User's account is required to provide the **correct** maximum bet amount.
  * It may be undefined if the user isn't logged in.
  *
- * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/getBetCalculation
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/bet/getBetCalculation
  *
  * @example
  * import { getBetCalculation } from '@azuro-org/toolkit'
@@ -8207,15 +7990,411 @@ const getBetCalculation = async (props) => {
         },
         body: JSON.stringify(params),
     });
+    if (!response.ok) {
+        throw new Error(`Status ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.response;
+};/** Serialize an object to URLSearchParams, filtering undefined values, and handling arrays to the expected format */
+function serializeApiParams(struct) {
+    const params = new URLSearchParams();
+    const append = (key, value) => {
+        if (value !== undefined) {
+            params.append(key, String(value));
+        }
+    };
+    Object.entries(struct).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            return value.forEach(subValue => {
+                append(key, subValue);
+            });
+        }
+        append(key, String(value));
+    });
+    return params;
+}/**
+ * Retrieves all bet orders for a specific bettor address with optional filtering.
+ * Supports pagination and filtering by state, result, affiliate, and redemption status.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/bet/getBetsByBettor
+ *
+ * @example
+ * import { getBetsByBettor } from '@azuro-org/toolkit'
+ *
+ * const chainId = 137
+ * const bettor = '0x...'
+ *
+ * // Get all bets
+ * const allBets = await getBetsByBettor({ chainId, bettor })
+ *
+ * // Get only resolved bets
+ * const resolvedBets = await getBetsByBettor({
+ *   chainId,
+ *   bettor,
+ *   state: 'Sent',
+ *   result: 'Won',
+ *   limit: 50,
+ * })
+ * */
+const getBetsByBettor = async (props) => {
+    const { chainId, bettor, offset, limit, result, affiliate, isRedeemed, state } = props;
+    const { api, environment } = chainsData[chainId];
+    if (!bettor) {
+        throw new Error('getBetsByBettor: "bettor" param is required');
+    }
+    const params = serializeApiParams({
+        environment,
+        offset: offset || 0,
+        limit: limit || 100,
+        state,
+        result,
+        affiliate,
+        isRedeemed,
+    });
+    const response = await fetch(`${api}/bet/orders/bettor/${bettor}?${params}`);
     if (response.status === 404) {
         return null;
     }
     if (!response.ok) {
-        throw new Error(`API /bet/calculation failed: Status ${response.status}: ${response.statusText}`);
+        throw new Error(`Status ${response.status}: ${response.statusText}`);
     }
     const data = await response.json();
-    return data.response;
-};var WaveLevelName;
+    return data.orders;
+};/**
+ * Fetches detailed conditions data for a given list of game IDs.
+ * Returns comprehensive condition information including outcomes, odds, and game relationships.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/getConditionsByGameIds
+ *
+ * @example
+ * import { getConditionsByGameIds } from '@azuro-org/toolkit'
+ *
+ * const conditions = await getConditionsByGameIds({
+ *   chainId: 137,
+ *   gameIds: ['1006000000000077484167'],
+ * })
+ * */
+const getConditionsByGameIds = async (props) => {
+    // TODO requested to be OPTIONAL in api because of other requested filters, not implemented yet
+    if (!props.gameIds?.length) {
+        return [];
+    }
+    const api = getApiEndpoint(props.chainId);
+    const environment = environments[props.chainId];
+    const params = serializeApiParams({
+        environment,
+        gameIds: props.gameIds,
+        // TODO requested to be in api, not implemented yet
+        states: props.states,
+        outcomeIds: props.outcomeIds,
+        maxMargin: props.maxMargin,
+        orderBy: props.orderBy,
+        orderDir: props.orderDir,
+    });
+    const response = await fetch(`${api}/market-manager/conditions-by-game-ids?${params}`, {
+        method: 'GET',
+        headers: {
+            'Accept': 'application/json',
+        },
+        cache: 'no-cache',
+    });
+    if (!response.ok) {
+        throw new Error(`getConditionsByGameIds API request failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.conditions;
+};/**
+ * Fetches up-to-date condition states and outcome odds for a list of conditions.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/getConditionsState
+ *
+ * @example
+ * import { getConditionsState } from '@azuro-org/toolkit'
+ *
+ * const conditions = await getConditionsState({
+ *   chainId: 137,
+ *   conditionIds: ['300610060000000000635055340000000000000000387193'],
+ * })
+ * */
+const getConditionsState = async (props) => {
+    const conditionIds = props.conditionIds?.filter(Boolean);
+    if (!conditionIds?.length) {
+        console.warn('getConditionsState: no conditionIds provided, skipping request');
+        return [];
+    }
+    const api = getApiEndpoint(props.chainId);
+    const response = await fetch(`${api}/market-manager/condition-batch`, {
+        method: 'POST',
+        headers: {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            conditionIds,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`getConditionsState API request failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.conditions;
+};/**
+ * Fetches games by applying various filters such as sport, league, or game state.
+ * Returns paginated results ideal for building sport/country/league listing pages.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/getGamesByFilters
+ *
+ * @example
+ * import { GameState, getGamesByFilters } from '@azuro-org/toolkit'
+ *
+ * const games = await getGamesByFilters({
+ *   chainId: 137,
+ *   state: GameState.Prematch,
+ *   page: 2,
+ *   perPage: 50,
+ * })
+ * */
+const getGamesByFilters = async (props) => {
+    const api = getApiEndpoint(props.chainId);
+    const environment = environments[props.chainId];
+    const params = serializeApiParams({
+        environment,
+        perPage: props.perPage || 1000,
+        page: props.page || 1,
+        // TODO requested to be in api, not implemented yet
+        state: props.state,
+        sportIds: props.sportIds,
+        leagueSlugs: props.leagueSlugs,
+        sportHub: props.sportHub,
+        // maxMargin: props.maxMargin,
+        conditionsState: props.conditionsState,
+        orderBy: props.orderBy,
+        orderDir: props.orderDir,
+    });
+    const response = await fetch(`${api}/market-manager/games-by-filters?${params}`, {
+        method: 'GET',
+        headers: {
+            'Accept': 'application/json',
+        },
+        cache: 'no-cache',
+    });
+    if (!response.ok) {
+        throw new Error(`getGamesByFilters API request failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+        ...data,
+        games: data.games.map(game => ({
+            ...game,
+            gameId: game.id,
+        })),
+    };
+};/**
+ * Fetches game data for a specific list of game IDs.
+ * Returns detailed information for each requested game including participants, timing, and league data.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/getGamesByIds
+ *
+ * @example
+ * import { getGamesByIds } from '@azuro-org/toolkit'
+ *
+ * const games = await getGamesByIds({
+ *   chainId: 137,
+ *   gameIds: ['1006000000000080373237'],
+ * })
+ *
+ * const gameData = games[0]
+ * */
+const getGamesByIds = async (props) => {
+    const gameIds = props.gameIds.filter(Boolean);
+    if (!gameIds.length) {
+        console.warn('getGamesByFilters: no gameIds provided, skipping request');
+        return [];
+    }
+    const api = getApiEndpoint(props.chainId);
+    const environment = environments[props.chainId];
+    const response = await fetch(`${api}/market-manager/games-batch`, {
+        method: 'POST',
+        headers: {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            environment,
+            gameIds,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`getGamesByFilters API request failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+};/**
+ * Fetches navigation structure with sports, countries, and leagues hierarchy.
+ * Returns active game counts at each level for building navigation menus.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/getNavigation
+ *
+ * @example
+ * import { getNavigation } from '@azuro-org/toolkit'
+ *
+ * const sports = await getNavigation({
+ *   chainId: 137,
+ *   sportHub: 'sports',
+ * })
+ * */
+const getNavigation = async (props) => {
+    const api = getApiEndpoint(props.chainId);
+    const environment = environments[props.chainId];
+    const params = serializeApiParams({
+        environment,
+        sportHub: props.sportHub,
+        sportIds: props.sportIds,
+    });
+    const response = await fetch(`${api}/market-manager/navigation?${params}`, {
+        method: 'GET',
+        headers: {
+            'Accept': 'application/json',
+        },
+        cache: 'no-cache',
+    });
+    if (!response.ok) {
+        throw new Error(`getNavigation API request failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.sports;
+};/**
+ * Fetches a complete sports hierarchy including countries, leagues, and games.
+ * Returns nested structure with all games organized by sport, country, and league.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/getSports
+ *
+ * @example
+ * import { GameState, getSports } from '@azuro-org/toolkit'
+ *
+ * const sports = await getSports({
+ *   chainId: 137,
+ *   states: [GameState.Prematch, GameState.Live],
+ *   page: 1,
+ *   perPage: 50,
+ * })
+ * */
+const getSports = async (props) => {
+    const api = getApiEndpoint(props.chainId);
+    const environment = environments[props.chainId];
+    const params = serializeApiParams({
+        environment,
+        perPage: props.perPage || 100,
+        page: props.page || 1,
+        states: props.states,
+        // TODO requested to be in api, not implemented yet
+        sportIds: props.sportIds,
+        sportHub: props.sportHub,
+        countrySlug: props.countrySlug,
+        leagueSlug: props.leagueSlug,
+        orderBy: props.orderBy,
+        orderDir: props.orderDir,
+    });
+    const response = await fetch(`${api}/market-manager/sports?${params}`, {
+        method: 'GET',
+        headers: {
+            'Accept': 'application/json',
+        },
+        cache: 'no-cache',
+    });
+    if (!response.ok) {
+        throw new Error(`getSports API request failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    // return data.sports.map((sport) => {
+    //   const sportId = String(sport.id)
+    //
+    //   return {
+    //     ...sport,
+    //     sportId,
+    //     countries: sport.countries.map((country) => {
+    //       return {
+    //         ...country,
+    //         leagues: country.leagues.map((league) => {
+    //           return {
+    //             ...league,
+    //             games: league.games.map(game => {
+    //               const sportInfo: GameData['sport'] = {
+    //                 ...game.sport,
+    //                 sportId,
+    //                 sporthub: {
+    //                   id: (game.sport as any).sportHub.id,
+    //                   slug: (game.sport as any).sportHub.slug,
+    //                 },
+    //               }
+    //
+    //               return {
+    //                 ...game,
+    //                 gameId: game.id,
+    //                 sport: sportInfo,
+    //               }
+    //             }),
+    //           }
+    //         }),
+    //       }
+    //     }),
+    //   }
+    // })
+    return data.sports;
+};const minQueryLength = 3;
+/**
+ * Searches for games by text query across game titles, leagues, and countries.
+ * Minimum query length is 3 characters. Returns paginated results.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/searchGames
+ *
+ * @example
+ * import { searchGames } from '@azuro-org/toolkit'
+ *
+ * const { games } = await searchGames({
+ *   chainId: 137,
+ *   query: 'Manchester',
+ *   page: 1,
+ *   perPage: 10,
+ * })
+ * */
+const searchGames = async (props) => {
+    const query = props.query?.trim();
+    if (query?.length < minQueryLength) {
+        console.warn(`searchGames: query param must be at least ${minQueryLength} characters long, got: '${props.query}', skipping request`);
+        return {
+            games: [],
+            page: 1,
+            perPage: 10,
+            total: 0,
+            totalPages: 0,
+        };
+    }
+    const api = getApiEndpoint(props.chainId);
+    const environment = environments[props.chainId];
+    const params = serializeApiParams({
+        environment,
+        // perPage: props.perPage || 1000,
+        // page: props.page || 1,
+        request: props.query,
+    });
+    const response = await fetch(`${api}/market-manager/search?${params}`, {
+        method: 'GET',
+        headers: {
+            'Accept': 'application/json',
+        },
+        cache: 'no-cache',
+    });
+    if (!response.ok) {
+        throw new Error(`searchGames API request failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+};var GameOrderBy;
+(function (GameOrderBy) {
+    GameOrderBy["StartsAt"] = "startsAt";
+    GameOrderBy["Turnover"] = "turnover";
+})(GameOrderBy || (GameOrderBy = {}));var WaveLevelName;
 (function (WaveLevelName) {
     WaveLevelName["Grey"] = "Grey";
     WaveLevelName["Mist"] = "Mist";
@@ -8313,7 +8492,33 @@ const getWaveLevels = async ({ waveId, chainId } = { waveId: 'active', chainId:
     const api = getApiEndpoint(chainId);
     const response = await fetch(`${api}/waves/${waveId}/participants/${account?.toLowerCase()}/activate`);
     await response.json();
-};const getPrecalculatedCashouts = async (props) => {
+};/**
+ * Retrieves precalculated cashout availability and prices for specified conditions.
+ * Returns margin information and outcome prices for each available condition.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/cashout/getPrecalculatedCashouts
+ *
+ * @example
+ * import { getPrecalculatedCashouts } from '@azuro-org/toolkit'
+ *
+ * const chainId = 100
+ * const conditionIds = ['123', '456', '789']
+ *
+ * const cashouts = await getPrecalculatedCashouts({
+ *   chainId,
+ *   conditionIds,
+ * })
+ *
+ * if (cashouts) {
+ *   cashouts.availables.forEach(({ conditionId, available, outcomes }) => {
+ *     console.log(`Condition ${conditionId} available: ${available}`)
+ *     outcomes.forEach(({ outcomeId, price }) => {
+ *       console.log(`  Outcome ${outcomeId}: ${price}`)
+ *     })
+ *   })
+ * }
+ * */
+const getPrecalculatedCashouts = async (props) => {
     const { chainId, conditionIds } = props;
     const { api, contracts } = chainsData[chainId];
     if (!contracts.cashout?.address) {
@@ -8337,7 +8542,31 @@ const getWaveLevels = async ({ waveId, chainId } = { waveId: 'active', chainId:
     }
     const data = await response.json();
     return data;
-};const getCalculatedCashout = async (props) => {
+};/**
+ * Retrieves the calculated cashout information for a specific bet, including the cashout amount and odds.
+ * Returns null if no cashout calculation is available for the bet.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/cashout/getCalculatedCashout
+ *
+ * @example
+ * import { getCalculatedCashout } from '@azuro-org/toolkit'
+ *
+ * const chainId = 100
+ * const account = '0x123...'
+ * const graphBetId = '456'
+ *
+ * const cashout = await getCalculatedCashout({
+ *   chainId,
+ *   account,
+ *   graphBetId,
+ * })
+ *
+ * if (cashout) {
+ *   console.log(`Cashout amount: ${cashout.cashoutAmount}`)
+ *   console.log(`Cashout odds: ${cashout.cashoutOdds}`)
+ * }
+ * */
+const getCalculatedCashout = async (props) => {
     const { chainId, account, graphBetId } = props;
     const { api, environment, contracts } = chainsData[chainId];
     if (!contracts.cashout?.address) {
@@ -8367,7 +8596,35 @@ const getWaveLevels = async ({ waveId, chainId } = { waveId: 'active', chainId:
         tokenId: betId,
         ...rest,
     };
-};const getCashoutTypedData = (props) => {
+};/**
+ * Generates EIP-712 typed data for signing a cashout order.
+ * This typed data must be signed by the user before submitting the cashout.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/cashout/getCashoutTypedData
+ *
+ * @example
+ * import { getCashoutTypedData } from '@azuro-org/toolkit'
+ * import { signTypedData } from 'viem/accounts'
+ *
+ * const chainId = 100
+ * const account = '0x123...'
+ * const tokenId = '456'
+ * const cashoutOdds = '1.85'
+ * const expiredAt = Math.floor(Date.now() / 1000) + 3600
+ * const attention = 'By signing this transaction, I agree to cash out on Azuro'
+ *
+ * const typedData = getCashoutTypedData({
+ *   chainId,
+ *   account,
+ *   attention,
+ *   tokenId,
+ *   cashoutOdds,
+ *   expiredAt,
+ * })
+ *
+ * const signature = await signTypedData(typedData)
+ * */
+const getCashoutTypedData = (props) => {
     const { account, chainId, attention, tokenId, cashoutOdds, expiredAt } = props;
     const { contracts } = chainsData[chainId];
     if (!contracts.cashout?.address) {
@@ -8404,6 +8661,29 @@ const getWaveLevels = async ({ waveId, chainId } = { waveId: 'active', chainId:
     CashoutState["Rejected"] = "REJECTED";
     CashoutState["Open"] = "OPEN";
 })(CashoutState || (CashoutState = {}));
+/**
+ * Creates a cashout order for an existing bet by submitting the signed cashout calculation to the Azuro API.
+ * This finalizes the cashout process after obtaining a calculation and signing the typed data.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/cashout/createCashout
+ *
+ * @example
+ * import { createCashout } from '@azuro-org/toolkit'
+ *
+ * const chainId = 100
+ * const calculationId = 'gnosis_0x123_456'
+ * const attention = 'By signing this transaction, I agree to cash out on Azuro'
+ * const signature = '0xabc...'
+ *
+ * const result = await createCashout({
+ *   chainId,
+ *   calculationId,
+ *   attention,
+ *   signature,
+ * })
+ *
+ * console.log(result.state) // 'PROCESSING', 'ACCEPTED', 'REJECTED', or 'OPEN'
+ * */
 const createCashout = async (props) => {
     const { chainId, calculationId, attention, signature } = props;
     const { api, contracts } = chainsData[chainId];
@@ -8428,15 +8708,31 @@ const createCashout = async (props) => {
         },
         body: JSON.stringify(signedCashout),
     });
-    if (response.status === 404) {
-        return null;
-    }
     if (!response.ok) {
         throw new Error(`Status ${response.status}: ${response.statusText}`);
     }
     const data = await response.json();
     return data;
-};const getCashout = async ({ chainId, orderId }) => {
+};/**
+ * Retrieves the status and details of a cashout order by its order ID.
+ * Returns null if the cashout order is not found.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/cashout/getCashout
+ *
+ * @example
+ * import { getCashout } from '@azuro-org/toolkit'
+ *
+ * const chainId = 100
+ * const orderId = 'abc123'
+ *
+ * const cashout = await getCashout({ chainId, orderId })
+ *
+ * if (cashout) {
+ *   console.log(`State: ${cashout.state}`)
+ *   console.log(`Transaction hash: ${cashout.txHash}`)
+ * }
+ * */
+const getCashout = async ({ chainId, orderId }) => {
     const { api, contracts } = chainsData[chainId];
     if (!contracts.cashout?.address) {
         throw new Error('provided chainId is not supported for cashout');
@@ -8450,7 +8746,26 @@ const createCashout = async (props) => {
     }
     const data = await response.json();
     return data;
-};const getBonuses = async (props) => {
+};/**
+ * Fetches all bonuses for a bettor account filtered by status.
+ * By default, retrieves only available bonuses. Returns null if no bonuses are found.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/bonus/getBonuses
+ *
+ * @example
+ * import { getBonuses, BonusStatus } from '@azuro-org/toolkit'
+ *
+ * const account = userWallet?.address
+ * const affiliate = '0x123...'
+ *
+ * const bonuses = await getBonuses({
+ *   chainId: 100,
+ *   account,
+ *   affiliate,
+ *   bonusStatus: BonusStatus.Available
+ * })
+ * */
+const getBonuses = async (props) => {
     const { chainId, account, affiliate, bonusStatus = BonusStatus.Available } = props;
     const { api } = chainsData[chainId];
     const response = await fetch(`${api}/bonus/get-by-addresses`, {
@@ -8511,7 +8826,29 @@ const createCashout = async (props) => {
         }
         return acc;
     }, []);
-};const getAvailableFreebets = async ({ chainId, account, affiliate, selections }) => {
+};/**
+ * Retrieves available freebets for a bettor that can be applied to specific bet selections.
+ * Returns null if no freebets are available for the given selections.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/bonus/getAvailableFreebets
+ *
+ * @example
+ * import { getAvailableFreebets } from '@azuro-org/toolkit'
+ *
+ * const account = userWallet?.address
+ * const affiliate = affiliateAddress
+ * const selections = [
+ *   { conditionId: '1', outcomeId: '1' },
+ * ]
+ *
+ * const freebets = await getAvailableFreebets({
+ *   chainId: 100,
+ *   account,
+ *   affiliate,
+ *   selections
+ * })
+ * */
+const getAvailableFreebets = async ({ chainId, account, affiliate, selections }) => {
     const { api, environment, betToken } = chainsData[chainId];
     const response = await fetch(`${api}/bonus/freebet/get-available`, {
         method: 'POST',
@@ -8570,4 +8907,4 @@ const createCashout = async (props) => {
             publicCustomData: bonus.publicCustomData,
         };
     });
-};export{Aggregation_Interval,BET_DATA_TYPES,ConditionStatus as BetConditionStatus,BetFragmentDoc,BetRestrictionType,BetResult,BetState,BetStatus,V3_Bet_OrderBy as Bet_OrderBy,BetsDocument,BettorFragmentDoc,BettorsDocument,BonusStatus,BonusType,CASHOUT_DATA_TYPES,CASHOUT_TYPED_DATA_DOMAIN_NAME,CASHOUT_TYPED_DATA_DOMAIN_VERSION,CLIENT_DATA_TYPES,COMBO_BET_DATA_TYPES,CashoutState,ConditionDocument,ConditionFragmentDoc,ConditionState,Condition_OrderBy,ConditionsBatchDocument,ConditionsDocument,Country_OrderBy,Environment,EventName,EventRestrictionState,Event_OrderBy,FreebetType,GameBetsDocument,GameDocument,GameInfoFragmentDoc,GameState,Game_OrderBy,GamesDocument,BetStatus$1 as GraphBetStatus,League_OrderBy,LegacyBetsDocument,GameStatus as LegacyGameStatus,LegacyLiveBetFragmentDoc,LegacyLiveGamesDocument,LegacyPrematchBetFragmentDoc,Bet_OrderBy as Legacy_Bet_OrderBy,NavigationDocument,ODDS_COMBO_FEE_MODIFIER,ODDS_DECIMALS,OrderDirection,OutcomeResult,Outcome_OrderBy,Participant_OrderBy,V3_SelectionConditionKind as SelectionKind,SelectionResult,SportHub_OrderBy,Sport_OrderBy,SportsDocument,SportsNavigationDocument,TYPED_DATA_DOMAIN_NAME,TYPED_DATA_DOMAIN_VERSION,VirtualCondition_OrderBy,VirtualGame_OrderBy,WaveLevelName,_SubgraphErrorPolicy_,activateWave,azuroBetAbi,baseData,baseSepoliaData,bscData,bscTestnetData,calcMindOdds,cashoutAbi,chainsData,chainsDataByEnv,chilizData,coreAbi,createBet,createCashout,createComboBet,environments,getApiEndpoint,getAvailableFreebets,getBet,getBetCalculation,getBetFee,getBetStatus,getBetTypedData,getBetsGraphqlEndpoint,getBonuses,getCalculatedCashout,getCashout,getCashoutTypedData,getComboBetTypedData,getFeedGraphqlEndpoint,getIsPendingResolution,getMaxBet,getPrecalculatedCashouts,getProviderFromId,getSocketEndpoint,getWaveLeaderBoard,getWaveLevels,getWavePeriods,getWaveStats,gnosisData,gnosisDevData,groupConditionsByMarket,lpAbi,paymasterAbi,polygonAmoyData,polygonData,relayerAbi,setupContracts,spicyData,vaultAbi};//# sourceMappingURL=index.js.map
+};export{BET_DATA_TYPES,ConditionStatus as BetConditionStatus,BetOrderResult,BetOrderState,BetRestrictionType,BetResult,BetStatus,V3_Bet_OrderBy as Bet_OrderBy,BettorFragmentDoc,BettorsDocument,BonusStatus,BonusType,CASHOUT_DATA_TYPES,CASHOUT_TYPED_DATA_DOMAIN_NAME,CASHOUT_TYPED_DATA_DOMAIN_VERSION,CLIENT_DATA_TYPES,COMBO_BET_DATA_TYPES,CashoutState,ConditionState,Environment,EventRestrictionState,FreebetType,GameBetsDocument,GameOrderBy,GameState,BetStatus$1 as GraphBetStatus,LegacyBetsDocument,GameStatus as LegacyGameStatus,LegacyLiveBetFragmentDoc,LegacyLiveGamesDocument,LegacyPrematchBetFragmentDoc,Bet_OrderBy as Legacy_Bet_OrderBy,ODDS_COMBO_FEE_MODIFIER,ODDS_DECIMALS,OrderDirection$1 as OrderDirection,V3_SelectionConditionKind as SelectionKind,SelectionResult,TYPED_DATA_DOMAIN_NAME,TYPED_DATA_DOMAIN_VERSION,WaveLevelName,activateWave,azuroBetAbi,baseData,baseSepoliaData,bscData,bscTestnetData,calcMinOdds,cashoutAbi,chainsData,chainsDataByEnv,chilizData,coreAbi,createBet,createCashout,createComboBet,environments,getApiEndpoint,getAvailableFreebets,getBet,getBetCalculation,getBetFee,getBetStatus,getBetTypedData,getBetsByBettor,getBetsGraphqlEndpoint,getBonuses,getCalculatedCashout,getCashout,getCashoutTypedData,getComboBetTypedData,getConditionsByGameIds,getConditionsState,getFeedGraphqlEndpoint,getGamesByFilters,getGamesByIds,getIsPendingResolution,getNavigation,getPrecalculatedCashouts,getProviderFromId,getSocketEndpoint,getSports,getWaveLeaderBoard,getWaveLevels,getWavePeriods,getWaveStats,gnosisData,gnosisDevData,groupConditionsByMarket,lpAbi,paymasterAbi,polygonAmoyData,polygonData,relayerAbi,searchGames,setupContracts,spicyData,vaultAbi};//# sourceMappingURL=index.js.map