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

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/utils/bet/createBet.d.ts

@@ -0,0 +1,39 @@
+import { type Address, type Hex } from 'viem';
+import { type CreateBetResponse, type BetClientData } from '../../global';
+export type CreateBetParams = {
+    account: Address;
+    clientData: BetClientData;
+    bet: {
+        conditionId: string | bigint;
+        outcomeId: string | number | bigint;
+        minOdds: string | bigint;
+        amount: string | bigint;
+        nonce: string | number | bigint;
+    };
+    signature: Hex;
+    bonusId?: string;
+};
+export type CreateBetResult = CreateBetResponse;
+/**
+ * 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 })
+ * */
+export declare const createBet: (props: CreateBetParams) => Promise<CreateBetResult>;

package/dist/utils/bet/createComboBet.d.ts

@@ -0,0 +1,44 @@
+import { type Address, type Hex } from 'viem';
+import { type CreateBetResponse, type BetClientData } from '../../global';
+export type CreateComboBetParams = {
+    account: Address;
+    amount: string | bigint;
+    minOdds: string | bigint;
+    nonce: string | number | bigint;
+    clientData: BetClientData;
+    bets: {
+        conditionId: string | bigint;
+        outcomeId: string | number | bigint;
+    }[];
+    signature: Hex;
+    bonusId?: string;
+};
+export type CreateComboBetResult = CreateBetResponse;
+/**
+ * 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,
+ * })
+ * */
+export declare const createComboBet: (props: CreateComboBetParams) => Promise<CreateComboBetResult>;

package/dist/utils/bet/getBet.d.ts

@@ -0,0 +1,28 @@
+import { type ChainId } from '../../config';
+import type { BetOrderData } from './types';
+export type GetBetParams = {
+    chainId: ChainId;
+    orderId: string;
+};
+export type GetBetResponse = BetOrderData;
+export type GetBetResult = GetBetResponse | null;
+/**
+ * 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)
+ * }
+ * */
+export declare const getBet: ({ chainId, orderId }: GetBetParams) => Promise<GetBetResult>;

package/dist/utils/{getBetCalculation.d.ts → bet/getBetCalculation.d.ts}

@@ -1,6 +1,11 @@
 import { type Address } from 'viem';
