@emberai/onchain-actions-registry 4.1.2 → 4.2.0

package/dist/index.mjs

@@ -1,3 +1,4 @@
+import { t as __export } from "./chunk-z5eko27R.mjs";
 import { InterestRate, LegacyUiPoolDataProvider, Pool, PoolBundle, UiPoolDataProvider } from "@aave/contract-helpers";
 import { ethers, utils } from "ethers";
 import { z } from "zod";
@@ -155,11 +156,6 @@ const LiquidityPositionRangeSchema = z.object({
 	fromPrice: z.string(),
 	toPrice: z.string()
 });
-const LiquiditySuppliedTokenSchema = z.object({
-	tokenUid: TokenIdentifierSchema,
-	suppliedAmount: z.string(),
-	owedTokens: z.string()
-});
 const LiquidityRewardsOwedTokenSchema = z.object({
 	tokenUid: TokenIdentifierSchema,
 	amount: z.string(),
@@ -169,12 +165,18 @@ const LiquidityRewardsOwedTokenSchema = z.object({
 });
 const LiquidityPooledTokenSchema = z.object({
 	tokenUid: TokenIdentifierSchema,
+	name: z.string(),
+	symbol: z.string(),
+	decimals: z.number().int(),
 	amount: z.string(),
 	usdPrice: z.string().optional(),
 	valueUsd: z.string().optional()
 });
 const LiquidityFeesOwedTokenSchema = z.object({
 	tokenUid: TokenIdentifierSchema,
+	name: z.string(),
+	symbol: z.string(),
+	decimals: z.number().int(),
 	amount: z.string(),
 	usdPrice: z.string().optional(),
 	valueUsd: z.string().optional()
@@ -183,7 +185,6 @@ const LiquidityPositionSchema = z.object({
 	positionId: z.string(),
 	poolIdentifier: TokenIdentifierSchema,
 	operator: z.string(),
-	suppliedTokens: z.array(LiquiditySuppliedTokenSchema),
 	pooledTokens: z.array(LiquidityPooledTokenSchema),
 	feesOwedTokens: z.array(LiquidityFeesOwedTokenSchema),
 	rewardsOwedTokens: z.array(LiquidityRewardsOwedTokenSchema),
@@ -485,6 +486,90 @@ const TokenizedYieldUserPositionsRequestSchema = z.object({
 });
 const TokenizedYieldUserPositionsResponseSchema = z.object({ positions: z.array(TokenizedYieldUserPositionSchema).describe("Array of user positions in tokenized yield markets") });
 
+//#endregion
+//#region src/core/index.ts
+var core_exports = /* @__PURE__ */ __export({
+	BorrowTokensRequestSchema: () => BorrowTokensRequestSchema,
+	BorrowTokensResponseSchema: () => BorrowTokensResponseSchema,
+	BuyPtRequestSchema: () => BuyPtRequestSchema,
+	BuyPtResponseSchema: () => BuyPtResponseSchema,
+	BuyYtRequestSchema: () => BuyYtRequestSchema,
+	BuyYtResponseSchema: () => BuyYtResponseSchema,
+	ChainSchema: () => ChainSchema,
+	ChainTypeSchema: () => ChainTypeSchema,
+	ClaimRewardsRequestSchema: () => ClaimRewardsRequestSchema,
+	ClaimRewardsResponseSchema: () => ClaimRewardsResponseSchema,
+	ClosePerpetualsOrdersRequestSchema: () => ClosePerpetualsOrdersRequestSchema,
+	ClosePerpetualsOrdersResponseSchema: () => ClosePerpetualsOrdersResponseSchema,
+	CreatePerpetualsPositionRequestSchema: () => CreatePerpetualsPositionRequestSchema,
+	CreatePerpetualsPositionResponseSchema: () => CreatePerpetualsPositionResponseSchema,
+	DecreasePositionSwapTypeSchema: () => DecreasePositionSwapTypeSchema,
+	FeeBreakdownSchema: () => FeeBreakdownSchema,
+	GetLiquidityPoolsResponseSchema: () => GetLiquidityPoolsResponseSchema,
+	GetPerpetualsMarketsOrdersRequestSchema: () => GetPerpetualsMarketsOrdersRequestSchema,
+	GetPerpetualsMarketsOrdersResponseSchema: () => GetPerpetualsMarketsOrdersResponseSchema,
+	GetPerpetualsMarketsPositionsRequestSchema: () => GetPerpetualsMarketsPositionsRequestSchema,
+	GetPerpetualsMarketsPositionsResponseSchema: () => GetPerpetualsMarketsPositionsResponseSchema,
+	GetPerpetualsMarketsRequestSchema: () => GetPerpetualsMarketsRequestSchema,
+	GetPerpetualsMarketsResponseSchema: () => GetPerpetualsMarketsResponseSchema,
+	GetWalletLendingPositionsRequestSchema: () => GetWalletLendingPositionsRequestSchema,
+	GetWalletLendingPositionsResponseSchema: () => GetWalletLendingPositionsResponseSchema,
+	GetWalletLiquidityPositionsRequestSchema: () => GetWalletLiquidityPositionsRequestSchema,
+	GetWalletLiquidityPositionsResponseSchema: () => GetWalletLiquidityPositionsResponseSchema,
+	LendTokenDetailSchema: () => LendTokenDetailSchema,
+	LiquidityFeesOwedTokenSchema: () => LiquidityFeesOwedTokenSchema,
+	LiquidityPayTokensSchema: () => LiquidityPayTokensSchema,
+	LiquidityPoolSchema: () => LiquidityPoolSchema,
+	LiquidityPoolTokens: () => LiquidityPoolTokens,
+	LiquidityPooledTokenSchema: () => LiquidityPooledTokenSchema,
+	LiquidityPositionRangeSchema: () => LiquidityPositionRangeSchema,
+	LiquidityPositionSchema: () => LiquidityPositionSchema,
+	LiquidityProvisionRangeSchema: () => LiquidityProvisionRangeSchema,
+	LiquidityRewardsOwedTokenSchema: () => LiquidityRewardsOwedTokenSchema,
+	MarketTokenizedYieldRequestSchema: () => MarketTokenizedYieldRequestSchema,
+	MarketTokenizedYieldResponseSchema: () => MarketTokenizedYieldResponseSchema,
+	MintPtAndYtRequestSchema: () => MintPtAndYtRequestSchema,
+	MintPtAndYtResponseSchema: () => MintPtAndYtResponseSchema,
+	OrderSchema: () => OrderSchema,
+	OrderTypeSchema: () => OrderTypeSchema,
+	OrdersDataSchema: () => OrdersDataSchema,
+	PerpetualMarketSchema: () => PerpetualMarketSchema,
+	PositionSchema: () => PositionSchema,
+	PositionSideSchema: () => PositionSideSchema,
+	PositionsDataSchema: () => PositionsDataSchema,
+	ProviderTrackingInfoSchema: () => ProviderTrackingInfoSchema,
+	ProviderTrackingStatusSchema: () => ProviderTrackingStatusSchema,
+	RedeemPtRequestSchema: () => RedeemPtRequestSchema,
+	RedeemPtResponseSchema: () => RedeemPtResponseSchema,
+	RepayTokensRequestSchema: () => RepayTokensRequestSchema,
+	RepayTokensResponseSchema: () => RepayTokensResponseSchema,
+	SellPtRequestSchema: () => SellPtRequestSchema,
+	SellPtResponseSchema: () => SellPtResponseSchema,
+	SellYtRequestSchema: () => SellYtRequestSchema,
+	SellYtResponseSchema: () => SellYtResponseSchema,
+	SupplyLiquidityRequestSchema: () => SupplyLiquidityRequestSchema,
+	SupplyLiquidityResponseSchema: () => SupplyLiquidityResponseSchema,
+	SupplyTokensRequestSchema: () => SupplyTokensRequestSchema,
+	SupplyTokensResponseSchema: () => SupplyTokensResponseSchema,
+	SwapEstimationSchema: () => SwapEstimationSchema,
+	SwapTokensRequestSchema: () => SwapTokensRequestSchema,
+	SwapTokensResponseSchema: () => SwapTokensResponseSchema,
+	TokenIdentifierSchema: () => TokenIdentifierSchema,
+	TokenSchema: () => TokenSchema,
+	TokenizedYieldMarketSchema: () => TokenizedYieldMarketSchema,
+	TokenizedYieldUserPositionSchema: () => TokenizedYieldUserPositionSchema,
+	TokenizedYieldUserPositionsRequestSchema: () => TokenizedYieldUserPositionsRequestSchema,
+	TokenizedYieldUserPositionsResponseSchema: () => TokenizedYieldUserPositionsResponseSchema,
+	TransactionPlanErrorSchema: () => TransactionPlanErrorSchema,
+	TransactionPlanSchema: () => TransactionPlanSchema,
+	TransactionTypeSchema: () => TransactionTypeSchema,
+	TransactionTypes: () => TransactionTypes,
+	WithdrawLiquidityRequestSchema: () => WithdrawLiquidityRequestSchema,
+	WithdrawLiquidityResponseSchema: () => WithdrawLiquidityResponseSchema,
+	WithdrawTokensRequestSchema: () => WithdrawTokensRequestSchema,
+	WithdrawTokensResponseSchema: () => WithdrawTokensResponseSchema
+});
+
 //#endregion
 //#region src/aave-lending-plugin/chain.ts
 /**
@@ -1409,6 +1494,594 @@ var PublicEmberPluginRegistry = class {
 	}
 };
 
+//#endregion
+//#region src/endpoint-interfaces/pagination.ts
+const PaginatedPossibleResultsRequestSchema = z.object({
+	cursor: z.string().optional().describe("Pagination cursor for cached results"),
+	page: z.number().int().positive().optional().describe("Page number to retrieve (defaults to 1)")
+});
+const PaginatedPossibleResultsResponseSchema = z.object({
+	cursor: z.string().describe("Pagination cursor for retrieving next/previous pages"),
+	currentPage: z.number().int().describe("Current page number"),
+	totalPages: z.number().int().describe("Total number of pages"),
+	totalItems: z.number().int().describe("Total number of items across all pages")
+});
+
+//#endregion
+//#region src/endpoint-interfaces/lending.ts
+const CreateLendingSupplyRequestSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will supply tokens to the lending protocol"),
+	amount: z.string().describe("The amount of tokens to supply to the lending protocol"),
+	supplyChain: z.string().describe("The blockchain network where the lending protocol exists"),
+	supplyToken: z.string().describe("The token symbol or name to supply to the lending protocol")
+});
+const PromptLendingSupplyRequestSchema = CreateLendingSupplyRequestSchema.pick({
+	walletAddress: true,
+	supplyToken: true,
+	supplyChain: true
+}).partial();
+const PossibleLendingSupplyRequestSchema = PaginatedPossibleResultsRequestSchema.merge(PromptLendingSupplyRequestSchema);
+const PossibleLendingSupplyOptionSchema = z.object({
+	createRequest: CreateLendingSupplyRequestSchema.pick({
+		supplyToken: true,
+		supplyChain: true
+	}),
+	data: z.object({}).describe("Additional lending supply data (currently empty)")
+});
+const PossibleLendingSupplyResponseSchema = PaginatedPossibleResultsResponseSchema.extend({ options: z.array(PossibleLendingSupplyOptionSchema).describe("Available tokens and chains where you can supply to lending protocols") });
+const CreateSupplyEndpointRequestSchema = SupplyTokensRequestSchema.omit({
+	supplyToken: true,
+	amount: true
+}).extend({
+	supplyTokenUid: TokenIdentifierSchema,
+	amount: z.string().transform((arg) => BigInt(arg))
+});
+const CreateLendingBorrowRequestSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will borrow tokens from the lending protocol"),
+	amount: z.string().describe("The amount of tokens to borrow from the lending protocol"),
+	borrowChain: z.string().describe("The blockchain network where the borrowing will occur"),
+	borrowToken: z.string().describe("The token symbol or name to borrow from lending protocols")
+});
+const PromptLendingBorrowRequestSchema = CreateLendingBorrowRequestSchema.pick({
+	walletAddress: true,
+	borrowToken: true,
+	borrowChain: true
+}).partial();
+const PossibleLendingBorrowRequestSchema = PaginatedPossibleResultsRequestSchema.merge(PromptLendingBorrowRequestSchema);
+const PossibleLendingBorrowOptionSchema = z.object({
+	createRequest: CreateLendingBorrowRequestSchema.pick({
+		borrowToken: true,
+		borrowChain: true
+	}),
+	data: z.object({}).describe("Additional borrow data (currently empty)")
+});
+const PossibleLendingBorrowResponseSchema = PaginatedPossibleResultsResponseSchema.extend({ options: z.array(PossibleLendingBorrowOptionSchema).describe("Available tokens and chains where you can borrow from lending protocols") });
+const CreateBorrowEndpointRequestSchema = BorrowTokensRequestSchema.omit({
+	borrowToken: true,
+	amount: true
+}).extend({
+	borrowTokenUid: TokenIdentifierSchema,
+	amount: z.string().transform((arg) => BigInt(arg))
+});
+const CreateLendingRepayRequestSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will repay tokens to the lending protocol"),
+	amount: z.string().describe("The amount of tokens to repay to the lending protocol"),
+	repayChain: z.string().describe("The blockchain network where repayment will occur"),
+	repayToken: z.string().describe("The token symbol or name to repay to lending protocols")
+});
+const PromptLendingRepayRequestSchema = CreateLendingRepayRequestSchema.pick({
+	walletAddress: true,
+	repayToken: true,
+	repayChain: true
+}).partial();
+const PossibleLendingRepayRequestSchema = PaginatedPossibleResultsRequestSchema.merge(PromptLendingRepayRequestSchema);
+const PossibleLendingRepayOptionSchema = z.object({
+	createRequest: CreateLendingRepayRequestSchema.pick({
+		repayToken: true,
+		repayChain: true
+	}),
+	data: z.object({}).describe("Additional repay data (currently empty)")
+});
+const PossibleLendingRepayResponseSchema = PaginatedPossibleResultsResponseSchema.extend({ options: z.array(PossibleLendingRepayOptionSchema).describe("Available tokens and chains where you can repay to lending protocols") });
+const CreateRepayEndpointRequestSchema = RepayTokensRequestSchema.omit({
+	repayToken: true,
+	amount: true
+}).extend({
+	repayTokenUid: TokenIdentifierSchema,
+	amount: z.string().transform((arg) => BigInt(arg))
+});
+const CreateLendingWithdrawRequestSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will withdraw tokens from the lending protocol"),
+	amount: z.string().describe("The amount of tokens to withdraw from the lending protocol"),
+	withdrawChain: z.string().describe("The blockchain network where the withdrawal will occur"),
+	withdrawToken: z.string().describe("The token symbol or name to withdraw from lending protocols")
+});
+const PromptLendingWithdrawRequestSchema = CreateLendingWithdrawRequestSchema.pick({
+	walletAddress: true,
+	withdrawToken: true,
+	withdrawChain: true
+}).partial();
+const PossibleLendingWithdrawRequestSchema = PaginatedPossibleResultsRequestSchema.merge(PromptLendingWithdrawRequestSchema);
+const PossibleLendingWithdrawOptionSchema = z.object({
+	createRequest: CreateLendingWithdrawRequestSchema.pick({
+		withdrawToken: true,
+		withdrawChain: true
+	}),
+	data: z.object({}).describe("Additional withdraw data (currently empty)")
+});
+const PossibleLendingWithdrawResponseSchema = PaginatedPossibleResultsResponseSchema.extend({ options: z.array(PossibleLendingWithdrawOptionSchema).describe("Available tokens and chains where you can withdraw from lending protocols") });
+const CreateWithdrawEndpointRequestSchema = WithdrawTokensRequestSchema.omit({
+	tokenToWithdraw: true,
+	amount: true
+}).extend({
+	tokenUidToWidthraw: TokenIdentifierSchema,
+	amount: z.string().transform((arg) => BigInt(arg))
+});
+
+//#endregion
+//#region src/endpoint-interfaces/liquidity.ts
+const NonMappedPayableTokens = z.object({
+	token: z.string().describe("The token to be paid"),
+	amount: z.string().describe("The amount of the token to be paid as a string")
+});
+const CreateLiquiditySupplyRequestSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will supply liquidity to the pool"),
+	payableTokens: z.array(NonMappedPayableTokens).describe("The tokens and amounts to be supplied to the liquidity pool"),
+	poolToken: z.string().describe("The liquidity pool token"),
+	supplyChain: z.string().describe("The blockchain network where the liquidity pool exists"),
+	range: LiquidityProvisionRangeSchema.describe("The price range for concentrated liquidity provision").optional()
+});
+const CreateLiquiditySupplyPayableTokenSchema = z.object({
+	tokenUid: TokenIdentifierSchema.describe("The token to be paid"),
+	amount: z.string().describe("The amount of the token to be paid as a string")
+});
+const CreateLiquiditySupplyEndpointRequestSchema = CreateLiquiditySupplyRequestSchema.omit({
+	payableTokens: true,
+	poolToken: true
+}).extend({
+	payableTokens: z.array(CreateLiquiditySupplyPayableTokenSchema).describe("The tokens and amounts to be supplied to the liquidity pool"),
+	poolIdentifier: TokenIdentifierSchema.describe("The liquidity pool token")
+});
+const CreateLiquidityWithdrawRequestSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that owns the liquidity position to withdraw"),
+	poolToken: z.string().describe("The LP token representing the liquidity position")
+});
+const PromptLiquidityWithdrawRequestSchema = CreateLiquidityWithdrawRequestSchema.partial();
+const PossibleLiquidityWithdrawRequestSchema = PaginatedPossibleResultsRequestSchema.merge(PromptLiquidityWithdrawRequestSchema);
+const LiquidityWithdrawOptionSchema = z.object({
+	createRequest: CreateLiquidityWithdrawRequestSchema.pick({
+		walletAddress: true,
+		poolToken: true
+	}),
+	data: z.object({})
+});
+const PossibleLiquidityWithdrawResponseSchema = PaginatedPossibleResultsResponseSchema.extend({ options: z.array(LiquidityWithdrawOptionSchema).describe("Available liquidity positions that can be withdrawn") });
+const CreateLiquidityWithdrawEndpointRequestSchema = z.object({
+	walletAddress: z.string().describe("The wallet owning the liquidity position to withdraw"),
+	poolTokenUid: TokenIdentifierSchema.describe("The LP token identifier")
+});
+
+//#endregion
+//#region src/endpoint-interfaces/perpetuals.ts
+const PerpetualsCreatePositionRequestSchema = z.object({
+	amount: z.string().describe("The amount of tokens to use for opening the perpetual position"),
+	walletAddress: z.string().describe("The wallet address that will create the perpetual position"),
+	chain: z.string().describe("The blockchain network where the perpetual position will be created"),
+	market: z.string().describe("The perpetual futures market to trade (e.g., BTC-USD, ETH-USD)"),
+	payToken: z.string().describe("The token used to pay for opening the position"),
+	collateralToken: z.string().describe("The token used as collateral for the perpetual position"),
+	referralCode: z.string().optional().describe("Optional referral code for fee discounts"),
+	limitPrice: z.string().optional().describe("Limit price for the order. If not provided, will execute at market price"),
+	leverage: z.string().describe("The leverage multiplier for the position (e.g., '2', '5', '10')")
+});
+const PerpetualsPositionPromptSchema = PerpetualsCreatePositionRequestSchema.pick({
+	chain: true,
+	market: true,
+	payToken: true,
+	collateralToken: true,
+	walletAddress: true
+}).partial();
+const PossiblePerpetualPositionsRequestSchema = PaginatedPossibleResultsRequestSchema.merge(PerpetualsPositionPromptSchema);
+const PossiblePerpetualPositionsOptionSchema = z.object({
+	createRequest: PerpetualsCreatePositionRequestSchema.pick({
+		market: true,
+		collateralToken: true,
+		payToken: true,
+		chain: true
+	}),
+	data: z.object({
+		fundingFee: z.string().describe("The funding fee rate for this perpetual market"),
+		borrowingFee: z.string().describe("The borrowing fee rate for this perpetual market")
+	})
+});
+const PossiblePerpetualPositionsResponseSchema = z.object({ options: z.array(PossiblePerpetualPositionsOptionSchema) }).merge(PaginatedPossibleResultsResponseSchema);
+const CreatePerpetualClosePositionRequestSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that owns the perpetual position to close"),
+	providerName: z.string().describe("The DeFi protocol provider where the position exists (e.g., GMX, dYdX)"),
+	market: z.string().describe("The perpetual futures market of the position to close"),
+	collateralToken: z.string().describe("The collateral token used in the position"),
+	positionSide: PositionSideSchema.describe("Whether the position is long or short"),
+	isLimit: z.boolean().describe("Whether to close using a limit order (true) or market order (false)")
+});
+const PerpetualsCloseOrderPromptSchema = CreatePerpetualClosePositionRequestSchema.pick({
+	walletAddress: true,
+	providerName: true,
+	market: true,
+	collateralToken: true,
+	positionSide: true
+}).extend({ isLimit: z.string().describe("Whether to use limit order ('true') or market order ('false') for closing") }).partial();
+const PossiblePerpetualCloseRequestSchema = PaginatedPossibleResultsRequestSchema.merge(CreatePerpetualClosePositionRequestSchema.omit({ walletAddress: true }).partial()).extend({ walletAddress: z.string().describe("The wallet address to check for closeable perpetual positions") });
+const PositionDataSchema = z.object({
+	sizeInUsd: z.string().describe("The size of the position in USD value"),
+	increasedAtTime: z.string().describe("Timestamp when the position was last increased"),
+	decreasedAtTime: z.string().describe("Timestamp when the position was last decreased"),
+	pnl: z.string().describe("Current profit and loss of the position in USD")
+});
+const LimitOrderDataSchema = z.object({
+	sizeDeltaUsd: z.string().describe("The USD size change for the limit order"),
+	acceptablePrice: z.string().describe("The acceptable execution price for the limit order"),
+	triggerPrice: z.string().describe("The trigger price that activates the limit order")
+});
+const TradingPositionDataSchema = z.discriminatedUnion("type", [z.object({ type: z.literal("limit") }).merge(LimitOrderDataSchema), z.object({ type: z.literal("market") }).merge(PositionDataSchema)]);
+const PerpetualCloseOptionSchema = z.object({
+	createRequest: CreatePerpetualClosePositionRequestSchema.pick({
+		providerName: true,
+		market: true,
+		collateralToken: true,
+		positionSide: true,
+		isLimit: true
+	}),
+	data: z.object({
+		collateralAmount: z.string().describe("The amount of collateral tokens in the position"),
+		orderData: TradingPositionDataSchema.describe("Details about the position or order to be closed")
+	})
+});
+const PossiblePerpetualCloseResponseSchema = z.object({ options: z.array(PerpetualCloseOptionSchema).describe("Available perpetual positions and orders that can be closed") }).merge(PaginatedPossibleResultsResponseSchema);
+const CreatePerpetualCloseSimplifiedEndpointRequestSchema = z.object({
+	walletAddress: z.string().describe("Wallet owning the perpetual position/order to close"),
+	marketAddress: z.string().describe("Perpetual market contract address").min(1),
+	positionSide: PositionSideSchema.optional().describe("long or short (optional filter)"),
+	isLimit: z.boolean().optional().describe("If true, target a limit order; if false, target a market position; if omitted, try market then limit")
+});
+
+//#endregion
+//#region src/endpoint-interfaces/queries.ts
+const GetChainsRequestSchema = z.object({});
+const GetChainsResponseSchema = z.object({ chains: z.array(ChainSchema) });
+const GetTokensRequestSchema = z.object({ chainIds: z.array(z.string()).optional() });
+const GetTokensResponseSchema = z.object({ tokens: z.array(TokenSchema) });
+const ProviderSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string().optional(),
+	website: z.string().optional(),
+	x: z.string().optional(),
+	type: z.string()
+});
+const GetProvidersRequestSchema = z.object({});
+const GetProvidersResponseSchema = z.object({ providers: z.array(ProviderSchema) });
+const BalanceSchema = z.object({
+	tokenUid: TokenIdentifierSchema,
+	amount: z.string(),
+	symbol: z.string().optional(),
+	valueUsd: z.number().optional(),
+	decimals: z.number().int().optional()
+});
+const GetWalletBalancesRequestSchema = z.object({ walletAddress: z.string() });
+const GetWalletBalancesResponseSchema = z.object({ balances: z.array(BalanceSchema) });
+
+//#endregion
+//#region src/endpoint-interfaces/swap.ts
+const AmountTypeSchema = z.union([z.literal("exactIn").describe("Specify exact input amount - you know how much you want to spend"), z.literal("exactOut").describe("Specify exact output amount - you know how much you want to receive")]);
+const CreateSwapRequestSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will perform the token swap"),
+	amount: z.string().describe("The amount of tokens to swap (input amount for exactIn, output amount for exactOut)"),
+	amountType: AmountTypeSchema.describe("Whether the amount represents input tokens (exactIn) or desired output tokens (exactOut)"),
+	toChain: z.string().describe("The destination blockchain network for the token swap"),
+	fromChain: z.string().describe("The source blockchain network for the token swap"),
+	fromToken: z.string().describe("The token to swap from (source token symbol or name)"),
+	toToken: z.string().describe("The token to swap to (destination token symbol or name)"),
+	slippageTolerance: z.string().optional().describe("Maximum acceptable slippage percentage (e.g., '0.5' for 0.5%)"),
+	expiration: z.string().optional().describe("Transaction expiration time in seconds from now")
+});
+const PromptSwapRequestSchema = CreateSwapRequestSchema.pick({
+	walletAddress: true,
+	fromToken: true,
+	toToken: true,
+	fromChain: true,
+	toChain: true
+}).partial();
+const PossibleSwapsRequestSchema = PaginatedPossibleResultsRequestSchema.merge(PromptSwapRequestSchema);
+const PossibleSwapOptionSchema = z.object({
+	createRequest: CreateSwapRequestSchema.pick({
+		fromToken: true,
+		fromChain: true,
+		toToken: true,
+		toChain: true
+	}),
+	data: z.object({}).describe("Additional swap data (currently empty)")
+});
+const PossibleSwapsResponseSchema = PaginatedPossibleResultsResponseSchema.extend({ options: z.array(PossibleSwapOptionSchema).describe("Available token swap pairs across different blockchain networks") });
+const CreateSwapEndpointRequestSchema = CreateSwapRequestSchema.omit({
+	fromToken: true,
+	toToken: true,
+	fromChain: true,
+	toChain: true
+}).extend({
+	fromTokenUid: TokenIdentifierSchema.describe("Identifier (chainId + address) for the source token"),
+	toTokenUid: TokenIdentifierSchema.describe("Identifier (chainId + address) for the destination token")
+});
+
+//#endregion
+//#region src/endpoint-interfaces/tokenizedYield.ts
+const CreateTokenizedYieldBuyPtEndpointRequestSchema = BuyPtRequestSchema.omit({
+	inputToken: true,
+	amount: true
+}).extend({
+	inputTokenUid: TokenIdentifierSchema,
+	amount: z.string().transform((arg) => BigInt(arg))
+});
+const CreateTokenizedYieldBuyPtResponseSchema = BuyPtResponseSchema.omit({ ptTokenIdentifier: true }).extend({
+	ptToken: TokenSchema,
+	displayPtAmount: z.string()
+});
+const CreateTokenizedYieldBuyPtSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will buy the PT tokens"),
+	inputToken: z.string().describe("The token symbol or name to be used as input"),
+	amount: z.string().describe("The amount of tokens to be used as input for buying PT"),
+	slippage: z.string().describe("The maximum acceptable slippage percentage for the buying transaction").default("0.01"),
+	chain: z.string().describe("The blockchain network to perform the action on"),
+	minimumMarketExpiry: z.string().describe("The minimum expiry date of the market to use")
+});
+const PromptTokenizedYieldBuyPtRequestSchema = CreateTokenizedYieldBuyPtSchema.pick({
+	walletAddress: true,
+	inputToken: true,
+	amount: true,
+	chain: true,
+	minimumMarketExpiry: true
+}).partial();
+const CreateTokenizedYieldBuyYtEndpointRequestSchema = BuyYtRequestSchema.omit({
+	inputToken: true,
+	amount: true
+}).extend({
+	inputTokenUid: TokenIdentifierSchema,
+	amount: z.string().transform((arg) => BigInt(arg))
+});
+const CreateTokenizedYieldBuyYtResponseSchema = BuyYtResponseSchema.omit({ ytTokenIdentifier: true }).extend({
+	ytToken: TokenSchema,
+	displayYtAmount: z.string()
+});
+const CreateTokenizedYieldBuyYtSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will buy the YT tokens"),
+	inputToken: z.string().describe("The token symbol or name to be used as input"),
+	amount: z.string().describe("The amount of tokens to be used as input for buying YT"),
+	slippage: z.string().describe("The maximum acceptable slippage percentage for the buying transaction").default("0.01"),
+	chain: z.string().describe("The blockchain network to perform the action on"),
+	minimumMarketExpiry: z.string().describe("The minimum expiry date of the market to use")
+});
+const PromptTokenizedYieldBuyYtRequestSchema = CreateTokenizedYieldBuyYtSchema.pick({
+	walletAddress: true,
+	inputToken: true,
+	amount: true,
+	chain: true,
+	minimumMarketExpiry: true
+}).partial();
+const CreateTokenizedYieldSellPtEndpointRequestSchema = SellPtRequestSchema.omit({
+	ptToken: true,
+	amount: true
+}).extend({
+	ptTokenUid: TokenIdentifierSchema,
+	amount: z.string().transform((arg) => BigInt(arg))
+});
+const CreateTokenizedYieldSellPtResponseSchema = SellPtResponseSchema.omit({ tokenOutIdentifier: true }).extend({
+	tokenOut: TokenSchema,
+	displayAmountOut: z.string()
+});
+const CreateTokenizedYieldSellPtSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will sell the PT tokens"),
+	ptToken: z.string().describe("The PT token symbol or name to be sold"),
+	amount: z.string().describe("The amount of PT tokens to sell"),
+	slippage: z.string().describe("The maximum acceptable slippage percentage for the selling transaction").default("0.01"),
+	chain: z.string().describe("The blockchain network to perform the action on")
+});
+const PromptTokenizedYieldSellPtRequestSchema = CreateTokenizedYieldSellPtSchema.pick({
+	walletAddress: true,
+	ptToken: true,
+	amount: true,
+	chain: true
+}).partial();
+const CreateTokenizedYieldSellYtEndpointRequestSchema = SellYtRequestSchema.omit({
+	ytToken: true,
+	amount: true
+}).extend({
+	ytTokenUid: TokenIdentifierSchema,
+	amount: z.string().transform((arg) => BigInt(arg))
+});
+const CreateTokenizedYieldSellYtResponseSchema = SellYtResponseSchema.omit({ tokenOutIdentifier: true }).extend({
+	tokenOut: TokenSchema,
+	displayAmountOut: z.string()
+});
+const CreateTokenizedYieldSellYtSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will sell the YT tokens"),
+	ytToken: z.string().describe("The YT token symbol or name to be sold"),
+	amount: z.string().describe("The amount of YT tokens to sell"),
+	slippage: z.string().describe("The maximum acceptable slippage percentage for the selling transaction").default("0.01"),
+	chain: z.string().describe("The blockchain network to perform the action on")
+});
+const PromptTokenizedYieldSellYtRequestSchema = CreateTokenizedYieldSellYtSchema.pick({
+	walletAddress: true,
+	ytToken: true,
+	amount: true,
+	chain: true
+}).partial();
+const CreateTokenizedYieldMintPtAndYtEndpointRequestSchema = MintPtAndYtRequestSchema.omit({
+	inputToken: true,
+	amount: true
+}).extend({
+	inputTokenUid: TokenIdentifierSchema,
+	amount: z.string().transform((arg) => BigInt(arg))
+});
+const CreateTokenizedYieldMintPtAndYtResponseSchema = MintPtAndYtResponseSchema.omit({
+	ptTokenIdentifier: true,
+	ytTokenIdentifier: true
+}).extend({
+	ptToken: TokenSchema,
+	displayPtAmount: z.string(),
+	ytToken: TokenSchema,
+	displayYtAmount: z.string()
+});
+const CreateTokenizedYieldMintPtAndYtSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will mint the PT and YT tokens"),
+	inputToken: z.string().describe("The token symbol or name to be used as input"),
+	amount: z.string().describe("The amount of tokens to be used as input for minting PT and YT"),
+	slippage: z.string().describe("The maximum acceptable slippage percentage for the minting transaction").default("0.01"),
+	chain: z.string().describe("The blockchain network to perform the action on"),
+	minimumMarketExpiry: z.string().describe("The minimum expiry date of the market to use")
+});
+const PromptTokenizedYieldMintPtAndYtRequestSchema = CreateTokenizedYieldMintPtAndYtSchema.pick({
+	walletAddress: true,
+	inputToken: true,
+	amount: true,
+	chain: true,
+	minimumMarketExpiry: true
+}).partial();
+const CreateTokenizedYieldRedeemPtEndpointRequestSchema = RedeemPtRequestSchema.omit({
+	ptToken: true,
+	amount: true
+}).extend({
+	ptTokenUid: TokenIdentifierSchema,
+	amount: z.string().transform((arg) => BigInt(arg))
+});
+const CreateTokenizedYieldRedeemPtResponseSchema = RedeemPtResponseSchema.omit({ underlyingTokenIdentifier: true }).extend({
+	underlyingToken: TokenSchema,
+	displayUnderlyingAmount: z.string()
+});
+const CreateTokenizedYieldRedeemPtSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will redeem the PT tokens"),
+	ptToken: z.string().describe("The PT token symbol or name to be redeemed after maturity"),
+	amount: z.string().describe("The amount of PT tokens to redeem"),
+	chain: z.string().describe("The blockchain network to perform the action on")
+});
+const PromptTokenizedYieldRedeemPtRequestSchema = CreateTokenizedYieldRedeemPtSchema.pick({
+	walletAddress: true,
+	ptToken: true,
+	amount: true,
+	chain: true
+}).partial();
+const CreateTokenizedYieldClaimRewardsEndpointRequestSchema = ClaimRewardsRequestSchema.omit({ ytToken: true }).extend({ ytTokenUid: TokenIdentifierSchema });
+const CreateTokenizedYieldClaimRewardsResponseSchema = ClaimRewardsResponseSchema;
+const CreateTokenizedYieldClaimRewardsSchema = z.object({
+	walletAddress: z.string().describe("The wallet address that will claim the rewards"),
+	ytToken: z.string().describe("The YT token symbol or name to claim rewards from"),
+	chain: z.string().describe("The blockchain network to perform the action on")
+});
+const PromptTokenizedYieldClaimRewardsRequestSchema = CreateTokenizedYieldClaimRewardsSchema.pick({
+	walletAddress: true,
+	ytToken: true,
+	chain: true
+}).partial();
+
+//#endregion
+//#region src/endpoint-interfaces/index.ts
+let EndpointInterfaces;
+(function(_EndpointInterfaces) {
+	_EndpointInterfaces.PaginatedPossibleResultsRequestSchema = PaginatedPossibleResultsRequestSchema;
+	_EndpointInterfaces.PaginatedPossibleResultsResponseSchema = PaginatedPossibleResultsResponseSchema;
+	_EndpointInterfaces.AmountTypeSchema = AmountTypeSchema;
+	_EndpointInterfaces.CreateSwapRequestSchema = CreateSwapRequestSchema;
+	_EndpointInterfaces.PromptSwapRequestSchema = PromptSwapRequestSchema;
+	_EndpointInterfaces.PossibleSwapsRequestSchema = PossibleSwapsRequestSchema;
+	_EndpointInterfaces.PossibleSwapOptionSchema = PossibleSwapOptionSchema;
+	_EndpointInterfaces.PossibleSwapsResponseSchema = PossibleSwapsResponseSchema;
+	_EndpointInterfaces.CreateSwapEndpointRequestSchema = CreateSwapEndpointRequestSchema;
+	_EndpointInterfaces.CreateLendingSupplyRequestSchema = CreateLendingSupplyRequestSchema;
+	_EndpointInterfaces.PromptLendingSupplyRequestSchema = PromptLendingSupplyRequestSchema;
+	_EndpointInterfaces.PossibleLendingSupplyRequestSchema = PossibleLendingSupplyRequestSchema;
+	_EndpointInterfaces.PossibleLendingSupplyOptionSchema = PossibleLendingSupplyOptionSchema;
+	_EndpointInterfaces.PossibleLendingSupplyResponseSchema = PossibleLendingSupplyResponseSchema;
+	_EndpointInterfaces.CreateSupplyEndpointRequestSchema = CreateSupplyEndpointRequestSchema;
+	_EndpointInterfaces.CreateLendingBorrowRequestSchema = CreateLendingBorrowRequestSchema;
+	_EndpointInterfaces.PromptLendingBorrowRequestSchema = PromptLendingBorrowRequestSchema;
+	_EndpointInterfaces.PossibleLendingBorrowRequestSchema = PossibleLendingBorrowRequestSchema;
+	_EndpointInterfaces.PossibleLendingBorrowOptionSchema = PossibleLendingBorrowOptionSchema;
+	_EndpointInterfaces.PossibleLendingBorrowResponseSchema = PossibleLendingBorrowResponseSchema;
+	_EndpointInterfaces.CreateBorrowEndpointRequestSchema = CreateBorrowEndpointRequestSchema;
+	_EndpointInterfaces.CreateLendingRepayRequestSchema = CreateLendingRepayRequestSchema;
+	_EndpointInterfaces.PromptLendingRepayRequestSchema = PromptLendingRepayRequestSchema;
+	_EndpointInterfaces.PossibleLendingRepayRequestSchema = PossibleLendingRepayRequestSchema;
+	_EndpointInterfaces.PossibleLendingRepayOptionSchema = PossibleLendingRepayOptionSchema;
+	_EndpointInterfaces.PossibleLendingRepayResponseSchema = PossibleLendingRepayResponseSchema;
+	_EndpointInterfaces.CreateRepayEndpointRequestSchema = CreateRepayEndpointRequestSchema;
+	_EndpointInterfaces.CreateLendingWithdrawRequestSchema = CreateLendingWithdrawRequestSchema;
+	_EndpointInterfaces.PromptLendingWithdrawRequestSchema = PromptLendingWithdrawRequestSchema;
+	_EndpointInterfaces.PossibleLendingWithdrawRequestSchema = PossibleLendingWithdrawRequestSchema;
+	_EndpointInterfaces.PossibleLendingWithdrawOptionSchema = PossibleLendingWithdrawOptionSchema;
+	_EndpointInterfaces.PossibleLendingWithdrawResponseSchema = PossibleLendingWithdrawResponseSchema;
+	_EndpointInterfaces.CreateWithdrawEndpointRequestSchema = CreateWithdrawEndpointRequestSchema;
+	_EndpointInterfaces.NonMappedPayableTokens = NonMappedPayableTokens;
+	_EndpointInterfaces.CreateLiquiditySupplyRequestSchema = CreateLiquiditySupplyRequestSchema;
+	_EndpointInterfaces.CreateLiquiditySupplyPayableTokenSchema = CreateLiquiditySupplyPayableTokenSchema;
+	_EndpointInterfaces.CreateLiquiditySupplyEndpointRequestSchema = CreateLiquiditySupplyEndpointRequestSchema;
+	_EndpointInterfaces.CreateLiquidityWithdrawRequestSchema = CreateLiquidityWithdrawRequestSchema;
+	_EndpointInterfaces.PromptLiquidityWithdrawRequestSchema = PromptLiquidityWithdrawRequestSchema;
+	_EndpointInterfaces.PossibleLiquidityWithdrawRequestSchema = PossibleLiquidityWithdrawRequestSchema;
+	_EndpointInterfaces.LiquidityWithdrawOptionSchema = LiquidityWithdrawOptionSchema;
+	_EndpointInterfaces.PossibleLiquidityWithdrawResponseSchema = PossibleLiquidityWithdrawResponseSchema;
+	_EndpointInterfaces.CreateLiquidityWithdrawEndpointRequestSchema = CreateLiquidityWithdrawEndpointRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldBuyPtEndpointRequestSchema = CreateTokenizedYieldBuyPtEndpointRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldBuyPtResponseSchema = CreateTokenizedYieldBuyPtResponseSchema;
+	_EndpointInterfaces.CreateTokenizedYieldBuyPtSchema = CreateTokenizedYieldBuyPtSchema;
+	_EndpointInterfaces.PromptTokenizedYieldBuyPtRequestSchema = PromptTokenizedYieldBuyPtRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldBuyYtEndpointRequestSchema = CreateTokenizedYieldBuyYtEndpointRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldBuyYtResponseSchema = CreateTokenizedYieldBuyYtResponseSchema;
+	_EndpointInterfaces.CreateTokenizedYieldBuyYtSchema = CreateTokenizedYieldBuyYtSchema;
+	_EndpointInterfaces.PromptTokenizedYieldBuyYtRequestSchema = PromptTokenizedYieldBuyYtRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldSellPtEndpointRequestSchema = CreateTokenizedYieldSellPtEndpointRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldSellPtResponseSchema = CreateTokenizedYieldSellPtResponseSchema;
+	_EndpointInterfaces.CreateTokenizedYieldSellPtSchema = CreateTokenizedYieldSellPtSchema;
+	_EndpointInterfaces.PromptTokenizedYieldSellPtRequestSchema = PromptTokenizedYieldSellPtRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldSellYtEndpointRequestSchema = CreateTokenizedYieldSellYtEndpointRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldSellYtResponseSchema = CreateTokenizedYieldSellYtResponseSchema;
+	_EndpointInterfaces.CreateTokenizedYieldSellYtSchema = CreateTokenizedYieldSellYtSchema;
+	_EndpointInterfaces.PromptTokenizedYieldSellYtRequestSchema = PromptTokenizedYieldSellYtRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldMintPtAndYtEndpointRequestSchema = CreateTokenizedYieldMintPtAndYtEndpointRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldMintPtAndYtResponseSchema = CreateTokenizedYieldMintPtAndYtResponseSchema;
+	_EndpointInterfaces.CreateTokenizedYieldMintPtAndYtSchema = CreateTokenizedYieldMintPtAndYtSchema;
+	_EndpointInterfaces.PromptTokenizedYieldMintPtAndYtRequestSchema = PromptTokenizedYieldMintPtAndYtRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldRedeemPtEndpointRequestSchema = CreateTokenizedYieldRedeemPtEndpointRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldRedeemPtResponseSchema = CreateTokenizedYieldRedeemPtResponseSchema;
+	_EndpointInterfaces.CreateTokenizedYieldRedeemPtSchema = CreateTokenizedYieldRedeemPtSchema;
+	_EndpointInterfaces.PromptTokenizedYieldRedeemPtRequestSchema = PromptTokenizedYieldRedeemPtRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldClaimRewardsEndpointRequestSchema = CreateTokenizedYieldClaimRewardsEndpointRequestSchema;
+	_EndpointInterfaces.CreateTokenizedYieldClaimRewardsResponseSchema = CreateTokenizedYieldClaimRewardsResponseSchema;
+	_EndpointInterfaces.CreateTokenizedYieldClaimRewardsSchema = CreateTokenizedYieldClaimRewardsSchema;
+	_EndpointInterfaces.PromptTokenizedYieldClaimRewardsRequestSchema = PromptTokenizedYieldClaimRewardsRequestSchema;
+	_EndpointInterfaces.PerpetualsCreatePositionRequestSchema = PerpetualsCreatePositionRequestSchema;
+	_EndpointInterfaces.PerpetualsPositionPromptSchema = PerpetualsPositionPromptSchema;
+	_EndpointInterfaces.PossiblePerpetualPositionsRequestSchema = PossiblePerpetualPositionsRequestSchema;
+	_EndpointInterfaces.PossiblePerpetualPositionsOptionSchema = PossiblePerpetualPositionsOptionSchema;
+	_EndpointInterfaces.PossiblePerpetualPositionsResponseSchema = PossiblePerpetualPositionsResponseSchema;
+	_EndpointInterfaces.CreatePerpetualClosePositionRequestSchema = CreatePerpetualClosePositionRequestSchema;
+	_EndpointInterfaces.PerpetualsCloseOrderPromptSchema = PerpetualsCloseOrderPromptSchema;
+	_EndpointInterfaces.PossiblePerpetualCloseRequestSchema = PossiblePerpetualCloseRequestSchema;
+	_EndpointInterfaces.PositionDataSchema = PositionDataSchema;
+	_EndpointInterfaces.LimitOrderDataSchema = LimitOrderDataSchema;
+	_EndpointInterfaces.TradingPositionDataSchema = TradingPositionDataSchema;
+	_EndpointInterfaces.PerpetualCloseOptionSchema = PerpetualCloseOptionSchema;
+	_EndpointInterfaces.PossiblePerpetualCloseResponseSchema = PossiblePerpetualCloseResponseSchema;
+	_EndpointInterfaces.CreatePerpetualCloseSimplifiedEndpointRequestSchema = CreatePerpetualCloseSimplifiedEndpointRequestSchema;
+	_EndpointInterfaces.GetChainsRequestSchema = GetChainsRequestSchema;
+	_EndpointInterfaces.GetChainsResponseSchema = GetChainsResponseSchema;
+	_EndpointInterfaces.GetTokensRequestSchema = GetTokensRequestSchema;
+	_EndpointInterfaces.GetTokensResponseSchema = GetTokensResponseSchema;
+	_EndpointInterfaces.ProviderSchema = ProviderSchema;
+	_EndpointInterfaces.GetProvidersRequestSchema = GetProvidersRequestSchema;
+	_EndpointInterfaces.GetProvidersResponseSchema = GetProvidersResponseSchema;
+	_EndpointInterfaces.BalanceSchema = BalanceSchema;
+	_EndpointInterfaces.GetWalletBalancesRequestSchema = GetWalletBalancesRequestSchema;
+	_EndpointInterfaces.GetWalletBalancesResponseSchema = GetWalletBalancesResponseSchema;
+})(EndpointInterfaces || (EndpointInterfaces = {}));
+
 //#endregion
 //#region src/index.ts
 /**
@@ -1422,5 +2095,5 @@ function initializePublicRegistry(chainConfigs) {
 }
 
 //#endregion
-export { BorrowTokensRequestSchema, BorrowTokensResponseSchema, BuyPtRequestSchema, BuyPtResponseSchema, BuyYtRequestSchema, BuyYtResponseSchema, ChainSchema, ChainTypeSchema, ClaimRewardsRequestSchema, ClaimRewardsResponseSchema, ClosePerpetualsOrdersRequestSchema, ClosePerpetualsOrdersResponseSchema, CreatePerpetualsPositionRequestSchema, CreatePerpetualsPositionResponseSchema, DecreasePositionSwapTypeSchema, FeeBreakdownSchema, GetLiquidityPoolsResponseSchema, GetPerpetualsMarketsOrdersRequestSchema, GetPerpetualsMarketsOrdersResponseSchema, GetPerpetualsMarketsPositionsRequestSchema, GetPerpetualsMarketsPositionsResponseSchema, GetPerpetualsMarketsRequestSchema, GetPerpetualsMarketsResponseSchema, GetWalletLendingPositionsRequestSchema, GetWalletLendingPositionsResponseSchema, GetWalletLiquidityPositionsRequestSchema, GetWalletLiquidityPositionsResponseSchema, LendTokenDetailSchema, LiquidityFeesOwedTokenSchema, LiquidityPayTokensSchema, LiquidityPoolSchema, LiquidityPoolTokens, LiquidityPooledTokenSchema, LiquidityPositionRangeSchema, LiquidityPositionSchema, LiquidityProvisionRangeSchema, LiquidityRewardsOwedTokenSchema, LiquiditySuppliedTokenSchema, MarketTokenizedYieldRequestSchema, MarketTokenizedYieldResponseSchema, MintPtAndYtRequestSchema, MintPtAndYtResponseSchema, OrderSchema, OrderTypeSchema, OrdersDataSchema, PerpetualMarketSchema, PositionSchema, PositionSideSchema, PositionsDataSchema, ProviderTrackingInfoSchema, ProviderTrackingStatusSchema, PublicEmberPluginRegistry, RedeemPtRequestSchema, RedeemPtResponseSchema, RepayTokensRequestSchema, RepayTokensResponseSchema, SellPtRequestSchema, SellPtResponseSchema, SellYtRequestSchema, SellYtResponseSchema, SupplyLiquidityRequestSchema, SupplyLiquidityResponseSchema, SupplyTokensRequestSchema, SupplyTokensResponseSchema, SwapEstimationSchema, SwapTokensRequestSchema, SwapTokensResponseSchema, TokenIdentifierSchema, TokenSchema, TokenizedYieldMarketSchema, TokenizedYieldUserPositionSchema, TokenizedYieldUserPositionsRequestSchema, TokenizedYieldUserPositionsResponseSchema, TransactionPlanErrorSchema, TransactionPlanSchema, TransactionTypeSchema, TransactionTypes, WithdrawLiquidityRequestSchema, WithdrawLiquidityResponseSchema, WithdrawTokensRequestSchema, WithdrawTokensResponseSchema, initializePublicRegistry };
+export { BorrowTokensRequestSchema, BorrowTokensResponseSchema, BuyPtRequestSchema, BuyPtResponseSchema, BuyYtRequestSchema, BuyYtResponseSchema, ChainSchema, ChainTypeSchema, ClaimRewardsRequestSchema, ClaimRewardsResponseSchema, ClosePerpetualsOrdersRequestSchema, ClosePerpetualsOrdersResponseSchema, CreatePerpetualsPositionRequestSchema, CreatePerpetualsPositionResponseSchema, DecreasePositionSwapTypeSchema, EndpointInterfaces, FeeBreakdownSchema, GetLiquidityPoolsResponseSchema, GetPerpetualsMarketsOrdersRequestSchema, GetPerpetualsMarketsOrdersResponseSchema, GetPerpetualsMarketsPositionsRequestSchema, GetPerpetualsMarketsPositionsResponseSchema, GetPerpetualsMarketsRequestSchema, GetPerpetualsMarketsResponseSchema, GetWalletLendingPositionsRequestSchema, GetWalletLendingPositionsResponseSchema, GetWalletLiquidityPositionsRequestSchema, GetWalletLiquidityPositionsResponseSchema, LendTokenDetailSchema, LiquidityFeesOwedTokenSchema, LiquidityPayTokensSchema, LiquidityPoolSchema, LiquidityPoolTokens, LiquidityPooledTokenSchema, LiquidityPositionRangeSchema, LiquidityPositionSchema, LiquidityProvisionRangeSchema, LiquidityRewardsOwedTokenSchema, MarketTokenizedYieldRequestSchema, MarketTokenizedYieldResponseSchema, MintPtAndYtRequestSchema, MintPtAndYtResponseSchema, OrderSchema, OrderTypeSchema, OrdersDataSchema, PerpetualMarketSchema, core_exports as PluginInterfaces, PositionSchema, PositionSideSchema, PositionsDataSchema, ProviderTrackingInfoSchema, ProviderTrackingStatusSchema, PublicEmberPluginRegistry, RedeemPtRequestSchema, RedeemPtResponseSchema, RepayTokensRequestSchema, RepayTokensResponseSchema, SellPtRequestSchema, SellPtResponseSchema, SellYtRequestSchema, SellYtResponseSchema, SupplyLiquidityRequestSchema, SupplyLiquidityResponseSchema, SupplyTokensRequestSchema, SupplyTokensResponseSchema, SwapEstimationSchema, SwapTokensRequestSchema, SwapTokensResponseSchema, TokenIdentifierSchema, TokenSchema, TokenizedYieldMarketSchema, TokenizedYieldUserPositionSchema, TokenizedYieldUserPositionsRequestSchema, TokenizedYieldUserPositionsResponseSchema, TransactionPlanErrorSchema, TransactionPlanSchema, TransactionTypeSchema, TransactionTypes, WithdrawLiquidityRequestSchema, WithdrawLiquidityResponseSchema, WithdrawTokensRequestSchema, WithdrawTokensResponseSchema, initializePublicRegistry };
 //# sourceMappingURL=index.mjs.map