@gearbox-protocol/ui-kit 3.11.2-next.1 → 3.12.0-next.1

package/dist/types/components/composites/index.d.ts

@@ -3,3 +3,4 @@ export * from './pool-assets-table';
 export * from './pool-credit-manager-info';
 export * from './pool-credit-managers-table';
 export * from './pool-table';
+export * from './strategies-table';

package/dist/types/components/composites/strategies-table/columns.d.ts

@@ -0,0 +1,50 @@
+import { LocaleKeys } from '../../../locale';
+import { TokenMetaInfo } from '../../../types/common';
+import { StrategyDTO, StrategyTableColumnDef } from './types';
+import type * as React from "react";
+interface ColumnHeaderOptions {
+    readonly header?: React.ReactNode;
+    readonly headerMessageId?: LocaleKeys;
+    /** Pass `null` to hide the default tip. */
+    readonly headerTip?: React.ReactNode | null;
+    readonly headerTipMessageId?: LocaleKeys;
+    readonly mobileTitle?: React.ReactNode;
+}
+/**
+ * Strategy name column — displays network, output token, strategy name, RWA tag
+ * and zero-slippage tag.
+ *
+ * Used by client-v3 strategy list through the app-local StrategiesTable proxy.
+ */
+export declare function strategyColumn<S extends StrategyDTO = StrategyDTO, T extends TokenMetaInfo = TokenMetaInfo, TSort extends string = string>(options?: ColumnHeaderOptions & {
+    readonly width?: string;
+    readonly mediumWidth?: string;
+    readonly sortField?: TSort;
+}): StrategyTableColumnDef<S, T, TSort>;
+/**
+ * Strategy rewards column — renders APR, points and rewards with the strategy
+ * rewards tooltip.
+ *
+ * Default sort field is `apy`; pass `sortField` when an app uses a different
+ * sort field name for the same column.
+ */
+export declare function strategyRewardsColumn<S extends StrategyDTO = StrategyDTO, T extends TokenMetaInfo = TokenMetaInfo, TSort extends string = string>(options?: ColumnHeaderOptions & {
+    readonly width?: string;
+    readonly mediumWidth?: string;
+    readonly sortField?: TSort;
+}): StrategyTableColumnDef<S, T, TSort>;
+/**
+ * Max leverage column — displays formatted strategy max leverage.
+ *
+ * Widths default to the legacy client-v3 desktop and medium table layout.
+ */
+export declare function strategyLeverageColumn<S extends StrategyDTO = StrategyDTO, T extends TokenMetaInfo = TokenMetaInfo, TSort extends string = string>(options?: ColumnHeaderOptions & {
+    readonly width?: string;
+    readonly mediumWidth?: string;
+}): StrategyTableColumnDef<S, T, TSort>;
+/**
+ * Generic custom strategy column — convenience helper to create a column with
+ * minimal boilerplate while preserving StrategiesTable DTO/context typing.
+ */
+export declare function customStrategyColumn<S extends StrategyDTO = StrategyDTO, T extends TokenMetaInfo = TokenMetaInfo, TSort extends string = string>(def: StrategyTableColumnDef<S, T, TSort>): StrategyTableColumnDef<S, T, TSort>;
+export {};

