cilantro-react 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -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 };