-import { type ChainId } from '../config';
-import { type Selection } from '../global';
+import { type ChainId } from '../../config';
+import { type Selection } from '../../global';
+export type GetBetCalculationParams = {
+    chainId: ChainId;
+    selections: Selection[];
+    account: Address | undefined;
+};
 export type GetBetCalculationResponse = {
     response: {
         /** if `minBet` is `undefined`, there is no bottom limit */
@@ -9,17 +14,13 @@ export type GetBetCalculationResponse = {
         maxPayout: `${number}`;
     };
 };
-type GetBetCalculation = {
-    chainId: ChainId;
-    selections: Selection[];
-    account: Address | undefined;
-};
+export type GetBetCalculationResult = GetBetCalculationResponse['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'
@@ -31,10 +32,4 @@ type GetBetCalculation = {
  *
  * const { minBet, maxBet } = await getBetCalculation({ selections, account })
  * */
-export declare const getBetCalculation: (props: GetBetCalculation) => Promise<{
-    /** if `minBet` is `undefined`, there is no bottom limit */
-    minBet: number | undefined;
-    maxBet: number;
-    maxPayout: `${number}`;
-} | null>;
-export {};
+export declare const getBetCalculation: (props: GetBetCalculationParams) => Promise<GetBetCalculationResult>;

package/dist/utils/bet/getBetFee.d.ts

@@ -0,0 +1,32 @@
+import { type ChainId } from '../../config';
+export type BetFeeResponse = {
+    gasLimit: number;
+    gasPrice: number;
+    betTokenRate: number;
+    gasPriceInBetToken: number;
+    slippage: number;
+    gasAmount: number;
+    relayerFeeAmount: string;
+    beautyRelayerFeeAmount: string;
+    symbol: string;
+    decimals: number;
+};
+export type GetBetFeeParams = ChainId;
+export type GetBetFeeResult = BetFeeResponse;
+/**
+ * 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)
+ * */
+export declare const getBetFee: (chainId: ChainId) => Promise<GetBetFeeResult>;

package/dist/utils/bet/getBetStatus.d.ts

@@ -0,0 +1,43 @@
+import { BetStatus as GraphBetStatus } from '../../docs/bets/types';
+import { BetOrderState, GameState } from '../../global';
+export declare enum BetStatus {
+    Accepted = 0,
+    Live = 1,
+    PendingResolution = 2,
+    Resolved = 3,
+    Canceled = 4,
+    Preparing = 5,
+    Rejected = 6
+}
+type Game = {
+    state: GameState;
+    startsAt: string;
+};
+type Props = {
+    games: Game[];
+    orderState: BetOrderState | null;
+    graphStatus: GraphBetStatus | null;
+};
+/**
+ * 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!')
+ * }
+ * */
+export declare const getBetStatus: (props: Props) => BetStatus;
+export {};

package/dist/utils/bet/getBetTypedData.d.ts

@@ -0,0 +1,38 @@
+import { type SignTypedDataParameters, type Address } from 'viem';
+import { BET_DATA_TYPES } from '../../config';
+import { type BetClientData } from '../../global';
+export type GetBetTypedDataParams = {
+    account: Address;
+    clientData: BetClientData;
+    bet: {
+        conditionId: string | bigint;
+        outcomeId: string | bigint;
+        minOdds: string | bigint;
+        amount: string | bigint;
+        nonce: string | bigint;
+    };
+};
+/**
+ * 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)
+ * */
+export declare const getBetTypedData: (props: GetBetTypedDataParams) => SignTypedDataParameters<typeof BET_DATA_TYPES>;

package/dist/utils/bet/getBetsByBettor.d.ts

@@ -0,0 +1,44 @@
+import type { Address } from 'viem';
+import type { BetOrderData } from './types';
+import { type BetOrderState, type BetOrderResult } from '../../global';
+import { type ChainId } from '../../config';
+export type GetBetsByBettorParams = {
+    chainId: ChainId;
+    bettor: Address;
+    affiliate?: Address;
+    result?: BetOrderResult | BetOrderResult[];
+    state?: BetOrderState | BetOrderState[];
+    isRedeemed?: boolean;
+    offset?: number;
+    /** default: 100 */
+    limit?: number;
+};
+export type GetBetsByBettorResponse = {
+    orders: BetOrderData[];
+};
+export type GetBetsByBettorResult = GetBetsByBettorResponse['orders'] | null;
+/**
+ * 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,
+ * })
+ * */
+export declare const getBetsByBettor: (props: GetBetsByBettorParams) => Promise<GetBetsByBettorResult>;

package/dist/utils/bet/getComboBetTypedData.d.ts

@@ -0,0 +1,42 @@
+import { type SignTypedDataParameters, type Address } from 'viem';
+import { COMBO_BET_DATA_TYPES } from '../../config';
+import { type BetClientData } from '../../global';
+export type GetComboBetTypedDataParams = {
+    account: Address;
+    minOdds: string | bigint;
+    amount: string | bigint;
+    nonce: string | bigint;
+    clientData: BetClientData;
+    bets: {
+        conditionId: string | bigint;
+        outcomeId: string | bigint;
+    }[];
+};
+/**
+ * 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)
+ * */
+export declare const getComboBetTypedData: (props: GetComboBetTypedDataParams) => SignTypedDataParameters<typeof COMBO_BET_DATA_TYPES>;

package/dist/utils/bet/types.d.ts

@@ -0,0 +1,128 @@
+import type { Address, Hex } from 'viem';
+import type { BetConditionStatus, BetResult, GraphBetStatus, SelectionResult } from '../../docs';
+import type { ConditionStatus } from '../../docs/bets/types';
+import type { Environment } from '../../envs';
+import type { BetOrderResult, BetOrderState, GameState, ISOTimestamp } from '../../global';
+export type BetMetaData = {
+    id: string;
+    core: {
+        type: 'V3';
+        address: Address;
+        liquidityPool: {
+            address: Address;
+        };
+    };
+    odds: string;
+    actor: string;
+    betId: string;
+    nonce: string;
+    owner: Address;
+    amount: string;
+    bettor: Address;
+    payout: null | string;
+    result: BetResult | null;
+    status: GraphBetStatus;
+    rawOdds: string;
+    affiliate: Address;
+    rawAmount: string;
+    rawPayout: null | string;
+    isRedeemed: boolean;
+    selections: Array<{
+        id: string;
+        odds: string;
+        result: SelectionResult | null;
+        outcome: {
+            condition: {
+                id: string;
+                gameId: string;
+                status: ConditionStatus;
+                outcomes: {
+                    result: SelectionResult | null;
+                    outcomeId: string;
+                    sortOrder: number;
+                }[];
+                conditionId: string;
+                coreAddress: Address;
+                wonOutcomeIds: null | string[];
+                _winningOutcomesCount: number;
+                createdBlockTimestamp: string;
+                resolvedBlockTimestamp: null | string;
+            };
+            outcomeId: string;
+            sortOrder: number;
+        };
+        rawOdds: string;
+        _outcomeId: string;
+    }>;
+    settledOdds: null | string;
+    createdTxHash: Hex;
+    rawSettledOdds: null | string;
+    potentialPayout: string;
+    potentialLossLimit: string;
+    rawPotentialPayout: string;
+    createdBlockTimestamp: string;
+    rawPotentialLossLimit: string;
+    resolvedBlockTimestamp: string | null;
+    isCashedOut: boolean;
+    isFreebetAmountReturnable: boolean | null;
+    paymasterContractAddress: Address | null;
+    redeemedTxHash: Hex | null;
+    cashout: null | {
+        payout: string;
+    };
+};
+export type BetOrderConditionData = {
+    conditionId: string;
+    outcomeId: number;
+    orderId: string;
+    gameId: string;
+    /**
+     * State of the game at the moment of bet placing, to determine whether the bet is Live or not.
+     * */
+    gameState: GameState.Live | GameState.Prematch;
+    conditionMargin: string;
+    selectionMargin: string;
+    settledSelectionMargin: string | null;
+    result: BetConditionStatus | null;
+    /**
+     * Formatted odds of the condition, e.g. "1.55"
+     * */
+    price: string;
+    /**
+     * Formatted amount,
+     * e.g. "18.5"
+     *
+     * in COMBO bets, it can have more fractional digits than bet token decimals,
+     * e.g. "18.057553956834532374" for 6 decimals USDT
+     * */
+    potentialAmount: string | null;
+    potentialLoss: string | null;
+};
+export type BetOrderData = {
+    id: string;
+    state: BetOrderState;
+    environment: Environment;
+    betType: 'ORDINARY' | 'COMBO';
+    core: Address;
+    bettor: Address;
+    owner: Address;
+    affiliate: Address;
+    amount: number;
+    payout: number | null;
+    odds: number;
+    bonusId: string | null;
+    isFreebet: boolean;
+    betId: number | null;
+    txHash: Hex | null;
+    margin: string;
+    settledMargin: string | null;
+    result: BetOrderResult | null;
+    createdAt: ISOTimestamp;
+    updatedAt: ISOTimestamp;
+    settledAt: ISOTimestamp | null;
+    redeemedAt: ISOTimestamp | null;
+    conditions: BetOrderConditionData[];
+    meta: BetMetaData | null;
+    error: string | null;
+    errorMessage: string | null;
+};

package/dist/utils/bonus/getAvailableFreebets.d.ts

@@ -5,12 +5,35 @@ import { type RawBonus } from './getBonuses';
 export type GetFreebetsResponse = {
     bonuses: RawBonus[];
 };
-type Props = {
+export type GetAvailableFreebetsParams = {
     chainId: ChainId;
     account: Address;
     affiliate: Address;
     selections: Selection[];
 };
+export type GetAvailableFreebetsResult = Freebet[] | null;
+/** @deprecated use GetAvailableFreebetsResult instead */
 export type GetAvailableFreebets = Freebet[] | null;
-export declare const getAvailableFreebets: ({ chainId, account, affiliate, selections }: Props) => Promise<GetAvailableFreebets>;
-export {};
+/**
+ * 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
+ * })
+ * */
+export declare const getAvailableFreebets: ({ chainId, account, affiliate, selections }: GetAvailableFreebetsParams) => Promise<GetAvailableFreebetsResult>;

package/dist/utils/bonus/getBonuses.d.ts

@@ -46,12 +46,32 @@ export type RawBonus = {
     createdAt: string;
     publicCustomData: Record<string, string> | null;
 };
+export type GetBonusesResult = Bonus[] | null;
+/** @deprecated use GetBonusesResult instead */
 export type GetBonuses = Bonus[] | null;
-type Props = {
+export type GetBonusesParams = {
     chainId: ChainId;
     account: Address;
     affiliate: Address;
     bonusStatus?: BonusStatus;
 };
-export declare const getBonuses: (props: Props) => Promise<GetBonuses>;
-export {};
+/**
+ * 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
+ * })
+ * */
+export declare const getBonuses: (props: GetBonusesParams) => Promise<GetBonusesResult>;

package/dist/utils/calcMinOdds.d.ts

@@ -0,0 +1,20 @@
+export type CalcMinOddsParams = {
+    odds: number | number[];
+    slippage?: number;
+};
+/**
+ * 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 })
+ * */
+export declare const calcMinOdds: (props: CalcMinOddsParams) => string;

package/dist/utils/cashout/createCashout.d.ts

@@ -11,11 +11,34 @@ export type CreateCashoutResponse = {
     state: CashoutState;
     errorMessage?: string;
 };
-type Props = {
+export type CreateCashoutResult = CreateCashoutResponse;
+export type CreateCashoutParams = {
     chainId: ChainId;
     calculationId: string;
     attention: string;
     signature: Hex;
 };
-export declare const createCashout: (props: Props) => Promise<CreateCashoutResponse | null>;
-export {};
+/**
+ * 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'
+ * */
+export declare const createCashout: (props: CreateCashoutParams) => Promise<CreateCashoutResult>;