/// <reference types="react" />
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as react from 'react';
import react__default, { ReactNode, ComponentProps, ChangeEvent } from 'react';
import { LottieComponentProps } from 'lottie-react';
import * as motion_react from 'motion/react';
import { motion } from 'motion/react';
import { Config } from 'tailwindcss';
import { ClassValue } from 'clsx';

type TextSize = "small" | "medium" | "large";
type SwitchSize = "small" | "large";
type ButtonVariant = "primary" | "secondary" | "tertiary";
type ButtonSize = "sm" | "md" | "lg";
type SwapDirection = "from" | "to";
type HistoryItemStatus = "completed" | "pending" | "failed" | "warning";
type DescriptionBlock = {
    type: "string";
    value: string;
} | {
    type: "image";
    value: string;
    rounded?: boolean;
};
interface SwapStep {
    descriptionBlocks: DescriptionBlock[];
    link?: string;
    status: ActionStatus;
}
declare enum SwapState {
    CONFIRM = 0,
    PROGRESS = 1,
    COMPLETED = 2,
    ERROR = 3,
    PARTIAL_SUCCESS = 4,
    CONFIRMATION_TOO_LONG = 5,
    CONFIRMATION_REJECTED = 6,
    NEEDS_GAS = 7
}
type ThemeType = "light" | "dark";
type ActionStatus = "pending" | "waiting" | "ongoing" | "executed" | "success" | "error" | "warning" | "refunded" | "troubleshoot";
type TransactionStateVariant = "full" | "compact" | "small";
type TransactionType = "swap" | "buy_nft" | "interaction" | "bridge";
type TokenPairVariant = "horizontal" | "vertical";
type TokenPairSize = "small" | "medium";
type ImageSize = "small" | "medium" | "large" | "xlarge" | "xxlarge";
type ImageRoundedSize = "xxs" | "xs" | "s" | "m" | "l" | "xl" | "xxl" | "full" | "none";
type ImageBorder = "none" | "inset" | "outline-sm" | "outline-lg";
type ChainTypeFilter = "source" | "destination";
type AssetsButtonVariant = "primary" | "accent";
type PropertyListItemSize = "small" | "large";
type DropdownPosition = "top" | "bottom" | "center";

declare enum ImageState {
    LOADING = 0,
    LOADED = 1,
    ERROR = 2
}
interface ImageProps extends React.ComponentProps<"img"> {
    src?: string;
    children?: React.ReactNode;
    size?: ImageSize;
    className?: string;
    placeholderImageUrl?: string;
    border?: ImageBorder;
    rounded?: ImageRoundedSize;
    shadow?: boolean;
    containerProps?: React.ComponentProps<"div">;
}
declare function Image({ src, size, className: propsClassName, placeholderImageUrl, border, rounded, shadow, children, containerProps, ...props }: ImageProps): react_jsx_runtime.JSX.Element;

interface BadgeImageProps {
    badge?: ImageProps;
    image?: ImageProps;
    extraMarginForBadge?: boolean;
    className?: string;
}
declare function BadgeImage({ image, badge, extraMarginForBadge, className, }: BadgeImageProps): false | react_jsx_runtime.JSX.Element;

interface DripProps {
    direction?: "horizontal" | "vertical";
    to: {
        logoURI: string;
        bgColor: string;
    };
    from: {
        logoURI: string;
        bgColor: string;
    };
}
declare const Drip: ({ direction, from, to }: DripProps) => react_jsx_runtime.JSX.Element;

interface IconLabelProps {
    src?: string;
    children?: ReactNode;
    rounded?: ImageRoundedSize;
}
declare function IconLabel({ src, children, rounded }: IconLabelProps): react_jsx_runtime.JSX.Element;

type ImageGroupSize = "small" | "large";
interface ImageGroupProps {
    imageUrls: string[];
    badge?: Omit<ImageProps, "border" | "size">;
    size?: ImageGroupSize;
}
declare function ImageGroup({ imageUrls, badge, size, }: ImageGroupProps): react_jsx_runtime.JSX.Element;

declare const LoadingProvider: react.Provider<boolean | null>;
interface LoadingSkeletonProps {
    className?: string;
    height?: string;
    isLoading?: boolean;
    children?: React.ReactNode;
    width?: string;
}
declare function LoadingSkeleton({ className, height, isLoading: isLoadingProp, children, width, }: LoadingSkeletonProps): string | number | true | Iterable<react.ReactNode> | react_jsx_runtime.JSX.Element;
interface LoadingTextProps$1 extends ComponentProps<"span"> {
    width?: string | [string, string];
    isLoading?: boolean;
    showGradient?: boolean;
}
declare function TextSkeleton({ className, width, children, isLoading, showGradient, ...props }: LoadingTextProps$1): string | number | boolean | Iterable<react.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
interface LoadingBlockProps extends ComponentProps<"div"> {
    isLoading?: boolean;
}
declare function BlockSkeleton({ isLoading, className, children, ...props }: LoadingBlockProps): string | number | boolean | Iterable<react.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;

interface PriceChangeProps {
    variant?: "small" | "large";
    value: string | number;
    highlightText?: boolean;
    triangle?: "none" | "prefix" | "suffix";
}
declare function PriceChange({ value: rawValue, variant, highlightText, triangle, }: PriceChangeProps): react_jsx_runtime.JSX.Element;

declare const statusTextClassMap: Record<ActionStatus, string>;
interface TransactionStateProps extends React.HTMLAttributes<HTMLDivElement> {
    status: ActionStatus;
    variant?: TransactionStateVariant;
    icon?: ReactNode;
}
declare function TransactionState({ status, variant, icon, ...props }: TransactionStateProps): react_jsx_runtime.JSX.Element;

interface UsdAmountProps {
    usdAmount: string;
}
declare function UsdAmount({ usdAmount }: UsdAmountProps): react_jsx_runtime.JSX.Element;

interface WalletLinkProps {
    imageURI: string;
    address: string;
}
declare function WalletLink({ imageURI, address }: WalletLinkProps): react_jsx_runtime.JSX.Element;

interface AccountsButtonProps extends React.ComponentProps<"button"> {
    imageUrls: string[];
}
declare function AccountsButton({ imageUrls, ...props }: AccountsButtonProps): react_jsx_runtime.JSX.Element;

interface AddressButtonProps extends React.HTMLAttributes<HTMLButtonElement> {
    label: string;
    imageUrl?: string;
    badgeUrl?: string;
    isLoading?: boolean;
}
declare function AddressButton({ label, imageUrl, badgeUrl, isLoading, ...props }: AddressButtonProps): react_jsx_runtime.JSX.Element;

interface ArrowButtonProps extends React.HTMLAttributes<HTMLButtonElement> {
    label: string;
    disabled?: boolean;
}
declare function ArrowButton({ label, disabled, ...props }: ArrowButtonProps): react_jsx_runtime.JSX.Element;

interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
    placeholder?: string;
    showIcon?: boolean;
    icon?: React.ReactNode;
    isError?: boolean;
    isWarning?: boolean;
    containerClassName?: string;
    actionButtonProps?: InputActionButtonProps;
    autoFocusTimeout?: number;
    inputRef?: React.RefObject<HTMLInputElement>;
}
declare function Input({ placeholder, showIcon, className, icon, isError, isWarning, containerClassName, actionButtonProps, autoFocusTimeout, inputRef: inputRefProp, ...props }: InputProps): react_jsx_runtime.JSX.Element;
interface InputActionButtonProps {
    onClick?: () => void;
    variant?: ButtonVariant;
    label?: string;
}

declare enum UserInputType {
    TOKEN = 0,
    USD = 1
}
interface UseNumericInputOptions {
    token: Pick<Token$4, "decimals" | "price">;
    onAmountChange: (tokenAmount: string) => void;
    forcedAmount?: string;
    formatIfVerySmall: {
        token: string;
        usd: string;
    };
    balance: string;
    inputModeButton?: {
        amountUsd?: string;
    };
    maxUsdDecimals?: number;
    debounceInput?: boolean;
    direction?: "from" | "to";
    initialInputMode?: UserInputType;
}
declare function useNumericInput({ onAmountChange, token, balance, debounceInput, forcedAmount, formatIfVerySmall, inputModeButton, maxUsdDecimals, direction, initialInputMode, }: UseNumericInputOptions): {
    userInputType: UserInputType;
    inputValue: string;
    handleInputChange: (e: ChangeEvent<HTMLInputElement>) => void;
    handleSwitchInputMode: () => void;
    isTokenAmountVerySmall: boolean;
    isUsdAmountVerySmall: boolean;
    amountFormatted: string;
    onBalanceButtonClick: () => void;
    balanceFormatted: string;
};

type TooltipWidth = "max" | "container";
type TooltipThreshold = "xxs" | "xs" | "s" | "m" | "l" | "xl" | "xxl";
interface TooltipProps {
    children: react__default.ReactNode;
    tooltipContent?: react__default.ReactNode;
    threshold?: TooltipThreshold;
    tooltipWidth?: TooltipWidth;
    containerClassName?: string;
    childrenClassName?: string;
    tooltipClassName?: string;
    displayDelayMs?: number;
    containerRef?: react__default.RefObject<HTMLElement>;
    containerProps?: react__default.ComponentProps<"div">;
    showOnMobile?: boolean;
}
declare function Tooltip(props: TooltipProps): react_jsx_runtime.JSX.Element;

interface Token$4 {
    price: number;
    symbol: string;
    decimals: number;
}
interface NumericInputProps {
    token: Token$4;
    onAmountChange: (tokenAmount: string) => void;
    forcedAmount?: string;
    formatIfVerySmall?: {
        token: string;
        usd: string;
    };
    balance?: string;
    inputModeButton?: {
        usdModeTooltip?: Omit<TooltipProps, "children">;
        tokenModeTooltip?: Omit<TooltipProps, "children">;
        amountUsd?: string;
    };
    maxUsdDecimals?: number;
    balanceButton?: {
        tooltip?: Omit<TooltipProps, "children">;
        hideMaxChip?: boolean;
    };
    debounceInput?: boolean;
    initialInputMode?: UserInputType;
    customSymbol?: string;
    hideControls?: boolean;
    hideBalance?: boolean;
    containerClassName?: string;
    inputClassName?: string;
}
interface Props$2 extends NumericInputProps, React.InputHTMLAttributes<HTMLInputElement> {
    direction?: SwapDirection;
    showDetails?: boolean;
    isLoading?: boolean;
    isInteractive?: boolean;
    priceImpactPercentage?: string;
    criticalPriceImpactPercentage?: number;
    error?: {
        message: string;
    };
}
declare function NumericInput({ priceImpactPercentage, balance, error, criticalPriceImpactPercentage, token, onAmountChange, forcedAmount, maxUsdDecimals, formatIfVerySmall, showDetails, isLoading, direction, inputModeButton, isInteractive, balanceButton, debounceInput, initialInputMode, customSymbol, hideControls, hideBalance, containerClassName, inputClassName, ...props }: Props$2): react_jsx_runtime.JSX.Element;

declare function LargeNumericInput({ balance, token, onAmountChange, forcedAmount, maxUsdDecimals, formatIfVerySmall, inputModeButton, balanceButton, debounceInput, }: NumericInputProps): react_jsx_runtime.JSX.Element;

interface RangeInputProps {
    label: string;
    initialValue?: string;
    onChange?: (value: string) => void;
    min?: number;
    max?: number;
    isWarning?: boolean;
}
declare function RangeInput({ label, initialValue, onChange, min, max, isWarning, }: RangeInputProps): react_jsx_runtime.JSX.Element;

interface SettingsSliderProps {
    value: number | undefined;
    type: "percentage" | "amount";
    onChange?: (value: number | undefined) => void;
    decimalsFormat?: number;
    min?: number;
    max?: number;
    isSelected?: boolean;
}
declare function SettingsSlider({ value, type, onChange, decimalsFormat, max, min, isSelected, }: SettingsSliderProps): react_jsx_runtime.JSX.Element;

interface SwitchProps {
    checked?: boolean;
    onChange?: (checked: boolean) => void;
    size: SwitchSize;
    disabled?: boolean;
    inputProps?: React.ComponentProps<"input">;
}
declare function Switch({ checked, onChange, size, disabled, inputProps, }: SwitchProps): react_jsx_runtime.JSX.Element;

interface AssetsButtonProps {
    token?: {
        iconUrl: string;
        fallbackIconUrl?: string;
        symbol: string;
        bgColor: string;
        textColor: string;
    };
    chain?: {
        iconUrl: string;
        bgColor: string;
    };
    onClick?: () => void;
    variant?: AssetsButtonVariant;
    isLoading?: boolean;
    tooltip?: Omit<TooltipProps, "children">;
    emptyTokenLabel?: string;
    showWarning?: boolean;
}
declare function AssetsButton({ chain, token, onClick, variant, isLoading, tooltip, emptyTokenLabel, showWarning, }: AssetsButtonProps): react_jsx_runtime.JSX.Element;

interface ChipProps extends React.HTMLAttributes<HTMLDivElement | HTMLButtonElement> {
    label?: string;
    icon?: React.ReactNode;
}
declare function Chip({ label, icon, ...props }: ChipProps): react_jsx_runtime.JSX.Element;

interface ButtonProps extends React.HTMLAttributes<HTMLButtonElement> {
    label?: string;
    icon?: React.ReactNode;
    variant: ButtonVariant;
    size: ButtonSize;
    disabled?: boolean;
    link?: string;
    isLoading?: boolean;
    isShimmering?: boolean;
    showLoader?: boolean;
    loaderSize?: LoaderSize;
    chip?: ChipProps;
    containerClassName?: string;
    buttonRef?: React.Ref<HTMLButtonElement>;
    anchorRef?: React.Ref<HTMLAnchorElement>;
}
type LoaderSize = "sm" | "md" | "lg";
declare const buttonRoundedClassMap: Record<ButtonSize, Record<ButtonVariant, string>>;
declare function Button({ label, disabled, size, variant, icon, link, isLoading, isShimmering, showLoader, loaderSize, chip, containerClassName, anchorRef, buttonRef, ...props }: ButtonProps): react_jsx_runtime.JSX.Element;

interface FeeButtonProps extends React.HTMLAttributes<HTMLButtonElement> {
    feeInUsd?: string;
    chipLabel?: string;
    tooltip?: Omit<TooltipProps, "children">;
}
declare function FeeButton({ feeInUsd, chipLabel, className, tooltip, ...props }: FeeButtonProps): react_jsx_runtime.JSX.Element;

interface FilterButtonProps {
    selected: boolean;
    numApplied?: number;
    onClick?: () => void;
}
declare function FilterButton({ selected, numApplied, onClick, }: FilterButtonProps): react_jsx_runtime.JSX.Element;

interface IconButtonProps extends React.ComponentProps<"button"> {
    icon: React.ReactNode;
}
declare const IconButton: react.ForwardRefExoticComponent<Omit<IconButtonProps, "ref"> & react.RefAttributes<HTMLButtonElement>>;

interface SettingsButtonProps {
    label: string;
    isSelected?: boolean;
    onClick?: () => void;
}
declare function SettingsButton({ label, isSelected, onClick, }: SettingsButtonProps): react_jsx_runtime.JSX.Element;

