@azuro-org/toolkit 2.0.0 → 4.0.0

package/dist/docs/prematch/bettors.d.ts

@@ -0,0 +1,21 @@
+import * as Types from './types';
+import * as Apollo from '@apollo/client';
+export type BettorsQueryVariables = Types.Exact<{
+    where: Types.Bettor_Filter;
+}>;
+export type BettorsQuery = {
+    __typename?: 'Query';
+    bettors: Array<{
+        __typename?: 'Bettor';
+        id: string;
+        rawToPayout: string;
+        rawInBets: string;
+        rawTotalPayout: string;
+        rawTotalProfit: string;
+        betsCount: number;
+        wonBetsCount: number;
+        lostBetsCount: number;
+    }>;
+};
+export declare const BettorsDocument: Apollo.DocumentNode;
+export type BettorsQueryResult = Apollo.QueryResult<BettorsQuery, BettorsQueryVariables>;

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

@@ -0,0 +1,38 @@
+import * as Types from './types';
+import * as Apollo from '@apollo/client';
+export type PrematchConditionQueryVariables = Types.Exact<{
+    id: Types.Scalars['String']['input'];
+}>;
+export type PrematchConditionQuery = {
+    __typename?: 'Query';
+    condition?: {
+        __typename?: 'Condition';
+        id: string;
+        conditionId: string;
+        status: Types.ConditionStatus;
+        isExpressForbidden: boolean;
+        outcomes: Array<{
+            __typename?: 'Outcome';
+            outcomeId: string;
+            odds: string;
+        }>;
+        core: {
+            __typename?: 'CoreContract';
+            address: string;
+            liquidityPool: {
+                __typename?: 'LiquidityPoolContract';
+                address: string;
+            };
+        };
+        game: {
+            __typename?: 'Game';
+            gameId: string;
+            sport: {
+                __typename?: 'Sport';
+                sportId: string;
+            };
+        };
+    } | null;
+};
+export declare const PrematchConditionDocument: Apollo.DocumentNode;
+export type PrematchConditionQueryResult = Apollo.QueryResult<PrematchConditionQuery, PrematchConditionQueryVariables>;

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

@@ -0,0 +1,39 @@
+import * as Types from './types';
+import * as Apollo from '@apollo/client';
+export type PrematchConditionsQueryVariables = Types.Exact<{
+    where: Types.Condition_Filter;
+}>;
+export type PrematchConditionsQuery = {
+    __typename?: 'Query';
+    conditions: Array<{
+        __typename?: 'Condition';
+        wonOutcomeIds?: Array<string> | null;
+        id: string;
+        conditionId: string;
+        status: Types.ConditionStatus;
+        isExpressForbidden: boolean;
+        outcomes: Array<{
+            __typename?: 'Outcome';
+            outcomeId: string;
+            odds: string;
+        }>;
+        core: {
+            __typename?: 'CoreContract';
+            address: string;
+            liquidityPool: {
+                __typename?: 'LiquidityPoolContract';
+                address: string;
+            };
+        };
+        game: {
+            __typename?: 'Game';
+            gameId: string;
+            sport: {
+                __typename?: 'Sport';
+                sportId: string;
+            };
+        };
+    }>;
+};
+export declare const PrematchConditionsDocument: Apollo.DocumentNode;
+export type PrematchConditionsQueryResult = Apollo.QueryResult<PrematchConditionsQuery, PrematchConditionsQueryVariables>;

package/dist/docs/prematch/conditionsBatch.d.ts

@@ -0,0 +1,22 @@
+import * as Types from './types';
+import * as Apollo from '@apollo/client';
+export type PrematchConditionsBatchQueryVariables = Types.Exact<{
+    conditionFilter?: Types.InputMaybe<Types.Condition_Filter>;
+}>;
+export type PrematchConditionsBatchQuery = {
+    __typename?: 'Query';
+    conditions: Array<{
+        __typename?: 'Condition';
+        id: string;
+        status: Types.ConditionStatus;
+        conditionId: string;
+        outcomes: Array<{
+            __typename?: 'Outcome';
+            id: string;
+            outcomeId: string;
+            odds: string;
+        }>;
+    }>;
+};
+export declare const PrematchConditionsBatchDocument: Apollo.DocumentNode;
+export type PrematchConditionsBatchQueryResult = Apollo.QueryResult<PrematchConditionsBatchQuery, PrematchConditionsBatchQueryVariables>;

package/dist/docs/prematch/fragments/bettor.d.ts

@@ -0,0 +1,12 @@
+export type BettorFragment = {
+    __typename?: 'Bettor';
+    id: string;
+    rawToPayout: string;
+    rawInBets: string;
+    rawTotalPayout: string;
+    rawTotalProfit: string;
+    betsCount: number;
+    wonBetsCount: number;
+    lostBetsCount: number;
+};
+export declare const BettorFragmentDoc: import("@apollo/client").DocumentNode;

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

