import * as AccordionPrimitive from "@radix-ui/react-accordion"; import { VariantProps } from "class-variance-authority"; import * as React$2 from "react"; import React$1, { Context, ForwardedRef, JSX, ReactElement, ReactNode } from "react"; import { AddressCandidateClassification } from "@openzeppelin/ui-utils"; import * as react_jsx_runtime0 from "react/jsx-runtime"; import * as TooltipPrimitive from "@radix-ui/react-tooltip"; import { DateRange, DayPicker } from "react-day-picker"; import * as CheckboxPrimitive from "@radix-ui/react-checkbox"; import * as PopoverPrimitive from "@radix-ui/react-popover"; import * as DialogPrimitive from "@radix-ui/react-dialog"; import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu"; import { Control, FieldError, FieldPath, FieldValues, FormProvider, UseFormReturn } from "react-hook-form"; import * as _radix_ui_react_label0 from "@radix-ui/react-label"; import * as ProgressPrimitive from "@radix-ui/react-progress"; import * as RadioGroupPrimitive from "@radix-ui/react-radio-group"; import * as SelectPrimitive from "@radix-ui/react-select"; import * as TabsPrimitive from "@radix-ui/react-tabs"; import { AddressLabelResolver, AddressNameResolver, AddressSuggestion, AddressSuggestionResolver, AddressingCapability, ContractSchema, Ecosystem, EcosystemMetadata, EnumValue, FieldValidation, FormFieldType, FunctionParameter, MapEntry, NameResolutionError, NameResolver, NetworkConfig, NetworkLabelResolver, NetworkType, RelayerDetails, RelayerDetailsRich, ResolutionResult, ResolvedAddress, ResolvedName, RuntimeCapability, TypeMappingCapability } from "@openzeppelin/ui-types"; import { ToasterProps } from "sonner"; import * as class_variance_authority_types0 from "class-variance-authority/types"; //#region src/version.d.ts declare const VERSION: string; //#endregion //#region src/components/ui/accordion.d.ts declare const accordionItemVariants: (props?: ({ variant?: "default" | "card" | null | undefined; } & class_variance_authority_types0.ClassProp) | undefined) => string; declare const accordionTriggerVariants: (props?: ({ variant?: "default" | "card" | null | undefined; } & class_variance_authority_types0.ClassProp) | undefined) => string; declare const accordionContentVariants: (props?: ({ variant?: "default" | "card" | null | undefined; } & class_variance_authority_types0.ClassProp) | undefined) => string; type AccordionVariant = 'default' | 'card'; type AccordionProps = (AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & { variant?: AccordionVariant; }; declare const Accordion: React$2.ForwardRefExoticComponent>; interface AccordionItemProps extends React$2.ComponentPropsWithoutRef, VariantProps {} declare const AccordionItem: React$2.ForwardRefExoticComponent>; interface AccordionTriggerProps extends React$2.ComponentPropsWithoutRef, VariantProps {} declare const AccordionTrigger: React$2.ForwardRefExoticComponent>; interface AccordionContentProps extends React$2.ComponentPropsWithoutRef, VariantProps {} declare const AccordionContent: React$2.ForwardRefExoticComponent>; //#endregion //#region src/components/ui/address-display/address-avatar.d.ts /** * Visual treatment for {@link AddressAvatar}. * * - `'fill'` – a square avatar that stretches to the parent slot's full * height and sits flush against its edges (default). Intended for a chip * whose container clips it with `overflow-hidden` + a border radius. * - `'circle'` – small round avatar sitting inline with the text (the * original look, kept as an opt-in). */ type AddressAvatarVariant = 'circle' | 'fill'; //#endregion //#region src/components/ui/address-display/address-display.d.ts /** * Visual style for the component container. * * - `"chip"` – rounded pill with a slate background (default). * - `"inline"` – no background, padding, or border-radius; just the text * and optional action buttons. Use when dropping into existing layouts * where the parent already provides styling (e.g. wallet display bars). */ type AddressDisplayVariant = 'chip' | 'inline'; interface AddressDisplayProps extends React$2.HTMLAttributes { /** * The blockchain address to display */ address: string; /** * Whether to truncate the address in the middle. * When omitted, defaults to `true` unless `truncateWhenLabeled` applies. */ truncate?: boolean; /** * When `true` and `truncate` is **not** explicitly set, the address truncates * only when a label is shown (via the `label` prop or * `AddressLabelContext`). Use this when a long raw address should stay * fully visible unless an alias already identifies the row. * @default false */ truncateWhenLabeled?: boolean; /** * When `truncate` is true, show the full address while the pointer is over * the component (on devices that support hover), or toggle on tap * (on touch-first / `(hover: none)` devices). * Has no effect when `truncate` is false. * @default false */ untruncateOnHover?: boolean; /** * Number of characters to show at the beginning when truncating * @default 6 */ startChars?: number; /** * Number of characters to show at the end when truncating * @default 4 */ endChars?: number; /** * Whether to show a copy button * @default false */ showCopyButton?: boolean; /** * Whether to show the copy button only on hover * @default false */ showCopyButtonOnHover?: boolean; /** * Optional explorer URL to make the address clickable */ explorerUrl?: string; /** * Human-readable label to display alongside the address. * Takes priority over any label resolved via `AddressLabelContext`. */ label?: string; /** * Callback to trigger label editing for this address. * When provided, a pencil icon is rendered. Takes priority over * the `onEditLabel` from `AddressLabelContext`. */ onLabelEdit?: () => void; /** * Optional network identifier used when resolving labels and triggering * edits via `AddressLabelContext`. Important for multi-network scenarios * where the same address may have different aliases per network. */ networkId?: string; /** * When `true`, render the instance fully raw: skip label resolution from * `AddressLabelContext` AND suppress any injected resolved name * (`resolvedName` prop / `AddressNameContext`). Useful for rendering an * address without any decoration (e.g. in a contract selector where the * contract name is already shown) — existing `disableLabel` call-sites * must not sprout a name once a resolver is wired app-wide. * @default false */ disableLabel?: boolean; /** * When `true` and the address is truncated, a tooltip shows the full * address on hover. Has no visual effect when `truncate` is `false`. * Mutually exclusive with `untruncateOnHover` — if both are set, * `showTooltip` takes precedence. * @default false */ showTooltip?: boolean; /** * Visual variant of the component container. * @default "chip" */ variant?: AddressDisplayVariant; /** * Optional presentational leading element (e.g. an avatar or icon), rendered * before the label/address block and vertically centered against it. Purely * visual — a `React.ReactNode`, not a capability, so this component stays * chain-agnostic. When omitted (the default at every existing call-site), the * rendered DOM and layout are byte-for-byte identical to the pre-avatar * component: no wrapper element, no reserved slot, in both render branches. */ avatar?: React$2.ReactNode; /** * Visual treatment for the leading avatar (both the record-constructed ENS * avatar and an explicit `avatar` node): * * - `'fill'` – a square avatar that stretches to the chip's full height and * sits flush against its top, bottom, and left edges (default; the chip * clips its outer corners). No effect when no avatar is shown. * - `'circle'` – small round avatar sitting inline with the text (the * original look, kept as an opt-in). * * @default "fill" */ avatarVariant?: AddressAvatarVariant; /** * An already-resolved reverse name record for this address (value type). * Highest precedence for the name channel — shadows the * `AddressNameContext` resolver, exactly as `label` shadows * `AddressLabelContext` (INV-120). The record's name renders only when * `forwardVerified === true` (INV-52, LOCKED): a mismatched record is * suppressed to hex — never name-alone, never name+warning. `undefined` * falls back to the context (if any), then to hex. */ resolvedName?: ResolvedName; /** * When `false`, suppresses the reverse cross-network fallback indicator * (amber triangle-alert icon + tooltip) inline after the verified name. * Default `true`. Provenance classification is unchanged — only presentation * is omitted so the labeled branch stays byte-identical to a row without fallback. */ showCrossNetworkFallbackDisclaimer?: boolean; /** * Additional CSS classes */ className?: string; } /** * Displays a blockchain address with optional truncation, copy button, * explorer link, tooltip, human-readable label, and (when an already-resolved * record is injected) a forward-verified name + avatar. * * Labels are resolved in priority order (INV-56): * 1. Explicit `label` prop * 2. `AddressLabelContext` resolver (via `AddressLabelProvider`) * 3. Forward-verified resolved name (`resolvedName` prop, else * `AddressNameContext` via `AddressNameProvider`) — a record with * `forwardVerified: false` is suppressed to hex (INV-52, LOCKED) * 4. No label (renders address only, identical to previous behavior) * * The component is synchronous and capability-free (INV-121): it never * resolves anything itself — it reads injected values. Hex renders on first * commit; the name+avatar swap in when the react layer feeds an updated * record (progressive enhancement, INV-61). With no `resolvedName` and no * `AddressNameProvider`, output is byte-identical to the pre-enhancement * component (INV-54, LOCKED). * * Pass `disableLabel` to render fully raw — it suppresses both the context * alias and any injected resolved name (e.g. when the surrounding UI already * shows a name, such as a contract selector). * * @example * ```tsx * // Basic usage (unchanged) * * * // Explicit label * * * // Auto-resolved via context (no changes needed at call site) * * * * * // Suppress label resolution for a specific instance * * * // Reveal full address on hover (still truncated when idle) * * * // Tooltip with full address on hover + copy icon on hover * * * // Inline variant (no chip background) — useful inside wallet bars * * * // Reverse-resolved name + avatar via an injected value (react layer owns the async) * * * // Or subtree-wide via context (rows stay plain ) * * * * * // Truncate only when an alias/label is present (full address when unlabeled) * * ``` */ declare function AddressDisplay({ address, truncate: truncateProp, truncateWhenLabeled, untruncateOnHover, startChars, endChars, showCopyButton, showCopyButtonOnHover, explorerUrl, label: labelProp, onLabelEdit: onLabelEditProp, networkId, disableLabel, showTooltip, variant, avatar, avatarVariant, resolvedName, showCrossNetworkFallbackDisclaimer, className, onPointerEnter, onPointerLeave, onMouseEnter, onMouseLeave, onClick, ...props }: AddressDisplayProps): React$2.ReactElement; //#endregion //#region src/components/ui/address-display/address-label-context.d.ts /** * Props for `AddressLabelProvider`. * * Accepts the same shape as `AddressLabelResolver` so the provider can be * spread directly from a resolver hook: ``. */ interface AddressLabelProviderProps extends AddressLabelResolver { children: React$2.ReactNode; } /** * Provides address label resolution to all `AddressDisplay` instances in the * subtree. Wrap your application (or a subsection) with this provider and * supply a `resolveLabel` function. * * @param props - Resolver functions and children * * @example * ```tsx * addressBook.get(addr)} * onEditLabel={(addr) => openEditor(addr)} * > * * * ``` */ declare function AddressLabelProvider({ children, resolveLabel, onEditLabel }: AddressLabelProviderProps): React$2.ReactElement; //#endregion //#region src/components/ui/address-display/use-address-label.d.ts /** * Return type for the `useAddressLabel` convenience hook. */ interface UseAddressLabelResult { /** Resolved label, or `undefined` if no resolver/label exists */ label: string | undefined; /** Edit handler bound to this address, or `undefined` if editing is not supported */ onEdit: (() => void) | undefined; } /** * Convenience hook that resolves a label for a specific address using the * nearest `AddressLabelProvider`. Returns `undefined` values when no provider * is mounted. * * @param address - The blockchain address to resolve * @param networkId - Optional network identifier for network-specific aliases * @returns Resolved label and edit handler for the address * * @example * ```tsx * function MyAddress({ address }: { address: string }) { * const { label, onEdit } = useAddressLabel(address, 'ethereum-mainnet'); * return {label ?? address}; * } * ``` */ declare function useAddressLabel(address: string, networkId?: string): UseAddressLabelResult; //#endregion //#region src/components/ui/address-display/address-name-context.d.ts /** * Props for `AddressNameProvider`. * * Accepts the same shape as `AddressNameResolver` so the provider can be * spread directly from a resolver source: ``. */ interface AddressNameProviderProps extends AddressNameResolver { children: React$2.ReactNode; } /** * Provides reverse-name resolution to all `AddressDisplay` instances in the * subtree. `resolveAddressName` MUST be synchronous — it is called during * render (INV-122). A resolver that returns `undefined` for an address is * behaviorally identical to mounting no provider (INV-54). * * @param props - Resolver function and children */ declare function AddressNameProvider({ children, resolveAddressName, resolveNetworkLabel }: AddressNameProviderProps): React$2.ReactElement; //#endregion //#region src/components/ui/address-display/use-address-name.d.ts /** * Return type for the `useAddressName` convenience hook. */ interface UseAddressNameResult { /** Resolved record, or `undefined` if no provider/record exists */ record: ResolvedName | undefined; } /** * Reads the `AddressNameContext` for one address, synchronously (INV-122). * Returns `{ record: undefined }` when no provider is mounted — never throws, * never suspends. Note the record is returned verbatim: callers rendering a * name from it must apply the same `forwardVerified === true` gate that * `AddressDisplay` applies (INV-52). * * @param address - The blockchain address to reverse-resolve * @param networkId - Optional network identifier scoping the lookup * @returns The current best-known record for the address * * @example * ```tsx * function EnsBadge({ address }: { address: string }) { * const { record } = useAddressName(address); * return record?.forwardVerified ? {record.name} : null; * } * ``` */ declare function useAddressName(address: string, networkId?: string): UseAddressNameResult; //#endregion //#region src/components/ui/alert.d.ts declare const Alert: React$2.ForwardRefExoticComponent & VariantProps<(props?: ({ variant?: "default" | "destructive" | "success" | null | undefined; } & class_variance_authority_types0.ClassProp) | undefined) => string> & React$2.RefAttributes>; declare const AlertTitle: React$2.ForwardRefExoticComponent & React$2.RefAttributes>; declare const AlertDescription: React$2.ForwardRefExoticComponent & React$2.RefAttributes>; //#endregion //#region src/components/ui/banner.d.ts type BannerVariant = 'info' | 'success' | 'warning' | 'error' | 'neutral'; type BannerSize = 'default' | 'compact'; interface BannerProps { /** * The variant/style of the banner * @default 'info' */ variant?: BannerVariant; /** * Density preset for padding and typography * @default 'default' */ size?: BannerSize; /** * Title text displayed at the top of the banner */ title?: React$2.ReactNode; /** * Body text/content of the banner */ children: React$2.ReactNode; /** * Whether the banner can be dismissed * @default true */ dismissible?: boolean; /** * Callback when the banner is dismissed */ onDismiss?: () => void; /** * Icon to display on the left (replaces default based on variant) */ icon?: React$2.ReactNode; /** * Additional CSS classes */ className?: string; } /** * Dismissible banner component for notifications and alerts * Can be used with various variants (info, success, warning, error, neutral) */ declare const Banner: React$2.ForwardRefExoticComponent>; //#endregion //#region src/utils/button-variants.d.ts declare const buttonVariants: (props?: ({ variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined; size?: "default" | "sm" | "lg" | "icon" | null | undefined; } & class_variance_authority_types0.ClassProp) | undefined) => string; //#endregion //#region src/components/ui/button.d.ts interface ButtonProps extends React$2.ButtonHTMLAttributes, VariantProps { asChild?: boolean; } declare const Button: React$2.ForwardRefExoticComponent>; //#endregion //#region src/components/ui/calendar.d.ts type CalendarProps = React$2.ComponentProps; /** * Calendar component built on react-day-picker with shadcn/ui styling. * Supports single date, multiple dates, and date range selection modes. */ declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): React$2.ReactElement; declare namespace Calendar { var displayName: string; } //#endregion //#region src/components/ui/card.d.ts /** Card container component with rounded borders. */ declare function Card({ className, ...props }: React.ComponentProps<'div'>): JSX.Element; /** Card header section for title and description. Provides top padding for the card. */ declare function CardHeader({ className, ...props }: React.ComponentProps<'div'>): JSX.Element; /** Card title with semibold styling. */ declare function CardTitle({ className, ...props }: React.ComponentProps<'div'>): JSX.Element; /** Card description with muted text styling. */ declare function CardDescription({ className, ...props }: React.ComponentProps<'div'>): JSX.Element; /** Card content area with horizontal padding, top spacing, and bottom padding. */ declare function CardContent({ className, ...props }: React.ComponentProps<'div'>): JSX.Element; /** Card footer with flex alignment for actions, top spacing, and bottom padding. */ declare function CardFooter({ className, ...props }: React.ComponentProps<'div'>): JSX.Element; //#endregion //#region src/components/ui/checkbox.d.ts /** Checkbox component wrapping Radix UI Checkbox primitive. */ declare function Checkbox({ className, ...props }: React$2.ComponentProps): React$2.ReactElement; //#endregion //#region src/components/ui/date-range-picker.d.ts /** * Props for the DateRangePicker component. */ interface DateRangePickerProps { /** The selected date range */ value?: DateRange; /** Callback when the date range changes */ onChange?: (range: DateRange | undefined) => void; /** Placeholder text when no date is selected */ placeholder?: string; /** Additional CSS classes */ className?: string; /** Whether the picker is disabled */ disabled?: boolean; /** Number of months to display (default: 2) */ numberOfMonths?: number; /** Alignment of the popover */ align?: 'start' | 'center' | 'end'; } /** * DateRangePicker component for selecting a date range. * Uses react-day-picker with Radix Popover for a shadcn-styled date range selection. * * @example * ```tsx * const [dateRange, setDateRange] = useState(); * * * ``` */ declare function DateRangePicker({ value, onChange, placeholder, className, disabled, numberOfMonths, align }: DateRangePickerProps): React.ReactElement; declare namespace DateRangePicker { var displayName: string; } //#endregion //#region src/components/ui/dialog.d.ts declare const Dialog: React$2.FC; declare const DialogTrigger: React$2.ForwardRefExoticComponent>; declare const DialogPortal: React$2.FC; declare const DialogClose: React$2.ForwardRefExoticComponent>; declare const DialogOverlay: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const DialogContent: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const DialogHeader: { ({ className, ...props }: React$2.HTMLAttributes): React$2.JSX.Element; displayName: string; }; declare const DialogFooter: { ({ className, ...props }: React$2.HTMLAttributes): React$2.JSX.Element; displayName: string; }; declare const DialogTitle: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const DialogDescription: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; //#endregion //#region src/components/ui/dropdown-menu.d.ts declare const DropdownMenu: React$2.FC; declare const DropdownMenuTrigger: React$2.ForwardRefExoticComponent>; declare const DropdownMenuGroup: React$2.ForwardRefExoticComponent>; declare const DropdownMenuPortal: React$2.FC; declare const DropdownMenuSub: React$2.FC; declare const DropdownMenuRadioGroup: React$2.ForwardRefExoticComponent>; declare const DropdownMenuSubTrigger: React$2.ForwardRefExoticComponent, "ref"> & { inset?: boolean; } & React$2.RefAttributes>; declare const DropdownMenuSubContent: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const DropdownMenuContent: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const DropdownMenuItem: React$2.ForwardRefExoticComponent, "ref"> & { inset?: boolean; } & React$2.RefAttributes>; declare const DropdownMenuCheckboxItem: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const DropdownMenuRadioItem: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const DropdownMenuLabel: React$2.ForwardRefExoticComponent, "ref"> & { inset?: boolean; } & React$2.RefAttributes>; declare const DropdownMenuSeparator: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const DropdownMenuShortcut: { ({ className, ...props }: React$2.HTMLAttributes): React$2.ReactNode; displayName: string; }; //#endregion //#region src/components/ui/ecosystem-dropdown.d.ts interface EcosystemDropdownOption { value: Ecosystem; label: string; enabled: boolean; disabledLabel?: string; } interface EcosystemDropdownProps { options: EcosystemDropdownOption[]; value: Ecosystem | null; onValueChange: (ecosystem: Ecosystem) => void; getEcosystemIcon?: (ecosystem: Ecosystem) => React$2.ReactNode; disabled?: boolean; className?: string; placeholder?: string; 'aria-labelledby'?: string; } /** Simple dropdown selector for choosing a blockchain ecosystem. */ declare function EcosystemDropdown({ options, value, onValueChange, getEcosystemIcon, disabled, className, placeholder, 'aria-labelledby': ariaLabelledby }: EcosystemDropdownProps): React$2.ReactElement; //#endregion //#region src/components/ui/ecosystem-icon.d.ts interface EcosystemIconProps { ecosystem: Pick; /** Text used to derive the initial letter when no icon is available */ fallbackLabel?: string; className?: string; size?: number; variant?: 'mono' | 'branded'; } /** Displays the appropriate icon for a blockchain ecosystem. */ declare function EcosystemIcon({ ecosystem, fallbackLabel, className, size, variant }: EcosystemIconProps): React$1.ReactElement; //#endregion //#region src/components/ui/empty-state.d.ts interface EmptyStateProps { /** * The icon to display - can be a React component or SVG path */ icon?: React$1.ReactNode; /** * Main heading text */ title: string; /** * Descriptive text explaining the empty state */ description: string; /** * Additional CSS classes for the container */ className?: string; /** * Size variant for the empty state * @default 'default' */ size?: 'small' | 'default' | 'large'; } /** * Reusable empty state component for showing helpful messages when content is not available */ declare function EmptyState({ icon, title, description, className, size }: EmptyStateProps): React$1.ReactElement; //#endregion //#region src/components/ui/external-link.d.ts declare const ExternalLink: React$1.ForwardRefExoticComponent & React$1.RefAttributes>; //#endregion //#region src/components/ui/footer.d.ts /** * Props for the Footer component */ interface FooterProps { /** * Company or organization name for the copyright notice * @default 'OpenZeppelin' */ companyName?: string; /** * Copyright year to display * @default Current year */ copyrightYear?: number; /** * URL for the privacy policy link * @default 'https://www.openzeppelin.com/privacy' */ privacyPolicyUrl?: string; /** * Text for the privacy policy link * @default 'Privacy Policy' */ privacyPolicyText?: string; /** * URL for the terms of service link * @default 'https://www.openzeppelin.com/tos' */ termsOfServiceUrl?: string; /** * Text for the terms of service link * @default 'Terms of Service' */ termsOfServiceText?: string; /** * Whether to show the privacy policy link * @default true */ showPrivacyPolicy?: boolean; /** * Whether to show the terms of service link * @default true */ showTermsOfService?: boolean; /** * Additional CSS classes for the footer container */ className?: string; } /** * Application footer component with customizable legal links and branding. * * This component provides a consistent footer layout with customizable: * - Company name and copyright year * - Privacy policy and terms of service links and text * - Optional visibility controls for legal links * - Custom styling support */ declare const Footer: ({ companyName, copyrightYear, privacyPolicyUrl, privacyPolicyText, termsOfServiceUrl, termsOfServiceText, showPrivacyPolicy, showTermsOfService, className }?: FooterProps) => JSX.Element; //#endregion //#region src/components/ui/form.d.ts /** * Context provider for the form */ declare const Form: ({ ...props }: React$2.ComponentProps>) => React$2.ReactElement; /** * Form field component */ declare const FormField: = FieldPath>({ ...props }: ControllerProps) => React$2.ReactElement; /** * Form item component */ declare const FormItem: React$2.ForwardRefExoticComponent & React$2.RefAttributes>; /** * Form label component */ declare const FormLabel: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes, "ref"> & React$2.RefAttributes>; /** * Form control component */ declare const FormControl: React$2.ForwardRefExoticComponent & React$2.RefAttributes>; /** * Form description component */ declare const FormDescription: React$2.ForwardRefExoticComponent & React$2.RefAttributes>; /** * Form error message component */ declare const FormMessage: React$2.ForwardRefExoticComponent & React$2.RefAttributes>; /** * Types for form controller props */ type ControllerProps = FieldPath> = { name: TName; control?: UseFormReturn['control']; render: (props: { field: { value: unknown; onChange: (...event: unknown[]) => void; onBlur: () => void; name: TName; ref: React$2.RefCallback; }; fieldState: { invalid: boolean; isTouched: boolean; isDirty: boolean; error?: unknown; }; formState: UseFormReturn['formState']; }) => React$2.ReactElement; }; //#endregion //#region src/components/ui/header.d.ts interface HeaderProps { title?: string; /** Open the mobile sidebar */ onOpenSidebar?: () => void; /** Content to display on the right side of the header */ rightContent?: React$1.ReactNode; } declare const Header: ({ title, onOpenSidebar, rightContent }: HeaderProps) => React$1.ReactElement; //#endregion //#region src/components/ui/input.d.ts /** * Input component that follows shadcn/ui styling and accessibility patterns */ type InputProps = React$2.InputHTMLAttributes; declare const Input: React$2.ForwardRefExoticComponent>; //#endregion //#region src/components/ui/label.d.ts /** * Label component for form fields, following shadcn/ui styling */ declare const Label: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; //#endregion //#region src/components/ui/loading-button.d.ts interface LoadingButtonProps extends React$2.ButtonHTMLAttributes, VariantProps { asChild?: boolean; loading?: boolean; } declare const LoadingButton: React$2.ForwardRefExoticComponent>; //#endregion //#region src/components/ui/network-icon.d.ts interface NetworkIconProps { network: Pick; className?: string; size?: number; variant?: 'mono' | 'branded'; } /** Displays the appropriate icon for a blockchain network. */ declare function NetworkIcon({ network, className, size, variant }: NetworkIconProps): React$1.ReactElement; //#endregion //#region src/components/ui/network-selector.d.ts interface NetworkSelectorBaseProps { networks: T[]; getNetworkLabel: (network: T) => string; getNetworkIcon?: (network: T) => React$2.ReactNode; getNetworkType?: (network: T) => NetworkType | undefined; getNetworkId: (network: T) => string; groupByEcosystem?: boolean; getEcosystem?: (network: T) => string; filterNetwork?: (network: T, query: string) => boolean; /** When true, the network cannot be selected */ isNetworkDisabled?: (network: T) => boolean; /** Optional label for disabled networks (e.g. "Self-host required") */ getNetworkDisabledLabel?: (network: T) => string | undefined; className?: string; placeholder?: string; } interface SingleSelectProps { multiple?: false; selectedNetwork: T | null; onSelectNetwork: (network: T) => void; selectedNetworkIds?: never; onSelectionChange?: never; renderTrigger?: never; } interface MultiSelectProps<_T> { multiple: true; selectedNetworkIds: string[]; onSelectionChange: (ids: string[]) => void; /** Override the default trigger button with a custom element. */ renderTrigger?: (props: { selectedCount: number; open: boolean; }) => React$2.ReactNode; selectedNetwork?: never; onSelectNetwork?: never; } type NetworkSelectorProps = NetworkSelectorBaseProps & (SingleSelectProps | MultiSelectProps); /** Searchable dropdown selector for blockchain networks with optional grouping and multi-select. */ declare function NetworkSelector({ networks, getNetworkLabel, getNetworkIcon, getNetworkType, getNetworkId, groupByEcosystem, getEcosystem, filterNetwork, isNetworkDisabled, getNetworkDisabledLabel, className, placeholder, ...modeProps }: NetworkSelectorProps): React$2.ReactElement; //#endregion //#region src/components/ui/network-status-badge.d.ts interface NetworkStatusBadgeProps { network: NetworkConfig | null; className?: string; } /** * NetworkStatusBadge - Displays network information in a compact badge format * Shows the network icon, ecosystem, and name with dashed borders for testnet/devnet */ declare function NetworkStatusBadge({ network, className }: NetworkStatusBadgeProps): React$1.ReactElement | null; //#endregion //#region src/components/ui/overflow-menu.d.ts /** Single action item within an OverflowMenu dropdown. */ interface OverflowMenuItem { id: string; label: string; icon?: React$2.ReactNode; destructive?: boolean; disabled?: boolean; onSelect: () => void; } /** Props for the OverflowMenu component. */ interface OverflowMenuProps { items: OverflowMenuItem[]; /** Align dropdown relative to trigger. @default "end" */ align?: 'start' | 'center' | 'end'; /** Additional classes on the trigger button. */ className?: string; /** Accessible label for the trigger button. @default "More actions" */ 'aria-label'?: string; } /** Compact "..." dropdown menu for secondary actions. */ declare function OverflowMenu({ items, align, className, 'aria-label': ariaLabel }: OverflowMenuProps): react_jsx_runtime0.JSX.Element | null; //#endregion //#region src/components/ui/popover.d.ts declare const Popover: React$2.FC; declare const PopoverTrigger: React$2.ForwardRefExoticComponent>; declare const PopoverAnchor: React$2.ForwardRefExoticComponent>; declare const PopoverContent: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; //#endregion //#region src/components/ui/progress.d.ts declare const Progress: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; //#endregion //#region src/components/ui/radio-group.d.ts declare const RadioGroup: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const RadioGroupItem: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; //#endregion //#region src/components/ui/select.d.ts declare const Select: React$2.FC; declare const SelectGroup: React$2.ForwardRefExoticComponent>; declare const SelectValue: React$2.ForwardRefExoticComponent>; declare const SelectTrigger: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const SelectScrollUpButton: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const SelectScrollDownButton: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const SelectContent: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const SelectLabel: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const SelectItem: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; declare const SelectSeparator: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; //#endregion //#region src/components/ui/sidebar/SidebarButton.d.ts interface SidebarButtonProps { icon?: ReactNode; children: ReactNode; onClick?: () => void; size?: 'default' | 'small'; badge?: string; disabled?: boolean; isSelected?: boolean; /** When provided, renders as an anchor element instead of a button */ href?: string; target?: React$1.HTMLAttributeAnchorTarget; rel?: string; className?: string; } /** * A styled button component for sidebar actions with consistent styling. * Can render as a button or anchor element depending on whether href is provided. */ declare function SidebarButton({ icon, children, onClick, size, badge, disabled, isSelected, href, target, rel, className }: SidebarButtonProps): React$1.ReactElement; //#endregion //#region src/components/ui/sidebar/SidebarGroup.d.ts interface SidebarGroupProps { /** Title displayed in the collapsible trigger */ title: string; /** Optional icon displayed before the title */ icon?: ReactNode; /** Content to render when expanded */ children: ReactNode; /** Whether the group is open by default */ defaultOpen?: boolean; /** Controlled open state */ open?: boolean; /** Callback when open state changes */ onOpenChange?: (open: boolean) => void; /** Additional CSS classes for the container */ className?: string; /** Additional CSS classes for the trigger */ triggerClassName?: string; /** Additional CSS classes for the content wrapper */ contentClassName?: string; } /** * A collapsible group component for organizing sidebar navigation items. * Supports both controlled and uncontrolled modes. */ declare function SidebarGroup({ title, icon, children, defaultOpen, open: controlledOpen, onOpenChange, className, triggerClassName, contentClassName }: SidebarGroupProps): React$1.ReactElement; //#endregion //#region src/components/ui/sidebar/SidebarLayout.d.ts interface SidebarLayoutProps { /** Content for the sidebar header (e.g., logo) */ header?: ReactNode; /** Content to be displayed below the header but above the scrollable area */ subHeader?: ReactNode; /** Main scrollable content area */ children: ReactNode; /** Content for the fixed footer (e.g., nav icons) */ footer?: ReactNode; /** Additional CSS classes for the sidebar container */ className?: string; /** Width of the sidebar (default: 289px) */ width?: number | string; /** Background color/class for the sidebar */ background?: string; /** Controls visibility in mobile slide-over */ mobileOpen?: boolean; /** Close handler for mobile slide-over */ onMobileOpenChange?: (open: boolean) => void; /** Aria label for mobile dialog */ mobileAriaLabel?: string; } /** * A flexible sidebar layout component with desktop sidebar and mobile slide-over. * Provides slots for header, scrollable content, and footer. */ declare function SidebarLayout({ header, subHeader, children, footer, className, width, background, mobileOpen, onMobileOpenChange, mobileAriaLabel }: SidebarLayoutProps): React$1.ReactElement; //#endregion //#region src/components/ui/sidebar/SidebarSection.d.ts interface SidebarSectionProps { /** Optional section title displayed above the content */ title?: string; /** Content to render within the section */ children: ReactNode; /** Additional CSS classes */ className?: string; /** CSS classes for the title element */ titleClassName?: string; /** Whether this section should grow to fill available space */ grow?: boolean; } /** * A generic sidebar section wrapper with optional title. * Used to group related sidebar items together. */ declare function SidebarSection({ title, children, className, titleClassName, grow }: SidebarSectionProps): React$1.ReactElement; //#endregion //#region src/components/ui/tabs.d.ts /** Tabs container component wrapping Radix UI Tabs Root. */ declare function Tabs({ className, ...props }: React$2.ComponentProps): React$2.ReactElement; /** Tabs list component containing tab triggers. */ declare function TabsList({ className, ...props }: React$2.ComponentProps): React$2.ReactElement; /** Individual tab trigger button. */ declare function TabsTrigger({ className, ...props }: React$2.ComponentProps): React$2.ReactElement; /** Tab content panel displayed when its trigger is active. */ declare function TabsContent({ className, ...props }: React$2.ComponentProps): React$2.ReactElement; //#endregion //#region src/components/ui/textarea.d.ts type TextareaProps = React$2.TextareaHTMLAttributes; declare const Textarea: React$2.ForwardRefExoticComponent>; //#endregion //#region src/components/ui/tooltip.d.ts declare const TooltipProvider: React$2.FC; declare const Tooltip: React$2.FC; declare const TooltipTrigger: React$2.ForwardRefExoticComponent>; declare const TooltipContent: React$2.ForwardRefExoticComponent, "ref"> & React$2.RefAttributes>; //#endregion //#region src/components/ui/view-contract-state-button.d.ts interface ViewContractStateButtonProps { contractAddress: string | null; onToggle: () => void; } /** * ViewContractStateButton - A button to toggle the contract state widget * Shows the contract address in a truncated format */ declare function ViewContractStateButton({ contractAddress, onToggle }: ViewContractStateButtonProps): React$1.ReactElement | null; //#endregion //#region src/components/ui/wizard/WizardStepper.d.ts type StepStatus = 'pending' | 'completed' | 'skipped'; type StepVisualState = 'completed' | 'current' | 'visited' | 'invalid' | 'upcoming'; interface WizardStepDef { id: string; title: string; status?: StepStatus; /** When true the step is highlighted with an error indicator. */ isInvalid?: boolean; } interface WizardStepperProps { steps: WizardStepDef[]; currentStepIndex: number; /** Index of the furthest step the user has reached. Steps up to this index stay clickable. */ furthestStepIndex?: number; onStepClick?: (index: number) => void; variant?: 'vertical' | 'horizontal'; /** When true all steps are clickable regardless of their state (used by scrollable layout). */ freeNavigation?: boolean; className?: string; } /** * A stepper component for navigating through a series of steps. * * @param props - The props for the WizardStepper component. * @returns A React node representing the stepper component. */ declare function WizardStepper(props: WizardStepperProps): ReactNode; //#endregion //#region src/components/ui/wizard/WizardNavigation.d.ts interface WizardNavigationProps { isFirstStep: boolean; isLastStep: boolean; canProceed?: boolean; onPrevious: () => void; onNext: () => void; onCancel?: () => void; /** Extra actions rendered between Cancel/Previous and Next (e.g. Show Code) */ extraActions?: ReactNode; nextLabel?: string; lastStepLabel?: string; /** * Optional secondary action on the **last step** only, shown to the left of the * primary control with a less prominent (outline) style. Omitted when either * `lastStepSecondaryLabel` or `onLastStepSecondary` is missing. */ onLastStepSecondary?: () => void; lastStepSecondaryLabel?: string; lastStepSecondaryDisabled?: boolean; /** * When `false` on the last step, the primary Next/Finish button is omitted * (e.g. when the step body provides its own primary action). * @default true */ showLastStepPrimary?: boolean; className?: string; } /** * A navigation component for the wizard. * * @param props - The props for the WizardNavigation component. * @returns A React node representing the navigation component. */ declare function WizardNavigation({ isFirstStep, isLastStep, canProceed, onPrevious, onNext, onCancel, extraActions, nextLabel, lastStepLabel, onLastStepSecondary, lastStepSecondaryLabel, lastStepSecondaryDisabled, showLastStepPrimary, className }: WizardNavigationProps): react_jsx_runtime0.JSX.Element; //#endregion //#region src/components/ui/wizard/WizardLayout.d.ts interface WizardStepConfig extends WizardStepDef { component: ReactNode; isValid?: boolean; } interface WizardLayoutProps { steps: WizardStepConfig[]; currentStepIndex: number; onStepChange: (index: number) => void; /** * Called when the user completes the wizard from the **scrollable** layout footer * (when that footer is shown), or as a fallback when the last step is confirmed * in **paged** layouts — see `onLastStepPrimary`. */ onComplete?: () => void; /** * Called when the user activates the primary control on the **last step** of a * **paged** layout (`vertical` / `horizontal`). When omitted, `onComplete` is * invoked instead for that interaction. */ onLastStepPrimary?: () => void; onCancel?: () => void; /** Label for the primary control on non-final steps. @default "Next" */ nextLabel?: string; /** Label for the primary control on the last step of paged layouts. @default "Finish" */ lastStepLabel?: string; /** * Optional secondary control on the **last step** of **paged** layouts only. * Rendered to the left of the primary action with an outline style. Both * `lastStepSecondaryLabel` and `onLastStepSecondary` must be set for it to appear. */ onLastStepSecondary?: () => void; lastStepSecondaryLabel?: string; lastStepSecondaryDisabled?: boolean; /** * When true, the primary Next/Finish control is omitted on the last step of * **paged** layouts. Use when the step content provides its own primary action. * @default false */ hideLastStepPrimary?: boolean; /** * When true, the optional footer button at the bottom of the **scrollable** * layout is omitted (even if `onComplete` is set). * @default false */ hideScrollableCompleteButton?: boolean; /** Label for the scrollable layout footer button. @default "Finish" */ scrollableCompleteLabel?: string; /** * Optional secondary footer button for the **scrollable** layout (outline style), * to the left of the complete button. Both `scrollableSecondaryLabel` and * `onScrollableSecondary` must be set for it to appear. */ onScrollableSecondary?: () => void; scrollableSecondaryLabel?: string; scrollableSecondaryDisabled?: boolean; /** * - `'vertical'` — Vertical sidebar stepper, one step visible at a time (paged). * - `'horizontal'` — Horizontal top stepper, one step visible at a time (paged). * - `'scrollable'` — Vertical sidebar stepper, all steps on a single scrollable page. */ variant?: 'vertical' | 'horizontal' | 'scrollable'; /** * Optional override for the highest step index reached in paged variants. * When omitted, the layout tracks this internally. */ furthestStepIndex?: number; /** Extra actions for the bottom navigation bar (paged variants only). */ navActions?: ReactNode; /** Header content rendered above the step content (e.g. title, breadcrumbs). */ header?: ReactNode; /** * Pixels of spacing preserved between the container top and an auto-scrolled * section heading (`scrollable` variant only). Defaults to 32 (matches `p-8`). */ scrollPadding?: number; className?: string; } /** * A layout component for the wizard. * * @param props - The props for the WizardLayout component. * @returns A React node representing the layout component. */ declare function WizardLayout(props: WizardLayoutProps): react_jsx_runtime0.JSX.Element; //#endregion //#region src/components/fields/BaseField.d.ts /** * Base props shared by all field components * * @template TFieldValues The field values type from React Hook Form */ interface BaseFieldProps { /** * Unique identifier for the field */ id: string; /** * Label text to display */ label: string; /** * Placeholder text when empty */ placeholder?: string; /** * Helper text to display below the field */ helperText?: string; /** * Field width for layout */ width?: 'full' | 'half' | 'third'; /** * Validation rules for the field */ validation?: FieldValidation; /** * Form control from React Hook Form */ control: Control; /** * Field name in the form */ name: FieldPath; /** * Whether the field should be displayed as read-only/disabled. * @default false */ readOnly?: boolean; } /** * BaseField component to provide a consistent layout for form fields * * @important This component is the foundation of the app rendering architecture and should * ONLY be used by field-specific components within the system, not as a standalone component. * * Architecture role: * 1. Provides a consistent layout structure for all field types * 2. Handles integration with React Hook Form through the FormField component * 3. Manages common rendering aspects like labels, error messages, and help text * 4. Delegates actual input rendering to field-specific components via renderInput * * Field component hierarchy: * - TransactionForm (top-level renderer) * - DynamicFormField (field type selector) * - Specific field components (TextField, NumberField, etc.) * - BaseField (common field structure - this component) * - Actual input element rendered by renderInput * * This component should only be extended by field-specific components like * TextField, NumberField, and AddressField - it is not meant for direct use in forms. */ declare function BaseField({ id, label, helperText, control, name, width, renderInput }: BaseFieldProps & { renderInput: (field: Record, props: { id: string; ref?: ForwardedRef; }) => ReactNode; ref?: ForwardedRef; }): ReactElement; declare namespace BaseField { var displayName: string; } //#endregion //#region src/components/fields/AddressField.d.ts interface AddressFieldProps extends BaseFieldProps { addressing?: AddressingCapability; /** * Explicit suggestion list. When provided, overrides context-based resolution. * Pass `false` to disable suggestions entirely (even when a context provider is mounted). * * Note: context-resolved suggestions are automatically capped at * `MAX_SUGGESTIONS` (5) entries, while explicitly passed arrays are * rendered as-is — callers should pre-slice if needed. */ suggestions?: AddressSuggestion[] | false; /** * Called when the user selects a suggestion. Receives the selected suggestion * so callers can perform additional side-effects beyond filling the field value. */ onSuggestionSelect?: (suggestion: AddressSuggestion) => void; /** * Fired when the resolved-and-name-matched name changes. Emits the resolved * NAME (not the hex) on `resolved` + name-match, and `undefined` in every * other state (idle / debouncing / loading / error / hex / cleared). * * Pure notification for consumers that want the human-readable name (e.g. * the address book's alias suggestion, SF-5 INV-109..111). It reads existing * resolution state and does NOT participate in the resolved-hex write path * (INV-75/79/80/81/85 unaffected). With no injected resolver it only ever * emits `undefined`, so the field stays behavior-identical (INV-82). */ onResolvedNameChange?: (name: string | undefined) => void; /** * When `false`, suppresses the forward cross-network fallback disclaimer under * the frozen "Resolved to …" template. Default `true`. Use when a sibling * `AddressDisplay` already surfaces the same message (e.g. demo resolved card). */ showCrossNetworkFallbackDisclaimer?: boolean; /** * When `false`, suppresses the mechanism-neutral **"Resolved to `0x…`"** * success announcer while still rendering loading, error, and chain-scope * mismatch outcomes. Default `true`. Use when a sibling `AddressDisplay` * already presents the resolved address (e.g. a rich ENS preview card). */ showForwardResolutionSuccessAnnouncer?: boolean; /** * Optional trailing content on the resolution announcer row (e.g. an entry-mode * toggle). When set, the announcer and slot share one flex row beneath the * input — the slot stays right-aligned and the announcer fills the left. * The row renders even when no resolver is mounted so the slot is always visible; * without a resolver the announcer cell is empty and no `min-h-5` is reserved. */ announcerEndSlot?: React$1.ReactNode; } /** * Address input field component specifically designed for blockchain addresses via React Hook Form integration. * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects the appropriate field component (like AddressField) based on field type * 4. BaseField provides consistent layout and hook form integration * 5. This component handles blockchain address-specific rendering and validation using the passed addressing capability * * The component includes: * - Integration with React Hook Form * - Blockchain address validation through the provided addressing capability * - Automatic error handling and reporting * - Chain-agnostic design (validation handled by capabilities) * - Full accessibility support with ARIA attributes * - Keyboard navigation * * Autocomplete suggestions can be provided in two ways: * * 1. **Context-based (zero-config)**: Mount an `AddressSuggestionProvider` in the * component tree. Every `AddressField` below it automatically resolves suggestions. * * 2. **Prop-based (explicit)**: Pass `suggestions` directly. This overrides context. * Pass `suggestions={false}` to opt out when a provider is mounted. * * The suggestion dropdown includes built-in debouncing, keyboard navigation (Arrow keys, * Enter, Escape), click-outside dismissal, and ARIA listbox semantics — all provided by * the shared headless `useAddressSuggestionField` hook + `AddressSuggestionList`. * * **Inline name resolution (SF-3, opt-in via context).** When a * `NameResolverProvider` is mounted, the field also accepts a name (e.g. * `alice.eth`): the name is resolved inline through the injected `resolveName` * and the RHF form value becomes the resolved hex — never the name, never a * silently-coerced value. The correctness spine is a shadow-state model: * the `` always shows the typed string (`inputValue`, INV-69); the RHF * value is `''` for every unresolved name state so submit stays gated with no * async validator (INV-75); the single name→hex write fires only on * `resolved` + normalized name-match (INV-79/80). With **no** provider mounted * every resolution branch below is dead code and the field is byte-identical * to its pre-ENS behavior (INV-82 — the LOCKED backward-compat guarantee). * The component stays capability-free: it never reads a runtime or wallet * state; everything arrives through the injected context (INV-118). */ declare function AddressField({ id, label, placeholder, helperText, control, name, width, validation, addressing, readOnly, suggestions: suggestionsProp, onSuggestionSelect, onResolvedNameChange, showCrossNetworkFallbackDisclaimer, showForwardResolutionSuccessAnnouncer, announcerEndSlot }: AddressFieldProps): React$1.ReactElement; declare namespace AddressField { var displayName: string; } //#endregion //#region src/components/fields/AddressFieldWithResolvedPreview.d.ts type AddressFieldWithResolvedPreviewProps = AddressFieldProps & { /** Current form value watched from the same field `name`. */ previewAddress: string | undefined; previewNetworkId?: string; className?: string; /** * Replace the default `ResolvedAddressFieldPreview`. Use when reverse * resolution needs a custom bridge (e.g. `AddressNameResolutionProvider`). */ preview?: React$2.ReactNode; }; /** * `AddressField` plus a rich ENS preview card. Suppresses the redundant forward * "Resolved to 0x…" announcer — the preview card below replaces it. * * Parent must `watch` the field and pass the value as `previewAddress`. */ declare function AddressFieldWithResolvedPreview({ previewAddress, previewNetworkId, addressing, className, preview, showCrossNetworkFallbackDisclaimer, showForwardResolutionSuccessAnnouncer, ...addressFieldProps }: AddressFieldWithResolvedPreviewProps): React$2.ReactElement; //#endregion //#region src/components/fields/ResolvedAddressFieldPreview.d.ts interface ResolvedAddressFieldPreviewProps { /** Resolved form value from AddressField (hex after ENS forward resolution). */ address: string | undefined; networkId?: string; addressing?: AddressingCapability; /** * Optional pre-resolved name record. Shadows `AddressNameContext` when set. * Omit when a parent `AddressNameProvider` feeds reverse resolution. */ resolvedName?: ResolvedName; /** Heading above the display. @default "Resolved account" */ label?: string; /** Props forwarded to the inner `AddressDisplay` (excluding `address` / `networkId` / `resolvedName`). */ displayProps?: Omit; } /** * Rich ENS preview shown below an `AddressField` once the value is a valid address. * Complements the field's mechanism-neutral "Resolved to 0x…" announcer with * reverse-resolved name + avatar via `AddressDisplay`. * * For async reverse resolution, wrap in `AddressNameProvider` (or * `AddressNameResolutionProvider` from `@openzeppelin/ui-renderer`) and omit * `resolvedName`. For sync / app-owned resolution, pass `resolvedName` directly. */ declare function ResolvedAddressFieldPreview({ address, networkId, addressing, resolvedName, label, displayProps }: ResolvedAddressFieldPreviewProps): React$2.ReactElement | null; //#endregion //#region src/components/fields/AddressListField/labels.d.ts /** * Localizable UI strings for {@link AddressListField} built-in chrome * (buttons, previews, bulk-add feedback). Domain copy such as placeholders and * format hints are passed as component props instead. */ interface AddressListFieldLabels { addSingleAddress: string; invalidSingleAddress: string; enableBulkEntry: string; enableSingleEntry: string; addAddresses: string; addAddressCount: (count: number) => string; invalidPrefix: string; invalidMore: (extraCount: number) => string; maxItemsReached: (maxItems: number) => string; addressesAdded: (count: number) => string; removeAddress: (index: number) => string; previewReadyToAdd: (count: number) => string; previewInvalid: (count: number) => string; previewAlreadyListed: (count: number) => string; previewDuplicateInPaste: (count: number) => string; bulkNothingAdded: string; bulkAdded: (count: number) => string; bulkInvalidFormats: (count: number) => string; bulkAlreadyListed: (count: number) => string; bulkDuplicatesInPaste: (count: number) => string; } /** Default English labels for {@link AddressListField}. */ declare const DEFAULT_ADDRESS_LIST_FIELD_LABELS: AddressListFieldLabels; /** Merges {@link DEFAULT_ADDRESS_LIST_FIELD_LABELS} with optional overrides. */ declare function resolveAddressListFieldLabels(overrides?: Partial): AddressListFieldLabels; /** Builds the inline helper preview shown while the user types in the draft textarea. */ declare function buildAddressListPreviewSummary(classification: AddressCandidateClassification | null, labels: AddressListFieldLabels): string | null; /** Formats post-add feedback after the user commits parsed addresses to the list. */ declare function formatAddressBulkSummary(classification: AddressCandidateClassification, addedCount: number, labels: AddressListFieldLabels): string | null; //#endregion //#region src/components/fields/AddressListField/AddressListField.d.ts type AddressListEntryMode = 'single' | 'bulk'; /** * AddressListField component properties. * * Uses a controlled `value` / `onChange` API for the committed address list. * Entry defaults to single-address mode ({@link AddressField} with address-book * suggestions); users can toggle to bulk paste mode — never both at once. */ interface AddressListFieldProps { /** Committed addresses currently shown in the list. */ value: readonly string[]; /** Called when addresses are added or removed. */ onChange: (addresses: string[]) => void; /** Placeholder for single-address entry (default mode). */ placeholder: string; /** Placeholder for bulk paste. Defaults to {@link placeholder}. */ bulkPlaceholder?: string; /** Shown in bulk mode only — delimiter and validation guidance. */ formatHint: string; /** When provided, each candidate is validated via {@link AddressingCapability.isValidAddress}. */ addressing?: AddressingCapability; /** Optional explorer URL resolver passed through to {@link AddressDisplay}. */ getExplorerUrl?: (address: string) => string | null | undefined; /** Optional field label rendered above the active entry control. */ label?: string; /** Optional domain-specific helper shown below the header row. */ helperText?: string; /** Maximum number of addresses allowed in {@link value}. */ maxItems?: number; /** Disables entry and remove actions. */ disabled?: boolean; /** Maximum invalid entries shown inline before truncating with a count suffix (bulk mode). */ maxInvalidPreview?: number; className?: string; /** Entry mode shown on mount. Defaults to `'single'`. */ defaultEntryMode?: AddressListEntryMode; /** * Whether users can switch between single and bulk entry. Defaults to `true`. * Set to `false` to hide the toggle and lock the field to {@link defaultEntryMode}. */ allowModeToggle?: boolean; /** Optional UI labels to override {@link DEFAULT_ADDRESS_LIST_FIELD_LABELS}. */ labels?: Partial; } /** * Multi-address list field with single-entry default and optional bulk paste. */ declare function AddressListField({ value, onChange, placeholder, bulkPlaceholder, formatHint, addressing, getExplorerUrl, label, helperText, maxItems, disabled, maxInvalidPreview, className, defaultEntryMode, allowModeToggle, labels: labelOverrides }: AddressListFieldProps): react_jsx_runtime0.JSX.Element; //#endregion //#region src/components/fields/address-suggestion/address-suggestion-context.d.ts /** * Props for `AddressSuggestionProvider`. * * Accepts the same shape as `AddressSuggestionResolver` so the provider can be * spread directly from a resolver hook: ``. */ interface AddressSuggestionProviderProps extends AddressSuggestionResolver { children: React$2.ReactNode; } /** * Provides address suggestion resolution to all `AddressField` instances in the * subtree. Wrap your application (or a subsection) with this provider and * supply a `resolveSuggestions` function. * * @param props - Resolver function and children * * @example * ```tsx * filterAliases(query, networkId)} * > * * * ``` */ declare function AddressSuggestionProvider({ children, resolveSuggestions }: AddressSuggestionProviderProps): React$2.ReactElement; //#endregion //#region src/components/fields/address-suggestion/useAddressSuggestions.d.ts /** * Return type for the `useAddressSuggestions` convenience hook. */ interface UseAddressSuggestionsResult { /** Resolved suggestions for the current query */ suggestions: AddressSuggestion[]; } /** Resolves address suggestions from the nearest `AddressSuggestionProvider`. */ declare function useAddressSuggestions(query: string, networkId?: string): UseAddressSuggestionsResult; //#endregion //#region src/components/fields/address-suggestion/useAddressSuggestionField.d.ts /** Arguments for {@link useAddressSuggestionField}. */ interface UseAddressSuggestionFieldArgs { /** The current input text — drives the debounce and dropdown visibility. */ readonly inputValue: string; /** * Explicit suggestion list. When an array, it overrides context resolution and * is rendered as-is (no cap). `false` disables suggestions entirely (even with * a provider mounted). `undefined` falls back to context resolution. */ readonly suggestions?: AddressSuggestion[] | false; /** Optional network id forwarded to the context resolver for scoping. */ readonly networkId?: string; } /** State and handlers returned by {@link useAddressSuggestionField}. */ interface UseAddressSuggestionFieldResult { /** Ref for the field container — used for click-outside detection. */ readonly containerRef: React.RefObject; /** The suggestions to render (context-resolved + capped, or the explicit array). */ readonly resolvedSuggestions: AddressSuggestion[]; /** `true` when the dropdown is open AND there is at least one suggestion. */ readonly hasSuggestions: boolean; /** Index of the keyboard-highlighted option, or `-1` when none. */ readonly highlightedIndex: number; /** `true` when suggestions are explicitly disabled (`suggestions === false`). */ readonly suggestionsDisabled: boolean; /** Set the highlighted option index (e.g. on hover). */ readonly setHighlightedIndex: (index: number) => void; /** Close the dropdown and clear the highlight. */ readonly closeSuggestions: () => void; /** Notify the hook of an input change — opens/closes the dropdown and resets highlight. */ readonly onInputChange: (value: string) => void; /** Container-level keydown handler: wrapping ArrowUp / ArrowDown navigation. */ readonly onContainerKeyDown: (e: React.KeyboardEvent) => void; } /** * Headless address-suggestion dropdown behavior. See the module docstring for * the full behavior contract. * * @param args - {@link UseAddressSuggestionFieldArgs}. * @returns {@link UseAddressSuggestionFieldResult}. */ declare function useAddressSuggestionField({ inputValue, suggestions: suggestionsProp, networkId }: UseAddressSuggestionFieldArgs): UseAddressSuggestionFieldResult; //#endregion //#region src/components/fields/address-suggestion/AddressSuggestionList.d.ts /** Props for {@link AddressSuggestionList}. */ interface AddressSuggestionListProps { /** Field id — anchors the listbox id (`${id}-suggestions`) and option ids. */ readonly id: string; /** The suggestions to render. */ readonly suggestions: AddressSuggestion[]; /** Index of the currently highlighted option, or `-1`. */ readonly highlightedIndex: number; /** Called when an option is selected (click / mouse-down). */ readonly onSelect: (suggestion: AddressSuggestion) => void; /** Called when an option is hovered, to sync the highlight. */ readonly onHighlight: (index: number) => void; } /** * Render the suggestion dropdown. Returns `null` when there are no suggestions * (the consuming field also gates on `hasSuggestions`, so this is a safety net). * * @param props - {@link AddressSuggestionListProps}. */ declare function AddressSuggestionList({ id, suggestions, highlightedIndex, onSelect, onHighlight }: AddressSuggestionListProps): React$2.ReactElement | null; declare namespace AddressSuggestionList { var displayName: string; } //#endregion //#region src/components/fields/name-resolution/context.d.ts /** * Value held by NameResolverContext. Extends the SF-3 injection seam with * optional network context for SF-6 chain-scope gating only. */ interface NameResolverContextValue extends NameResolver { /** * Active network id for chain-scope submit gating (opaque string). * When absent, `isChainScopeMismatch` is never true and coinType wrong-chain * protection is the integrator's responsibility. */ readonly activeNetworkId?: string | null; /** * Optional human-readable active network name — interpolated into the * chain-scope mismatch message only (same seam as INV-78 networkName). */ readonly activeNetworkName?: string; /** * Optional slug → display name for provenance disclaimer copy (003 SF-3). */ readonly resolveNetworkLabel?: NetworkLabelResolver; } /** * @internal Shared context instance consumed by both AddressField and * NameResolverProvider (INV-118). Kept in its own file so component files * export only components (required by React Fast Refresh). * * `null` means no provider is mounted — every ENS branch in `AddressField` is * then dead code and the field is byte-identical to its pre-ENS behavior * (INV-82). */ declare const NameResolverContext: Context; //#endregion //#region src/components/fields/name-resolution/name-resolver-context.d.ts /** * Props for `NameResolverProvider`. * * Accepts the same shape as `NameResolver` so the provider can be spread * directly from a resolver hook: `` — * the same idiom as `AddressSuggestionProvider` / `AddressLabelProvider`. */ interface NameResolverProviderProps extends NameResolverContextValue { children: React$2.ReactNode; } /** * Provides forward name resolution to all `AddressField` instances in the * subtree (zero call-site wiring, SC-001). Both functions are optional: an * absent `resolveName` means forward resolution is unsupported and a typed * name surfaces `UNSUPPORTED_NETWORK` (INV-119 / SC-006). * * ## Stable resolver identity (integrator contract) * * The injected resolver **must be referentially stable across renders** — * memoize it (e.g. `useMemo`) or use `useRuntimeNameResolver` from * `@openzeppelin/ui-react`, which is stable by construction. A resolver whose * function identity changes on every render (e.g. a fresh inline function) is a * misconfiguration: the field keys inline resolution on that identity, so a * churning identity would otherwise re-dispatch on every render — an unbounded * RPC loop on a funds path. * * The base component **detects and withstands** this (it is not merely a caveat): * dispatch is bounded per resolution intent so a churning resolver can never drive * an unbounded loop (INV-123), a one-shot development-only warning names the * misconfiguration (INV-124), and the field degrades to a **safe gated state** * (empty value, submit blocked — never a wrong address, never a throw; INV-125) * until the resolver is memoized. A **genuine** resolver/network swap — a single * identity change for a given input — is still honored and re-resolves within * budget (INV-119). The bound is a backstop; the contract is a stable identity. * * @param props - Injected resolver functions and children */ declare function NameResolverProvider({ children, isValidName, resolveName, activeNetworkId, activeNetworkName, resolveNetworkLabel }: NameResolverProviderProps): React$2.ReactElement; //#endregion //#region src/components/fields/name-resolution/useNameResolver.d.ts /** * Read the injected resolver context. Returns `null` when no * `NameResolverProvider` is mounted — the consuming field must then treat * every ENS branch as dead code (INV-82). * * @returns The extended context value, or `null` when no provider is mounted. */ declare function useNameResolver(): NameResolverContextValue | null; //#endregion //#region src/components/fields/name-resolution/useInjectedNameResolution.d.ts /** * Default debounce window (ms) for typed names — mirrors SF-2's * `forwardDebounceMs` default so the field and the bare hook feel identical. */ declare const NAME_RESOLUTION_DEBOUNCE_MS = 300; /** Forward resolver function injected through `NameResolverContext`. */ type InjectedResolveName = (name: string) => Promise>; /** * Machine result — a discriminated union keyed on `status`, shaped like SF-2's * `UseResolveNameResult` so downstream rendering logic carries over verbatim. * `name` is always the normalized (trim + lowercase) input the arm refers to. */ type InjectedNameResolutionResult = { readonly status: 'idle'; } | { readonly status: 'debouncing'; readonly name: string; } | { readonly status: 'loading'; readonly name: string; } | { readonly status: 'resolved'; readonly name: string; readonly data: ResolvedAddress; } | { readonly status: 'error'; readonly name: string; readonly error: NameResolutionError; readonly retry: () => void; }; /** Parameters for {@link useInjectedNameResolution}. */ interface UseInjectedNameResolutionParams { /** The raw typed input (the field's display string). Normalized internally. */ readonly input: string; /** * INV-83: `true` only when `classification === 'name-candidate'` AND an * injected `resolveName` exists. `false` forces `idle` with zero calls. */ readonly enabled: boolean; /** The injected forward resolver. Absent → the machine stays `idle`. */ readonly resolveName?: InjectedResolveName; /** Debounce override (ms); `<= 0` disables debouncing. */ readonly debounceMs?: number; } /** * Debounce + dispatch + status derivation over an injected `resolveName`. * * Guarantees: * - INV-83: no call unless `enabled` (name-candidate + injected method), and * never for a debounced copy that lags the current normalized input. * - INV-117: a settled result whose requested name ≠ the current debounced * input is discarded (last-write-wins at the component boundary). * - INV-87: a rejecting resolver (contract violation) is mapped to a typed * `ADAPTER_ERROR` — nothing throws into the render tree. * - INV-123: resolver dispatches are bounded per resolution intent (normalized * debounced input × retry attempt) at {@link MAX_DISPATCHES_PER_INTENT}, * regardless of render count or resolver-identity oscillation; the budget * resets on intent change or when leaving the name-resolution path — never on * `settled.source` mismatch; `retry()` never consumes an existing budget. * - INV-124: an identity-churning resolver that exhausts the budget triggers a * one-shot, development-only `logger.warn` (silent in production). * - INV-125: under sustained churn the field stays in the safe gated state — the * perpetually-changing identity keeps failing the `settled.source` check, so * the machine derives `loading`, never `resolved`; combined with INV-87 it * never throws and never writes a hex. * - No `setState` after unmount: every dispatch is cancelled on cleanup. * * @param params - {@link UseInjectedNameResolutionParams} * @returns The current {@link InjectedNameResolutionResult}. */ declare function useInjectedNameResolution({ input, enabled, resolveName, debounceMs }: UseInjectedNameResolutionParams): InjectedNameResolutionResult; //#endregion //#region src/components/fields/AmountField.d.ts /** * AmountField component properties */ interface AmountFieldProps extends BaseFieldProps { /** * Minimum value validation */ min?: number; /** * Maximum value validation */ max?: number; /** * Step value for increment/decrement */ step?: number; /** * Number of decimal places to allow */ decimals?: number; /** * Currency/token symbol to display */ symbol?: string; /** * Position of the symbol (before or after the amount) */ symbolPosition?: 'prefix' | 'suffix'; /** * Custom validation function for amount values */ validateAmount?: (value: number) => boolean | string; } /** * Amount input field component specifically designed for currency/token amounts with React Hook Form integration. * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects the appropriate field component based on field type * 4. BaseField provides consistent layout and hook form integration * 5. This component handles amount-specific rendering and validation * * The component includes: * - Integration with React Hook Form * - Support for currency/token symbols * - Numeric-specific validations (min, max, decimals) * - Customizable validation through adapter integration * - Automatic error handling and reporting * - Full accessibility support with ARIA attributes * - Keyboard navigation with arrow keys for numeric increment/decrement */ declare function AmountField({ id, label, placeholder, helperText, control, name, width, validation, min, max, step, decimals, symbol, symbolPosition, validateAmount }: AmountFieldProps): React$1.ReactElement; declare namespace AmountField { var displayName: string; } //#endregion //#region src/components/fields/ArrayField.d.ts /** * ArrayField component properties */ interface ArrayFieldProps extends BaseFieldProps { /** * The type of elements in the array (e.g., 'text', 'number', 'blockchain-address') */ elementType?: FormFieldType['type']; /** * Minimum number of array elements */ minItems?: number; /** * Maximum number of array elements */ maxItems?: number; /** * Base configuration for array element fields. * This allows specifying common properties like placeholder, helperText, or specific validation * for each element in the array. */ elementFieldConfig?: Partial; /** * Render function for array elements. * This is crucial for rendering complex elements or integrating custom field components. */ renderElement?: (field: FormFieldType, index: number) => React$1.ReactNode; } /** * Array input field component specifically designed for React Hook Form integration. * * This component provides a dynamic interface for managing array inputs with: * - Add/remove functionality for array items * - Validation for array length constraints * - Integration with existing field components for array elements * - Full accessibility support * * The component reuses existing field components (TextField, NumberField, etc.) * for individual array elements, maintaining consistency across the form system. * * Why the extra guards and synchronization exist (post-mortem/rationale): * - In certain runtime states (StrictMode double-invocation, preview remounts, state rehydration * from storage), React Hook Form's useFieldArray may not synchronously reflect an `append()` * or `remove()` call in the immediately subsequent read (e.g., reading `fields.length` or * `getValues(name)` right after the call). This resulted in newly added items (especially * falsy defaults like 0/false) appearing briefly and then disappearing, or remove operations * not updating the UI. * - To make array operations deterministic and resilient across flows (preview form with * FormProvider and the wizard's "Use Hardcoded Value" without a provider), we: * 1) Read a stable snapshot of the array value BEFORE `append()` and, if the immediate * post-append read doesn't reflect the addition, we coerce the state to * "previousSnapshot + newValue" via `setValue` (when context exists) or `replace`. * 2) Avoid `remove()` race conditions by always computing the new array via filter and * applying it with `replace`, which proved to be the most consistent across contexts. * 3) Keep `fields` in sync with the watched array value using a guarded `replace` in an effect. * A ref flag (`isReplacingRef`) prevents infinite loops when we ourselves are driving * the `replace`. * 4) Use optional chaining for form context (`formContext?.control`, `formContext?.getValues`, * `formContext?.setValue`) so the component works with either an inherited FormProvider or * an explicit `control` prop. * 5) Use `queueMicrotask` to reset the guard flag after our `replace` has been scheduled, * avoiding an extra timer tick while ensuring the effect observes the final state. * * Guarantees: * - Operations are idempotent: the fallback only runs when the immediate read does not reflect * the intended state, so we don't double-append/remove. * - Works both with and without FormProvider (preview vs wizard) due to context-agnostic state * reads and `replace` fallback. */ declare function ArrayField({ id, label, helperText, control, name, width, validation, elementType, minItems, maxItems, elementFieldConfig, renderElement, readOnly }: ArrayFieldProps): React$1.ReactElement; declare namespace ArrayField { var displayName: string; } //#endregion //#region src/components/fields/ArrayObjectField.d.ts /** * ArrayObjectField component properties */ interface ArrayObjectFieldProps extends BaseFieldProps { /** * The components/properties of each object in the array. * Defines the schema for the nested fields within each object item. */ components?: FunctionParameter[]; /** * Minimum number of array elements */ minItems?: number; /** * Maximum number of array elements */ maxItems?: number; /** * Render function for object properties. * This function is responsible for rendering each individual property * of an object within an array item. */ renderProperty?: (field: FormFieldType, itemIndex: number, propertyName: string) => React$1.ReactNode; /** * Whether items should be collapsible. * Useful for managing UI complexity when objects have many properties. */ collapsible?: boolean; /** * Whether items should start collapsed. */ defaultCollapsed?: boolean; /** * The type-mapping capability for chain-specific field generation. * Essential for correctly determining field types for object properties. */ typeMapping?: TypeMappingCapability; /** * Optional contract schema to enrich nested field generation. */ contractSchema?: ContractSchema; } /** * Array of objects input field component specifically designed for React Hook Form integration. * * This component provides a dynamic interface for managing arrays of composite objects with: * - Add/remove functionality for array items * - Structured rendering of object properties within each array item * - Collapsible items for better UX with complex objects * - Validation for array constraints and object properties (though individual property validation is largely via rendered component) * - Full accessibility support * * The component combines the functionality of ArrayField and ObjectField to handle * complex nested data structures commonly found in blockchain contracts. */ declare function ArrayObjectField({ id, label, helperText, control, name, width, validation, components, minItems, maxItems, renderProperty, collapsible, defaultCollapsed, readOnly, typeMapping, contractSchema }: ArrayObjectFieldProps): React$1.ReactElement; declare namespace ArrayObjectField { var displayName: string; } //#endregion //#region src/components/fields/BigIntField.d.ts /** * BigIntField component properties */ interface BigIntFieldProps extends BaseFieldProps { /** * Custom validation function for big integer string values */ validateBigInt?: (value: string) => boolean | string; } /** * Big integer input field component for large numbers beyond JavaScript's Number precision. * * This component is designed for blockchain integer types like uint128, uint256, int128, int256 * that can hold values larger than JavaScript's Number.MAX_SAFE_INTEGER (2^53 - 1). * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects BigIntField for large integer types * 4. This component handles string-based integer input with validation * 5. Adapters convert the string to BigInt when submitting transactions * * The component includes: * - Integer-only validation (no decimals allowed) * - String-based storage to avoid JavaScript Number precision issues * - Integration with React Hook Form * - Automatic error handling and reporting * - Full accessibility support with ARIA attributes * - Keyboard navigation */ declare function BigIntField({ id, label, placeholder, helperText, control, name, width, validation, validateBigInt, readOnly }: BigIntFieldProps): React$1.ReactElement; declare namespace BigIntField { var displayName: string; } //#endregion //#region src/components/fields/BooleanField.d.ts /** * BooleanField component properties */ interface BooleanFieldProps extends BaseFieldProps { /** * Custom validation function for boolean values */ validateBoolean?: (value: boolean) => boolean | string; } /** * Boolean input field component (checkbox) specifically designed for React Hook Form integration. * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects the appropriate field component (like BooleanField) based on field type * 4. BaseField provides consistent layout and hook form integration * 5. This component handles boolean-specific rendering and validation * * The component includes: * - Integration with React Hook Form * - Checkbox-specific behavior * - Customizable validation through adapter integration * - Automatic error handling and reporting * - Full accessibility support with ARIA attributes * - Keyboard navigation with Space/Enter for toggling */ declare function BooleanField({ id, label, helperText, control, name, width, validation, validateBoolean, readOnly }: BooleanFieldProps): React$1.ReactElement; declare namespace BooleanField { var displayName: string; } //#endregion //#region src/components/fields/BytesField.d.ts /** * BytesField component properties */ interface BytesFieldProps extends BaseFieldProps { /** * Number of rows for the textarea */ rows?: number; /** * Maximum length in bytes (not characters) */ maxBytes?: number; /** * Exact length in bytes required (for fixed-size types like bytes32) * When set, the value must be exactly this many bytes. * Takes precedence over maxBytes. */ exactBytes?: number; /** * Whether to accept hex, base64, or both formats */ acceptedFormats?: 'hex' | 'base64' | 'both'; /** * Whether to automatically add/remove 0x prefix for hex values */ autoPrefix?: boolean; /** * Whether to allow 0x prefix in hex input (defaults to true) */ allowHexPrefix?: boolean; } /** * Specialized input field for bytes data with built-in hex/base64 validation. * * This component provides proper validation for blockchain bytes data including: * - Hex encoding validation (with optional 0x prefix support) * - Base64 encoding validation * - Byte length validation * - Format detection and conversion * * Key props for EVM compatibility: * - `allowHexPrefix`: Whether to accept 0x prefixed input (defaults to true) * - `autoPrefix`: Whether to automatically add 0x prefixes (defaults to false) * * These are separate concerns - you can accept 0x input without auto-adding prefixes. * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects BytesField for 'bytes' field types * 4. BaseField provides consistent layout and hook form integration * 5. This component handles bytes-specific validation and formatting */ declare function BytesField({ id, label, helperText, control, name, width, validation, placeholder, rows, maxBytes, exactBytes, acceptedFormats, autoPrefix, allowHexPrefix, readOnly }: BytesFieldProps): React$1.ReactElement; declare namespace BytesField { var displayName: string; } //#endregion //#region src/components/fields/DateTimeField.d.ts /** * DateTimeField component properties */ interface DateTimeFieldProps extends BaseFieldProps { /** * Placeholder text displayed when the field is empty */ placeholder?: string; /** * If true, clears the field when user clicks Escape; otherwise just blurs */ clearOnEscape?: boolean; } /** * Datetime-local input field component specifically designed for React Hook Form integration. * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects the appropriate field component (like DateTimeField) based on field type * 4. BaseField provides consistent layout and hook form integration * 5. This component handles date-time specific rendering, conversion, and validation * * The component includes: * - Integration with React Hook Form * - Conversion between input value (YYYY-MM-DDTHH:mm) and ISO 8601 strings (toISOString) * - Customizable validation through adapter integration * - Automatic error handling and reporting * - Full accessibility support with ARIA attributes * - Keyboard navigation with Escape-to-clear behavior */ declare function DateTimeField({ id, label, placeholder, helperText, control, name, width, validation, readOnly, clearOnEscape }: DateTimeFieldProps): React$1.ReactElement; declare namespace DateTimeField { var displayName: string; } //#endregion //#region src/components/fields/EnumField.d.ts /** * Enum variant definition */ interface EnumVariant { /** Name of the variant (e.g., 'One', 'Two', 'Three') */ name: string; /** Type of variant: 'void' for unit variants, 'tuple' for variants with payload, 'integer' for numeric enums */ type: 'void' | 'tuple' | 'integer'; /** For tuple variants: array of payload type names (e.g., ['U32', 'ScString']) */ payloadTypes?: string[]; /** Optional nested component definitions for tuple payload entries */ payloadComponents?: (FunctionParameter[] | undefined)[]; /** For integer variants: the numeric value */ value?: number; /** Flag indicating if this variant has a single Tuple payload (for serialization) */ isSingleTuplePayload?: boolean; } /** * Enum metadata extracted from contract spec */ interface EnumMetadata { /** Name of the enum type */ name: string; /** Array of variants in the enum */ variants: EnumVariant[]; /** True if all variants are unit variants (no payloads), suitable for simple select/radio */ isUnitOnly: boolean; } /** * Enum field value structure for blockchain enum types */ type EnumFieldValue = EnumValue; /** * EnumField component properties */ interface EnumFieldProps extends BaseFieldProps { /** * Enum metadata containing variant information */ enumMetadata?: EnumMetadata; /** * Custom validation function for enum values */ validateEnum?: (value: EnumFieldValue) => boolean | string; /** * Render function for payload input fields. * This allows the parent component to provide appropriate field components * based on the payload type, maintaining separation of concerns. */ renderPayloadField?: (field: FormFieldType, payloadIndex: number) => React$1.ReactNode; } /** * Composite enum field component for blockchain enum types. * * This component handles both unit enums (simple variants) and tagged enums (variants with payloads). * For unit enums, it renders as a simple select dropdown. * For tagged enums, it renders a variant picker plus conditional input fields for payload data. * * The value format is designed to be chain-agnostic: * - Unit variants: { tag: "VariantName" } * - Tuple variants: { tag: "VariantName", values: [...] } */ declare function EnumField({ id, label, placeholder, helperText, control, name, width, validation, enumMetadata, validateEnum, renderPayloadField, readOnly }: EnumFieldProps): React$1.ReactElement; declare namespace EnumField { var displayName: string; } //#endregion //#region src/components/fields/FileUploadField.d.ts /** * FileUploadField component properties */ interface FileUploadFieldProps extends BaseFieldProps { /** * Accepted file types (e.g., ".zip,.tar.gz") */ accept?: string; /** * Maximum file size in bytes */ maxSize?: number; /** * Whether to convert the file to base64 string */ convertToBase64?: boolean; } /** File upload field component with drag-and-drop support. */ declare function FileUploadField({ id, label, placeholder, helperText, control, name, width, validation, readOnly, accept, maxSize, convertToBase64 }: FileUploadFieldProps): React.ReactElement; //#endregion //#region src/components/fields/MapField/MapField.d.ts /** * MapField component properties */ interface MapFieldProps extends BaseFieldProps { /** * Map metadata containing key and value type information */ mapMetadata?: { keyType?: string; valueType?: string; keyFieldConfig?: Partial; valueFieldConfig?: Partial; }; /** * Minimum number of map entries */ minItems?: number; /** * Render function for map keys. * This allows the parent component to provide appropriate field components * based on the key type, maintaining separation of concerns. */ renderKeyField?: (field: FormFieldType, entryIndex: number) => React$1.ReactNode; /** * Render function for map values. * This allows the parent component to provide appropriate field components * based on the value type, maintaining separation of concerns. */ renderValueField?: (field: FormFieldType, entryIndex: number) => React$1.ReactNode; } /** * Map (key-value dictionary) input field component specifically designed for React Hook Form integration. * * This component provides a dynamic interface for managing map/dictionary inputs with: * - Add/remove functionality for key-value pairs * - Validation for map size constraints * - Integration with existing field components for keys and values * - Chain-agnostic data format (array of {key, value} objects) * - Full accessibility support * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects the appropriate field component (like MapField) based on field type * 4. BaseField provides consistent layout and hook form integration * 5. This component handles map-specific rendering and validation * * The component stores data in a chain-agnostic format as an array of {key, value} objects. * The adapter is responsible for converting this to the chain-specific format (e.g., SorobanMapEntry[]) * when submitting to the blockchain. */ declare function MapField({ id, label, helperText, control, name, width, validation, mapMetadata, minItems, renderKeyField, renderValueField, readOnly }: MapFieldProps): React$1.ReactElement; declare namespace MapField { var displayName: string; } //#endregion //#region src/components/fields/MapField/MapEntryRow.d.ts interface Props { keyField: FormFieldType; valueField: FormFieldType; isDuplicateKey: boolean; renderKeyField?: (field: FormFieldType, entryIndex: number) => React$1.ReactNode; renderValueField?: (field: FormFieldType, entryIndex: number) => React$1.ReactNode; index: number; } /** Renders a single key-value entry row in a map field. */ declare function MapEntryRow({ keyField, valueField, isDuplicateKey, renderKeyField, renderValueField, index }: Props): React$1.ReactElement; //#endregion //#region src/components/fields/MapField/hooks/useChildTouched.d.ts /** Computes whether any child field in a map has been touched. */ declare function computeChildTouched(formContext: UseFormReturn | undefined, name: string, watchedValue: unknown): boolean; //#endregion //#region src/components/fields/MapField/hooks/useDuplicateKeyIndexes.d.ts /** Hook that returns indexes of map entries with duplicate keys. */ declare function useDuplicateKeyIndexes(watchedValue: unknown): Set; //#endregion //#region src/components/fields/MapField/hooks/useMapFieldSync.d.ts /** * Keeps a field array synchronized with a watched value's length using replace, * while preventing infinite loops via a guard ref. */ declare function useMapFieldSync(watchedValue: unknown, fieldsLength: number, replace: (value: TReplaceValue) => void): ReturnType>; //#endregion //#region src/components/fields/MapField/validation/validateMapStructure.d.ts interface ValidateArgs { value: unknown; required: boolean; minItems?: number; } /** Validates a map field's structure including duplicates and required entries. */ declare function validateMapStructure({ value, required, minItems }: ValidateArgs): string | true; //#endregion //#region src/components/fields/NumberField.d.ts /** * NumberField component properties */ interface NumberFieldProps extends BaseFieldProps { /** * Minimum value validation */ min?: number; /** * Maximum value validation */ max?: number; /** * Step value for increment/decrement */ step?: number; /** * Custom validation function for number values */ validateNumber?: (value: number) => boolean | string; } /** * Number input field component specifically designed for React Hook Form integration. * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects the appropriate field component (like NumberField) based on field type * 4. BaseField provides consistent layout and hook form integration * 5. This component handles number-specific rendering and validation * * The component includes: * - Integration with React Hook Form * - Numeric-specific validations (min, max, step) * - Customizable validation through adapter integration * - Automatic error handling and reporting * - Full accessibility support with ARIA attributes * - Keyboard navigation with arrow keys for numeric increment/decrement */ declare function NumberField({ id, label, placeholder, helperText, control, name, width, validation, min, max, step, validateNumber, readOnly }: NumberFieldProps): React$1.ReactElement; declare namespace NumberField { var displayName: string; } //#endregion //#region src/components/fields/ObjectField.d.ts /** * ObjectField component properties */ interface ObjectFieldProps extends BaseFieldProps { /** * The components/properties of the object. * These define the schema for the nested fields within the object. */ components?: FunctionParameter[]; /** * Render function for object properties. * This is crucial for rendering complex properties or integrating custom field components. */ renderProperty?: (field: FormFieldType, propertyName: string) => React$1.ReactNode; /** * Whether to show the object in a card container. * Useful for visually grouping object properties. */ showCard?: boolean; /** * The type-mapping capability for chain-specific field generation. * Essential for correctly determining field types for object properties. */ typeMapping?: TypeMappingCapability; /** * Optional contract schema for nested metadata (structs/enums). */ contractSchema?: ContractSchema; } /** * Object (composite/nested) input field component specifically designed for React Hook Form integration. * * This component provides a structured interface for managing object inputs with: * - Nested field rendering based on object components * - Validation for required properties (currently, the object itself can be required) * - Integration with existing field components for object properties * - Full accessibility support * * The component reuses existing field components for individual properties, * maintaining consistency across the form system while supporting complex nested structures. */ declare function ObjectField({ id, label, helperText, control, name, width, validation, components, renderProperty, showCard, readOnly, typeMapping, contractSchema }: ObjectFieldProps): React$1.ReactElement; declare namespace ObjectField { var displayName: string; } //#endregion //#region src/components/fields/PasswordField.d.ts /** * PasswordField component properties */ interface PasswordFieldProps extends BaseFieldProps { /** * Placeholder text displayed when the field is empty */ placeholder?: string; /** * Whether to show the password visibility toggle button * @default true */ showToggle?: boolean; } /** * Password input field component specifically designed for React Hook Form integration. * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects the appropriate field component (like PasswordField) based on field type * 4. BaseField provides consistent layout and hook form integration * 5. This component handles password-specific rendering and validation * * The component includes: * - Integration with React Hook Form * - Password visibility toggle functionality * - Password-specific validations (minLength, maxLength, pattern) * - Customizable validation through adapter integration * - Automatic error handling and reporting * - Full accessibility support with ARIA attributes * - Keyboard navigation */ declare function PasswordField({ id, label, placeholder, helperText, control, name, width, validation, readOnly, showToggle }: PasswordFieldProps): React$1.ReactElement; declare namespace PasswordField { var displayName: string; } //#endregion //#region src/components/fields/RadioField.d.ts /** * Option item for radio fields */ interface RadioOption { /** * Value to be submitted with the form */ value: string; /** * Display label for the option */ label: string; /** * Whether this option is disabled */ disabled?: boolean; } /** * RadioField component properties */ interface RadioFieldProps extends BaseFieldProps { /** * Available options for selection */ options?: RadioOption[]; /** * Direction of radio options layout */ layout?: 'horizontal' | 'vertical'; /** * Custom validation function for radio values */ validateRadio?: (value: string) => boolean | string; } /** * Radio button field component specifically designed for React Hook Form integration. * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects the appropriate field component based on field type * 4. BaseField provides consistent layout and hook form integration * 5. This component handles radio-specific rendering and validation * * The component includes: * - Integration with React Hook Form * - Customizable options list * - Horizontal or vertical layout options * - Customizable validation through adapter integration * - Automatic error handling and reporting * - Full accessibility support with ARIA attributes */ declare function RadioField({ id, label, helperText, control, name, width, validation, options, layout, validateRadio }: RadioFieldProps): React$1.ReactElement; declare namespace RadioField { var displayName: string; } //#endregion //#region src/components/fields/SelectField.d.ts /** * Option item for select fields */ interface SelectOption { /** * Value to be submitted with the form */ value: string; /** * Display label for the option */ label: string; /** * Whether this option is disabled */ disabled?: boolean; } /** * SelectField component properties */ interface SelectFieldProps extends BaseFieldProps { /** * Available options for selection */ options?: SelectOption[]; /** * Custom validation function for select values */ validateSelect?: (value: string) => boolean | string; /** * Optional default value used when the field has no value yet */ defaultValue?: string; } /** * Select dropdown field component specifically designed for React Hook Form integration. * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects the appropriate field component based on field type * 4. BaseField provides consistent layout and hook form integration * 5. This component handles radio-specific rendering and validation * * The component includes: * - Integration with React Hook Form * - Customizable options list * - Horizontal or vertical layout options * - Customizable validation through adapter integration * - Automatic error handling and reporting * - Full accessibility support with ARIA attributes */ declare function SelectField({ id, label, placeholder, helperText, control, name, width, validation, options, validateSelect, defaultValue }: SelectFieldProps): React$1.ReactElement; declare namespace SelectField { var displayName: string; } //#endregion //#region src/components/fields/SelectGroupedField.d.ts /** * Option item for select fields with visual indicators */ interface GroupedSelectOption { /** * Value to be submitted with the form */ value: string; /** * Display label for the option */ label: string; /** * Whether this option is disabled */ disabled?: boolean; /** * Custom CSS class to apply to the option */ className?: string; } /** * Option group structure */ interface OptionGroup { /** * Group label to display */ label: string; /** * Options within this group */ options: GroupedSelectOption[]; } /** * SelectGroupedField component properties */ interface SelectGroupedFieldProps extends BaseFieldProps { /** * Available option groups for selection */ groups?: OptionGroup[]; /** * Custom validation function for select values */ validateSelect?: (value: string) => boolean | string; } /** * Select dropdown field component with grouped options specifically designed for React Hook Form integration. * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects the appropriate field component based on field type * 4. BaseField provides consistent layout and hook form integration * 5. This component handles radio-specific rendering and validation * * The component includes: * - Integration with React Hook Form * - Customizable options list * - Horizontal or vertical layout options * - Customizable validation through adapter integration * - Automatic error handling and reporting * - Full accessibility support with ARIA attributes */ declare function SelectGroupedField({ id, label, placeholder, helperText, control, name, width, validation, groups, validateSelect }: SelectGroupedFieldProps): React$1.ReactElement; declare namespace SelectGroupedField { var displayName: string; } //#endregion //#region src/components/fields/TextAreaField.d.ts /** * TextAreaField component properties */ interface TextAreaFieldProps extends BaseFieldProps { /** * Number of rows for the textarea */ rows?: number; /** * Maximum characters allowed in textarea */ maxLength?: number; /** * Custom validation function for textarea values */ validateTextArea?: (value: string) => boolean | string; /** * Optional trailing content pinned under the textarea's bottom-right edge * (e.g. an entry-mode toggle). When set, helper text renders on a separate * row beneath with spacing so the slot stays flush to the textarea. */ helperEndSlot?: React$1.ReactNode; } /** * Multi-line text input field component specifically designed for React Hook Form integration. * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects the appropriate field component based on field type * 4. BaseField provides consistent layout and hook form integration * 5. This component handles textarea-specific rendering and validation * * The component includes: * - Integration with React Hook Form * - Resizable multi-line text input * - Character limit support * - Customizable validation through adapter integration * - Automatic error handling and reporting * - Full accessibility support with ARIA attributes * - Keyboard navigation with Escape to clear */ declare function TextAreaField({ id, label, placeholder, helperText, control, name, width, validation, rows, maxLength, validateTextArea, readOnly, helperEndSlot }: TextAreaFieldProps): React$1.ReactElement; declare namespace TextAreaField { var displayName: string; } //#endregion //#region src/components/fields/TextField.d.ts /** * TextField component properties */ interface TextFieldProps extends BaseFieldProps { /** * Placeholder text displayed when the field is empty */ placeholder?: string; /** * Fired with the new value on USER-originated edits only — keystrokes and the * Escape-clear — never on programmatic writes (`setValue`/`reset`). This is * the discriminator consumers need to tell "the user claimed this field" from * "code seeded this field" (e.g. the address book's ENS alias suggestion, * SF-5 INV-103/INV-105); RHF's `dirtyFields` cannot express it because any * form-wide dirty recompute retroactively marks a seeded value dirty. */ onUserEdit?: (value: string) => void; } /** * Text input field component specifically designed for React Hook Form integration. * * Architecture flow: * 1. Form schemas are generated from contract functions using adapters * 2. TransactionForm renders the overall form structure with React Hook Form * 3. DynamicFormField selects the appropriate field component (like TextField) based on field type * 4. BaseField provides consistent layout and hook form integration * 5. This component handles text-specific rendering and validation * * The component includes: * - Integration with React Hook Form * - Text-specific validations (minLength, maxLength, pattern) * - Customizable validation through adapter integration * - Automatic error handling and reporting * - Full accessibility support with ARIA attributes * - Keyboard navigation */ declare function TextField({ id, label, placeholder, helperText, control, name, width, validation, readOnly, onUserEdit }: TextFieldProps): React$1.ReactElement; declare namespace TextField { var displayName: string; } //#endregion //#region src/components/fields/UrlField.d.ts /** * URL input field component specifically designed for React Hook Form integration. */ declare function UrlField({ id, label, placeholder, helperText, control, name, width, validation, readOnly }: BaseFieldProps): React$1.ReactElement; declare namespace UrlField { var displayName: string; } //#endregion //#region src/components/fields/utils/accessibility.d.ts /** * Accessibility utilities for form field components */ /** * Default aria-describedby ID generator based on field ID */ declare function getDescribedById(id: string, type?: 'error' | 'description' | 'counter'): string; /** * Interface for accessibility attributes to be applied to form fields */ interface AccessibilityProps { /** * ARIA attributes for accessibility */ 'aria-invalid'?: boolean; 'aria-required'?: boolean; 'aria-describedby'?: string; 'aria-errormessage'?: string; 'aria-labelledby'?: string; /** * Indicates if the input is required */ required?: boolean; /** * Indicates if the input is disabled */ disabled?: boolean; /** * Indicates if the input is readonly */ readOnly?: boolean; /** * Tab index for keyboard navigation * Use 0 for normal tab order * Use -1 to remove from tab order */ tabIndex?: number; } /** * Generates accessibility attributes for form fields */ declare function getAccessibilityProps({ id, hasError, isRequired, isDisabled, isReadOnly, hasHelperText, hasCharacterCounter }: { id: string; hasError?: boolean; isRequired?: boolean; isDisabled?: boolean; isReadOnly?: boolean; hasHelperText?: boolean; hasCharacterCounter?: boolean; }): AccessibilityProps; /** * Utility function to handle keyboard events for interactive elements * Helps ensure keyboard users can interact with form controls */ declare function handleKeyboardEvent(event: React.KeyboardEvent, handlers: { onEnter?: () => void; onSpace?: () => void; onEscape?: () => void; onArrowUp?: () => void; onArrowDown?: () => void; onArrowLeft?: () => void; onArrowRight?: () => void; onTab?: () => void; }): void; /** * Field focus management utility * For managing focus within a field group or complex form component */ declare function createFocusManager(): { focusFirstElement: (container: HTMLElement | null) => void; focusElementById: (id: string) => void; trapFocus: (event: KeyboardEvent, container: HTMLElement | null) => void; }; /** * Provides a handler for Escape key to clear input fields * * @param onChange - Function to call when value changes * @param value - Current value of the input * @returns A function to handle the Escape key press */ declare function handleEscapeKey(onChange: (value: string) => void, value: unknown): (e: React.KeyboardEvent) => void; /** * Provides a handler for Space/Enter keys for toggle components (checkboxes, switches) * * @param onChange - Function to call when value changes * @param value - Current value of the input * @returns A function to handle the Space/Enter key press */ declare function handleToggleKeys(onChange: (value: boolean) => void, value: boolean): (e: React.KeyboardEvent) => void; /** * Provides a handler for arrow keys for numeric inputs * * @param onChange - Function to call when value changes * @param value - Current numeric value * @param step - Step amount for increments/decrements * @param min - Minimum allowed value (optional) * @param max - Maximum allowed value (optional) * @returns A function to handle arrow key presses */ declare function handleNumericKeys(onChange: (value: number) => void, value: number, step?: number, min?: number, max?: number): (e: React.KeyboardEvent) => void; //#endregion //#region src/components/fields/utils/ErrorMessage.d.ts interface ErrorMessageProps { /** * The error object from React Hook Form */ error?: FieldError; /** * The ID of the error message for aria-errormessage references */ id: string; /** * Optional custom error message to display instead of the error from React Hook Form */ message?: string; /** * Optional additional CSS classes */ className?: string; } /** * Displays validation error messages for form fields */ declare function ErrorMessage({ error, id, message, className }: ErrorMessageProps): React$1.ReactElement | null; //#endregion //#region src/components/fields/utils/integerValidation.d.ts /** * Shared integer validation patterns for BigInt fields and validation utilities. * * These patterns ensure consistent validation across the application. */ /** * Integer validation pattern - requires at least one digit * Used for validation to ensure complete integers are entered * Matches: -123, 0, 456 * Does not match: -, abc, 12.3 */ declare const INTEGER_PATTERN: RegExp; /** * Integer input pattern - allows partial input during typing * Used during input to allow users to type minus sign first * Matches: -, -1, 123, (empty string) * Does not match: abc, 12.3 */ declare const INTEGER_INPUT_PATTERN: RegExp; /** * HTML pattern attribute for integer inputs * Must use [0-9] instead of \d for HTML5 pattern attribute */ declare const INTEGER_HTML_PATTERN = "-?[0-9]*"; //#endregion //#region src/components/fields/utils/layout.d.ts /** * Layout utility functions for form components */ /** * Helper function to get width classes based on the field width */ declare function getWidthClasses(width: 'full' | 'half' | 'third'): string; //#endregion //#region src/components/fields/utils/validation.d.ts /** * Determines if a field has an error */ declare function hasFieldError(error: FieldError | undefined): boolean; /** * Gets appropriate error message from field error */ declare function getErrorMessage(error: FieldError | undefined): string | undefined; /** * Formats validation error messages for display */ declare function formatValidationError(error: FieldError | undefined, fieldName?: string): string | undefined; /** * Generates common CSS classes for field validation states */ declare function getValidationStateClasses(error: FieldError | undefined, touched?: boolean): string; /** * Helper for handling form validation errors with React Hook Form */ declare function handleValidationError(error: FieldError | undefined, id: string): { errorId: string; errorMessage: string | undefined; hasError: boolean; validationClasses: string; }; /** * Creates a validation result object for field components */ declare function createValidationResult(id: string, error: FieldError | undefined, touched?: boolean): { hasError: boolean; errorMessage: string | undefined; errorId: string; validationClasses: string; 'aria-invalid': boolean; 'aria-errormessage'?: string; }; /** * Generic field validation function that can be used to validate any field type * based on common validation criteria */ declare function validateField(value: unknown, validation?: FieldValidation): string | boolean; /** * Map validation utilities */ /** * Checks if a map entry at the given index has a duplicate key * @param entries - Array of map entries * @param currentIndex - Index of the entry to check * @returns true if the key at currentIndex is duplicated elsewhere in the array */ declare function isDuplicateMapKey(entries: MapEntry[], currentIndex: number): boolean; /** * Validates an array of map entries for duplicate keys * @param entries - Array of map entries to validate * @returns Validation error message if duplicates found, otherwise undefined */ declare function validateMapEntries(entries: MapEntry[]): string | undefined; //#endregion //#region src/components/RelayerDetailsCard/RelayerDetailsCard.d.ts interface RelayerDetailsCardProps { details: RelayerDetails; enhancedDetails?: RelayerDetailsRich | null; loading?: boolean; className?: string; /** Optional UI labels to override default copy */ labels?: Partial<{ detailsTitle: string; active: string; paused: string; systemDisabled: string; network: string; relayerId: string; balance: string; nonce: string; pending: string; lastTransaction: string; }>; } declare const RelayerDetailsCard: React$1.FC; //#endregion //#region src/components/network-errors/NetworkErrorNotificationProvider.d.ts interface NetworkErrorNotificationProviderProps { children: React.ReactNode; } /** Provider component for managing and displaying network error notifications. */ declare function NetworkErrorNotificationProvider({ children }: NetworkErrorNotificationProviderProps): React.ReactNode; //#endregion //#region src/components/network-errors/useNetworkErrors.d.ts type NetworkErrorType = 'rpc' | 'explorer'; interface NetworkError { id: string; type: NetworkErrorType; networkId: string; networkName: string; message: string; timestamp: number; } interface NetworkErrorContextValue { errors: NetworkError[]; reportNetworkError: (type: NetworkErrorType, networkId: string, networkName: string, message: string) => void; clearError: (id: string) => void; clearAllErrors: () => void; onOpenNetworkSettings?: (networkId: string) => void; setOpenNetworkSettingsHandler: (handler: (networkId: string) => void) => void; } /** Hook to access network error reporting and management functions. */ declare function useNetworkErrors(): NetworkErrorContextValue; /** * Hook for reporting network errors for a specific runtime-bound capability */ declare function useNetworkErrorReporter(capability: RuntimeCapability | null): { reportRpcError: (message: string) => void; reportExplorerError: (message: string) => void; }; //#endregion //#region src/components/network-errors/NetworkErrorAwareAdapter.d.ts /** * Creates an adapter proxy that intercepts and reports network errors */ declare function useNetworkErrorAwareAdapter(capability: T | null): T | null; //#endregion //#region src/components/network-errors/NetworkServiceErrorBanner.d.ts interface NetworkServiceErrorBannerProps { /** The network configuration for which the service connection failed */ networkConfig: NetworkConfig; /** The type of service that failed (e.g., 'rpc', 'explorer', 'indexer') */ serviceType: string; /** Optional custom error message to display */ errorMessage?: string; /** Optional custom title override */ title?: string; /** Optional custom description to show below the error message */ description?: string; /** * Optional callback to open network settings dialog. * If not provided, will try to use the context from NetworkErrorNotificationProvider. * If neither is available, the settings button will not be rendered. */ onOpenNetworkSettings?: (networkId: string) => void; } /** * User-friendly banner displayed when a network service connection fails. * Works with any service type (RPC, Explorer, Indexer, etc.) and provides * a clear explanation of the issue with a call-to-action to open the * network settings dialog where users can configure an alternative endpoint. * * This component can be used with or without the NetworkErrorNotificationProvider: * - With provider: The settings handler is obtained from context * - Without provider: Pass onOpenNetworkSettings prop directly, or the button won't render */ declare function NetworkServiceErrorBanner({ networkConfig, serviceType, errorMessage, title, description, onOpenNetworkSettings: onOpenNetworkSettingsProp }: NetworkServiceErrorBannerProps): React.ReactNode; //#endregion //#region src/components/network-availability/NetworkAvailabilityNotice.d.ts interface NetworkAvailabilityNoticeProps { /** Display name of the hosting app, e.g. "UI Builder" */ appName: string; /** GitHub repository URL for self-hosting instructions */ selfHostRepoUrl: string; className?: string; } /** * Banner shown when the deployment disables mainnet or specific network IDs. * Hidden when no network availability policy is active. */ declare function NetworkAvailabilityNotice({ appName, selfHostRepoUrl, className }: NetworkAvailabilityNoticeProps): React$1.ReactElement | null; //#endregion //#region src/components/icons/MidnightIcon.d.ts interface MidnightIconProps { size?: number; className?: string; variant?: 'mono' | 'branded'; } /** * MidnightIcon - SVG icon for the Midnight blockchain * Inline SVG to ensure it renders correctly when this package is consumed as a library */ declare function MidnightIcon({ size, className, variant: _variant }: MidnightIconProps): React$1.ReactElement; //#endregion //#region src/components/ui/sonner.d.ts declare const Toaster: ({ ...props }: ToasterProps) => JSX.Element; //#endregion export { AccessibilityProps, Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, type AddressAvatarVariant, AddressDisplay, type AddressDisplayProps, type AddressDisplayVariant, AddressField, AddressFieldProps, AddressFieldWithResolvedPreview, AddressFieldWithResolvedPreviewProps, AddressLabelProvider, type AddressLabelProviderProps, AddressListEntryMode, AddressListField, AddressListFieldLabels, AddressListFieldProps, AddressNameProvider, type AddressNameProviderProps, AddressSuggestionList, type AddressSuggestionListProps, AddressSuggestionProvider, type AddressSuggestionProviderProps, Alert, AlertDescription, AlertTitle, AmountField, AmountFieldProps, ArrayField, ArrayFieldProps, ArrayObjectField, ArrayObjectFieldProps, Banner, BannerProps, BannerSize, BannerVariant, BaseField, BaseFieldProps, BigIntField, BigIntFieldProps, BooleanField, BooleanFieldProps, Button, ButtonProps, BytesField, BytesFieldProps, Calendar, CalendarProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, DEFAULT_ADDRESS_LIST_FIELD_LABELS, type DateRange, DateRangePicker, DateRangePickerProps, DateTimeField, DateTimeFieldProps, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EcosystemDropdown, EcosystemDropdownOption, EcosystemDropdownProps, EcosystemIcon, EcosystemIconProps, EmptyState, EmptyStateProps, EnumField, EnumFieldProps, EnumFieldValue, EnumMetadata, EnumVariant, ErrorMessage, ExternalLink, FileUploadField, FileUploadFieldProps, Footer, FooterProps, Form, FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage, GroupedSelectOption, Header, HeaderProps, INTEGER_HTML_PATTERN, INTEGER_INPUT_PATTERN, INTEGER_PATTERN, type InjectedNameResolutionResult, type InjectedResolveName, Input, InputProps, Label, LoadingButton, LoadingButtonProps, MapEntryRow, MapField, MapFieldProps, MidnightIcon, NAME_RESOLUTION_DEBOUNCE_MS, NameResolverContext, NameResolverProvider, type NameResolverProviderProps, NetworkAvailabilityNotice, type NetworkAvailabilityNoticeProps, type NetworkError, NetworkErrorNotificationProvider, type NetworkErrorType, NetworkIcon, NetworkIconProps, NetworkSelector, NetworkSelectorProps, NetworkServiceErrorBanner, type NetworkServiceErrorBannerProps, NetworkStatusBadge, NumberField, NumberFieldProps, ObjectField, ObjectFieldProps, OptionGroup, OverflowMenu, OverflowMenuItem, OverflowMenuProps, PasswordField, PasswordFieldProps, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, Progress, RadioField, RadioFieldProps, RadioGroup, RadioGroupItem, RadioOption, RelayerDetailsCard, type RelayerDetailsCardProps, ResolvedAddressFieldPreview, ResolvedAddressFieldPreviewProps, Select, SelectContent, SelectField, SelectFieldProps, SelectGroup, SelectGroupedField, SelectGroupedFieldProps, SelectItem, SelectLabel, SelectOption, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, SidebarButton, type SidebarButtonProps, SidebarGroup, type SidebarGroupProps, SidebarLayout, type SidebarLayoutProps, SidebarSection, type SidebarSectionProps, type StepStatus, type StepVisualState, Tabs, TabsContent, TabsList, TabsTrigger, TextAreaField, TextAreaFieldProps, TextField, TextFieldProps, Textarea, TextareaProps, Toaster, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, UrlField, type UseAddressLabelResult, type UseAddressNameResult, type UseAddressSuggestionFieldArgs, type UseAddressSuggestionFieldResult, type UseAddressSuggestionsResult, type UseInjectedNameResolutionParams, VERSION, ViewContractStateButton, WizardLayout, type WizardLayoutProps, WizardNavigation, type WizardNavigationProps, type WizardStepConfig, type WizardStepDef, WizardStepper, type WizardStepperProps, buildAddressListPreviewSummary, buttonVariants, computeChildTouched, createFocusManager, createValidationResult, formatAddressBulkSummary, formatValidationError, getAccessibilityProps, getDescribedById, getErrorMessage, getValidationStateClasses, getWidthClasses, handleEscapeKey, handleKeyboardEvent, handleNumericKeys, handleToggleKeys, handleValidationError, hasFieldError, isDuplicateMapKey, resolveAddressListFieldLabels, useAddressLabel, useAddressName, useAddressSuggestionField, useAddressSuggestions, useDuplicateKeyIndexes, useInjectedNameResolution, useMapFieldSync, useNameResolver, useNetworkErrorAwareAdapter, useNetworkErrorReporter, useNetworkErrors, validateField, validateMapEntries, validateMapStructure }; //# sourceMappingURL=index.d.mts.map