cilantro-react 0.1.0 → 0.1.2

package/README.md

@@ -59,6 +59,7 @@ export default function RootLayout({ children }: { children: React.ReactNode })
 - **CilantroProvider** – Root provider: initializes storage, auth, and wallet context. Requires `platformApiKey`; optional `apiUrl`, storage keys, and callbacks. Use this unless you only need auth.
 - **CilantroAuthProvider** – Auth only (token, user, login, register, logout). Use when you don’t need the full provider stack (e.g. auth-only pages).
 - **WalletProvider** – Wallet list and selection. Depends on auth; usually used inside `CilantroProvider`.
+- **ThemeProvider** – Optional: sets `data-theme="light"` or `"dark"` on a wrapper and injects default CSS variables for light/dark. Props: `theme` (`"light"` | `"dark"` | `"system"`), `defaultTheme`, `storageKey`, `className`, `injectStyles`. See [Themes](#built-in-theme-themeprovider).
 
 **CilantroAuthProvider props:** `platformApiKey` (required), `apiUrl`, `jwtStorageKey`, `onLoginSuccess`, `onLogout`, `onRegisterSuccess`.
 
@@ -106,6 +107,32 @@ Wallet list and selection. Use inside `CilantroProvider` (which includes `Wallet
 
 ---
 
+#### useSelectedWallet
+
+Convenience hook when you only need the currently selected wallet (and loading/refresh), not the full list. Use inside `CilantroProvider`.
+
+**Returns:** `UseSelectedWalletResult`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `selectedWallet` | `WalletData \| null` | Currently selected wallet. |
+| `isLoading` | `boolean` | True while loading wallets. |
+| `refreshWallets` | `() => Promise<void>` | Reload wallets from the API. |
+
+**Use when:** You need the current wallet without the full wallet list or `selectWallet`.
+
+---
+
+#### useWalletAddress
+
+Returns the address of the currently selected wallet (handles both `address` and `walletAddress` on WalletData). Use inside `CilantroProvider`.
+
+**Returns:** `string | null`
+
+**Use when:** You need the selected wallet's address for display or building transactions.
+
+---
+
 #### useSigners
 
 Load signers for a wallet. Use inside `CilantroProvider` (auth required).
@@ -129,6 +156,22 @@ When `walletId` is null/undefined, `signers` is empty and `refresh` no-ops.
 
 ---
 
+#### useSignersForSelectedWallet
+
+Signers for the currently selected wallet (or a `walletId` override). Composes `useWallets` + `useSigners` so you don't pass `walletId` yourself. Use inside `CilantroProvider`.
+
+**Options:** `UseSignersForSelectedWalletOptions`
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `walletId` | `string \| null \| undefined` | Override; when omitted, uses the selected wallet from context. |
+
+**Returns:** Same as `useSigners` – `UseSignersResult` (`signers`, `isLoading`, `error`, `refresh`).
+
+**Use when:** You need signers for the current wallet without calling `useWallets()` and `useSigners({ walletId })` in every component (e.g. SignerList-style UIs).
+
+---
+
 #### useSignerSelection
 
 Wallet + signer selection state for signing flows. Uses `useWallets` and `useSigners` internally. Use inside `CilantroProvider`.
@@ -156,6 +199,56 @@ Wallet + signer selection state for signing flows. Uses `useWallets` and `useSig
 
 ---
 
+#### useDelegatedKeys
+
+Load delegated keys for a wallet (same data as DelegatedKeySelector). Use for custom delegated-key UI or logic. Use inside `CilantroProvider` (auth required).
+
+**Options:** `UseDelegatedKeysOptions`
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `walletId` | `string \| null \| undefined` | Wallet ID to load delegated keys for. When null/undefined, keys are empty. |
+| `filterActive` | `boolean` | When true (default), filter to active and non-expired keys only. |
+
+**Returns:** `UseDelegatedKeysResult`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `keys` | `DelegatedKeyData[]` | List of delegated keys. |
+| `isLoading` | `boolean` | True while loading. |
+| `error` | `string \| null` | Error message if load failed. |
+| `refresh` | `() => Promise<void>` | Reload delegated keys. |
+
+**Use when:** You need the list of delegated keys in custom UI or logic without using the DelegatedKeySelector component.
+
+---
+
+#### useCanSign
+
+Derived "is the user ready to sign?" for disabling sign buttons or showing prompts. Use inside `CilantroProvider`.
+
+**Options:** `UseCanSignOptions`
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `signingMethod` | `SigningMethod \| null` | Override; default `'sdk-signer'`. |
+| `requireSigner` | `boolean` | When true (default), require a selected signer for sdk-signer. |
+| `walletAdapterConnected` | `boolean` | When using wallet-adapter, pass true when the adapter is connected so `canSign*` reflects it. |
+
+**Returns:** `UseCanSignResult`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `hasToken` | `boolean` | True when the user has a valid token. |
+| `hasWallet` | `boolean` | True when a wallet is selected. |
+| `hasSigner` | `boolean` | True when a signer is selected (sdk-signer) or wallet-adapter is connected (when `walletAdapterConnected` is passed). |
+| `canSignMessage` | `boolean` | True when ready to sign a message. |
+| `canSignTransaction` | `boolean` | True when ready to sign/send a transaction (connection still required for send). |
+
+**Use when:** You need to disable sign buttons or show "Select wallet" / "Select signer" prompts without reimplementing token/wallet/signer checks. For wallet-adapter, pass `walletAdapterConnected` from your adapter state.
+
+---
+
 #### useMessageSigning
 
 Sign a message with the selected signer or wallet-adapter. Use inside `CilantroProvider`.
@@ -238,6 +331,11 @@ All components accept `className`. Many accept a `classNames` object (see TypeSc
 | **AddSignerForm** | Add signer (email, phone, passkey, external wallet). | `walletId`, `open?`, `onOpenChange?`, `onSuccess?`, `onCancel?`, `onError?(error)`, `asDialog?` (default true), `className`, `classNames?`. |
 | **DelegatedKeySelector** | Select delegated key for a wallet. | `walletId`, `value?`, `onChange?(keyId, key)`, `filterActive?` (default true), `placeholder`, `className`, `classNames?`. Headless: `children?` (keys, selectedKeyId, onSelect, isLoading, error, refresh). |
 
+#### UI primitives
+
+- **Skeleton** – Shadcn-style skeleton placeholder (`rounded-md bg-muted animate-pulse`). Use for loading states or custom UI. Exported for headless use.
+- **ThemeProvider** – See [Themes](#built-in-theme-themeprovider).
+
 #### Signing form components
 
 | Component | Purpose | Key props |
@@ -636,9 +734,64 @@ See TypeScript types and [cilantro-sdk](https://www.npmjs.com/package/cilantro-s
 
 ## Theming
 
-Components use Shadcn-style class names and CSS variables (e.g. `border-input`, `bg-primary`, `text-muted-foreground`). Ensure your app has Tailwind and, if you use Shadcn, your theme or `globals.css` defines those variables so colors and spacing match your design. You can override any part via `className` or `classNames`.
+Components use Shadcn-style class names and CSS variables (e.g. `border-input`, `bg-primary`, `text-muted-foreground`). Ensure your app has **Tailwind CSS** so utility classes work; the library does not bundle Tailwind.
+
+### Built-in theme (ThemeProvider)
+
+You can opt into a built-in light/dark theme without bringing your own Shadcn setup. Wrap your app (or just the Cilantro UI) with `ThemeProvider`:
+
+```tsx
+import { ThemeProvider } from 'cilantro-react'
+
+<ThemeProvider theme="system" defaultTheme="dark" className="min-h-screen">
+  <CilantroProvider platformApiKey="...">
+    {children}
+  </CilantroProvider>
+</ThemeProvider>
+```
+
+- **theme** – `"light"` | `"dark"` | `"system"`. `"system"` follows `prefers-color-scheme`.
+- **defaultTheme** – Initial theme when using `"system"` (default: `"dark"`).
+- **storageKey** – Optional localStorage key to persist the resolved theme when using `"system"`.
+- **injectStyles** – When `true` (default), the provider injects a minimal set of CSS variables (`--background`, `--foreground`, `--primary`, `--muted`, `--border`, `--input`, `--ring`, etc.) for light and `[data-theme="dark"]`. You can set `injectStyles={false}` and import the theme file yourself: `import 'cilantro-react/themes/default.css'`.
+
+Tailwind is still required so utility classes apply; ThemeProvider only sets the variables.
+
+For full Shadcn theming, see [Theming - shadcn/ui](https://ui.shadcn.com/docs/theming).
+
+---
+
+## Accessibility
+
+Components are built with screen readers and keyboard use in mind:
+
+- **Live regions** – Signing result messages (MessageSigningForm, TransactionSigningForm) use `role="status"` and `aria-live="polite"` (or `assertive` for errors). Loading states use `aria-busy`.
+- **Form labels** – Auth, login, register, message signing, and add-signer forms use visible labels with correct `id` / `htmlFor`. Error blocks use `role="alert"` so errors are announced immediately.
+- **Selects and dialogs** – WalletSelector and DelegatedKeySelector triggers have `aria-label`. Radix Dialog handles focus trap and restore in AddSignerForm.
+- **Loading** – WalletSelector, SignerSelector, SignerList, DelegatedKeySelector, and AuthGuard use `aria-busy` and `aria-live="polite"` when loading so screen readers announce loading state.
+
+Buttons use `focus-visible:ring-2` for focus indication; icon-only or custom buttons can receive `aria-label` via standard HTML attributes.
+
+---
+
+## Mobile
+
+Key actions use touch-friendly targets and dialogs are responsive:
+
+- **Touch targets** – The Button component has a `touch` size (`min-h-[44px] min-w-[44px]`) used on primary actions: AuthForm/LoginForm/RegisterForm submit, MessageSigningForm sign button, and SignerList “Add signer”. Use `size="touch"` on your own primary buttons when needed.
+- **Responsive layout** – Auth forms use `w-full max-w-sm`. MessageSigningForm and TransactionSigningForm use responsive button groups (`flex-col` on small screens). Result blocks use `overflow-auto` on `<pre>` so content doesn’t overflow.
+- **Dialog** – DialogContent has `max-h-[100dvh] sm:max-h-[90vh]` and `overflow-y-auto` so dialogs (e.g. AddSignerForm) are scrollable on small screens. You can add `className="rounded-none sm:rounded-lg"` or full-height classes for a more mobile-friendly dialog.
+
+---
+
+## Loading states
+
+Loading is shown with skeleton placeholders where it improves perceived performance:
 
-For Shadcn theming, see [Theming - shadcn/ui](https://ui.shadcn.com/docs/theming).
+- **Skeleton** – A `Skeleton` UI primitive is available (`import { Skeleton } from 'cilantro-react'`). Components use it when loading: WalletSelector and DelegatedKeySelector show a skeleton trigger; SignerSelector and SignerList show 2–3 skeleton rows.
+- **useSkeleton** – WalletSelector, SignerSelector, SignerList, and DelegatedKeySelector accept an optional **useSkeleton** prop (default: `true`). Set `useSkeleton={false}` to show plain “Loading…” text instead.
+- **classNames** – These components support `classNames.skeleton` and `classNames.loading` so you can style the skeleton or the loading container.
+- **AuthGuard** – Optional skeleton while checking auth: set **useSkeleton={true}** to show a small skeleton card instead of “Loading…” text.
 
 ---
 

package/dist/index.d.mts

@@ -1,7 +1,14 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
 import { ReactNode } from 'react';
+import { WalletControllerFindAllResult, WalletControllerListSignersResult, WalletControllerSubmitTransactionResult } from 'cilantro-sdk/wallet';
+export { WalletControllerFindAllResult, WalletControllerFindOneResult, WalletControllerListSignersResult, WalletControllerSubmitTransactionResult } from 'cilantro-sdk/wallet';
 import { SignerInfo } from 'cilantro-sdk/helpers';
+import { DelegatedKeyControllerFindAllResult } from 'cilantro-sdk/delegated-keys';
+export { DelegatedKeyControllerFindAllResult } from 'cilantro-sdk/delegated-keys';
 import { Transaction, PublicKey } from '@solana/web3.js';
+export { AuthControllerLogin200Data } from 'cilantro-sdk/auth';
+export { TransactionControllerSendRawPasskeyTransactionResult } from 'cilantro-sdk/transactions';
 
 interface CilantroProviderProps {
     children: ReactNode;
@@ -17,6 +24,7 @@ interface CilantroProviderProps {
 }
 declare function CilantroProvider({ children, platformApiKey, apiUrl, jwtStorageKey, walletStorageKey, onLoginSuccess, onLogout, onRegisterSuccess, }: CilantroProviderProps): react_jsx_runtime.JSX.Element;
 
+/** Minimal user view; populated from SDK login result data.user when available. */
 interface User {
     username?: string;
     email?: string;
@@ -43,16 +51,14 @@ interface CilantroAuthProviderProps {
 declare function CilantroAuthProvider({ children, platformApiKey, apiUrl, jwtStorageKey, onLoginSuccess, onLogout, onRegisterSuccess, }: CilantroAuthProviderProps): react_jsx_runtime.JSX.Element;
 declare function useCilantroAuth(): CilantroAuthContextType;
 
-interface WalletData {
-    id: string;
-    walletId: string;
-    walletName?: string;
+/** SDK wallet list item type (element of WalletsListResponseDto.data). */
+type WalletDataDto = WalletControllerFindAllResult["data"] extends readonly (infer E)[] ? E : WalletControllerFindAllResult["data"] extends (infer E)[] ? E : never;
+/** WalletDataDto with backward-compat aliases (id, address, active) for existing UI. */
+type WalletData = WalletDataDto & {
+    id?: string;
     address?: string;
-    walletAddress?: string;
-    chain?: string;
     active?: boolean;
-    [key: string]: unknown;
-}
+};
 interface WalletContextType {
     selectedWallet: WalletData | null;
     wallets: WalletData[];
@@ -67,6 +73,29 @@ interface WalletProviderProps {
 declare function WalletProvider({ children, storageKey }: WalletProviderProps): react_jsx_runtime.JSX.Element;
 declare function useWallets(): WalletContextType;
 
+interface UseSelectedWalletResult {
+    selectedWallet: WalletData | null;
+    isLoading: boolean;
+    refreshWallets: () => Promise<void>;
+}
+/**
+ * Returns the currently selected wallet, loading state, and refresh.
+ * Use when you only need the current wallet, not the full wallet list.
+ * Must be used inside CilantroProvider (WalletProvider).
+ */
+declare function useSelectedWallet(): UseSelectedWalletResult;
+
+/**
+ * Returns the address of the currently selected wallet.
+ * Handles both `address` and `walletAddress` on WalletData.
+ * Must be used inside CilantroProvider (WalletProvider).
+ */
+declare function useWalletAddress(): string | null;
+
+/**
+ * Normalized signer shape aligned with SDK SignerDataDto / WalletSignerDataDto.
+ * Uses SDK field names (signerId, signerType, signerPubkey, authId); id is an alias for signerId or WalletSignerDataDto.id.
+ */
 interface SignerData extends Omit<SignerInfo, "signerId"> {
     id: string;
     signerId: string;
@@ -96,6 +125,60 @@ interface UseSignersResult {
 }
 declare function useSigners(options?: UseSignersOptions): UseSignersResult;
 
+type SignersListResponseDto = WalletControllerListSignersResult;
+interface UseSignersRawOptions {
+    /** Wallet ID to load signers for. When null/undefined, response is null. */
+    walletId?: string | null;
+}
+interface UseSignersRawResult {
+    /** Exact SDK response from listSigners (success, data: { authenticationSigners, onChainSigners }). */
+    signersRaw: SignersListResponseDto | null;
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+}
+/**
+ * Load signers for a wallet and return the exact SDK shape (SignersListResponseDto).
+ * Use when you need SDK-exact output; for a normalized list use useSigners instead.
+ * Must be used inside CilantroProvider (auth required).
+ */
+declare function useSignersRaw(options?: UseSignersRawOptions): UseSignersRawResult;
+
+interface UseSignersForSelectedWalletOptions {
+    /** Override wallet ID; when omitted, uses the selected wallet from context. */
+    walletId?: string | null;
+}
+/**
+ * Returns signers for the currently selected wallet (or the given walletId override).
+ * Composes useWallets + useSigners so you don't have to pass walletId yourself.
+ * Must be used inside CilantroProvider.
+ */
+declare function useSignersForSelectedWallet(options?: UseSignersForSelectedWalletOptions): UseSignersResult;
+
+/** SDK delegated key type (element of DelegatedKeysListResponseDto.data). Canonical id is delegatedKeyId. */
+type DelegatedKeyDataDto = DelegatedKeyControllerFindAllResult["data"] extends readonly (infer E)[] ? E : DelegatedKeyControllerFindAllResult["data"] extends (infer E)[] ? E : never;
+/** DelegatedKeyDataDto with backward-compat id alias (id = delegatedKeyId) for existing UI. */
+type DelegatedKeyData = DelegatedKeyDataDto & {
+    id?: string;
+};
+interface UseDelegatedKeysOptions {
+    /** Wallet ID to load delegated keys for. When null/undefined, keys are empty. */
+    walletId?: string | null;
+    /** When true (default), filter to active keys and non-expired only. */
+    filterActive?: boolean;
+}
+interface UseDelegatedKeysResult {
+    keys: DelegatedKeyData[];
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+}
+/**
+ * Load delegated keys for a wallet. Use for custom delegated-key UI or logic.
+ * Must be used inside CilantroProvider (auth required).
+ */
+declare function useDelegatedKeys(options?: UseDelegatedKeysOptions): UseDelegatedKeysResult;
+
 type SigningMethod = "wallet-adapter" | "sdk-signer";
 interface UseSignerSelectionOptions {
     /** Override wallet ID; if not set, uses selected wallet from WalletProvider */
@@ -114,6 +197,33 @@ interface UseSignerSelectionResult {
 }
 declare function useSignerSelection(options?: UseSignerSelectionOptions): UseSignerSelectionResult;
 
+interface UseCanSignOptions {
+    /** Override signing method; when omitted, uses default "sdk-signer". */
+    signingMethod?: SigningMethod | null;
+    /** When true (default for sdk-signer), require a selected signer. When false, only wallet is required. */
+    requireSigner?: boolean;
+    /** When using wallet-adapter, pass true when the adapter is connected. Omit if not using wallet-adapter. */
+    walletAdapterConnected?: boolean;
+}
+interface UseCanSignResult {
+    /** True when the user has a valid token. */
+    hasToken: boolean;
+    /** True when a wallet is selected. */
+    hasWallet: boolean;
+    /** True when a signer is selected (sdk-signer) or wallet-adapter is connected (when walletAdapterConnected is passed). */
+    hasSigner: boolean;
+    /** True when ready to sign a message (hasToken + hasWallet + hasSigner for current method). */
+    canSignMessage: boolean;
+    /** True when ready to sign/send a transaction (same as canSignMessage; connection is required for send). */
+    canSignTransaction: boolean;
+}
+/**
+ * Derived "is the user ready to sign?" for disabling sign buttons or showing prompts.
+ * For wallet-adapter, pass walletAdapterConnected when your adapter is connected so canSign reflects it.
+ * Must be used inside CilantroProvider.
+ */
+declare function useCanSign(options?: UseCanSignOptions): UseCanSignResult;
+
 /**
  * Type Utilities - common types and utilities for SDK interactions
  */
@@ -198,12 +308,16 @@ interface WalletSelectorClassNames {
     trigger?: string;
     content?: string;
     item?: string;
+    skeleton?: string;
+    loading?: string;
 }
 interface WalletSelectorProps {
     value?: string;
     onWalletChange?: (walletId: string, wallet: WalletData | null) => void;
     className?: string;
     classNames?: WalletSelectorClassNames;
+    /** When true (default), show skeleton in trigger while loading; when false, show "Loading..." text. */
+    useSkeleton?: boolean;
     placeholder?: string;
     renderTrigger?: (props: {
         selectedWallet: WalletData | null;
@@ -233,6 +347,8 @@ interface SignerSelectorClassNames {
     list?: string;
     item?: string;
     message?: string;
+    skeleton?: string;
+    loading?: string;
 }
 interface SignerSelectorProps {
     /** Wallet ID (signers are loaded for this wallet when used with useSigners) */
@@ -249,6 +365,8 @@ interface SignerSelectorProps {
     className?: string;
     /** Override class names for sub-elements */
     classNames?: SignerSelectorClassNames;
+    /** When true (default), show skeleton rows while loading; when false, show "Loading signers..." text. */
+    useSkeleton?: boolean;
     /** Custom list render (headless) */
     renderList?: (props: {
         signers: SignerData[];
@@ -267,25 +385,16 @@ interface SignerSelectorProps {
         isLoading: boolean;
     }) => React.ReactNode;
 }
-declare function SignerSelector({ selectedWalletId, availableSigners, selectedSigner, isLoadingSigners, onSignerSelect, className, classNames, renderList, children, }: SignerSelectorProps): react_jsx_runtime.JSX.Element | null;
+declare function SignerSelector({ selectedWalletId, availableSigners, selectedSigner, isLoadingSigners, onSignerSelect, className, classNames, useSkeleton, renderList, children, }: SignerSelectorProps): react_jsx_runtime.JSX.Element | null;
 
-interface DelegatedKeyData {
-    id: string;
-    walletId: string;
-    name?: string;
-    publicKey: string;
-    permissions: Record<string, unknown>;
-    isActive?: boolean;
-    createdAt?: string;
-    expiresAt?: string;
-    [key: string]: unknown;
-}
 interface DelegatedKeySelectorClassNames {
     root?: string;
     trigger?: string;
     content?: string;
     item?: string;
     message?: string;
+    skeleton?: string;
+    loading?: string;
 }
 interface DelegatedKeySelectorProps {
     walletId: string;
@@ -294,6 +403,8 @@ interface DelegatedKeySelectorProps {
     filterActive?: boolean;
     className?: string;
     classNames?: DelegatedKeySelectorClassNames;
+    /** When true (default), show skeleton trigger while loading; when false, show "Loading delegated keys..." text. */
+    useSkeleton?: boolean;
     placeholder?: string;
     children?: (props: {
         keys: DelegatedKeyData[];
@@ -500,6 +611,8 @@ declare function AuthForm({ defaultMode, className, classNames, onSuccess, onErr
 interface AuthGuardClassNames {
     root?: string;
     fallback?: string;
+    skeleton?: string;
+    loading?: string;
 }
 interface AuthGuardProps {
     children: ReactNode;
@@ -510,12 +623,14 @@ interface AuthGuardProps {
     classNames?: AuthGuardClassNames;
     /** When true, show fallback (login) instead of children when unauthenticated. When false, render null when unauthenticated. */
     showFallback?: boolean;
+    /** When true, show a small skeleton card while loading; when false (default), show "Loading..." text. */
+    useSkeleton?: boolean;
 }
 /**
  * Wraps content and shows fallback (e.g. LoginForm) when the user is not authenticated.
  * Use inside CilantroAuthProvider.
  */
-declare function AuthGuard({ children, fallback, className, classNames, showFallback, }: AuthGuardProps): react_jsx_runtime.JSX.Element | null;
+declare function AuthGuard({ children, fallback, className, classNames, showFallback, useSkeleton, }: AuthGuardProps): react_jsx_runtime.JSX.Element | null;
 
 type AddSignerType = "email" | "phone" | "passkey" | "external";
 interface AddSignerFormClassNames {
@@ -549,6 +664,8 @@ interface SignerListClassNames {
     item?: string;
     addButton?: string;
     message?: string;
+    skeleton?: string;
+    loading?: string;
 }
 interface SignerListProps {
     walletId: string;
@@ -556,6 +673,8 @@ interface SignerListProps {
     classNames?: SignerListClassNames;
     /** Callback when a signer is added (e.g. to refresh parent state) */
     onSignerAdded?: () => void;
+    /** When true (default), show skeleton rows while loading; when false, show "Loading signers..." text. */
+    useSkeleton?: boolean;
     /** Custom render for the list of signers */
     children?: (props: {
         signers: SignerData[];
@@ -565,18 +684,44 @@ interface SignerListProps {
         openAddSigner: () => void;
     }) => React.ReactNode;
 }
-declare function SignerList({ walletId, className, classNames, onSignerAdded, children, }: SignerListProps): react_jsx_runtime.JSX.Element;
+declare function SignerList({ walletId, className, classNames, onSignerAdded, useSkeleton, children, }: SignerListProps): react_jsx_runtime.JSX.Element;
+
+interface SkeletonProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare const Skeleton: React$1.ForwardRefExoticComponent<SkeletonProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type Theme = "light" | "dark" | "system";
+type ResolvedTheme = "light" | "dark";
+interface ThemeProviderProps {
+    /** Current theme: "light", "dark", or "system" (follows prefers-color-scheme). */
+    theme?: Theme;
+    /** Default theme when theme is "system" or for initial render. */
+    defaultTheme?: ResolvedTheme;
+    /** Optional localStorage key for persisting theme when using "system". */
+    storageKey?: string;
+    /** Optional class for the wrapper div. */
+    className?: string;
+    children: React$1.ReactNode;
+    /** When true, inject the default theme CSS variables (light/dark). Your app must still use Tailwind. */
+    injectStyles?: boolean;
+}
+declare function ThemeProvider({ theme, defaultTheme, storageKey, className, children, injectStyles, }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
 
 declare function extractErrorMessage(error: unknown): string;
 
 declare function getSignerPublicKey(walletId: string, signer: SignerData, signerType: string, signerId: string): Promise<PublicKey>;
 
-declare function signMessageWithSigner(walletId: string, signer: SignerData, messageText: string): Promise<{
+/** Result shape aligned with SDK SignMessageDataDto (signature base64, message) plus optional helper fields. */
+interface SignMessageResult {
+    /** Signature in base64 (SDK SignMessageDataDto shape). */
     signature: string;
+    /** Original message that was signed (SDK SignMessageDataDto shape). */
+    message: string;
     publicKey?: string;
     signerType: string;
     signer?: string;
-}>;
+}
+declare function signMessageWithSigner(walletId: string, signer: SignerData, messageText: string): Promise<SignMessageResult>;
 
 /** Connection-like interface for sign-and-send (passkey). Consumer provides from their Solana config. */
 interface SignAndSendConnection {
@@ -590,14 +735,19 @@ interface SignAndSendConnection {
         lastValidBlockHeight: number;
     }) => Promise<void>;
 }
+/** SDK submit transaction data (SubmitTransactionResponseDto.data). */
+type SubmitTransactionDataDto = WalletControllerSubmitTransactionResult["data"];
 declare function signTransactionWithSigner(walletId: string, signer: SignerData, transactionBuffer: Uint8Array): Promise<{
     signature: string;
     signerType: string;
 }>;
-declare function signAndSendTransactionWithSigner(walletId: string, signer: SignerData, transaction: Transaction, connection?: SignAndSendConnection | null): Promise<{
+/** Result of sign-and-send; status is the SDK SubmitTransactionDataDto.status, confirmationStatus is the same for backward compat. */
+interface SignAndSendResult {
     signature: string;
+    status: string;
     confirmationStatus: string;
-}>;
+}
+declare function signAndSendTransactionWithSigner(walletId: string, signer: SignerData, transaction: Transaction, connection?: SignAndSendConnection | null): Promise<SignAndSendResult>;
 
 declare function getWalletData(walletId: string): Promise<{
     walletPublicKey: PublicKey;
@@ -613,4 +763,4 @@ declare const SIGNER_TYPES: {
 };
 type SignerType = (typeof SIGNER_TYPES)[keyof typeof SIGNER_TYPES];
 
-export { type ActionState, AddSignerForm, type AddSignerFormClassNames, type AddSignerFormProps, type AddSignerType, type ApiResponse, AuthForm, type AuthFormClassNames, type AuthFormMode, type AuthFormProps, AuthGuard, type AuthGuardClassNames, type AuthGuardProps, type CilantroAuthContextType, CilantroAuthProvider, type CilantroAuthProviderProps, CilantroProvider, type DelegatedKeyData, DelegatedKeySelector, type DelegatedKeySelectorClassNames, type DelegatedKeySelectorProps, type ErrorResponse, LoginForm, type LoginFormClassNames, type LoginFormProps, MessageSigningForm, type MessageSigningFormClassNames, type MessageSigningFormProps, RegisterForm, type RegisterFormClassNames, type RegisterFormProps, SIGNER_TYPES, type SignAndSendConnection, type SignerData, SignerList, type SignerListClassNames, type SignerListProps, SignerSelector, type SignerSelectorClassNames, type SignerSelectorProps, type SignerType, type SigningMethod, TransactionSigningForm, type TransactionSigningFormClassNames, type TransactionSigningFormProps, type UseMessageSigningOptions, type UseMessageSigningResult, type UseSignerSelectionOptions, type UseSignerSelectionResult, type UseSignersOptions, type UseSignersResult, type UseTransactionSigningOptions, type UseTransactionSigningResult, type User, type WalletContextType, type WalletData, WalletProvider, type WalletProviderProps, WalletSelector, type WalletSelectorClassNames, type WalletSelectorProps, extractErrorMessage, extractResponseData, getSignerPublicKey, getWalletData, signAndSendTransactionWithSigner, signMessageWithSigner, signTransactionWithSigner, useCilantroAuth, useMessageSigning, useSignerSelection, useSigners, useTransactionSigning, useWallets };
+export { type ActionState, AddSignerForm, type AddSignerFormClassNames, type AddSignerFormProps, type AddSignerType, type ApiResponse, AuthForm, type AuthFormClassNames, type AuthFormMode, type AuthFormProps, AuthGuard, type AuthGuardClassNames, type AuthGuardProps, type CilantroAuthContextType, CilantroAuthProvider, type CilantroAuthProviderProps, CilantroProvider, type DelegatedKeyData, type DelegatedKeyDataDto, DelegatedKeySelector, type DelegatedKeySelectorClassNames, type DelegatedKeySelectorProps, type ErrorResponse, LoginForm, type LoginFormClassNames, type LoginFormProps, MessageSigningForm, type MessageSigningFormClassNames, type MessageSigningFormProps, RegisterForm, type RegisterFormClassNames, type RegisterFormProps, type ResolvedTheme, SIGNER_TYPES, type SignAndSendConnection, type SignAndSendResult, type SignMessageResult, type SignerData, SignerList, type SignerListClassNames, type SignerListProps, SignerSelector, type SignerSelectorClassNames, type SignerSelectorProps, type SignerType, type SignersListResponseDto, type SigningMethod, Skeleton, type SubmitTransactionDataDto, type Theme, ThemeProvider, type ThemeProviderProps, TransactionSigningForm, type TransactionSigningFormClassNames, type TransactionSigningFormProps, type UseCanSignOptions, type UseCanSignResult, type UseDelegatedKeysOptions, type UseDelegatedKeysResult, type UseMessageSigningOptions, type UseMessageSigningResult, type UseSelectedWalletResult, type UseSignerSelectionOptions, type UseSignerSelectionResult, type UseSignersForSelectedWalletOptions, type UseSignersOptions, type UseSignersRawOptions, type UseSignersRawResult, type UseSignersResult, type UseTransactionSigningOptions, type UseTransactionSigningResult, type User, type WalletContextType, type WalletData, type WalletDataDto, WalletProvider, type WalletProviderProps, WalletSelector, type WalletSelectorClassNames, type WalletSelectorProps, extractErrorMessage, extractResponseData, getSignerPublicKey, getWalletData, signAndSendTransactionWithSigner, signMessageWithSigner, signTransactionWithSigner, useCanSign, useCilantroAuth, useDelegatedKeys, useMessageSigning, useSelectedWallet, useSignerSelection, useSigners, useSignersForSelectedWallet, useSignersRaw, useTransactionSigning, useWalletAddress, useWallets };