@@ -0,0 +1,30 @@
+import * as Types from '../types';
+export type PrematchConditionFragment = {
+    __typename?: 'Condition';
+    id: string;
+    conditionId: string;
+    status: Types.ConditionStatus;
+    isExpressForbidden: boolean;
+    outcomes: Array<{
+        __typename?: 'Outcome';
+        outcomeId: string;
+        odds: string;
+    }>;
+    core: {
+        __typename?: 'CoreContract';
+        address: string;
+        liquidityPool: {
+            __typename?: 'LiquidityPoolContract';
+            address: string;
+        };
+    };
+    game: {
+        __typename?: 'Game';
+        gameId: string;
+        sport: {
+            __typename?: 'Sport';
+            sportId: string;
+        };
+    };
+};
+export declare const PrematchConditionFragmentDoc: import("@apollo/client").DocumentNode;

package/dist/docs/prematch/fragments/liveBet.d.ts

@@ -0,0 +1,42 @@
+import * as Types from '../types';
+export type LiveBetFragment = {
+    __typename?: 'LiveBet';
+    id: string;
+    amount: string;
+    status: Types.BetStatus;
+    potentialPayout: string;
+    payout?: string | null;
+    result?: Types.BetResult | null;
+    isRedeemed: boolean;
+    isRedeemable: boolean;
+    odds: string;
+    settledOdds?: string | null;
+    affiliate?: string | null;
+    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;
+            };
+        };
+    }>;
+};
+export declare const LiveBetFragmentDoc: import("@apollo/client").DocumentNode;

package/dist/docs/prematch/fragments/mainGameInfo.d.ts

@@ -0,0 +1,31 @@
+import * as Types from '../types';
+export type MainGameInfoFragment = {
+    __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 MainGameInfoFragmentDoc: import("@apollo/client").DocumentNode;

package/dist/docs/prematch/fragments/prematchBet.d.ts

@@ -0,0 +1,75 @@
+import * as Types from '../types';
+export type PrematchBetFragment = {
+    __typename?: 'Bet';
+    id: string;
+    amount: string;
+    status: Types.BetStatus;
+    potentialPayout: string;
+    payout?: string | null;
+    result?: Types.BetResult | null;
+    isRedeemed: boolean;
+    isRedeemable: boolean;
+    odds: string;
+    settledOdds?: string | null;
+    affiliate?: string | null;
+    tokenId: string;
+    createdAt: string;
+    txHash: string;
+    core: {
+        __typename?: 'CoreContract';
+        address: string;
+        liquidityPool: {
+            __typename?: 'LiquidityPoolContract';
+            address: string;
+        };
+    };
+    selections: Array<{
+        __typename?: 'Selection';
+        odds: string;
+        result?: Types.SelectionResult | null;
+        outcome: {
+            __typename?: 'Outcome';
+            outcomeId: string;
+            condition: {
+                __typename?: 'Condition';
+                conditionId: string;
+                status: Types.ConditionStatus;
+                game: {
+                    __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;
+                    }>;
+                };
+            };
+        };
+    }>;
+    freebet?: {
+        __typename?: 'Freebet';
+        freebetId: string;
+        contractAddress: string;
+    } | null;
+};
+export declare const PrematchBetFragmentDoc: import("@apollo/client").DocumentNode;

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