package/dist/types/components/composites/strategies-table/components/apy-feature/apy-feature.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { FeatureProps } from '../feature';
+export interface APYFeatureProps {
+    theme?: FeatureProps["theme"];
+}
+export declare function APYFeature({ theme, children, }: React.PropsWithChildren<APYFeatureProps>): import("react/jsx-runtime").JSX.Element;
+export interface APYFeatureTooltipProps {
+    title?: React.ReactNode;
+    value?: React.ReactNode;
+    tip?: React.ReactNode;
+    theme?: FeatureProps["theme"];
+}
+export declare function APYFeatureTooltip({ theme, title, value, tip, }: APYFeatureTooltipProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/composites/strategies-table/components/apy-feature/index.d.ts

@@ -0,0 +1 @@
+export * from './apy-feature';

package/dist/types/components/composites/strategies-table/components/cells/cells.d.ts

@@ -0,0 +1,38 @@
+import { StrategiesTableBonusApy, StrategiesTableTokenTitleSource } from '../../types/cells';
+import { StrategiesTableDebtReward, StrategiesTablePointsReward } from '../../types/points-reward';
+import { PointsFeatureProps } from '../points-feature';
+export interface ZeroSlippageFeatureProps {
+    token: StrategiesTableTokenTitleSource;
+    disabledStyle: boolean;
+}
+export declare function ZeroSlippageFeature({ token, disabledStyle, }: ZeroSlippageFeatureProps): import("react/jsx-runtime").JSX.Element;
+export interface RWAFeatureProps {
+    disabledStyle: boolean;
+}
+export declare function RWAFeature({ disabledStyle }: RWAFeatureProps): import("react/jsx-runtime").JSX.Element;
+export interface StrategiesRewardsCellProps {
+    maxAPY: number;
+    bonusAPY: StrategiesTableBonusApy | undefined;
+    rewards: ReadonlyArray<StrategiesTablePointsReward>;
+    rewardRates: readonly (bigint | "soon")[];
+    debtRewards: ReadonlyArray<StrategiesTableDebtReward>;
+    debtRewardRates: readonly (bigint | "soon")[];
+    hasAPY: boolean;
+    hasRewards: boolean;
+    hasDebtRewards: boolean;
+    disabledStyle: boolean;
+    apyLoading: boolean;
+    apyFormat?: "feature" | "featureless";
+}
+export declare function StrategiesRewardsCell({ maxAPY, bonusAPY, rewards, rewardRates, debtRewards, debtRewardRates, hasAPY, hasRewards, hasDebtRewards, disabledStyle, apyLoading, apyFormat, }: StrategiesRewardsCellProps): import("react/jsx-runtime").JSX.Element;
+export interface StrategyPointsProps {
+    rewards: ReadonlyArray<StrategiesTablePointsReward>;
+    rewardRates: readonly (bigint | "soon")[];
+    debtRewards: ReadonlyArray<StrategiesTableDebtReward>;
+    debtRewardRates: readonly (bigint | "soon")[];
+    hasRewards: boolean;
+    hasDebtRewards: boolean;
+    disabledStyle: boolean;
+    theme?: PointsFeatureProps["theme"];
+}
+export declare function StrategyPoints({ rewards, rewardRates, debtRewards, debtRewardRates, hasRewards, hasDebtRewards, disabledStyle, theme, }: StrategyPointsProps): (import("react/jsx-runtime").JSX.Element | import("react/jsx-runtime").JSX.Element[] | undefined)[];

package/dist/types/components/composites/strategies-table/components/cells/cells.styles.d.ts

@@ -0,0 +1,7 @@
+import { default as React, HTMLAttributes } from 'react';
+export interface DisabledWrapProps extends HTMLAttributes<HTMLDivElement> {
+    disabled?: boolean;
+}
+export declare const DisabledWrap: ({ disabled, className, ...props }: DisabledWrapProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Plus: ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>) => import("react/jsx-runtime").JSX.Element;
+export declare const TitleGrid: ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/composites/strategies-table/components/cells/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cells';
+export * from './cells.styles';

package/dist/types/components/composites/strategies-table/components/feature/feature.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { FeatureSize, FeatureTheme } from './feature.styles';
+export interface FeatureProps {
+    title: React.ReactNode;
+    value?: React.ReactNode;
+    tip?: React.ReactNode;
+    theme?: FeatureTheme;
+    size?: FeatureSize;
+    padding?: string;
+}
+export declare function Feature({ title, value, tip, theme, size, padding, }: FeatureProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/composites/strategies-table/components/feature/feature.styles.d.ts

@@ -0,0 +1,14 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+export type FeatureTheme = "empty" | "light" | "dark";
+export type FeatureSize = "sm" | "md";
+declare const featureRootVariants: (props?: ({
+    theme?: "dark" | "light" | "empty" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type FeatureRootVariants = VariantProps<typeof featureRootVariants>;
+export interface FeatureRootProps extends React.HTMLAttributes<HTMLDivElement>, FeatureRootVariants {
+    readonly padding?: string;
+}
+export declare const FeatureRoot: React.ForwardRefExoticComponent<FeatureRootProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/components/composites/strategies-table/components/feature/index.d.ts

@@ -0,0 +1,2 @@
+export * from './feature';
+export * from './feature.styles';

package/dist/types/components/composites/strategies-table/components/index.d.ts

@@ -0,0 +1,7 @@
+export * from './apy-feature';
+export * from './cells';
+export * from './feature';
+export * from './not-found-line';
+export * from './points-feature';
+export * from './rewards-tooltip';
+export * from './strategies-table';

package/dist/types/components/composites/strategies-table/components/not-found-line.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare function StrategiesTableNotFoundLine(): React.ReactElement;

package/dist/types/components/composites/strategies-table/components/points-feature/index.d.ts

@@ -0,0 +1 @@
+export * from './points-feature';

package/dist/types/components/composites/strategies-table/components/points-feature/points-feature.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { StrategiesTablePointsReward } from '../../types/points-reward';
+import { FeatureProps } from '../feature';
+export interface PointsFeatureProps {
+    reward: StrategiesTablePointsReward;
+    points: PointsValueProps["points"];
+    precision?: number;
+    theme?: FeatureProps["theme"];
+}
+export declare function PointsFeature({ reward, points, precision, theme, }: PointsFeatureProps): import("react/jsx-runtime").JSX.Element;
+export declare function PointsFeatureTooltip({ reward, points, precision, tip, theme, }: PointsFeatureProps & {
+    tip?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+interface PointsLabelProps {
+    reward: StrategiesTablePointsReward;
+}
+export declare function PointsLabel({ reward }: PointsLabelProps): import("react/jsx-runtime").JSX.Element;
+interface PointsValueProps {
+    points: bigint | "soon";
+    precision?: number;
+    startWith?: string;
+    endWith?: string;
+}
+export {};

package/dist/types/components/composites/strategies-table/components/rewards-tooltip/index.d.ts

@@ -0,0 +1,4 @@
+export * from './rewards-tooltip';
+export * from './rewards-tooltip-root';
+export * from './rewards-tooltip-view';
+export * from './tooltip-content';

package/dist/types/components/composites/strategies-table/components/rewards-tooltip/rewards-tooltip-root.d.ts

@@ -0,0 +1,17 @@
+import { VariantProps } from 'class-variance-authority';
+import { RewardsTooltipTheme } from '../../types/rewards-tooltip';
+declare const rewardsTooltipRootVariants: (props?: ({
+    theme?: "box" | "modal" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type RewardsTooltipRootVariants = VariantProps<typeof rewardsTooltipRootVariants>;
+export interface RewardsTooltipRootProps extends RewardsTooltipRootVariants {
+    readonly children: React.ReactNode;
+    readonly className?: string;
+    readonly theme?: RewardsTooltipTheme;
+}
+/**
+ * Root container for rewards tooltip: flex layout, padding, width (mobile-first),
+ * theme background, border, rounded, shadow.
+ */
+export declare const RewardsTooltipRoot: import('react').ForwardRefExoticComponent<RewardsTooltipRootProps & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/components/composites/strategies-table/components/rewards-tooltip/rewards-tooltip-view.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { RewardsTooltipContentProps } from './tooltip-content';
+export interface RewardsTooltipViewProps {
+    readonly children: React.ReactElement;
+    readonly handleTooltipChangeState: () => void;
+    readonly handleTooltipChange: (next: boolean) => void;
+    readonly open: boolean;
+    readonly props: Omit<RewardsTooltipContentProps, "onClose">;
+}
+export declare function RewardsTooltipView({ children, handleTooltipChangeState, handleTooltipChange, open, props, }: RewardsTooltipViewProps): React.ReactElement | null;

package/dist/types/components/composites/strategies-table/components/rewards-tooltip/rewards-tooltip.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { RewardsTooltipContentProps } from './tooltip-content';
+export interface RewardsTooltipProps extends Omit<RewardsTooltipContentProps, "onClose"> {
+    children: React.ReactElement;
+}
+export declare function RewardsTooltip({ children, ...props }: RewardsTooltipProps): import("react/jsx-runtime").JSX.Element;
+export declare function RewardsTooltipHover({ children, ...props }: RewardsTooltipProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/composites/strategies-table/components/rewards-tooltip/tooltip-content.d.ts

@@ -0,0 +1,14 @@
+import { Address } from 'viem';
+import { RewardsTooltipCellInfo, RewardsTooltipTheme, RewardsTooltipTokenMeta } from '../../types/rewards-tooltip';
+export interface RewardsTooltipContentProps {
+    cellInfo: RewardsTooltipCellInfo;
+    targetToken: Address;
+    apyList: Partial<Record<Address, number>> | undefined;
+    tokensList: Partial<Record<Address, RewardsTooltipTokenMeta>> | undefined;
+    strategyCreditManagers: Partial<Record<Address, {
+        readonly underlyingToken: Address;
+    }>>;
+    theme?: RewardsTooltipTheme;
+    onClose?: () => void;
+}
+export declare function RewardsTooltipContent({ cellInfo, targetToken, apyList: baseAPYList, tokensList, strategyCreditManagers, onClose, theme, }: RewardsTooltipContentProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/composites/strategies-table/components/strategies-table.d.ts

@@ -0,0 +1,35 @@
+import { TokenMetaInfo } from '../../../../types/common';
+import { StrategiesTableProps, StrategyDTO, StrategyTableRowDTO } from '../types';
+/**
+ * StrategiesTable — configurable strategy table constructor component.
+ *
+ * Accepts an array of column definitions (built-in + custom) and prebuilt row
+ * DTOs. Handles loading skeletons, error states, empty state, disabled rows,
+ * mobile layout, row click callbacks, stable test ids, and partial loading out
+ * of the box.
+ *
+ * @example
+ * ```tsx
+ * import {
+ *   StrategiesTable,
+ *   strategyColumn,
+ *   strategyRewardsColumn,
+ *   strategyLeverageColumn,
+ * } from "@gearbox-protocol/ui-kit";
+ *
+ * const columns = [
+ *   strategyColumn(),
+ *   strategyRewardsColumn(),
+ *   strategyLeverageColumn(),
+ * ];
+ *
+ * <StrategiesTable
+ *   columns={columns}
+ *   rows={rows}
+ *   loading={isLoading}
+ *   sort={sort}
+ *   onStrategyClick={row => track(row.strategy)}
+ * />
+ * ```
+ */
+export declare function StrategiesTable<S extends StrategyDTO = StrategyDTO, T extends TokenMetaInfo = TokenMetaInfo, TSort extends string = string, R extends StrategyTableRowDTO<S, T> = StrategyTableRowDTO<S, T>>({ columns, rows, loading, partialLoading, error, emptyContent, skeletonRows, rowHeight, size, mobileColumnsXs, mobileColumnsMd, className, wrapperClassName, sort, onStrategyClick, rootTestId, rowTestId, loaderTestId, }: StrategiesTableProps<S, T, TSort, R>): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/composites/strategies-table/index.d.ts

@@ -0,0 +1,3 @@
+export * from './columns';
+export * from './components';
+export type * from './types';

package/dist/types/components/composites/strategies-table/types/cells.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Bonus APY chip payload (`bonusAPY.value`) — structurally matches app `BonusAPYInfo`.
+ */
+export interface StrategiesTableBonusApy {
+    readonly value: number;
+}
+/** Minimal token shape for 0-slippage tooltip copy (display title only). */
+export type StrategiesTableTokenTitleSource = {
+    readonly title?: string;
+} | undefined;

package/dist/types/components/composites/strategies-table/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cells';
+export * from './points-reward';
+export * from './rewards-tooltip';
+export * from './table';

package/dist/types/components/composites/strategies-table/types/points-reward.d.ts

@@ -0,0 +1,11 @@
+import { DebtReward, PointsReward } from '@gearbox-protocol/sdk/rewards';
+/**
+ * SDK points / debt rewards used across strategies-table composites.
+ *
+ * Use `string` as the reward-kind parameter — matches Gearbox app conventions
+ * (`PointsReward<string>`, `DebtReward<string>`).
+ */
+export type StrategiesTablePointsReward = PointsReward<string>;
+export type StrategiesTableDebtReward = DebtReward<string>;
+export type RewardsTooltipPointsReward = StrategiesTablePointsReward;
+export type RewardsTooltipDebtReward = StrategiesTableDebtReward;

package/dist/types/components/composites/strategies-table/types/rewards-tooltip.d.ts

@@ -0,0 +1,53 @@
+import { NetworkApyData } from '@gearbox-protocol/sdk/plugins/apy';
+import { Address } from 'viem';
+import { StrategiesTableDebtReward, StrategiesTablePointsReward } from './points-reward';
+/** Background variant for {@link RewardsTooltipRoot}. */
+export type RewardsTooltipTheme = "modal" | "box";
+/**
+ * Credit manager fields consumed by the tooltip (borrow rate label, extra-collateral lookup).
+ * Not replaced by a single SDK human/state type: call sites use app legacy CM shapes.
+ */
+export interface RewardsTooltipCreditManager {
+    readonly chainId: number;
+    readonly pool: Address;
+    readonly underlyingToken: Address;
+    readonly baseBorrowRate: number;
+}
+/** Matches Strategy "bonus APY" payloads passed from apps (`bonusAPY.value`). */
+export interface RewardsTooltipBonusApy {
+    readonly value: number;
+}
+/** Per-chain APY snapshot from the SDK (`apySnapshot.apy`); tooltip only reads `extraCollateralAPYList`. */
+export type RewardsTooltipApyListByNetwork = Partial<Record<number, NetworkApyData | undefined>> | undefined;
+/**
+ * Domain-neutral cell payload for the rewards tooltip body (`RewardsTooltipContent`).
+ *
+ * Call sites may pass richer hook results as long as required fields match
+ * (structural typing).
+ */
+export interface RewardsTooltipCellInfo {
+    readonly maxAPY: number;
+    readonly minCreditManager: RewardsTooltipCreditManager | undefined;
+    readonly bonusAPY: RewardsTooltipBonusApy | undefined;
+    readonly rewards: readonly StrategiesTablePointsReward[];
+    readonly debtRewards: readonly StrategiesTableDebtReward[];
+    readonly rewardRates: readonly (bigint | "soon")[];
+    readonly debtRewardRates: readonly (bigint | "soon")[];
+    readonly apyLoading: boolean;
+    readonly hasPoints: boolean;
+    readonly isPointsWithAPY: boolean;
+    readonly hasAPY?: boolean;
+    readonly maxLeverage: bigint;
+    readonly apyListByNetwork: RewardsTooltipApyListByNetwork;
+    readonly quotaRate: bigint;
+    /**
+     * Present on some call sites that reuse hook-shaped objects; the tooltip body
+     * does not read these fields.
+     */
+    readonly hasRewards?: boolean;
+    readonly hasDebtRewards?: boolean;
+}
+/** Minimal token row used to resolve borrow-label symbols in tips. */
+export interface RewardsTooltipTokenMeta {
+    readonly title?: string;
+}

package/dist/types/components/composites/strategies-table/types/table.d.ts

@@ -0,0 +1,99 @@
+import { Address } from 'viem';
+import { TokenMetaInfo } from '../../../../types/common';
+import { RewardsTooltipCellInfo } from './rewards-tooltip';
+import type * as React from "react";
+export type StrategiesTableSortFields = "strategyName" | "apy";
+type StrategiesTableSortDirection = "desc" | "asc";
+export interface StrategiesTableSort<S extends string = StrategiesTableSortFields> {
+    readonly state: {
+        readonly field: S | string;
+        readonly sort: StrategiesTableSortDirection;
+    } | null;
+    readonly set: (field: S, startFromSort?: StrategiesTableSortDirection) => void;
+}
+export interface StrategyDTO {
+    readonly chainId: number;
+    readonly id: string;
+    readonly tokenOutAddress: Address;
+    readonly name: string;
+    readonly network: string | undefined;
+    readonly strategyMarketType?: readonly string[];
+}
+export interface StrategyTableDelayedConfig {
+    readonly withdrawalPhantomToken: Address;
+}
+export interface StrategyTableCreditManager {
+    readonly underlyingToken: Address;
+}
+export interface StrategyTableRowDTO<S extends StrategyDTO = StrategyDTO, T extends TokenMetaInfo = TokenMetaInfo> {
+    readonly strategy: S;
+    readonly href?: string;
+    readonly maxLeverage: bigint;
+    readonly tokensList: Partial<Record<Address, T>> | undefined;
+    readonly apyList: Partial<Record<Address, number>> | undefined;
+    readonly strategyCreditManagers: Partial<Record<Address, StrategyTableCreditManager>>;
+    readonly disabled?: boolean;
+    readonly disabledStyle?: boolean;
+    readonly disabledTooltip?: React.ReactNode;
+    readonly rewardsCellInfo: RewardsTooltipCellInfo;
+    readonly zeroSlippageTokens: Partial<Record<Address, boolean>> | undefined;
+    readonly delayedConfigs: ReadonlyArray<StrategyTableDelayedConfig> | undefined;
+    readonly loading?: boolean;
+}
+export type StrategyTableRow = StrategyTableRowDTO;
+export interface StrategyTableCellContext<S extends StrategyDTO = StrategyDTO, T extends TokenMetaInfo = TokenMetaInfo> {
+    readonly row: StrategyTableRowDTO<S, T>;
+    readonly strategy: S;
+    readonly tokensList: Partial<Record<Address, T>> | undefined;
+    readonly targetToken: T | undefined;
+    readonly targetTokenAddress: Address;
+    readonly rewardsCellInfo: RewardsTooltipCellInfo;
+    readonly isMobile: boolean;
+    readonly isDesktop: boolean;
+}
+export interface StrategyTableColumnSortDef<S extends string = string> {
+    readonly field: S;
+    readonly defaultDirection?: StrategiesTableSortDirection;
+}
+export interface StrategyTableColumnSortState {
+    readonly direction: StrategiesTableSortDirection | null;
+    readonly onSort: () => void;
+}
+export interface StrategyTableColumnDef<S extends StrategyDTO = StrategyDTO, T extends TokenMetaInfo = TokenMetaInfo, TSort extends string = string> {
+    readonly id: string;
+    readonly header: React.ReactNode | ((sort: StrategyTableColumnSortState | undefined) => React.ReactNode);
+    readonly headerTip?: React.ReactNode;
+    readonly headerClassName?: string;
+    readonly cell: (ctx: StrategyTableCellContext<S, T>) => React.ReactNode;
+    readonly mobileCell?: (ctx: StrategyTableCellContext<S, T>) => React.ReactNode;
+    readonly mobileTitle?: React.ReactNode;
+    readonly hideOnMobile?: boolean;
+    readonly width?: string;
+    readonly mediumWidth?: string;
+    readonly align?: "left" | "right" | "center";
+    readonly gapBefore?: "sm" | "md" | "none";
+    readonly sort?: StrategyTableColumnSortDef<TSort>;
+    readonly hideOnMedium?: boolean;
+    readonly className?: string;
+}
+export interface StrategiesTableProps<S extends StrategyDTO = StrategyDTO, T extends TokenMetaInfo = TokenMetaInfo, TSort extends string = string, R extends StrategyTableRowDTO<S, T> = StrategyTableRowDTO<S, T>> {
+    readonly columns: ReadonlyArray<StrategyTableColumnDef<S, T, TSort>>;
+    readonly rows: ReadonlyArray<R> | null | undefined;
+    readonly loading?: boolean;
+    readonly partialLoading?: boolean;
+    readonly error?: Error | null;
+    readonly emptyContent?: React.ReactNode;
+    readonly skeletonRows?: number;
+    readonly rowHeight?: number;
+    readonly size?: "sm" | "default" | "lg";
+    readonly mobileColumnsXs?: number;
+    readonly mobileColumnsMd?: number;
+    readonly className?: string;
+    readonly wrapperClassName?: string;
+    readonly sort?: StrategiesTableSort<TSort>;
+    readonly onStrategyClick?: (row: R) => void;
+    readonly rootTestId?: string;
+    readonly rowTestId?: string;
+    readonly loaderTestId?: string;
+}
+export {};

package/dist/types/locale/en.json.d.ts

@@ -122,7 +122,33 @@ declare const _default: {
   "components.poolTable.notFound.list": "No Markets found",
   "components.poolTable.notFound.description.dashboard": "Choose earn above.",
   "components.poolTable.notFound.description.list": "Choose another chain or toggle Show All Markets",
-  "components.poolTable.externalApy.tooltipShort": "{value} APY boost when depositing via {name}"
+  "components.poolTable.externalApy.tooltipShort": "{value} APY boost when depositing via {name}",
+
+  "components.rewardsTooltip.without.title": "Without Leverage",
+  "components.rewardsTooltip.without.extra": "Extra APY",
+  "components.rewardsTooltip.without.extra.tip": "Any deposit through Gearbox",
+  "components.rewardsTooltip.with.title": "With {leverage} Leverage",
+  "components.rewardsTooltip.with.borrowRate": "{symbol} borrow rate",
+  "components.rewardsTooltip.with.quotaRate": "Quota rate",
+  "components.rewardsTooltip.with.bonusAPY.title": "Target Bonuses Yield",
+  "components.rewardsTooltip.with.bonusAPY.tip": "Expected Bonuses APY is calculated by the Asset Issuer and represents the expected value to be paid out in points.",
+  "components.rewardsTooltip.with.extra": "+ Extra APR",
+  "components.rewardsTooltip.button": "Click to show rewards details",
+
+  "components.strategiesTable.head.name": "Strategy",
+  "components.strategiesTable.head.rewards": "Rewards",
+  "components.strategiesTable.head.leverage": "Max Leverage",
+  "components.strategiesTable.head.earn": "You Can Earn",
+  "components.strategiesTable.body.notFound": "No strategy found",
+  "components.strategiesTable.line.disabled": "This strategy is currently not available, cause of lack or quota or liquidity. Please contact us on Discord, and we’ll assist you.",
+  "components.strategiesTable.line.name.disabled": "This strategy is currently not available",
+  "components.strategiesTable.line.points.tip": "For debt nominated in {symbol}",
+  "components.strategiesTable.line.points.tipAny": "For debt",
+
+  "components.strategiesTable.line.0slippage": "0-slippage",
+  "components.strategiesTable.line.0slippage.tip": "Wrapping/unwrapping happens directly through smart-contracts, so {symbol} deposits and withdrawals don't incur slippage.",
+  "components.strategiesTable.line.rwa": "RWA",
+  "components.strategiesTable.line.rwa.tip": "This strategy is available on RWA market."
 }
 ;
 

package/dist/types/test-ids/index.d.ts

@@ -10,3 +10,4 @@ export * from './pool-credit-manager-info';
 export * from './pool-credit-managers-table';
 export * from './pool-table';
 export * from './smart-number-input';
+export * from './strategies-table';

package/dist/types/test-ids/strategies-table.d.ts

@@ -0,0 +1,5 @@
+export declare const strategiesTableTestIds: {
+    readonly root: "strategies-table";
+    readonly activeLine: "strategies-table-active-line";
+    readonly activeLineLoading: "strategies-table-active-line-loading";
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/ui-kit",
-  "version": "3.11.2-next.1",
+  "version": "3.12.0-next.1",
   "description": "Internal UI components",
   "repository": "https://github.com/gearbox-protocol/ui-kit",
   "license": "MIT",