interface TokenOnlyButtonProps {
    token?: {
        iconUrl: string;
        fallbackIconUrl?: string;
        symbol: string;
        bgColor: string;
        textColor: string;
    };
    onClick?: () => void;
    variant?: AssetsButtonVariant;
    isLoading?: boolean;
    tooltip?: Omit<TooltipProps, "children">;
    emptyTokenLabel?: string;
}
declare function TokenOnlyButton({ token, onClick, variant, isLoading, tooltip, emptyTokenLabel, }: TokenOnlyButtonProps): react_jsx_runtime.JSX.Element;

interface AnimateNumberProps {
    number: string;
    showMask?: boolean;
    className?: string;
    isLoading?: boolean;
}
declare function AnimateNumber({ isLoading, number, showMask, className, }: AnimateNumberProps): react_jsx_runtime.JSX.Element;

interface LoadingTextProps extends React.HTMLAttributes<HTMLSpanElement> {
    variant?: ButtonVariant;
}
declare function LoadingText({ children, className, ...props }: LoadingTextProps): react_jsx_runtime.JSX.Element;

declare function Approve(): react_jsx_runtime.JSX.Element;

declare function ArrowRightIcon(): react_jsx_runtime.JSX.Element;
declare function ArrowRightDownIcon({ size, className, strokeWidth, }: {
    size?: string;
    className?: string;
    strokeWidth?: string;
}): react_jsx_runtime.JSX.Element;
declare function ArrowRightUpIcon({ size, className, strokeWidth, }: {
    size?: string;
    className?: string;
    strokeWidth?: string;
}): react_jsx_runtime.JSX.Element;
declare function ChevronArrowIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ArrowTriangle({ className }: {
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function PauseIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ChevronTopSmallIcon(): react_jsx_runtime.JSX.Element;
declare function ChevronLargeDownIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ChevronTopIcon(props: ComponentProps<"svg">): react_jsx_runtime.JSX.Element;
declare function ChevronLargeRightIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ChevronRightIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function ChevronRightSmallIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function ArrowLeftIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function ArrowRightUpCircleIcon(): react_jsx_runtime.JSX.Element;
declare function ArrowRightUpCircleFilledIcon({ className, }: {
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ArrowRightDownCircleIcon(): react_jsx_runtime.JSX.Element;
declare function ArrowOutOfBoxIcon(): react_jsx_runtime.JSX.Element;
declare function ChevronGrabberVerticalIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function SquareArrowTopRightIcon({ className, size, strokeWidth, }: {
    className?: string;
    size?: string;
    strokeWidth?: string;
}): react_jsx_runtime.JSX.Element;
declare function SquareArrowTopRight2Icon({ className, size, strokeWidth, }: {
    className?: string;
    size?: string;
    strokeWidth?: string;
}): react_jsx_runtime.JSX.Element;
declare function SquareArrowTopLeftIcon({ size }: {
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function ArrowBottomTopIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function ArrowWallDownIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function ReorderIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ArrowsSwapIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ArrowUpIcon(): react_jsx_runtime.JSX.Element;
declare function ArrowCornerDownRightIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ChevronDownSmallIcon({ size, strokeWidth, className, }: {
    size?: string;
    strokeWidth?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ArrowDownIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ArrowSplit({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function ArrowRotate(): react_jsx_runtime.JSX.Element;

declare function PunkIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;

declare function ShoppingBagIcon(): react_jsx_runtime.JSX.Element;
declare function BackpackIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function BankIcon(): react_jsx_runtime.JSX.Element;

declare function BoostBadge(): react_jsx_runtime.JSX.Element;

declare function Calendar(): react_jsx_runtime.JSX.Element;

declare function ChainLink({ size, strokeWidth, }: {
    size?: string;
    strokeWidth?: string;
}): react_jsx_runtime.JSX.Element;

declare function Checkmark1Icon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function Checkmark2Icon({ className, size, style, }: {
    className?: string;
    size?: string;
    style?: React.CSSProperties;
}): react_jsx_runtime.JSX.Element;

declare function ClockSolidIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function ClockOutlineIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare const SettingsGearIcon: ({ size, className, }: {
    className?: string;
    size?: string;
}) => react_jsx_runtime.JSX.Element;
declare const ExplosionIcon: ({ size, className, }: {
    className?: string;
    size?: string;
}) => react_jsx_runtime.JSX.Element;
declare function TimeFliesIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function TimeFliesSolidIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function CoinsIcon(): react_jsx_runtime.JSX.Element;
declare function CoinsAddIcon(): react_jsx_runtime.JSX.Element;
declare function DollarOutlinedIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function StocksIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function DollarSolidIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function CollectionIcon(): react_jsx_runtime.JSX.Element;

declare function CompassRoundOutlinedIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CompassRoundSolidIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CircleX({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CircleMinusIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CirclePlusIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CircleXFilledIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function TranslateIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function PowerIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function CrossAnimatedIcon({ size, isOpen, transitionDuration, className, }: {
    size?: number;
    isOpen?: boolean;
    transitionDuration?: React.CSSProperties["transitionDuration"];
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function DashboardFast({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

interface DockIconProps {
    isSelected?: boolean;
}
declare function DockIconSwap({ isSelected }: DockIconProps): react_jsx_runtime.JSX.Element;
declare function DockIconCheckout({ isSelected }: DockIconProps): react_jsx_runtime.JSX.Element;
declare function DockIconScan({ isSelected }: DockIconProps): react_jsx_runtime.JSX.Element;
declare function DockIconAnalytics({ isSelected }: DockIconProps): react_jsx_runtime.JSX.Element;
declare function DockIconProfile({ isSelected }: DockIconProps): react_jsx_runtime.JSX.Element;
declare function DockIconHelp({ isSelected }: DockIconProps): react_jsx_runtime.JSX.Element;

declare function DotGrid1x3HorizontalIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;

declare function EmojiSadIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function EmojiMeh({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function SmileIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function EthereumIcon(): react_jsx_runtime.JSX.Element;

declare function FavouriteFilterIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function FilterIcon(): react_jsx_runtime.JSX.Element;

declare function GhostIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function GhostCircleIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function SettingsSliderIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function EyeOpenIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function BellAlarmIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function LimitIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function PoopIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CatSquareIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function FilterAscendingIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ImageIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function FilterTimelineIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function NewspaperIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function AtomIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function SunriseSmallIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function CoinsOutlinedIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function PhoneIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function LaptopIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CopyOutlinedIcon({ size, strokeWidth, className, }: {
    size?: string;
    className?: string;
    strokeWidth?: string;
}): react_jsx_runtime.JSX.Element;
declare function Copy2Icon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function FileDownloadIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CodeSolidSquareIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CodeBracketsIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CommandIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function NewsIcon({ className }: {
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CelebrateIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function SmileFilledIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function StarLinesIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function QrCodeIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ArrowExpandIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function MoneyBagIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function PluginIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CircleCheckIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;

declare function EmptyHeartIcon({ className }: {
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function FilledHeartIcon({ className }: {
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function BrokenHeartIcon({ className }: {
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function HeartSmallIcon(): react_jsx_runtime.JSX.Element;

declare function HelpIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function GasIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ReceiptBillIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function SnapIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function HomeIcon({ className }: {
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function MenuSwapIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ColorPaletteIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function ConsoleIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function BubblesIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function ImageSparkle(): react_jsx_runtime.JSX.Element;

declare function InfinityIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function LinkIcon(props: ComponentProps<"svg">): react_jsx_runtime.JSX.Element;

interface LoaderProps extends ComponentProps<"svg"> {
    size?: string;
    strokeWidth?: string;
    rotateDuration?: string;
}
declare function Loader({ size, strokeWidth, className, rotateDuration, ...props }: LoaderProps): react_jsx_runtime.JSX.Element;

declare function MarketCapIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function HighestPriceRangeIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function MaxIcon(): react_jsx_runtime.JSX.Element;

declare function NotAllowedIcon({ size }: {
    size?: string;
}): react_jsx_runtime.JSX.Element;

declare function GooglePayIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function ApplePayIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function CreditCardIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;

declare function PercentIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function PathSquareIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function PieChartIcon(): react_jsx_runtime.JSX.Element;

declare function PlusIcon({ className, size, strokeWidth, }: {
    className?: string;
    size?: string;
    strokeWidth?: string;
}): react_jsx_runtime.JSX.Element;

declare function RefreshIcon(): react_jsx_runtime.JSX.Element;

declare function SearchIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;

declare function XSocialIcon({ className, size, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function GithubIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function DiscordIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function MirrorIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function FarcasterIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function TelegramIcon({ className, size, }: {
    className?: string;
    size?: string;
}): react_jsx_runtime.JSX.Element;

declare function SortIcon(): react_jsx_runtime.JSX.Element;

declare function SparklesIcon(): react_jsx_runtime.JSX.Element;
declare function SparkleIcon(): react_jsx_runtime.JSX.Element;

declare function SquareArrowCenter(): react_jsx_runtime.JSX.Element;

declare function DockSwapIcon(): react_jsx_runtime.JSX.Element;

declare function SquidLogo({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function SwapInputsIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function SwapIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function SwapSuccessIcon(): react_jsx_runtime.JSX.Element;
declare function SwapErrorIcon(): react_jsx_runtime.JSX.Element;
declare function SwapWarningIcon(): react_jsx_runtime.JSX.Element;

declare function SwapStepSeparator(): react_jsx_runtime.JSX.Element;

declare function TagIcon({ size }: {
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function TagIconFilled(): react_jsx_runtime.JSX.Element;

declare function ThumbsUp({ size, fill, }: {
    size?: string;
    fill?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function Tick({ className }: {
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function TickLarge({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function Timeline({ className, ...props }: ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare namespace Timeline {
    var ArrowDown: (props: react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    var ArrowReverse: (props: react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    var ArrowRight: (props: react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    var ArrowUp: (props: react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    var CapBottom: (props: react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    var CapTop: (props: react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    var Straight: ({ className, ...props }: react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
}

declare function TradingViewStepsIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function TriangleExclamation({ size, ...props }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function WalletIcon({ size }: {
    size?: string;
}): react_jsx_runtime.JSX.Element;
declare function WalletFilledIcon({ size }: {
    size?: string;
}): react_jsx_runtime.JSX.Element;

declare function SunriseIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function SunIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function MoonIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function SunOutlinedIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function CrossedOutSunSolidIcon({ size, className, }: {
    size?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

interface Props$1 extends Omit<LottieComponentProps, "src" | "animationData"> {
    style?: React.CSSProperties;
    autoplay?: boolean;
    loop?: boolean;
    src: unknown;
}
declare const AnimationWrapper: ({ src, ...playerProps }: Props$1) => react_jsx_runtime.JSX.Element;
declare function AnimationCard({ children }: {
    children?: React.ReactNode;
}): react_jsx_runtime.JSX.Element;

interface AnnouncementProps {
    message: string;
    mainIcon?: React.ReactNode;
    detail?: React.ReactNode;
    link?: string;
}
declare function Announcement({ message, detail, mainIcon, link, }: AnnouncementProps): react_jsx_runtime.JSX.Element;

interface AppContainerProps extends ComponentProps<typeof motion.div> {
    layoutKey?: string;
}
declare function AppContainer({ children, className, layoutKey, ...props }: AppContainerProps): react_jsx_runtime.JSX.Element;
declare namespace AppContainer {
    var Nav: ({ className, children, ...props }: Omit<motion_react.HTMLMotionProps<"div">, "ref"> & react.RefAttributes<HTMLDivElement>) => react_jsx_runtime.JSX.Element;
    var Content: (props: Omit<motion_react.HTMLMotionProps<"div">, "ref"> & react.RefAttributes<HTMLDivElement>) => react_jsx_runtime.JSX.Element;
}

declare function Breadcrumb({ children, className, }: {
    children: ReactNode;
    className?: string;
}): react_jsx_runtime.JSX.Element;

interface CardProps {
    children: React.ReactNode;
    variant: "transparent";
    className?: string;
}
declare const Card: ({ variant, className, children, }: CardProps) => react_jsx_runtime.JSX.Element;

interface CollapseProps extends ComponentProps<"div"> {
    collapsed: boolean;
    collapsedHeight?: number;
    duration?: number;
    contentsClassName?: string;
}
declare function Collapse({ collapsed, collapsedHeight, children, className, duration, contentsClassName, ...props }: CollapseProps): react_jsx_runtime.JSX.Element;
interface SizeTransitionProps extends ComponentProps<"div"> {
}
declare function SizeTransition({ children, className, disableInitialAnimation, ...props }: SizeTransitionProps & {
    disableInitialAnimation?: boolean;
}): react_jsx_runtime.JSX.Element;

interface CollapsibleMenuProps {
    menuRef: React.MutableRefObject<HTMLDivElement | null>;
    size: {
        open: {
            width: string;
            height: string;
        };
        closed: {
            width: string;
            height: string;
        };
    };
    children?: React.ReactNode;
    isOpen?: boolean;
    transitionDuration?: React.CSSProperties["transitionDuration"];
    className?: string;
}
declare function CollapsibleMenu({ children, menuRef, isOpen, transitionDuration, size, className, }: CollapsibleMenuProps): react_jsx_runtime.JSX.Element;

interface DescriptionBlocksProps extends ComponentProps<"div"> {
    blocks: DescriptionBlock[] | string;
}
declare function DescriptionBlocks({ className, blocks: blocksProp, ...props }: DescriptionBlocksProps): react_jsx_runtime.JSX.Element;
declare function Inline({ className, children, ...props }: ComponentProps<"div">): react_jsx_runtime.JSX.Element;

interface StopsProps extends React.ComponentProps<"button"> {
    stopsCount?: string | number;
    estimatedTime?: string;
    tooltip?: Omit<TooltipProps, "children">;
    providers: Provider[];
}
interface Provider {
    logoUrl: string;
    key: string;
}

interface DetailsToolbarProps {
    errorMessage?: string;
    flipButton?: {
        onClick?: () => void;
        tooltip?: Omit<TooltipProps, "children">;
        isDisabled?: boolean;
    };
    feeButton?: {
        feeInUsd: string;
        tooltip?: Omit<TooltipProps, "children">;
        onClick: () => void;
    };
    isLoading?: boolean;
    isEmpty?: boolean;
    helpButton?: {
        label: string;
        onClick: () => void;
    };
    stopsButton?: StopsProps;
}
declare function DetailsToolbar({ errorMessage, helpButton, isLoading, isEmpty, flipButton, feeButton, stopsButton, }: DetailsToolbarProps): react_jsx_runtime.JSX.Element;

interface DropdownMenuProps {
    dropdownRef?: React.RefObject<HTMLDivElement>;
    menuRef?: React.RefObject<HTMLDivElement>;
    className?: string;
    isHidden?: boolean;
    listClassName?: string;
    containerClassName?: string;
    containerRef?: React.RefObject<HTMLDivElement>;
    children?: React.ReactNode;
    contentWrapperProps?: React.ComponentProps<"div">;
    menuContentClassName?: string;
    trigger?: React.ReactNode;
}
declare function DropdownMenu({ dropdownRef, className, menuRef, isHidden, listClassName, containerClassName, children, contentWrapperProps, menuContentClassName, trigger, }: DropdownMenuProps): react_jsx_runtime.JSX.Element;

type ErrorMessageProps = {
    message: string;
    showIcon?: boolean;
};
declare function ErrorMessage({ message, showIcon }: ErrorMessageProps): react_jsx_runtime.JSX.Element;

interface HashLinkProps {
    showTx?: boolean;
    hash: string;
    children?: ReactNode;
    showCopyButton?: boolean;
    url?: string;
    className?: string;
    formattedHash?: string;
    size?: "default" | "small";
}
declare function HashLink({ showTx, hash, showCopyButton, url, children, className, formattedHash, size, }: HashLinkProps): react_jsx_runtime.JSX.Element;

interface ImageStackProps extends ImageProps {
    imageUrls: string[];
    spacing: string;
    border?: ImageProps["border"];
    rounded?: ImageProps["rounded"];
    size?: ImageProps["size"];
    stackOnTop?: boolean;
    addExtraPadding?: boolean;
    removeDuplicates?: boolean;
    containerProps?: React.HTMLAttributes<HTMLDivElement>;
}
declare function ImageStack({ imageUrls, spacing, stackOnTop, addExtraPadding, removeDuplicates, containerProps, ...imageProps }: ImageStackProps): react_jsx_runtime.JSX.Element;

interface InfoBoxProps {
    title: string;
    description: string | ReactNode;
    icon?: ReactNode;
}
declare function InfoBox({ title, description, icon }: InfoBoxProps): react_jsx_runtime.JSX.Element;

interface JoinProps {
    children?: ReactNode;
    glue: () => ReactNode;
}
declare function Join({ children, glue }: JoinProps): react_jsx_runtime.JSX.Element[] | null | undefined;

type Rounded = "sm" | "lg";
interface MenuProps extends react__default.ComponentProps<"div"> {
    containerClassName?: string;
    contentClassName?: string;
    rounded?: Rounded;
    menuRef?: react__default.RefObject<HTMLDivElement>;
    contentWrapperProps?: react__default.ComponentProps<"div">;
}
declare function Menu({ children, containerClassName, contentClassName, rounded, menuRef, contentWrapperProps, ...props }: MenuProps): react_jsx_runtime.JSX.Element;

type ModalWidth = "large" | "extra-large";
interface ModalProps {
    children: React.ReactNode;
    className?: string;
    onBackdropClick?: () => void;
    isOpen?: boolean;
    maxHeight?: boolean;
    width?: ModalWidth;
    animateOpacity?: boolean;
    backdropStyle?: React.CSSProperties;
}
declare function Modal({ children, className, onBackdropClick, isOpen: _isOpen, maxHeight, width, animateOpacity, backdropStyle, }: ModalProps): false | react_jsx_runtime.JSX.Element;

type ModalContentBorderType = "border" | "outline";
interface ModalContentProps extends React.HTMLAttributes<HTMLDivElement> {
    children?: React.ReactNode;
    addGap?: boolean;
    paddingY?: boolean;
    borderType?: ModalContentBorderType;
    className?: string;
}
declare function ModalContent({ children, addGap, paddingY, borderType, className, ...props }: ModalContentProps): react_jsx_runtime.JSX.Element;
declare function ModalContentDivider(): react_jsx_runtime.JSX.Element;

interface ModalTitleProps {
    title: string;
}
declare function ModalTitle({ title }: ModalTitleProps): react_jsx_runtime.JSX.Element;

interface ActionButton {
    labelOrIcon: string | React.ReactNode;
    onClick?: () => void;
    id: React.Key;
    tooltip?: Omit<TooltipProps, "children">;
    chip?: ChipProps;
}
interface NavigationBarProps extends React.ComponentProps<"nav"> {
    title?: string;
    displayBackButton?: boolean;
    logoUrl?: string;
    transparent?: boolean;
    displayButtonShadows?: boolean;
    onBackButtonClick?: () => void;
    actions?: ActionButton[];
    isLoading?: boolean;
    subtitle?: string;
    paddingRight?: number;
}
declare function NavigationBar({ title, displayBackButton, logoUrl, transparent, displayButtonShadows, onBackButtonClick, actions, isLoading, subtitle, paddingRight, ...props }: NavigationBarProps): react_jsx_runtime.JSX.Element;

interface Props extends ComponentProps<"div"> {
    size?: "default" | "small" | "large";
}
declare function PipeSeparator({ className, size, ...props }: Props): react_jsx_runtime.JSX.Element;

declare function ProductCard({ children }: React.PropsWithChildren): react_jsx_runtime.JSX.Element;
declare function BorderedContainer({ children, className, }: {
    children: React.ReactNode;
    className?: string;
}): react_jsx_runtime.JSX.Element;

interface QrCodeProps {
    matrix: boolean[][];
    size: number;
    imageUrl?: string;
}
declare function QrCode({ matrix, size: renderedSize, imageUrl }: QrCodeProps): react_jsx_runtime.JSX.Element;

interface QrCodeModalProps {
    qrData: boolean[][] | undefined;
    imageUrl?: string;
    handleClose: () => void;
    handleGoBack?: () => void;
    isModalOpen: boolean | undefined;
    footerContent: React.ReactNode;
    title: string;
    isError?: boolean;
    ctaButton?: Partial<ButtonProps>;
}
declare function QrCodeModal({ qrData, imageUrl, handleClose, handleGoBack, isModalOpen, footerContent, title, isError, ctaButton, }: QrCodeModalProps): react_jsx_runtime.JSX.Element;

interface AddressHeaderProps {
    direction: SwapDirection;
    onClick?: () => void;
    isDisabled?: boolean;
    tooltip?: Omit<TooltipProps, "children">;
    label: string;
    walletIconUrl?: string | null;
    isLoading?: boolean;
    displayLabel?: boolean;
    highlightLabel?: boolean;
    showIcon?: boolean;
}
declare const AddressHeader: ({ direction, onClick, isDisabled, tooltip, label, walletIconUrl, isLoading, displayLabel, highlightLabel, showIcon, }: AddressHeaderProps) => react_jsx_runtime.JSX.Element;
interface SwapConfigurationProps {
    direction: SwapDirection;
    priceImpactPercentage?: string;
    amount?: string;
    tokenPrice?: number;
    balance?: string;
    isFetching?: boolean;
    chain?: {
        iconUrl: string;
        bgColor: string;
    };
    token?: {
        iconUrl: string;
        fallbackIconUrl?: string;
        symbol: string;
        bgColor: string;
        textColor: string;
        decimals: number;
    };
    onAmountChange?: (amount: string) => void;
    error?: {
        message: string;
    };
    criticalPriceImpactPercentage?: number;
    maxUsdDecimals?: number;
    isInputInteractive?: boolean;
    isLoading?: boolean;
    inputModeButton?: {
        usdModeTooltip?: Omit<TooltipProps, "children">;
        tokenModeTooltip?: Omit<TooltipProps, "children">;
        amountUsd?: string;
    };
    balanceButton?: {
        tooltip?: Omit<TooltipProps, "children">;
        hideMaxChip?: boolean;
    };
    assetsButton?: {
        tooltip?: Omit<TooltipProps, "children">;
        onClick?: () => void;
        variant?: AssetsButtonVariant;
        showWarning?: boolean;
    };
    walletButton?: {
        tooltip?: Omit<TooltipProps, "children">;
        onClick?: () => void;
        address?: string;
        emptyAddressLabel?: string;
        disabled?: boolean;
        walletIconUrl?: string | null;
        showIcon?: boolean;
    };
    showNumericInputDetails?: boolean;
    fullHeight?: boolean;
    debounceInput?: boolean;
    showWalletButtonHeader?: boolean;
    hideChainSelector?: boolean;
}
declare function SwapConfiguration({ amount, tokenPrice, isFetching: isFetchingProp, chain, token, direction, onAmountChange, balance, criticalPriceImpactPercentage, error, priceImpactPercentage, maxUsdDecimals, isInputInteractive, isLoading, inputModeButton, balanceButton, assetsButton, walletButton, showNumericInputDetails, fullHeight, debounceInput, showWalletButtonHeader, hideChainSelector, }: SwapConfigurationProps): react_jsx_runtime.JSX.Element;

interface SwapStepsCollapsedFooterButton {
    label: string;
    link?: string;
    onClick?: () => void;
}
interface SwapStepsCollapsedProps {
    steps: SwapStep[];
    currentStepIndex: number;
    onOpen?: () => void;
    onClose?: () => void;
    footerButton?: SwapStepsCollapsedFooterButton;
}
declare const SwapStepsCollapsed: react.ForwardRefExoticComponent<SwapStepsCollapsedProps & react.RefAttributes<{
    handleToggleRouteSteps: () => void;
}>>;

interface ToastProps {
    title: string;
    description: string;
    headerContent?: React.ReactNode;
    actionsContent?: React.ReactNode;
    chipLabel?: string;
}
declare function Toast({ headerContent, actionsContent, description, chipLabel, title, }: ToastProps): react_jsx_runtime.JSX.Element;

interface Token$3 {
    address: string;
    name: string;
    symbol: string;
    image: string;
    fallbackImage?: string;
    chainId: string;
}
interface Chain {
    name: string;
    image: string;
}
type Timeframe = "1H" | "1D" | "1W" | "1Y";
interface TokenDetailsViewProps {
    isOpen: boolean;
    onClose: () => void;
    token: Token$3;
    chain: Chain;
    tokenPrice: string;
    priceChange: string | number;
    balance: string;
    balanceUSD: string;
    volume24h: string;
    marketCap: string;
    totalSupply: string;
    loading: boolean;
    onLikeToken: () => void;
    isFavorite?: boolean;
    Chart?: React.ComponentType<{
        timeframe: Timeframe;
    }>;
    initialTimeframe?: Timeframe;
    onTimeframeChange?: (timeframe: Timeframe) => void;
    footerButtons: FooterButtonProps[];
    backdropStyle?: React.CSSProperties;
    colors?: {
        backgroundColor: string;
        textColor: string;
    };
}
interface FooterButtonProps extends React.ComponentProps<"button"> {
    label: string;
    icon: React.ReactNode;
}
declare const TokenDetailsView: ({ isOpen, onClose, token, chain, tokenPrice, priceChange, balance, balanceUSD, volume24h, marketCap, totalSupply, loading, onLikeToken, isFavorite, Chart, initialTimeframe, onTimeframeChange, footerButtons, backdropStyle, colors, }: TokenDetailsViewProps) => react_jsx_runtime.JSX.Element;

interface TokenPairProps {
    firstToken?: {
        logoURI: string;
        bgColor: string;
    };
    secondToken?: {
        logoURI: string;
        bgColor: string;
    };
    variant?: TokenPairVariant;
    size?: TokenPairSize;
}
declare function TokenPair({ firstToken, secondToken, variant, size, }: TokenPairProps): react_jsx_runtime.JSX.Element;

interface ChainData$2 {
    iconURI: string;
    id: string;
    name: string;
}

interface TransactionFiltersProps {
    chainType: ChainTypeFilter;
    setChainType: (chainType: ChainTypeFilter) => void;
    chain?: ChainData$2;
    handleChain: (chain?: ChainData$2) => void;
    fromDate?: Date;
    handleFromDate: (fromDate?: Date) => void;
    toDate?: Date;
    handleToDate: (toDate?: Date) => void;
    status?: string;
    statuses?: Array<{
        label: string;
        value: string;
        icon: React.ReactNode;
    }>;
    handleStatus: (status?: string) => void;
    chains: ChainData$2[];
}
declare function TransactionFilters({ chainType, setChainType, chain, handleChain, fromDate, handleFromDate, toDate, handleToDate, status, statuses, handleStatus, chains, }: TransactionFiltersProps): react_jsx_runtime.JSX.Element;
interface CheckboxProps {
    checked: boolean;
    className?: string;
}
declare function Checkbox({ checked, className }: CheckboxProps): react_jsx_runtime.JSX.Element;

interface BaseTransactionHeaderLayoutProps {
    status?: ActionStatus;
    title?: string;
    media?: ReactNode;
    children?: ReactNode;
}
type TransactionHeaderLayoutProps = (BaseTransactionHeaderLayoutProps & {
    isLoading: true;
}) | (Required<BaseTransactionHeaderLayoutProps> & {
    isLoading?: false;
});
declare function TransactionHeaderLayout({ isLoading, status, title, media, children, }: TransactionHeaderLayoutProps): react_jsx_runtime.JSX.Element;

interface PropertiesLayoutProps {
    children?: ReactNode;
    className?: string;
}
declare function PropertiesLayout({ children, className, }: PropertiesLayoutProps): react_jsx_runtime.JSX.Element;

interface TransactionSearchProps {
    query: string;
    setQuery: (query: string) => void;
    children?: ReactNode;
    className?: string;
    onFocus?: () => void;
    onBlur?: () => void;
}
declare function TransactionSearch({ query, setQuery, children, className, onFocus, onBlur, }: TransactionSearchProps): react_jsx_runtime.JSX.Element;

interface FromToProps {
    isLoading?: boolean;
    from?: ReactNode;
    to?: ReactNode;
    className?: string;
}
declare function Transfer({ isLoading, from, to, className }: FromToProps): react_jsx_runtime.JSX.Element;

interface TxProgressViewHeaderProps {
    title: string;
    description: string;
    isWarning?: boolean;
}
declare function TxProgressViewHeader({ title, description, isWarning, }: TxProgressViewHeaderProps): react_jsx_runtime.JSX.Element;

interface UnsupportedPairNoticeProps {
    description: string;
    fromImageUrl: string;
    toImageUrl: string;
}
declare function UnsupportedPairNotice({ description, fromImageUrl, toImageUrl, }: UnsupportedPairNoticeProps): react_jsx_runtime.JSX.Element;

interface AccountListItemProps {
    isConnected?: boolean;
    imageUrls?: string[];
    imageUrl?: string;
    badgeUrl?: string;
    actions?: React.ReactNode;
    title?: string;
    subtitle?: string;
}
declare function AccountListItem({ isConnected, imageUrls, imageUrl, badgeUrl, actions, subtitle, title, }: AccountListItemProps): react_jsx_runtime.JSX.Element;

/**
 * Utility type to allow for a type to be either all of the properties of another type, or none of them
 * @example
 * type Person = { age: number } & AllOrNone<{ name: string, lastName: string }>
 * const person: Person = { age: 30 } // ok
 * const person: Person = { age: 30, name: "John" } // error, requires lastName
 * const person: Person = { age: 30, name: "John", lastName: "Doe" } // ok, all properties are present
 */
type AllOrNone<T> = T | {
    [K in keyof T]?: never;
};
type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

declare const THEME_COLOR_KEYS: readonly ["grey-100", "grey-200", "grey-300", "grey-400", "grey-500", "grey-600", "grey-700", "grey-800", "grey-900", "royal-300", "royal-400", "royal-500", "royal-600", "royal-700", "highlight-700", "status-positive", "status-negative", "status-partial", "button-lg-primary-bg", "button-lg-primary-text", "button-lg-secondary-bg", "button-lg-secondary-text", "button-lg-tertiary-bg", "button-lg-tertiary-text", "button-md-primary-bg", "button-md-primary-text", "button-md-secondary-bg", "button-md-secondary-text", "button-md-tertiary-bg", "button-md-tertiary-text", "button-sm-primary-bg", "button-sm-primary-text", "button-sm-secondary-bg", "button-sm-secondary-text", "button-sm-tertiary-bg", "button-sm-tertiary-text", "input-placeholder", "input-text", "input-selection", "input-bg", "animation-bg", "animation-text", "modal-backdrop", "menu-bg", "menu-text", "menu-backdrop", "material-light-thin", "material-light-average", "material-light-thick", "material-dark-thin", "material-dark-average", "material-dark-thick", "grey-100-005", "material-light-blend-grey-900", "material-light-blend-grey-800"];
declare const THEME_BORDER_RADIUS_KEYS: readonly ["button-lg-primary", "button-lg-secondary", "button-lg-tertiary", "button-md-primary", "button-md-secondary", "button-md-tertiary", "button-sm-primary", "button-sm-secondary", "button-sm-tertiary", "container", "input", "menu-sm", "menu-lg", "modal"];
declare const THEME_FONT_SIZE_KEYS: readonly ["caption", "body-large", "body-medium", "body-small", "heading-small", "heading-medium", "heading-large"];
declare const THEME_FONT_WEIGHT_KEYS: readonly ["caption", "body-small", "body-medium", "body-large", "heading-small", "heading-medium", "heading-large"];
declare const THEME_FONT_FAMILY_KEYS: readonly ["squid-main"];
declare const THEME_BOX_SHADOW_KEYS: readonly ["container"];
type ThemeColors = Record<(typeof THEME_COLOR_KEYS)[number], string>;
type ThemeFontSize = Record<(typeof THEME_FONT_SIZE_KEYS)[number], string>;
type ThemeFontWeight = Record<(typeof THEME_FONT_WEIGHT_KEYS)[number], string>;
type ThemeBorderRadius = Record<(typeof THEME_BORDER_RADIUS_KEYS)[number], string>;
type ThemeFontFamily = Record<(typeof THEME_FONT_FAMILY_KEYS)[number], string>;
type ThemeBoxShadow = Record<(typeof THEME_BOX_SHADOW_KEYS)[number], string>;
/**
 * Full theme, includes internal colors.
 */
interface InternalTheme {
    color: ThemeColors;
    fontSize: ThemeFontSize;
    fontWeight: ThemeFontWeight;
    borderRadius: ThemeBorderRadius;
    fontFamily: ThemeFontFamily;
    boxShadow: ThemeBoxShadow;
}
/**
 * These colors are optional
 * and will be generated internally using the base colors if not provided
 */
type OptionalColorsKeys = "button-lg-primary-bg" | "button-lg-primary-text" | "button-lg-secondary-bg" | "button-lg-secondary-text" | "button-lg-tertiary-bg" | "button-lg-tertiary-text" | "button-md-primary-bg" | "button-md-primary-text" | "button-md-secondary-bg" | "button-md-secondary-text" | "button-md-tertiary-bg" | "button-md-tertiary-text" | "button-sm-primary-bg" | "button-sm-primary-text" | "button-sm-secondary-bg" | "button-sm-secondary-text" | "button-sm-tertiary-bg" | "button-sm-tertiary-text" | "input-placeholder" | "input-text" | "input-selection" | "input-bg" | "animation-bg" | "animation-text" | "modal-backdrop" | "menu-bg" | "menu-text" | "menu-backdrop";
/**
 * These colors are generated internally using the base colors
 */
type HiddenColorsKeys = "material-light-thin" | "material-light-average" | "material-light-thick" | "material-dark-thin" | "material-dark-average" | "material-dark-thick" | "grey-100-005" | "material-light-blend-grey-900" | "material-light-blend-grey-800";
/**
 * Public theme, excluding some colors that are generated internally
 * and making some colors optional.
 */
interface PublicTheme extends Omit<InternalTheme, "color"> {
    color: // Remove the hidden colors and the optional colors
    Omit<InternalTheme["color"], HiddenColorsKeys | OptionalColorsKeys> & Partial<Pick<InternalTheme["color"], OptionalColorsKeys>>;
}
/**
 * The theme interface exposed for the end user
 * Everything is optional, any missing config will be generated internally
 */
type Theme = DeepPartial<PublicTheme>;
interface CssVariable {
    cssVariable: string;
}
type ThemeCssVariables = {
    [K in keyof InternalTheme]: Record<keyof InternalTheme[K], CssVariable>;
};
declare const themeKeysToCssVariables: ThemeCssVariables;
interface Settings {
    showProgressAnimation: boolean;
}

interface DropdownMenuItemControl extends Omit<SwitchProps, "size"> {
    type: "switch";
}
interface DropdownMenuItemProps {
    label: string;
    labelClassName?: string;
    imageUrl?: string;
    icon?: React.ReactNode;
    onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
    link?: string;
    control?: DropdownMenuItemControl;
    detail?: React.ReactNode;
    isSelected?: boolean;
    itemRef?: React.RefObject<HTMLLIElement>;
    children?: React.ReactNode;
    contentRef?: React.RefObject<HTMLButtonElement>;
}
declare function DropdownMenuItem(props: DropdownMenuItemProps & AllOrNone<{
    submenu: React.ReactNode;
    containerRef: React.RefObject<HTMLDivElement>;
}>): react_jsx_runtime.JSX.Element;

declare function DropdownMenuTitle({ title }: {
    title: string;
}): react_jsx_runtime.JSX.Element;

interface HistoryItemProps {
    firstImageUrl: string;
    secondImageUrl: string;
    status: HistoryItemStatus;
    fromLabel: string;
    toLabel: string;
    dateCompleted: string;
    fromAmount: string;
    toAmount: string;
    itemsContainerRef?: React.RefObject<HTMLElement>;
    onClick?: () => void;
    warningLabel?: string;
    dropdownMenuContent?: React.ReactNode;
    txType: "swap" | "send";
}
declare function HistoryItem({ firstImageUrl, secondImageUrl, dateCompleted, fromAmount, fromLabel, toAmount, toLabel, dropdownMenuContent, itemsContainerRef, status, warningLabel, txType, onClick, }: HistoryItemProps): react_jsx_runtime.JSX.Element;

type HTMLInteractiveItem = HTMLButtonElement | HTMLDivElement | HTMLLabelElement;
interface ListItemProps extends React.HTMLAttributes<HTMLButtonElement> {
    itemTitle: string | React.ReactNode;
    mainImageUrl?: string;
    secondaryImageUrl?: string;
    placeholderImageUrl?: string;
    subtitle?: string;
    subtitleOnHover?: React.ReactNode;
    detail?: string;
    icon?: React.ReactNode;
    size?: ListItemSize;
    mainIcon?: React.ReactNode;
    isSelected?: boolean;
    className?: string;
    onDetailClick?: () => void;
    showDetailOnHoverOnly?: boolean;
    rounded?: ImageRoundedSize;
    detailButtonClassName?: string;
    loading?: {
        subtitle?: boolean | string;
    };
    containerProps?: React.HTMLAttributes<HTMLLIElement>;
    compactOnMobile?: boolean;
    extraPadding?: boolean;
    dropdownMenuContent?: React.ReactNode;
    itemsContainerRef?: React.RefObject<HTMLElement>;
    imageGroup?: string[];
    multilineSubtitle?: boolean;
    control?: React.ReactNode;
    onClick?: (event: React.MouseEvent<HTMLInteractiveItem>) => void;
    tooltip?: Omit<TooltipProps, "children">;
}
type ListItemSize = "small" | "large";
declare function ListItem({ itemTitle, mainImageUrl, subtitle, subtitleOnHover, detail, icon, secondaryImageUrl, placeholderImageUrl, size, mainIcon, className, isSelected, onDetailClick, showDetailOnHoverOnly, rounded, detailButtonClassName, loading, containerProps, compactOnMobile, extraPadding, itemsContainerRef, dropdownMenuContent, imageGroup, multilineSubtitle, control, tooltip, ...props }: ListItemProps): react_jsx_runtime.JSX.Element;
declare const ListItemActionsButton: react.ForwardRefExoticComponent<Omit<react.ClassAttributes<HTMLButtonElement> & react.ButtonHTMLAttributes<HTMLButtonElement> & {
    isActive?: boolean | undefined;
}, "ref"> & react.RefAttributes<HTMLButtonElement>>;

interface MenuItemProps {
    label: string;
    imageUrl?: string;
    icon?: React.ReactNode;
}
declare function MenuItem({ label, imageUrl, icon }: MenuItemProps): react_jsx_runtime.JSX.Element;

interface PropertyListItemProps extends ComponentProps<"li"> {
    isLoading?: boolean;
    label?: React.ReactNode;
    icon?: React.ReactNode;
    detail?: React.ReactNode;
    variant?: PropertyListItemSize;
    showGradientBg?: boolean;
    labelClassName?: string;
    iconClassName?: string;
    detailClassName?: string;
    tooltip?: Omit<TooltipProps, "children">;
    collapsibleContent?: React.ReactNode;
    addExtraPadding?: boolean;
}
declare function PropertyListItem({ isLoading, label, detail, icon, className, variant, showGradientBg, labelClassName, iconClassName, detailClassName, tooltip, collapsibleContent, addExtraPadding, ...props }: PropertyListItemProps): react_jsx_runtime.JSX.Element;

interface RouteStepProps {
    imageUrl: string;
    descriptionBlocks: DescriptionBlock[];
    subtitle: string;
    showStepSeparator?: boolean;
}
declare function RouteStep({ imageUrl, descriptionBlocks, subtitle, showStepSeparator, }: RouteStepProps): react_jsx_runtime.JSX.Element;

interface SectionTitleProps extends React.HTMLAttributes<HTMLDivElement> {
    title: string;
    icon?: React.ReactNode;
    accessory?: string | null;
    actionIcon?: React.ReactNode;
    className?: string;
}
declare function SectionTitle({ title, icon, accessory, actionIcon, className, ...props }: SectionTitleProps): react_jsx_runtime.JSX.Element;

type SettingsControl = {
    type: "percentage";
    value: number | undefined;
    onChange: (value: number | undefined) => void;
    min?: number;
    max?: number;
    decimalsFormat?: number;
    resetValueControl: {
        label: string;
        onSelect: () => void;
        value: number | undefined;
    };
} | {
    type: "amount";
    value: number | undefined;
    onChange: (value: number | undefined) => void;
    options: {
        value: number;
    }[];
    decimalsFormat?: number;
    resetValueControl: {
        label: string;
        value: number | undefined;
    };
} | {
    type: "switch";
    checked: boolean;
    onChange: (checked: boolean) => void;
    tooltip?: Omit<TooltipProps, "children">;
    disabled?: boolean;
} | {
    type: "options";
    selectedLabel: string;
    options: {
        label: string;
        onSelect: () => void;
    }[];
};
interface SettingsItemProps {
    icon: React.ReactNode;
    label: string;
    control?: SettingsControl;
    link?: string;
    transparent?: boolean;
    helpTooltip?: Omit<TooltipProps, "children">;
}
declare function SettingsItem({ icon, label, control, link, transparent, helpTooltip, }: SettingsItemProps): react_jsx_runtime.JSX.Element;

interface SwapStepItemProps {
    descriptionBlocks: DescriptionBlock[];
    showStepSeparator?: boolean;
    link?: string;
    status?: ActionStatus;
}
declare const STEP_ITEM_HEIGHT = 52;
declare function SwapStepItem({ descriptionBlocks, showStepSeparator, link, status, }: SwapStepItemProps): react_jsx_runtime.JSX.Element;

type TokenGroupVariant = "compact" | "large" | "small";
interface TokenGroupProps<T> {
    isSelected?: boolean;
    imageUrl: string;
    fallbackImageUrl?: string;
    symbol: string;
    name: string;
    chainImageUrl: string;
    balance?: string;
    balanceUsd?: string;
    priceChange?: string | number;
    tokenItems?: T[];
    extraSpacing?: boolean;
    onClick?: (event: React.MouseEvent<HTMLButtonElement | HTMLDivElement>) => void;
    variant?: TokenGroupVariant;
    className?: string;
    onChildClick?: (tokenProps: T) => void;
    isAdjacentToPreviousExpanded?: boolean;
    isAdjacentToNextExpanded?: boolean;
}
declare function TokenGroup<T extends TokenGroupProps<T>>({ isSelected, tokenItems, priceChange, balance, balanceUsd, extraSpacing, chainImageUrl, imageUrl, fallbackImageUrl, symbol, name, onClick, variant, className, onChildClick, isAdjacentToPreviousExpanded, isAdjacentToNextExpanded, }: TokenGroupProps<T>): react_jsx_runtime.JSX.Element;

interface TokenGroupsProps<T extends TokenGroupProps<T>> {
    groups: T[];
    className?: string;
    onGroupChildClick?: (token: T) => void;
    variant?: TokenGroupVariant;
}
declare function TokenGroups<T extends TokenGroupProps<T>>({ groups, className, onGroupChildClick, variant, }: TokenGroupsProps<T>): react_jsx_runtime.JSX.Element;

interface ActionLayoutProps {
    lineCap?: ReactNode;
    status?: ActionStatus;
    showTimeline?: boolean;
    statusIcon?: ReactNode;
    nextStatus?: ActionStatus;
    description?: ReactNode;
    title?: string;
    icon?: ReactNode;
    children?: ReactNode;
    showBody?: boolean;
}
declare function ActionLayout({ lineCap, status, showTimeline, showBody, nextStatus, statusIcon, description, title, icon, children, }: ActionLayoutProps): react_jsx_runtime.JSX.Element;
interface ActionPropertiesProps {
    timestamp?: number;
    hash?: string;
    url?: string;
}
declare function ActionProperties({ timestamp, hash, url, }: ActionPropertiesProps): react_jsx_runtime.JSX.Element;
declare const ActionLineOutRow: ({ status }: {
    status?: ActionStatus;
}) => react_jsx_runtime.JSX.Element;
declare const ActionStatusRow: ({ children, status, icon, }: {
    children?: ReactNode;
    status: ActionStatus;
    icon?: ReactNode;
}) => react_jsx_runtime.JSX.Element;
declare function ActionRow({ className, ...props }: ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function ActionWrapper({ children, status, className, }: {
    children?: ReactNode;
    status?: ActionStatus;
    className?: string;
}): react_jsx_runtime.JSX.Element;
interface TimestampProps {
    time: number;
}
declare function Timestamp({ time }: TimestampProps): react_jsx_runtime.JSX.Element;

interface BaseActionProps {
    status: ActionStatus;
    /** if set, renders a line upwards to the next item in the status color */
    nextStatus?: ActionStatus;
    /** should we render a line down to the previous item? (default true) */
    showTimeline?: boolean;
    /** if false, fades out everything but the status line (for collapsed timeline state) */
    showBody?: boolean;
}

interface ApproveActionProps extends BaseActionProps {
    profile: {
        imageURI: string;
        label: string;
    };
    chain: {
        logoURI: string;
        name: string;
    };
    wallet: {
        imageURI: string;
        address: string;
        url: string;
    };
    timestamp?: number;
    hash?: string;
    url?: string;
}
declare function ApproveAction({ status, nextStatus, showTimeline, showBody, profile, chain, wallet, timestamp, hash, url, }: ApproveActionProps): react_jsx_runtime.JSX.Element;

interface BridgeActionProps extends BaseActionProps {
    token: {
        logoURI: string;
        symbol: string;
    };
    chain: {
        logoURI: string;
        name: string;
    };
    provider: {
        logoURI: string;
        name: string;
    };
    timestamp?: number;
    hash?: string;
    url?: string;
}
declare function BridgeAction({ status, nextStatus, showTimeline, showBody, token, chain, provider, timestamp, hash, url, }: BridgeActionProps): react_jsx_runtime.JSX.Element;

interface FeesActionProps extends BaseActionProps {
    total: FeesRowProps;
    lines?: FeesRowProps[];
}
declare function FeesAction({ status, nextStatus, showTimeline, total, lines, }: FeesActionProps): react_jsx_runtime.JSX.Element;
interface FeesTotalProps {
    status: ActionStatus;
    nextStatus?: ActionStatus;
    total: FeesRowProps;
    showTimeline?: boolean;
    collapsed?: boolean;
}
declare function FeesTotal({ status, nextStatus, total, showTimeline, collapsed, }: FeesTotalProps): react_jsx_runtime.JSX.Element;
interface FeesLinesProps {
    status: ActionStatus;
    lines?: FeesRowProps[];
    showTimeline?: boolean;
}
declare function FeesLines({ status, lines }: FeesLinesProps): react_jsx_runtime.JSX.Element;
interface FeesRowProps {
    label: string;
    amount?: number | string;
    symbol?: string;
    usd: number | string;
    collapsed?: boolean;
    className?: string;
}

interface IncompleteActionProps extends BaseActionProps {
    message: string;
    buttons: ReactNode;
}
declare function IncompleteAction({ status, nextStatus, message, buttons, }: IncompleteActionProps): react_jsx_runtime.JSX.Element;

interface ReceiveNFTActionProps extends BaseActionProps {
    nft: {
        imageURI: string;
        name: string;
    };
    chain: {
        logoURI: string;
        name: string;
    };
    wallet: {
        imageURI: string;
        address: string;
        url: string;
    };
    timestamp: number;
    hash: string;
    url: string;
}
declare function ReceiveNFTAction({ status, nextStatus, showTimeline, showBody, nft, chain, wallet, timestamp, hash, url, }: ReceiveNFTActionProps): react_jsx_runtime.JSX.Element;

interface ReceiveTokensActionProps extends BaseActionProps {
    amount: string;
    token: {
        logoURI: string;
        symbol: string;
    };
    chain: {
        logoURI: string;
        name: string;
    };
    wallet: {
        imageURI: string;
        address: string;
        url: string;
    };
    timestamp: number;
    hash: string;
    url: string;
}
declare function ReceiveTokensAction({ status, nextStatus, showTimeline, showBody, token, amount, chain, wallet, timestamp, hash, url, }: ReceiveTokensActionProps): react_jsx_runtime.JSX.Element;

interface SendTokensActionProps extends BaseActionProps {
    amount: string;
    token: {
        logoURI: string;
        symbol: string;
    };
    chain: {
        logoURI: string;
        name: string;
    };
    wallet: {
        imageURI: string;
        address: string;
        url: string;
    };
    timestamp: number;
    hash: string;
    url: string;
}
declare function SendTokensAction({ status, nextStatus, showTimeline, showBody, token, amount, chain, wallet, timestamp, hash, url, }: SendTokensActionProps): react_jsx_runtime.JSX.Element;

interface StakeActionProps extends BaseActionProps {
    token: {
        logoURI: string;
        symbol: string;
    };
    provider: {
        logoURI: string;
        name: string;
    };
    timestamp: number;
    hash: string;
    url: string;
}
declare function StakeAction({ status, nextStatus, showTimeline, showBody, token, provider, timestamp, hash, url, }: StakeActionProps): react_jsx_runtime.JSX.Element;

interface StartActionProps extends BaseActionProps {
    timestamp?: number;
    hash?: string;
    url?: string;
}
declare function StartAction({ status, nextStatus, showTimeline, showBody, timestamp, hash, url, }: StartActionProps): react_jsx_runtime.JSX.Element;

interface SuccessActionProps extends BaseActionProps {
    description?: string;
    timestamp?: number;
    hash?: string;
    url?: string;
}
declare function SuccessAction({ nextStatus, status, description, showTimeline, showBody, timestamp, hash, url, }: SuccessActionProps): react_jsx_runtime.JSX.Element;

interface SwapActionProps extends BaseActionProps {
    fromToken: {
        logoURI: string;
        symbol: string;
    };
    toToken: {
        logoURI: string;
        symbol: string;
    };
    provider: {
        logoURI: string;
        name: string;
    };
    timestamp?: number;
    hash?: string;
    url?: string;
}
declare function SwapAction({ status, nextStatus, showTimeline, showBody, fromToken, toToken, provider, timestamp, hash, url, }: SwapActionProps): react_jsx_runtime.JSX.Element;

interface WrapActionProps extends BaseActionProps {
    fromToken: {
        logoURI: string;
        symbol: string;
    };
    toToken: {
        logoURI: string;
        symbol: string;
    };
    provider: {
        logoURI: string;
        name: string;
    };
    timestamp?: number;
    hash?: string;
    url?: string;
}
declare function WrapAction({ status, nextStatus, showTimeline, showBody, fromToken, toToken, provider, timestamp, hash, url, }: WrapActionProps): react_jsx_runtime.JSX.Element;

declare const actionComponentMap: {
    readonly success: typeof SuccessAction;
    readonly receive_tokens: typeof ReceiveTokensAction;
    readonly receive_nft: typeof ReceiveNFTAction;
    readonly approve: typeof ApproveAction;
    readonly send_tokens: typeof SendTokensAction;
    readonly swap: typeof SwapAction;
    readonly bridge: typeof BridgeAction;
    readonly wrap: typeof WrapAction;
    readonly stake: typeof StakeAction;
    readonly start: typeof StartAction;
    readonly fees: typeof FeesAction;
    readonly incomplete: typeof IncompleteAction;
};
type TransactionActionComponents = typeof actionComponentMap;
type TransactionActionType = keyof TransactionActionComponents;
type TransactionActionProps = {
    [Type in TransactionActionType]: {
        type: Type;
        props: ComponentProps<TransactionActionComponents[Type]>;
    };
}[TransactionActionType];
declare function TransactionAction({ type, props }: TransactionActionProps): react_jsx_runtime.JSX.Element;

declare function linkActionTimelineProps(actions: TransactionActionProps[], collapsed: boolean): TransactionActionProps[];

interface Token$2 {
    symbol: string;
    bgColor: string;
    logoURI: string;
}
interface NFT$1 {
    imageUrl: string;
}
interface BaseTransactionItemProps {
    status: ActionStatus;
    type: TransactionType;
    hash: string;
    toToken: Token$2;
    fromToken: Token$2;
    fromChain: {
        logoURI: string;
        name: string;
    };
    toChain: {
        logoURI: string;
        name: string;
    };
    fromAmount: string;
    toAmount: string;
    timestamp: number;
    timeToComplete?: string;
}
interface SwapTransactionProps extends BaseTransactionItemProps {
    type: "swap";
}
interface BuyNFTTransactionProps extends Omit<BaseTransactionItemProps, "toToken"> {
    type: "buy_nft";
    toToken: {
        symbol: string;
    };
    nft: NFT$1;
}
interface BridgeTransactionProps extends BaseTransactionItemProps {
    type: "bridge";
}
type TransactionItemProps = SwapTransactionProps | BuyNFTTransactionProps | BridgeTransactionProps;
declare const TransactionItem: (props: TransactionItemProps) => react_jsx_runtime.JSX.Element;

declare const TransactionItemSkeleton: () => react_jsx_runtime.JSX.Element;

type TabSize = "small" | "large";
interface TabsProps {
    tabs: Array<{
        label: string;
        isDisabled?: boolean;
    }>;
    size?: TabSize;
    activeTab?: number;
    onTabChange?: (tabIndex: number) => void;
    isDisabled?: boolean;
}
declare function Tabs({ tabs, size, onTabChange, activeTab, isDisabled, }: TabsProps): react_jsx_runtime.JSX.Element;
interface TabProps extends react__default.ComponentProps<"button"> {
    label: string;
    size: TabSize;
    isActive?: boolean;
    isDisabled?: boolean;
}
declare function Tab({ label, isActive, size, isDisabled, ...props }: TabProps): react_jsx_runtime.JSX.Element;

interface BodyTextProps extends React.HTMLAttributes<HTMLSpanElement> {
    children: ReactNode;
    size: TextSize;
    bold?: boolean;
    tight?: boolean;
    loading?: {
        isLoading?: boolean;
        width?: string;
    };
}
declare function BodyText({ size, children, bold, tight, loading, ...props }: BodyTextProps): react_jsx_runtime.JSX.Element;

interface CaptionProps extends React.HTMLAttributes<HTMLSpanElement> {
    children: ReactNode;
    bold?: boolean;
    tight?: boolean;
    loading?: {
        isLoading?: boolean;
        width?: string;
    };
    truncate?: boolean;
}
declare function CaptionText({ children, bold, loading, tight, truncate, ...props }: CaptionProps): react_jsx_runtime.JSX.Element;

interface HeadingTextProps {
    children?: ReactNode;
    size: TextSize;
    bold?: boolean;
    className?: string;
}
declare function HeadingText({ children, bold, size, className, }: HeadingTextProps): react_jsx_runtime.JSX.Element;

interface ChainData$1 {
    networkName: string;
    logoUrl: string;
}
interface Token$1 {
    symbol: string;
    logoUrl: string;
}
declare function DepositAddressView({ isOpen, fromToken, toToken, handleClose, fromChain, toChain, fromAmount, toAmount, depositAddress, depositAddressFormatted, timeRemainingSeconds, tooltips, description, title, headerContent, }: {
    isOpen?: boolean;
    fromToken: Token$1;
    toToken: Token$1;
    handleClose?: () => void;
    fromChain: ChainData$1;
    toChain: ChainData$1;
    fromAmount: string;
    toAmount: string;
    depositAddress: string;
    depositAddressFormatted: string;
    timeRemainingSeconds?: number;
    tooltips?: {
        depositAddress?: react__default.ReactNode;
        timeRemaining?: react__default.ReactNode;
    };
    title: string;
    description: string;
    headerContent?: react__default.ReactNode;
}): react_jsx_runtime.JSX.Element;

interface ChainData {
    networkName: string;
    logoUrl: string;
}
interface Token {
    symbol: string;
    logoUrl: string;
    bgColor: string;
}
declare function SwapProgressView({ steps, isOpen, handleClose, handleComplete, supportLink, fromAmount, fromChain, fromToken, toAmount, toChain, toToken, fromAddressFormatted, toAddressFormatted, swapState, estimatedTimeToComplete, footerButton, refundTokenSymbol, addGasLink, shareSwapDropdownContent, isSendTransaction, isBridgeTransaction, }: {
    steps: SwapStep[];
    handleClose?: (swapState: SwapState) => void;
    handleComplete?: () => void;
    isOpen?: boolean;
    shareSwapDropdownContent?: React.ReactNode;
    supportLink?: string;
    fromToken: Token;
    toToken: Token;
    fromAmount: string;
    toAmount: string;
    fromChain: ChainData;
    toChain: ChainData;
    fromAddressFormatted: string;
    toAddressFormatted: string;
    swapState: SwapState;
    estimatedTimeToComplete?: string;
    footerButton?: SwapStepsCollapsedFooterButton;
    refundTokenSymbol?: string;
    addGasLink?: string;
    isSendTransaction?: boolean;
    isBridgeTransaction?: boolean;
}): react_jsx_runtime.JSX.Element;

interface NFT {
    imageUrl: string;
    name: string;
    imageURI: string;
    collection: {
        name: string;
        imageURI: string;
    };
    tokenID: string;
    nftType: string;
}
interface Collection {
    image: string;
    name: string;
}
interface BaseTransactionViewProps {
    title?: string;
    hash: string;
    status: ActionStatus;
    url?: string;
    actions?: TransactionActionProps[];
    fees: FeesActionProps;
    timeToComplete: string;
    timestamp: number;
}

interface BaseBuyNFTTransactionViewProps extends BaseTransactionViewProps {
    price: string;
    token: {
        logoURI: string;
        symbol: string;
    };
    marketplace: {
        logoURI: string;
        name: string;
    };
    fromChain: {
        logoURI: string;
        name: string;
    };
    toChain: {
        logoURI: string;
        name: string;
    };
    fromAddress: string;
    toAddress: string;
    boosted?: boolean;
    nft: NFT;
    timeToComplete: string;
}
type BuyNFTTransactionViewProps = (BaseBuyNFTTransactionViewProps & {
    isLoading?: false;
}) | (Partial<BaseBuyNFTTransactionViewProps> & {
    isLoading: true;
});
declare function BuyNFTTransactionView({ title, hash, status, url, price, token, marketplace, fromChain, toChain, fromAddress, toAddress, boosted, timeToComplete, timestamp, nft, actions, fees, isLoading, }: BuyNFTTransactionViewProps): react_jsx_runtime.JSX.Element;

interface BaseInteractionTransactionViewProps extends BaseTransactionViewProps {
    image: ReactNode;
    chain: {
        logoURI: string;
        name: string;
    };
    address: string;
    boosted?: boolean;
    timeToComplete: string;
}
type InteractionTransactionViewProps = (BaseInteractionTransactionViewProps & {
    isLoading?: false;
}) | (Partial<BaseInteractionTransactionViewProps> & BaseTransactionViewProps & {
    isLoading: true;
});
declare function InteractionTransactionView({ title, hash, status, url, chain, address, timeToComplete, timestamp, actions, fees, isLoading, }: InteractionTransactionViewProps): react_jsx_runtime.JSX.Element;

interface BaseSwapTransactionViewProps extends BaseTransactionViewProps {
    fromAmount: string;
    fromToken: {
        logoURI: string;
        bgColor: string;
        symbol: string;
    };
    toAmount: string;
    toToken: {
        logoURI: string;
        bgColor: string;
        symbol: string;
    };
    fromChain: {
        logoURI: string;
        name: string;
    };
    toChain: {
        logoURI: string;
        name: string;
    };
    fromLink?: string;
    toLink?: string;
    fromAddress: string;
    toAddress: string;
    exchangeRate: string;
    boosted?: boolean;
}
type SwapTransactionViewProps = (BaseSwapTransactionViewProps & {
    isLoading?: false;
}) | (Partial<Omit<BaseSwapTransactionViewProps, keyof BaseTransactionViewProps>> & BaseTransactionViewProps & {
    isLoading: true;
});
declare function SwapTransactionView({ title, hash, toLink, fromLink, status, url, fromAmount, fromToken, toAmount, toToken, fromChain, toChain, fromAddress, toAddress, exchangeRate, timeToComplete, timestamp, actions, fees, isLoading, }: SwapTransactionViewProps): react_jsx_runtime.JSX.Element;

interface BaseBridgeTransactionViewProps extends BaseTransactionViewProps {
    fromToken: {
        logoURI: string;
        bgColor: string;
        symbol: string;
    };
    toToken: {
        logoURI: string;
        bgColor: string;
        symbol: string;
    };
    fromChain: {
        logoURI: string;
        name: string;
        bgColor: string;
    };
    toChain: {
        logoURI: string;
        name: string;
        bgColor: string;
    };
    fromAddress: string;
    toAddress: string;
    boosted?: boolean;
    timeToComplete: string;
    fromLink?: string;
    toLink?: string;
    fromAmount: string;
    toAmount: string;
}
type BridgeTransactionViewProps = (BaseBridgeTransactionViewProps & {
    isLoading?: false;
}) | (Partial<Omit<BaseBridgeTransactionViewProps, keyof BaseTransactionViewProps>> & BaseTransactionViewProps & {
    isLoading: true;
});
declare function BridgeTransactionView({ title, hash, fromLink, toLink, status, url, fromAmount, toAmount, fromToken, toToken, fromChain, toChain, fromAddress, toAddress, actions, fees, timeToComplete, timestamp, isLoading, }: BridgeTransactionViewProps): react_jsx_runtime.JSX.Element;

declare const componentMap: {
    readonly swap: typeof SwapTransactionView;
    readonly buy_nft: typeof BuyNFTTransactionView;
    readonly interaction: typeof InteractionTransactionView;
    readonly bridge: typeof BridgeTransactionView;
};
type TransactionViewComponents = typeof componentMap;
type TransactionViewProps = {
    [Type in TransactionType]: {
        type: Type;
        isLoading?: false;
        data: Omit<Partial<ComponentProps<TransactionViewComponents[Type]>>, "isLoading">;
    } | {
        type: Type;
        isLoading: true;
        data?: Omit<Partial<ComponentProps<TransactionViewComponents[Type]>>, "isLoading">;
    };
}[TransactionType];
declare function TransactionView({ type, isLoading, data, }: TransactionViewProps): react_jsx_runtime.JSX.Element | null;

interface TransactionViewLayoutProps extends ComponentProps<"div"> {
    isLoading?: boolean;
    header?: ReactNode;
    properties?: ReactNode;
    actions?: TransactionActionProps[];
    fees?: FeesActionProps;
}
declare function TransactionViewLayout({ isLoading, header, properties, actions, fees, ...props }: TransactionViewLayoutProps): react_jsx_runtime.JSX.Element;

declare const TransactionNotFoundView: () => react_jsx_runtime.JSX.Element;

interface ThemeProviderProps extends React.ComponentProps<"div"> {
    theme?: Theme;
    children?: React.ReactNode;
    themeType?: ThemeType;
    settings?: Partial<Settings>;
}
declare function ThemeProvider({ theme, children, themeType, settings, ...props }: ThemeProviderProps): react_jsx_runtime.JSX.Element;

declare function useCollapsibleMenu(): {
    isMenuOpen: boolean;
    toggleMenu: () => void;
    menuRef: react.RefObject<HTMLDivElement>;
};

interface DropdownStyles {
    position: DropdownPosition;
    maxHeight: number | null;
}
interface UseDropdownMenuParams {
    initialIsDropdownOpen?: boolean;
    itemsContainerRef?: react__default.RefObject<HTMLElement>;
}
declare function useDropdownMenu(props?: UseDropdownMenuParams): {
    isDropdownOpen: boolean;
    openDropdown: () => void;
    closeDropdown: () => void;
    dropdownRef: react__default.RefObject<HTMLDivElement>;
    openDropdownButtonRef: react__default.RefObject<HTMLButtonElement>;
    dropdownStyles: DropdownStyles | null;
    itemRef: react__default.RefObject<HTMLLIElement>;
    menuRef: react__default.RefObject<HTMLDivElement>;
};

interface UseMediaQueryOptions {
    /**
     * The default value to return if the hook is being run on the server.
     * @default false
     */
    defaultValue?: boolean;
    /**
     * If `true` (default), the hook will initialize reading the media query. In SSR, you should set it to `false`, returning `options.defaultValue` or `false` initially.
     * @default true
     */
    initializeWithValue?: boolean;
}
/**
 * Custom hook that tracks the state of a media query using the [`Match Media API`](https://developer.mozilla.org/en-US/docs/Web/API/Window/matchMedia).
 * @param {string} query - The media query to track.
 * @param {?UseMediaQueryOptions} [options] - The options for customizing the behavior of the hook (optional).
 * @returns {boolean} The current state of the media query (true if the query matches, false otherwise).
 * @public
 * @example
 * ```tsx
 * const isSmallScreen = useMediaQuery('(max-width: 600px)');
 * // Use `isSmallScreen` to conditionally apply styles or logic based on the screen size.
 * ```
 */
declare function useMediaQuery(query: string, { defaultValue, initializeWithValue, }?: UseMediaQueryOptions): boolean;

declare function useOnResize(ref: React.RefObject<HTMLElement>, callback: (rect: DOMRectReadOnly) => void): void;
declare function useRect(ref: React.RefObject<HTMLElement>): DOMRectReadOnly;

declare const useTimer: ({ startTime: _startTime, immediateStart, }: {
    startTime?: number;
    immediateStart?: boolean;
}) => {
    timer: string;
    stopTimer: () => void;
    startTimer: () => void;
};

declare enum ThemePreference {
    LIGHT = "light",
    DARK = "dark",
    SYSTEM = "system"
}
declare function useUserTheme(): {
    themePreference: ThemePreference;
    themeType: ThemeType;
    theme: PublicTheme;
    setThemeManually: (theme: ThemePreference) => void;
    isDarkMode: boolean;
};

declare function useVersion<T>(value: T, equal?: (a: T, b: T) => boolean): number;

declare const CSS_VARS: {
    MOVE_WITH_SPRING_BOUNCE_DURATION: string;
    DISPLAY_DELAYED_DURATION: string;
    COLLAPSE_ROUTE_DURATION: string;
    EXPAND_ROUTE_DURATION: string;
    FADE_IN_DURATION: string;
    FADE_OUT_DURATION: string;
    SCALE_AND_FADE_UP_DURATION: string;
    SCALE_AND_FADE_DOWN_DURATION: string;
    TRANSLATE_TOP_OR_BOTTOM: string;
    SHOW_MODAL_DURATION: string;
    HIDE_MODAL_DURATION: string;
    SLIDE_TO_TOP_DURATION: string;
    SLIDE_TO_BOTTOM_DURATION: string;
    BLUR_IN_DURATION: string;
    BLUR_OUT_DURATION: string;
    COLLAPSIBLE_MENU_OPEN_WIDTH: string;
    COLLAPSIBLE_MENU_OPEN_HEIGHT: string;
    COLLAPSIBLE_MENU_CLOSED_WIDTH: string;
    COLLAPSIBLE_MENU_CLOSED_HEIGHT: string;
};
declare const ANIMATION_DURATIONS: {
    SHOW_ROUTE: number;
    HIDE_ROUTE: number;
    CHANGE_SWAP_STEP: number;
    SHOW_MODAL: number;
    HIDE_MODAL: number;
    GENERIC: number;
};
type MediaQuery = "MOBILE_LG" | "MOBILE_SM_HEIGHT" | "MOBILE_XS" | "MOBILE_XS_HEIGHT";
declare const MEDIA_QUERIES: Record<MediaQuery, {
    media: string;
    key: string;
    value: number;
}>;

declare const lightTheme: PublicTheme;
declare const darkTheme: PublicTheme;

declare const spacing: {
    "squid-xxs": string;
    "squid-xs": string;
    "squid-s": string;
    "squid-m": string;
    "squid-l": string;
    "squid-xl": string;
    "squid-xl2": string;
    "squid-xxl": string;
};
declare const baseTailwindConfig: Config;

/**
 * Combines multiple class names into a single string
 *
 * @example cn('px-2 py-1 bg-red hover:bg-dark-red', 'p-3 bg-[#B91C1C]') → 'hover:bg-dark-red p-3 bg-[#B91C1C]'
 *
 * @param inputs - The class names to be combined.
 * @returns The combined class names as a string.
 */
declare const cn: (...inputs: ClassValue[]) => string;
declare const remToPx: (rem: string | number, baseFontSize?: number) => number;
declare const pxToRem: (px: string | number, baseFontSize?: number) => number;

interface RGB {
    r: number;
    g: number;
    b: number;
    a: number;
}
/**
 * Parses the user readable config to css variables
 * and adds the material-* variants
 * @param style
 */
declare const parseSquidTheme: (userTheme: Theme, themeType: ThemeType) => Record<string, string | undefined> | undefined;
declare function getContrastColor({ r, g, b, }: {
    r: number;
    g: number;
    b: number;
}, threshold?: number): "dark" | "light";
/**
 * Returns a hexadecimal color with opacity based on the given color and opacity percentage.
 *
 * @example getHexColorFromOpacityPercentage('#FF0000', 0.5) // '#FF000080'
 *
 * @param {string} color - The base color in hexadecimal format.
 * @param {number} opacity - The opacity percentage (0-1).
 * @returns {string} The hexadecimal color with opacity.
 */
declare function getHexColorFromOpacityPercentage(color: string, opacity: number): string;
declare function hexToRgb(hex: string): {
    r: number;
    g: number;
    b: number;
    a: number;
} | null;
declare function rgbToHex(r: number, g: number, b: number): string;
declare function blendColors(foreground: string, background: string): string | null;
declare function adjustColorForContrast(foreground: string, background: string, factor?: number): string | null;
declare const isValidHexColor: (hex: string) => boolean;
declare function parseColor(color: string): RGB | null;
declare const getColorBrightness: (color: string) => number;

declare const transactionPendingAnimation: {
    v: string;
    fr: number;
    ip: number;
    op: number;
    w: number;
    h: number;
    nm: string;
    ddd: number;
    assets: never[];
    layers: ({
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: ({
                            i: {
                                x: number;
                                y: number;
                            };
                            o: {
                                x: number;
                                y: number;
                            };
                            t: number;
                            s: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            }[];
                        } | {
                            t: number;
                            s: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            }[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: {
                            t: number;
                            s: number[];
                            h: number;
                        }[];
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    s?: undefined;
                    e?: undefined;
                    o?: undefined;
                    m?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    s: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    e: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    m: number;
                    ix: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ind?: undefined;
                    ks?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    s?: undefined;
                    e?: undefined;
                    m?: undefined;
                    p?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    e?: undefined;
                    m?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: ({
                        i: {
                            x: number[];
                            y: number[];
                        };
                        o: {
                            x: number[];
                            y: number[];
                        };
                        t: number;
                        s: number[];
                    } | {
                        t: number;
                        s: number[];
                        i?: undefined;
                        o?: undefined;
                    })[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        hd: boolean;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                s: boolean;
                x: {
                    a: number;
                    k: number;
                    ix: number;
                };
                y: {
                    a: number;
                    k: number;
                    ix: number;
                };
                a?: undefined;
                k?: undefined;
                ix?: undefined;
                l?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        ip: number;
        op: number;
        st: number;
        bm: number;
        parent?: undefined;
        shapes?: undefined;
        ct?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: ({
                            i: {
                                x: number;
                                y: number;
                            };
                            o: {
                                x: number;
                                y: number;
                            };
                            t: number;
                            s: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            }[];
                        } | {
                            t: number;
                            s: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            }[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: {
                            t: number;
                            s: number[];
                            h: number;
                        }[];
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    s?: undefined;
                    e?: undefined;
                    o?: undefined;
                    m?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    s: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    e: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    m: number;
                    ix: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ind?: undefined;
                    ks?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    s?: undefined;
                    e?: undefined;
                    m?: undefined;
                    p?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    e?: undefined;
                    m?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: ({
                        i: {
                            x: number[];
                            y: number[];
                        };
                        o: {
                            x: number[];
                            y: number[];
                        };
                        t: number;
                        s: number[];
                    } | {
                        t: number;
                        s: number[];
                        i?: undefined;
                        o?: undefined;
                    })[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                d: number;
                ty: string;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                a?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        parent?: undefined;
        hd?: undefined;
    })[];
    markers: never[];
};
declare const transactionProcessingAnimation: {
    v: string;
    fr: number;
    ip: number;
    op: number;
    w: number;
    h: number;
    nm: string;
    ddd: number;
    assets: never[];
    layers: ({
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
                x?: undefined;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: {
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        }[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        parent?: undefined;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
                x?: undefined;
            };
            p: {
                s: boolean;
                x: {
                    a: number;
                    k: number;
                    ix: number;
                };
                y: {
                    a: number;
                    k: number;
                    ix: number;
                };
                a?: undefined;
                k?: undefined;
                ix?: undefined;
                l?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        }[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        parent?: undefined;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
                x?: undefined;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: {
                            t: number;
                            s: number[];
                            h: number;
                        }[];
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: ({
                        i: {
                            x: number;
                            y: number;
                        };
                        o: {
                            x: number;
                            y: number;
                        };
                        t: number;
                        s: number[];
                        to: number[];
                        ti: number[];
                    } | {
                        t: number;
                        s: number[];
                        i?: undefined;
                        o?: undefined;
                        to?: undefined;
                        ti?: undefined;
                    })[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: ({
                        i: {
                            x: number[];
                            y: number[];
                        };
                        o: {
                            x: number[];
                            y: number[];
                        };
                        t: number;
                        s: number[];
                    } | {
                        t: number;
                        s: number[];
                        i?: undefined;
                        o?: undefined;
                    })[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: ({
                        i: {
                            x: number[];
                            y: number[];
                        };
                        o: {
                            x: number[];
                            y: number[];
                        };
                        t: number;
                        s: number[];
                    } | {
                        t: number;
                        s: number[];
                        i?: undefined;
                        o?: undefined;
                    })[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: ({
                        i: {
                            x: number[];
                            y: number[];
                        };
                        o: {
                            x: number[];
                            y: number[];
                        };
                        t: number;
                        s: number[];
                    } | {
                        t: number;
                        s: number[];
                        i?: undefined;
                        o?: undefined;
                    })[];
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        parent?: undefined;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
                x: string;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: {
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: ({
                        i: {
                            x: number[];
                            y: number[];
                        };
                        o: {
                            x: number[];
                            y: number[];
                        };
                        t: number;
                        s: number[];
                    } | {
                        t: number;
                        s: number[];
                        i?: undefined;
                        o?: undefined;
                    })[];
                    ix: number;
                    x: string;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        }[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
                x: string;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: {
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        }[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        hd: boolean;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
                x?: undefined;
            };
            p: {
                s: boolean;
                x: {
                    a: number;
                    k: number;
                    ix: number;
                };
                y: {
                    a: number;
                    k: number;
                    ix: number;
                };
                a?: undefined;
                k?: undefined;
                ix?: undefined;
                l?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        ip: number;
        op: number;
        st: number;
        bm: number;
        shapes?: undefined;
        ct?: undefined;
        parent?: undefined;
    })[];
    markers: never[];
};
declare const transactionFailureAnimation: {
    v: string;
    fr: number;
    ip: number;
    op: number;
    w: number;
    h: number;
    nm: string;
    ddd: number;
    assets: never[];
    layers: ({
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: {
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        }[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: {
                            t: number;
                            s: number[];
                            h: number;
                        }[];
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    d: number;
                    ty: string;
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    e?: undefined;
                    o?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    s: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    e: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    m: number;
                    ix: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    d?: undefined;
                    p?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    d?: undefined;
                    s?: undefined;
                    p?: undefined;
                    e?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    d?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    e?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        ip: number;
        op: number;
        st: number;
        bm: number;
        parent?: undefined;
        shapes?: undefined;
        ct?: undefined;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: {
                            t: number;
                            s: number[];
                            h: number;
                        }[];
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    d: number;
                    ty: string;
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    e?: undefined;
                    o?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    s: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    e: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    m: number;
                    ix: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    d?: undefined;
                    p?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    d?: undefined;
                    s?: undefined;
                    p?: undefined;
                    e?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    d?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    e?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: {
                            t: number;
                            s: number[];
                            h: number;
                        }[];
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    d: number;
                    ty: string;
                    s: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    e?: undefined;
                    o?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    s: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    e: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    m: number;
                    ix: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    d?: undefined;
                    p?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    d?: undefined;
                    s?: undefined;
                    p?: undefined;
                    e?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    d?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    e?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: ({
                        i: {
                            x: number[];
                            y: number[];
                        };
                        o: {
                            x: number[];
                            y: number[];
                        };
                        t: number;
                        s: number[];
                    } | {
                        t: number;
                        s: number[];
                        i?: undefined;
                        o?: undefined;
                    })[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: ({
                        i: {
                            x: number[];
                            y: number[];
                        };
                        o: {
                            x: number[];
                            y: number[];
                        };
                        t: number;
                        s: number[];
                    } | {
                        t: number;
                        s: number[];
                        i?: undefined;
                        o?: undefined;
                    })[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        hd: boolean;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                    h?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        ip: number;
        op: number;
        st: number;
        bm: number;
        parent?: undefined;
        shapes?: undefined;
        ct?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: {
                            t: number;
                            s: number[];
                            h: number;
                        }[];
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    d: number;
                    ty: string;
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    e?: undefined;
                    o?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    s: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    e: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    m: number;
                    ix: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    d?: undefined;
                    p?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    d?: undefined;
                    s?: undefined;
                    p?: undefined;
                    e?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    d?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    e?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: ({
                        i: {
                            x: number[];
                            y: number[];
                        };
                        o: {
                            x: number[];
                            y: number[];
                        };
                        t: number;
                        s: number[];
                    } | {
                        t: number;
                        s: number[];
                        i?: undefined;
                        o?: undefined;
                    })[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        hd: boolean;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        ip: number;
        op: number;
        st: number;
        bm: number;
        parent?: undefined;
        shapes?: undefined;
        ct?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                s: boolean;
                x: {
                    a: number;
                    k: ({
                        i: {
                            x: number[];
                            y: number[];
                        };
                        o: {
                            x: number[];
                            y: number[];
                        };
                        t: number;
                        s: number[];
                        h?: undefined;
                    } | {
                        t: number;
                        s: number[];
                        h: number;
                        i?: undefined;
                        o?: undefined;
                    } | {
                        t: number;
                        s: number[];
                        i?: undefined;
                        o?: undefined;
                        h?: undefined;
                    })[];
                    ix: number;
                };
                y: {
                    a: number;
                    k: number;
                    ix: number;
                };
                a?: undefined;
                k?: undefined;
                ix?: undefined;
                l?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                d: number;
                ty: string;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                a?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        parent?: undefined;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: {
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        }[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        parent?: undefined;
        hd?: undefined;
    })[];
    markers: never[];
};
declare const transactionSuccessAnimation: {
    v: string;
    fr: number;
    ip: number;
    op: number;
    w: number;
    h: number;
    nm: string;
    ddd: number;
    assets: never[];
    layers: ({
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ty: string;
                    it: ({
                        ind: number;
                        ty: string;
                        ix: number;
                        ks: {
                            a: number;
                            k: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            };
                            ix: number;
                        };
                        nm: string;
                        mn: string;
                        hd: boolean;
                        p?: undefined;
                        a?: undefined;
                        s?: undefined;
                        r?: undefined;
                        o?: undefined;
                        sk?: undefined;
                        sa?: undefined;
                    } | {
                        ty: string;
                        p: {
                            a: number;
                            k: number[];
                            ix: number;
                        };
                        a: {
                            a: number;
                            k: number[];
                            ix: number;
                        };
                        s: {
                            a: number;
                            k: number[];
                            ix: number;
                        };
                        r: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        o: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        sk: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        sa: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        nm: string;
                        ind?: undefined;
                        ix?: undefined;
                        ks?: undefined;
                        mn?: undefined;
                        hd?: undefined;
                    })[];
                    nm: string;
                    np: number;
                    cix: number;
                    bm: number;
                    ix: number;
                    mn: string;
                    hd: boolean;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    o?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: ({
                            i: {
                                x: number;
                                y: number;
                            };
                            o: {
                                x: number;
                                y: number;
                            };
                            t: number;
                            s: number[];
                            to: number[];
                            ti: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                            to?: undefined;
                            ti?: undefined;
                        })[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    it?: undefined;
                    np?: undefined;
                    cix?: undefined;
                    bm?: undefined;
                    ix?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ln?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: {
                        t: number;
                        s: number[];
                        h: number;
                    }[];
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                ix?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ty: string;
                    it: ({
                        ind: number;
                        ty: string;
                        ix: number;
                        ks: {
                            a: number;
                            k: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            };
                            ix: number;
                        };
                        nm: string;
                        mn: string;
                        hd: boolean;
                        s?: undefined;
                        e?: undefined;
                        o?: undefined;
                        m?: undefined;
                        p?: undefined;
                        a?: undefined;
                        r?: undefined;
                        sk?: undefined;
                        sa?: undefined;
                    } | {
                        ty: string;
                        s: {
                            a: number;
                            k: ({
                                i: {
                                    x: number[];
                                    y: number[];
                                };
                                o: {
                                    x: number[];
                                    y: number[];
                                };
                                t: number;
                                s: number[];
                            } | {
                                t: number;
                                s: number[];
                                i?: undefined;
                                o?: undefined;
                            })[];
                            ix: number;
                        };
                        e: {
                            a: number;
                            k: ({
                                i: {
                                    x: number[];
                                    y: number[];
                                };
                                o: {
                                    x: number[];
                                    y: number[];
                                };
                                t: number;
                                s: number[];
                            } | {
                                t: number;
                                s: number[];
                                i?: undefined;
                                o?: undefined;
                            })[];
                            ix: number;
                        };
                        o: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        m: number;
                        ix: number;
                        nm: string;
                        mn: string;
                        hd: boolean;
                        ind?: undefined;
                        ks?: undefined;
                        p?: undefined;
                        a?: undefined;
                        r?: undefined;
                        sk?: undefined;
                        sa?: undefined;
                    } | {
                        ty: string;
                        p: {
                            a: number;
                            k: number[];
                            ix: number;
                        };
                        a: {
                            a: number;
                            k: number[];
                            ix: number;
                        };
                        s: {
                            a: number;
                            k: number[];
                            ix: number;
                        };
                        r: {
                            a: number;
                            k: ({
                                i: {
                                    x: number[];
                                    y: number[];
                                };
                                o: {
                                    x: number[];
                                    y: number[];
                                };
                                t: number;
                                s: number[];
                            } | {
                                t: number;
                                s: number[];
                                i?: undefined;
                                o?: undefined;
                            })[];
                            ix: number;
                        };
                        o: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        sk: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        sa: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        nm: string;
                        ind?: undefined;
                        ix?: undefined;
                        ks?: undefined;
                        mn?: undefined;
                        hd?: undefined;
                        e?: undefined;
                        m?: undefined;
                    })[];
                    nm: string;
                    np: number;
                    cix: number;
                    bm: number;
                    ix: number;
                    mn: string;
                    hd: boolean;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    o?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    it: ({
                        ind: number;
                        ty: string;
                        ix: number;
                        ks: {
                            a: number;
                            k: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            };
                            ix: number;
                        };
                        nm: string;
                        mn: string;
                        hd: boolean;
                        s?: undefined;
                        e?: undefined;
                        o?: undefined;
                        m?: undefined;
                        p?: undefined;
                        a?: undefined;
                        r?: undefined;
                        sk?: undefined;
                        sa?: undefined;
                    } | {
                        ty: string;
                        s: {
                            a: number;
                            k: ({
                                i: {
                                    x: number[];
                                    y: number[];
                                };
                                o: {
                                    x: number[];
                                    y: number[];
                                };
                                t: number;
                                s: number[];
                            } | {
                                t: number;
                                s: number[];
                                i?: undefined;
                                o?: undefined;
                            })[];
                            ix: number;
                        };
                        e: {
                            a: number;
                            k: ({
                                i: {
                                    x: number[];
                                    y: number[];
                                };
                                o: {
                                    x: number[];
                                    y: number[];
                                };
                                t: number;
                                s: number[];
                            } | {
                                t: number;
                                s: number[];
                                i?: undefined;
                                o?: undefined;
                            })[];
                            ix: number;
                        };
                        o: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        m: number;
                        ix: number;
                        nm: string;
                        mn: string;
                        hd: boolean;
                        ind?: undefined;
                        ks?: undefined;
                        p?: undefined;
                        a?: undefined;
                        r?: undefined;
                        sk?: undefined;
                        sa?: undefined;
                    } | {
                        ty: string;
                        p: {
                            a: number;
                            k: number[];
                            ix: number;
                        };
                        a: {
                            a: number;
                            k: number[];
                            ix: number;
                        };
                        s: {
                            a: number;
                            k: number[];
                            ix: number;
                        };
                        r: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        o: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        sk: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        sa: {
                            a: number;
                            k: number;
                            ix: number;
                        };
                        nm: string;
                        ind?: undefined;
                        ix?: undefined;
                        ks?: undefined;
                        mn?: undefined;
                        hd?: undefined;
                        e?: undefined;
                        m?: undefined;
                    })[];
                    nm: string;
                    np: number;
                    cix: number;
                    bm: number;
                    ix: number;
                    mn: string;
                    hd: boolean;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    o?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: ({
                            i: {
                                x: number;
                                y: number;
                            };
                            o: {
                                x: number;
                                y: number;
                            };
                            t: number;
                            s: number[];
                            to: number[];
                            ti: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                            to?: undefined;
                            ti?: undefined;
                        })[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    it?: undefined;
                    np?: undefined;
                    cix?: undefined;
                    bm?: undefined;
                    ix?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ln?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                ix?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                d: number;
                ty: string;
                s: {
                    a: number;
                    k: ({
                        i: {
                            x: number[];
                            y: number[];
                        };
                        o: {
                            x: number[];
                            y: number[];
                        };
                        t: number;
                        s: number[];
                    } | {
                        t: number;
                        s: number[];
                        i?: undefined;
                        o?: undefined;
                    })[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                d: number;
                ty: string;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                a?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
    })[];
    markers: never[];
};
declare const transactionHalfSuccessAnimation: {
    v: string;
    fr: number;
    ip: number;
    op: number;
    w: number;
    h: number;
    nm: string;
    ddd: number;
    assets: never[];
    layers: ({
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        parent?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                d: number;
                ty: string;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        parent?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: {
                            t: number;
                            s: number[];
                            h: number;
                        }[];
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                d: number;
                ty: string;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        parent?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: {
            ty: string;
            it: ({
                d: number;
                ty: string;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                a?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        }[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
    })[];
    markers: never[];
};
declare const transactionErrorPauseAnimation: {
    v: string;
    fr: number;
    ip: number;
    op: number;
    w: number;
    h: number;
    nm: string;
    ddd: number;
    assets: never[];
    layers: ({
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: {
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        }[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        parent?: undefined;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                    h?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: {
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                r?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        }[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                    h?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: {
                            t: number;
                            s: number[];
                            h: number;
                        }[];
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                    h?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                })[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: {
                            t: number;
                            s: number[];
                            h: number;
                        }[];
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        hd: boolean;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                s: boolean;
                x: {
                    a: number;
                    k: number;
                    ix: number;
                };
                y: {
                    a: number;
                    k: number;
                    ix: number;
                };
                a?: undefined;
                k?: undefined;
                ix?: undefined;
                l?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        ip: number;
        op: number;
        st: number;
        bm: number;
        shapes?: undefined;
        ct?: undefined;
        parent?: undefined;
    })[];
    markers: never[];
};
declare const transactionRejectedAnimation: {
    v: string;
    fr: number;
    ip: number;
    op: number;
    w: number;
    h: number;
    nm: string;
    ddd: number;
    assets: never[];
    layers: ({
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    h?: undefined;
                })[];
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                })[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: ({
                            i: {
                                x: number;
                                y: number;
                            };
                            o: {
                                x: number;
                                y: number;
                            };
                            t: number;
                            s: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            }[];
                        } | {
                            t: number;
                            s: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            }[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: ({
                            i: {
                                x: number;
                                y: number;
                            };
                            o: {
                                x: number;
                                y: number;
                            };
                            t: number;
                            s: number[];
                            to: number[];
                            ti: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                            to?: undefined;
                            ti?: undefined;
                        })[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: {
                            t: number;
                            s: number[];
                            h: number;
                        }[];
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    d: number;
                    ty: string;
                    s: {
                        a: number;
                        k: ({
                            t: number;
                            s: number[];
                            h: number;
                            i?: undefined;
                            o?: undefined;
                        } | {
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                            h?: undefined;
                        } | {
                            t: number;
                            s: number[];
                            h?: undefined;
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    p: {
                        a: number;
                        k: ({
                            t: number;
                            s: number[];
                            h: number;
                            i?: undefined;
                            o?: undefined;
                            to?: undefined;
                            ti?: undefined;
                        } | {
                            i: {
                                x: number;
                                y: number;
                            };
                            o: {
                                x: number;
                                y: number;
                            };
                            t: number;
                            s: number[];
                            to: number[];
                            ti: number[];
                            h?: undefined;
                        } | {
                            t: number;
                            s: number[];
                            h?: undefined;
                            i?: undefined;
                            o?: undefined;
                            to?: undefined;
                            ti?: undefined;
                        })[];
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    e?: undefined;
                    o?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    s: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                            h?: undefined;
                        } | {
                            t: number;
                            s: number[];
                            h: number;
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    e: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                            h?: undefined;
                        } | {
                            t: number;
                            s: number[];
                            h: number;
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    m: number;
                    ix: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    d?: undefined;
                    p?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    d?: undefined;
                    s?: undefined;
                    p?: undefined;
                    e?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    d?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    e?: undefined;
                    m?: undefined;
                    ix?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        hd: boolean;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                s: boolean;
                x: {
                    a: number;
                    k: number;
                    ix: number;
                };
                y: {
                    a: number;
                    k: number;
                    ix: number;
                };
                a?: undefined;
                k?: undefined;
                ix?: undefined;
                l?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        ip: number;
        op: number;
        st: number;
        bm: number;
        parent?: undefined;
        shapes?: undefined;
        ct?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        parent: number;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: ({
                    i: {
                        x: number[];
                        y: number[];
                    };
                    o: {
                        x: number[];
                        y: number[];
                    };
                    t: number;
                    s: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    h?: undefined;
                })[];
                ix: number;
            };
            p: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                    h?: undefined;
                })[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: ({
                    i: {
                        x: number;
                        y: number;
                    };
                    o: {
                        x: number;
                        y: number;
                    };
                    t: number;
                    s: number[];
                    to: number[];
                    ti: number[];
                    h?: undefined;
                } | {
                    t: number;
                    s: number[];
                    h: number;
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                } | {
                    t: number;
                    s: number[];
                    i?: undefined;
                    o?: undefined;
                    to?: undefined;
                    ti?: undefined;
                    h?: undefined;
                })[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: ({
                            i: {
                                x: number;
                                y: number;
                            };
                            o: {
                                x: number;
                                y: number;
                            };
                            t: number;
                            s: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            }[];
                        } | {
                            t: number;
                            s: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            }[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    c?: undefined;
                    o?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    p?: undefined;
                    a?: undefined;
                    s?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: ({
                            i: {
                                x: number;
                                y: number;
                            };
                            o: {
                                x: number;
                                y: number;
                            };
                            t: number;
                            s: number[];
                            to: number[];
                            ti: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                            to?: undefined;
                            ti?: undefined;
                        })[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: {
                            t: number;
                            s: number[];
                            h: number;
                        }[];
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: {
                            i: number[][];
                            o: number[][];
                            v: number[][];
                            c: boolean;
                        };
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    s?: undefined;
                    e?: undefined;
                    o?: undefined;
                    m?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    s: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    e: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    m: number;
                    ix: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ind?: undefined;
                    ks?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    s?: undefined;
                    e?: undefined;
                    m?: undefined;
                    p?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: ({
                            i: {
                                x: number;
                                y: number;
                            };
                            o: {
                                x: number;
                                y: number;
                            };
                            t: number;
                            s: number[];
                            to: number[];
                            ti: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                            to?: undefined;
                            ti?: undefined;
                        })[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    e?: undefined;
                    m?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                it: ({
                    ind: number;
                    ty: string;
                    ix: number;
                    ks: {
                        a: number;
                        k: ({
                            i: {
                                x: number;
                                y: number;
                            };
                            o: {
                                x: number;
                                y: number;
                            };
                            t: number;
                            s: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            }[];
                        } | {
                            t: number;
                            s: {
                                i: number[][];
                                o: number[][];
                                v: number[][];
                                c: boolean;
                            }[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    nm: string;
                    mn: string;
                    hd: boolean;
                    s?: undefined;
                    e?: undefined;
                    o?: undefined;
                    m?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    s: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    e: {
                        a: number;
                        k: ({
                            i: {
                                x: number[];
                                y: number[];
                            };
                            o: {
                                x: number[];
                                y: number[];
                            };
                            t: number;
                            s: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                        })[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    m: number;
                    ix: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ind?: undefined;
                    ks?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                    p?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    c: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    w: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    lc: number;
                    lj: number;
                    bm: number;
                    nm: string;
                    mn: string;
                    hd: boolean;
                    ln: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    s?: undefined;
                    e?: undefined;
                    m?: undefined;
                    p?: undefined;
                    a?: undefined;
                    r?: undefined;
                    sk?: undefined;
                    sa?: undefined;
                } | {
                    ty: string;
                    p: {
                        a: number;
                        k: ({
                            i: {
                                x: number;
                                y: number;
                            };
                            o: {
                                x: number;
                                y: number;
                            };
                            t: number;
                            s: number[];
                            to: number[];
                            ti: number[];
                        } | {
                            t: number;
                            s: number[];
                            i?: undefined;
                            o?: undefined;
                            to?: undefined;
                            ti?: undefined;
                        })[];
                        ix: number;
                    };
                    a: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    s: {
                        a: number;
                        k: number[];
                        ix: number;
                    };
                    r: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    o: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sk: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    sa: {
                        a: number;
                        k: number;
                        ix: number;
                    };
                    nm: string;
                    ind?: undefined;
                    ix?: undefined;
                    ks?: undefined;
                    mn?: undefined;
                    hd?: undefined;
                    e?: undefined;
                    m?: undefined;
                    c?: undefined;
                    w?: undefined;
                    lc?: undefined;
                    lj?: undefined;
                    bm?: undefined;
                    ln?: undefined;
                })[];
                nm: string;
                np: number;
                cix: number;
                bm: number;
                ix: number;
                mn: string;
                hd: boolean;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                o?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                it?: undefined;
                np?: undefined;
                cix?: undefined;
                bm?: undefined;
                ix?: undefined;
                mn?: undefined;
                hd?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                ty: string;
                d: number;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                ml: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                r?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                r: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                a?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                ml?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        hd?: undefined;
    } | {
        ddd: number;
        ind: number;
        ty: number;
        nm: string;
        sr: number;
        ks: {
            o: {
                a: number;
                k: number;
                ix: number;
            };
            r: {
                a: number;
                k: number;
                ix: number;
            };
            p: {
                a: number;
                k: number[];
                ix: number;
                l: number;
                s?: undefined;
                x?: undefined;
                y?: undefined;
            };
            a: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
            s: {
                a: number;
                k: number[];
                ix: number;
                l: number;
            };
        };
        ao: number;
        shapes: ({
            ty: string;
            it: ({
                ind: number;
                ty: string;
                ix: number;
                ks: {
                    a: number;
                    k: {
                        i: number[][];
                        o: number[][];
                        v: number[][];
                        c: boolean;
                    };
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                p?: undefined;
                a?: undefined;
                s?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                ind?: undefined;
                ix?: undefined;
                ks?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        } | {
            ty: string;
            it: ({
                d: number;
                ty: string;
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                nm: string;
                mn: string;
                hd: boolean;
                c?: undefined;
                o?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
                a?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                c: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                w: {
                    a: number;
                    k: number;
                    ix: number;
                };
                lc: number;
                lj: number;
                bm: number;
                nm: string;
                mn: string;
                hd: boolean;
                ln: string;
                d?: undefined;
                s?: undefined;
                p?: undefined;
                a?: undefined;
                r?: undefined;
                sk?: undefined;
                sa?: undefined;
            } | {
                ty: string;
                p: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                a: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                s: {
                    a: number;
                    k: number[];
                    ix: number;
                };
                r: {
                    a: number;
                    k: number;
                    ix: number;
                };
                o: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sk: {
                    a: number;
                    k: number;
                    ix: number;
                };
                sa: {
                    a: number;
                    k: number;
                    ix: number;
                };
                nm: string;
                d?: undefined;
                mn?: undefined;
                hd?: undefined;
                c?: undefined;
                w?: undefined;
                lc?: undefined;
                lj?: undefined;
                bm?: undefined;
                ln?: undefined;
            })[];
            nm: string;
            np: number;
            cix: number;
            bm: number;
            ix: number;
            mn: string;
            hd: boolean;
        })[];
        ip: number;
        op: number;
        st: number;
        ct: number;
        bm: number;
        parent?: undefined;
        hd?: undefined;
    })[];
    markers: never[];
};

export { ANIMATION_DURATIONS, AccountListItem, AccountsButton, type ActionButton, ActionLayout, ActionLineOutRow, ActionProperties, ActionRow, type ActionStatus, ActionStatusRow, ActionWrapper, AddressButton, AddressHeader, type AllOrNone, AnimateNumber, AnimationCard, AnimationWrapper, Announcement, type AnnouncementProps, AppContainer, ApplePayIcon, Approve, ApproveAction, ArrowBottomTopIcon, ArrowButton, ArrowCornerDownRightIcon, ArrowDownIcon, ArrowExpandIcon, ArrowLeftIcon, ArrowOutOfBoxIcon, ArrowRightDownCircleIcon, ArrowRightDownIcon, ArrowRightIcon, ArrowRightUpCircleFilledIcon, ArrowRightUpCircleIcon, ArrowRightUpIcon, ArrowRotate, ArrowSplit, ArrowTriangle, ArrowUpIcon, ArrowWallDownIcon, ArrowsSwapIcon, AssetsButton, type AssetsButtonVariant, AtomIcon, BackpackIcon, BadgeImage, BankIcon, type BaseActionProps, type BaseTransactionViewProps, BellAlarmIcon, BlockSkeleton, BodyText, BoostBadge, BorderedContainer, Breadcrumb, BridgeAction, BrokenHeartIcon, BubblesIcon, Button, type ButtonProps, type ButtonSize, type ButtonVariant, BuyNFTTransactionView, CSS_VARS, Calendar, CaptionText, Card, CatSquareIcon, CelebrateIcon, ChainLink, Checkbox, Checkmark1Icon, Checkmark2Icon, ChevronArrowIcon, ChevronDownSmallIcon, ChevronGrabberVerticalIcon, ChevronLargeDownIcon, ChevronLargeRightIcon, ChevronRightIcon, ChevronRightSmallIcon, ChevronTopIcon, ChevronTopSmallIcon, Chip, type ChipProps, CircleCheckIcon, CircleMinusIcon, CirclePlusIcon, CircleX, CircleXFilledIcon, ClockOutlineIcon, ClockSolidIcon, CodeBracketsIcon, CodeSolidSquareIcon, CoinsAddIcon, CoinsIcon, CoinsOutlinedIcon, Collapse, CollapsibleMenu, type Collection, CollectionIcon, ColorPaletteIcon, CommandIcon, CompassRoundOutlinedIcon, CompassRoundSolidIcon, ConsoleIcon, Copy2Icon, CopyOutlinedIcon, CreditCardIcon, CrossAnimatedIcon, CrossedOutSunSolidIcon, DashboardFast, type DeepPartial, DepositAddressView, type DescriptionBlock, DescriptionBlocks, DetailsToolbar, DiscordIcon, DockIconAnalytics, DockIconCheckout, DockIconHelp, DockIconProfile, DockIconScan, DockIconSwap, DockSwapIcon, DollarOutlinedIcon, DollarSolidIcon, DotGrid1x3HorizontalIcon, Drip, DropdownMenu, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuTitle, type DropdownPosition, type DropdownStyles, EmojiMeh, EmojiSadIcon, EmptyHeartIcon, ErrorMessage, EthereumIcon, ExplosionIcon, EyeOpenIcon, FarcasterIcon, FavouriteFilterIcon, FeeButton, FeesAction, type FeesActionProps, FeesLines, FeesTotal, FileDownloadIcon, FilledHeartIcon, FilterAscendingIcon, FilterButton, FilterIcon, FilterTimelineIcon, GasIcon, GhostCircleIcon, GhostIcon, GithubIcon, GooglePayIcon, HashLink, HeadingText, HeartSmallIcon, HelpIcon, HighestPriceRangeIcon, HistoryItem, type HistoryItemStatus, HomeIcon, IconButton, type IconButtonProps, IconLabel, Image, ImageGroup, ImageIcon, type ImageProps, ImageSparkle, ImageStack, ImageState, IncompleteAction, InfinityIcon, InfoBox, Inline, Input, InteractionTransactionView, Join, LaptopIcon, LargeNumericInput, LimitIcon, LinkIcon, ListItem, ListItemActionsButton, Loader, LoadingProvider, LoadingSkeleton, LoadingText, MEDIA_QUERIES, MarketCapIcon, MaxIcon, Menu, MenuItem, MenuSwapIcon, MirrorIcon, Modal, ModalContent, ModalContentDivider, ModalTitle, MoneyBagIcon, MoonIcon, type NFT, NavigationBar, NewsIcon, NewspaperIcon, NotAllowedIcon, NumericInput, type NumericInputProps, PathSquareIcon, PauseIcon, PercentIcon, PhoneIcon, PieChartIcon, PipeSeparator, PluginIcon, PlusIcon, PoopIcon, PowerIcon, PriceChange, ProductCard, PropertiesLayout, PropertyListItem, type PropertyListItemProps, type Props$2 as Props, type PublicTheme, PunkIcon, QrCode, QrCodeIcon, QrCodeModal, RangeInput, ReceiptBillIcon, ReceiveNFTAction, ReceiveTokensAction, RefreshIcon, ReorderIcon, RouteStep, STEP_ITEM_HEIGHT, SearchIcon, SectionTitle, SendTokensAction, type Settings, SettingsButton, type SettingsButtonProps, type SettingsControl, SettingsGearIcon, SettingsItem, type SettingsItemProps, SettingsSlider, SettingsSliderIcon, type SettingsSliderProps, ShoppingBagIcon, SizeTransition, SmileFilledIcon, SmileIcon, SnapIcon, SortIcon, SparkleIcon, SparklesIcon, SquareArrowCenter, SquareArrowTopLeftIcon, SquareArrowTopRight2Icon, SquareArrowTopRightIcon, SquidLogo, StakeAction, StarLinesIcon, StartAction, StocksIcon, SuccessAction, SunIcon, SunOutlinedIcon, SunriseIcon, SunriseSmallIcon, SwapAction, SwapConfiguration, SwapErrorIcon, SwapIcon, SwapInputsIcon, SwapProgressView, SwapState, type SwapStep, SwapStepItem, SwapStepSeparator, SwapStepsCollapsed, type SwapStepsCollapsedFooterButton, SwapSuccessIcon, SwapTransactionView, SwapWarningIcon, Switch, type SwitchProps, Tab, Tabs, TagIcon, TagIconFilled, TelegramIcon, TextSkeleton, type Theme, ThemePreference, ThemeProvider, type ThemeType, ThumbsUp, Tick, TickLarge, TimeFliesIcon, TimeFliesSolidIcon, type Timeframe, Timeline, Timestamp, Toast, TokenDetailsView, TokenGroup, type TokenGroupProps, type TokenGroupVariant, TokenGroups, TokenOnlyButton, TokenPair, Tooltip, type TooltipProps, type TooltipThreshold, type TooltipWidth, TradingViewStepsIcon, TransactionAction, type TransactionActionProps, type TransactionActionType, TransactionFilters, TransactionHeaderLayout, TransactionItem, type TransactionItemProps, TransactionItemSkeleton, TransactionNotFoundView, TransactionSearch, TransactionState, TransactionView, TransactionViewLayout, type TransactionViewProps, Transfer, TranslateIcon, TriangleExclamation, TxProgressViewHeader, UnsupportedPairNotice, UsdAmount, UserInputType, WalletFilledIcon, WalletIcon, WalletLink, WrapAction, XSocialIcon, adjustColorForContrast, baseTailwindConfig, blendColors, buttonRoundedClassMap, cn, darkTheme, getColorBrightness, getContrastColor, getHexColorFromOpacityPercentage, hexToRgb, isValidHexColor, lightTheme, linkActionTimelineProps, parseColor, parseSquidTheme, pxToRem, remToPx, rgbToHex, spacing, statusTextClassMap, themeKeysToCssVariables, transactionErrorPauseAnimation, transactionFailureAnimation, transactionHalfSuccessAnimation, transactionPendingAnimation, transactionProcessingAnimation, transactionRejectedAnimation, transactionSuccessAnimation, useCollapsibleMenu, useDropdownMenu, useMediaQuery, useNumericInput, useOnResize, useRect, useTimer, useUserTheme, useVersion };