@@ -0,0 +1,39 @@
+import * as Types from './types';
+import * as Apollo from '@apollo/client';
+export type GameQueryVariables = Types.Exact<{
+    gameId: Types.Scalars['BigInt']['input'];
+}>;
+export type GameQuery = {
+    __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 GameDocument: Apollo.DocumentNode;
+export type GameQueryResult = Apollo.QueryResult<GameQuery, GameQueryVariables>;

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

@@ -0,0 +1,54 @@
+import * as Types from './types';
+import * as Apollo from '@apollo/client';
+export type GameBetsQueryVariables = Types.Exact<{
+    gameId: Types.Scalars['String']['input'];
+    actor?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type GameBetsQuery = {
+    __typename?: 'Query';
+    bets: Array<{
+        __typename?: 'Bet';
+        rawAmount: string;
+        rawPotentialPayout: string;
+        result?: Types.BetResult | null;
+        selections: Array<{
+            __typename?: 'Selection';
+            rawOdds: string;
+            outcome: {
+                __typename?: 'Outcome';
+                outcomeId: string;
+                condition: {
+                    __typename?: 'Condition';
+                    conditionId: string;
+                    game: {
+                        __typename?: 'Game';
+                        gameId: string;
+                    };
+                };
+            };
+        }>;
+        freebet?: {
+            __typename?: 'Freebet';
+            id: string;
+        } | null;
+    }>;
+    liveBets: Array<{
+        __typename?: 'LiveBet';
+        rawAmount: string;
+        rawPotentialPayout: string;
+        result?: Types.BetResult | null;
+        selections: Array<{
+            __typename?: 'LiveSelection';
+            outcome: {
+                __typename?: 'LiveOutcome';
+                outcomeId: string;
+                condition: {
+                    __typename?: 'LiveCondition';
+                    conditionId: string;
+                };
+            };
+        }>;
+    }>;
+};
+export declare const GameBetsDocument: Apollo.DocumentNode;
+export type GameBetsQueryResult = Apollo.QueryResult<GameBetsQuery, GameBetsQueryVariables>;

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

@@ -0,0 +1,43 @@
+import * as Types from './types';
+import * as Apollo from '@apollo/client';
+export type GamesQueryVariables = 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 GamesQuery = {
+    __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 GamesDocument: Apollo.DocumentNode;
+export type GamesQueryResult = Apollo.QueryResult<GamesQuery, GamesQueryVariables>;

package/dist/docs/prematch/liveBets.d.ts

@@ -0,0 +1,54 @@
+import * as Types from './types';
+import * as Apollo from '@apollo/client';
+export type LiveBetsQueryVariables = 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 LiveBetsQuery = {
+    __typename?: 'Query';
+    liveBets: Array<{
+        __typename?: 'LiveBet';
+        id: string;
+        amount: string;
+        status: Types.BetStatus;
+        potentialPayout: string;
+        payout?: string | null;
+        result?: Types.BetResult | null;
+        isRedeemed: boolean;
+        isRedeemable: boolean;
+        odds: string;
+        settledOdds?: string | null;
+        affiliate?: string | null;
+        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;
+                };
+            };
+        }>;
+    }>;
+};
+export declare const LiveBetsDocument: Apollo.DocumentNode;
+export type LiveBetsQueryResult = Apollo.QueryResult<LiveBetsQuery, LiveBetsQueryVariables>;

package/dist/docs/prematch/navigation.d.ts

@@ -0,0 +1,34 @@
+import * as Types from './types';
+import * as Apollo from '@apollo/client';
+export type NavigationQueryVariables = Types.Exact<{
+    first?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    where?: Types.InputMaybe<Types.Game_Filter>;
+    withGameCount: Types.Scalars['Boolean']['input'];
+}>;
+export type NavigationQuery = {
+    __typename?: 'Query';
+    sports: Array<{
+        __typename?: 'Sport';
+        id: string;
+        slug: string;
+        name: string;
+        countries: Array<{
+            __typename?: 'Country';
+            id: string;
+            slug: string;
+            name: string;
+            leagues: Array<{
+                __typename?: 'League';
+                id: string;
+                slug: string;
+                name: string;
+                games?: Array<{
+                    __typename?: 'Game';
+                    id: string;
+                }>;
+            }>;
+        }>;
+    }>;
+};
+export declare const NavigationDocument: Apollo.DocumentNode;
+export type NavigationQueryResult = Apollo.QueryResult<NavigationQuery, NavigationQueryVariables>;

package/dist/docs/prematch/prematchBets.d.ts

@@ -0,0 +1,87 @@
+import * as Types from './types';
+import * as Apollo from '@apollo/client';
+export type PrematchBetsQueryVariables = 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 PrematchBetsQuery = {
+    __typename?: 'Query';
+    bets: Array<{
+        __typename?: 'Bet';
+        id: string;
+        amount: string;
+        status: Types.BetStatus;
+        potentialPayout: string;
+        payout?: string | null;
+        result?: Types.BetResult | null;
+        isRedeemed: boolean;
+        isRedeemable: boolean;
+        odds: string;
+        settledOdds?: string | null;
+        affiliate?: string | null;
+        tokenId: string;
+        createdAt: string;
+        txHash: string;
+        core: {
+            __typename?: 'CoreContract';
+            address: string;
+            liquidityPool: {
+                __typename?: 'LiquidityPoolContract';
+                address: string;
+            };
+        };
+        selections: Array<{
+            __typename?: 'Selection';
+            odds: string;
+            result?: Types.SelectionResult | null;
+            outcome: {
+                __typename?: 'Outcome';
+                outcomeId: string;
+                condition: {
+                    __typename?: 'Condition';
+                    conditionId: string;
+                    status: Types.ConditionStatus;
+                    game: {
+                        __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;
+                        }>;
+                    };
+                };
+            };
+        }>;
+        freebet?: {
+            __typename?: 'Freebet';
+            freebetId: string;
+            contractAddress: string;
+        } | null;
+    }>;
+};
+export declare const PrematchBetsDocument: Apollo.DocumentNode;
+export type PrematchBetsQueryResult = Apollo.QueryResult<PrematchBetsQuery, PrematchBetsQueryVariables>;