@sudobility/wildduck_client 0.0.14

package/README.md

@@ -0,0 +1,354 @@
+# WildDuck Client Library
+
+TypeScript client library for the WildDuck email API with React and React Native support.
+
+[![npm version](https://badge.fury.io/js/@sudobility%2Fwildduck_client.svg)](https://www.npmjs.com/package/@sudobility/wildduck_client)
+[![CI/CD](https://github.com/0xmail/wildduck_client/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/0xmail/wildduck_client/actions/workflows/ci-cd.yml)
+
+## Features
+
+- ✅ **Complete Type Safety** - Full TypeScript support with comprehensive type definitions
+- ✅ **React Integration** - Built-in hooks using @tanstack/react-query for optimal data fetching
+- ✅ **Crypto Authentication** - SIWE (Sign-in with Ethereum) and traditional password authentication
+- ✅ **Comprehensive API** - User, mailbox, message, address, filter, and autoreply management
+- ✅ **Development Mode** - Mock data for testing without a live server
+- ✅ **Integration Tests** - Full test coverage with real WildDuck server testing
+- ✅ **Cloudflare Worker Support** - Optional worker URL configuration for proxying requests
+
+## Installation
+
+```bash
+npm install @sudobility/wildduck_client
+```
+
+### Peer Dependencies
+
+This library requires the following peer dependencies:
+
+```bash
+npm install react @tanstack/react-query @sudobility/di @sudobility/types axios
+```
+
+## Quick Start
+
+### 1. Authentication
+
+```typescript
+import { useWildduckAuth } from '@sudobility/wildduck_client';
+
+function LoginComponent() {
+  const networkClient = useNetworkClient();
+  const config = { endpoint: 'https://api.wildduck.example.com' };
+
+  const { authenticate, isAuthenticated } = useWildduckAuth(
+    networkClient,
+    config
+  );
+
+  // Authenticate with crypto signature (SIWE)
+  const handleCryptoLogin = async () => {
+    await authenticate({
+      username: 'user@example.com',
+      signature: '0x...',
+      message: 'Sign-in with Ethereum message',
+      nonce: 'random-nonce',
+      signer: '0xWalletAddress'
+    });
+  };
+
+  // Or authenticate with password
+  const handlePasswordLogin = async () => {
+    await authenticate({
+      username: 'user@example.com',
+      password: 'your-password'
+    });
+  };
+
+  return (
+    <div>
+      {isAuthenticated ? (
+        <p>Logged in!</p>
+      ) : (
+        <>
+          <button onClick={handleCryptoLogin}>Login with Wallet</button>
+          <button onClick={handlePasswordLogin}>Login with Password</button>
+        </>
+      )}
+    </div>
+  );
+}
+```
+
+### 2. Fetching Messages
+
+```typescript
+import { useWildduckGetMessages } from '@sudobility/wildduck_client';
+
+function MessageList({ userAuth, mailboxId }) {
+  const networkClient = useNetworkClient();
+  const config = { endpoint: 'https://api.wildduck.example.com' };
+
+  const { getMessages } = useWildduckGetMessages(networkClient, config);
+  const [messages, setMessages] = useState([]);
+
+  useEffect(() => {
+    async function fetchMessages() {
+      const result = await getMessages(userAuth, mailboxId, {
+        limit: 50,
+        unseen: true, // Only unread messages
+        order: 'desc'
+      });
+      setMessages(result.results);
+    }
+    fetchMessages();
+  }, [mailboxId]);
+
+  return (
+    <div>
+      {messages.map(msg => (
+        <div key={msg.id}>
+          <h3>{msg.subject}</h3>
+          <p>From: {msg.from.address}</p>
+          <span>{msg.unseen ? '🔵 Unread' : '✓ Read'}</span>
+        </div>
+      ))}
+    </div>
+  );
+}
+```
+
+### 3. Sending Messages
+
+```typescript
+import { useWildduckSendMessage } from '@sudobility/wildduck_client';
+
+function ComposeEmail({ userAuth }) {
+  const networkClient = useNetworkClient();
+  const config = { endpoint: 'https://api.wildduck.example.com' };
+
+  const { sendMessage } = useWildduckSendMessage(networkClient, config);
+
+  const handleSend = async () => {
+    await sendMessage(userAuth, {
+      to: [{ name: 'John Doe', address: 'john@example.com' }],
+      subject: 'Hello from WildDuck Client',
+      text: 'This is a test message',
+      html: '<p>This is a <strong>test</strong> message</p>'
+    });
+  };
+
+  return <button onClick={handleSend}>Send Email</button>;
+}
+```
+
+## API Coverage
+
+Currently implements ~15% of the WildDuck API endpoints (see [GAP_ANALYSIS.md](./GAP_ANALYSIS.md) for details):
+
+### Implemented Endpoints
+
+| Category | Status | Coverage |
+|----------|--------|----------|
+| Authentication | ✅ Complete | 100% |
+| Users | ⚠️ Partial | ~12% |
+| Mailboxes | ✅ Mostly Complete | 80% |
+| Messages | ⚠️ Partial | ~31% |
+| Addresses | ✅ Mostly Complete | 64% |
+| Filters | ✅ Complete | 100% |
+| Autoreply | ⚠️ Partial | ~67% |
+| Health | ✅ Complete | 100% |
+| Settings | ✅ Mostly Complete | 67% |
+
+### Priority Features to Implement
+
+See [GAP_ANALYSIS.md](./GAP_ANALYSIS.md) for a comprehensive breakdown of missing endpoints and implementation priorities.
+
+## Available Hooks
+
+### Messages
+- `useWildduckGetMessages` - List messages in a mailbox
+- `useWildduckGetMessage` - Get a single message
+- `useWildduckUpdateMessage` - Update message properties (mark as read, move, flag)
+- `useWildduckDeleteMessage` - Delete a message
+- `useWildduckSearchMessages` - Search messages across mailboxes
+- `useWildduckGetMessageSource` - Get raw RFC822 message source
+- `useWildduckGetMessageAttachment` - Download message attachment
+- `useWildduckForwardMessage` - Forward a message
+- `useWildduckSendMessage` - Send a new email
+- `useWildduckUploadMessage` - Upload raw message to mailbox
+- `useWildduckSubmitDraft` - Submit a draft for delivery
+
+### Mailboxes
+- `useWildduckGetMailboxes` - List all mailboxes
+- `useWildduckGetMailbox` - Get specific mailbox info
+- `useWildduckCreateMailbox` - Create new mailbox/folder
+- `useWildduckUpdateMailbox` - Update mailbox properties
+- `useWildduckDeleteMailbox` - Delete a mailbox
+
+### Users
+- `useWildduckGetUser` - Get user information
+- `useWildduckCreateUser` - Create new user (admin)
+- `useWildduckUpdateUser` - Update user settings
+- `useWildduckDeleteUser` - Delete user account
+
+### Addresses
+- `useWildduckGetAddresses` - List user's email addresses
+- Additional address management hooks
+
+### Autoreply
+- `useWildduckGetAutoreply` - Get autoreply settings
+- `useWildduckUpdateAutoreply` - Update autoreply (vacation mode)
+- `useWildduckDeleteAutoreply` - Delete autoreply
+
+### Filters
+- Complete filter management hooks
+
+### Other
+- `useWildduckHealth` - Server health check
+- `useWildduckSettings` - Settings management
+
+For detailed documentation on all hooks, see [HOOKS_DOCUMENTATION.md](./HOOKS_DOCUMENTATION.md).
+
+## Development
+
+### Setup
+
+```bash
+# Install dependencies
+npm install
+
+# Run type checking
+npm run typecheck
+
+# Run linting
+npm run lint
+
+# Run unit tests
+npm test
+
+# Run integration tests (requires WildDuck server)
+WILDDUCK_ENDPOINT=http://localhost:8080 npm run test:integration
+
+# Build the library
+npm run build
+```
+
+### Development Scripts
+
+```bash
+npm run build              # Build for production
+npm run build:watch        # Build in watch mode
+npm run clean              # Clean build artifacts
+npm run test               # Run tests in watch mode
+npm run test:run           # Run tests once
+npm run test:coverage      # Run tests with coverage
+npm run test:integration   # Run integration tests
+npm run lint               # Run ESLint
+npm run lint:fix           # Fix linting issues
+npm run format             # Format code with Prettier
+npm run typecheck          # Run TypeScript type checking
+npm run check-all          # Run all checks (lint + typecheck + test)
+```
+
+## Testing
+
+### Unit Tests
+
+```bash
+npm run test:run
+```
+
+### Integration Tests
+
+Integration tests require a live WildDuck server running in crypto mode:
+
+```bash
+# Set required environment variables
+export WILDDUCK_ENDPOINT=http://localhost:8080
+export WILDDUCK_EMAIL_DOMAIN=example.com  # Optional
+
+# Run integration tests
+npm run test:integration
+```
+
+For more details, see [INTEGRATION_TESTS.md](./INTEGRATION_TESTS.md).
+
+## Documentation
+
+- **[HOOKS_DOCUMENTATION.md](./HOOKS_DOCUMENTATION.md)** - Comprehensive hook documentation with examples
+- **[WILDDUCK_API_ENDPOINTS.md](./WILDDUCK_API_ENDPOINTS.md)** - Complete API endpoint reference
+- **[GAP_ANALYSIS.md](./GAP_ANALYSIS.md)** - Analysis of implemented vs. missing endpoints
+- **[INTEGRATION_TESTS.md](./INTEGRATION_TESTS.md)** - Integration testing guide
+- **[CI_CD_SETUP.md](./CI_CD_SETUP.md)** - CI/CD workflow documentation
+- **[DEPLOYMENT.md](./DEPLOYMENT.md)** - Deployment guide
+
+## Architecture
+
+```
+wildduck_client/
+├── src/
+│   ├── network/          # API client and HTTP layer
+│   ├── hooks/            # React hooks for data fetching
+│   │   ├── messages/     # Message-related hooks
+│   │   ├── mailboxes/    # Mailbox-related hooks
+│   │   ├── addresses/    # Address-related hooks
+│   │   ├── autoreply/    # Autoreply-related hooks
+│   │   └── users/        # User-related hooks
+│   ├── types/            # TypeScript type definitions
+│   ├── utils/            # Utility functions
+│   └── __tests__/        # Test files
+│       └── integration/  # Integration tests
+├── dist/                 # Compiled output
+└── docs/                 # Documentation files
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/my-feature`
+3. Make your changes and add tests
+4. Run checks: `npm run check-all`
+5. Commit your changes: `git commit -m "Add my feature"`
+6. Push to the branch: `git push origin feature/my-feature`
+7. Open a pull request
+
+### Code Quality
+
+This project maintains high code quality standards:
+
+- TypeScript with strict mode enabled
+- ESLint for code linting
+- Prettier for code formatting
+- Comprehensive unit and integration tests
+- CI/CD pipeline that runs on every push
+
+## Deployment
+
+### NPM Publishing
+
+The library is automatically published to NPM when you push to the `main` branch:
+
+1. Update version: `npm version patch|minor|major`
+2. Push to main: `git push origin main --tags`
+3. CI/CD automatically publishes to NPM
+
+For more details, see [DEPLOYMENT.md](./DEPLOYMENT.md).
+
+## License
+
+MIT
+
+## Related Projects
+
+- [WildDuck](https://github.com/nodemailer/wildduck) - The WildDuck email server
+- [@sudobility/types](https://www.npmjs.com/package/@sudobility/types) - Shared type definitions
+- [0xmail](https://github.com/0xmail) - Blockchain-based email platform
+
+## Support
+
+- [GitHub Issues](https://github.com/0xmail/wildduck_client/issues)
+- [API Documentation](https://docs.wildduck.email/api/)
+
+## Changelog
+
+See [GitHub Releases](https://github.com/0xmail/wildduck_client/releases) for version history and release notes.

package/dist/hooks/ServiceProvider.d.ts

@@ -0,0 +1,15 @@
+export interface ServiceContainer {
+    get<T>(key: string): T;
+    register<T>(key: string, factory: (container: ServiceContainer) => T, singleton?: boolean): void;
+}
+export interface ServiceResolver {
+    getStorage(): any;
+    getAnalytics(): any;
+    getConfig(): any;
+}
+declare const ServiceContainerContext: import("react").Context<ServiceContainer | null>;
+declare const ServiceResolverContext: import("react").Context<ServiceResolver | null>;
+declare const useServiceContainer: () => ServiceContainer;
+declare const useServiceResolver: () => ServiceResolver;
+export { ServiceContainerContext, ServiceResolverContext, useServiceContainer, useServiceResolver, };
+//# sourceMappingURL=ServiceProvider.d.ts.map

package/dist/hooks/ServiceProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceProvider.d.ts","sourceRoot":"","sources":["../../src/hooks/ServiceProvider.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,gBAAgB;IAC/B,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC;IACvB,QAAQ,CAAC,CAAC,EACR,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,CAAC,SAAS,EAAE,gBAAgB,KAAK,CAAC,EAC3C,SAAS,CAAC,EAAE,OAAO,GAClB,IAAI,CAAC;CACT;AAMD,MAAM,WAAW,eAAe;IAC9B,UAAU,IAAI,GAAG,CAAC;IAClB,YAAY,IAAI,GAAG,CAAC;IACpB,SAAS,IAAI,GAAG,CAAC;CAClB;AAGD,QAAA,MAAM,uBAAuB,kDAA+C,CAAC;AAG7E,QAAA,MAAM,sBAAsB,iDAA8C,CAAC;AAM3E,QAAA,MAAM,mBAAmB,QAAO,gBAS/B,CAAC;AAMF,QAAA,MAAM,kBAAkB,QAAO,eAS9B,CAAC;AAGF,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,GACnB,CAAC"}

package/dist/hooks/ServiceProvider.js

@@ -0,0 +1,21 @@
+import { createContext, useContext } from "react";
+const ServiceContainerContext = createContext(null);
+const ServiceResolverContext = createContext(null);
+const useServiceContainer = () => {
+    const container = useContext(ServiceContainerContext);
+    if (!container) {
+        throw new Error("useServiceContainer must be used within a ServiceProvider. " +
+            "Make sure to set up the service container properly in your app.");
+    }
+    return container;
+};
+const useServiceResolver = () => {
+    const resolver = useContext(ServiceResolverContext);
+    if (!resolver) {
+        throw new Error("useServiceResolver must be used within a ServiceProvider. " +
+            "Make sure to set up the service container properly in your app.");
+    }
+    return resolver;
+};
+export { ServiceContainerContext, ServiceResolverContext, useServiceContainer, useServiceResolver, };
+//# sourceMappingURL=ServiceProvider.js.map

package/dist/hooks/ServiceProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceProvider.js","sourceRoot":"","sources":["../../src/hooks/ServiceProvider.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AA0BlD,MAAM,uBAAuB,GAAG,aAAa,CAA0B,IAAI,CAAC,CAAC;AAG7E,MAAM,sBAAsB,GAAG,aAAa,CAAyB,IAAI,CAAC,CAAC;AAM3E,MAAM,mBAAmB,GAAG,GAAqB,EAAE;IACjD,MAAM,SAAS,GAAG,UAAU,CAAC,uBAAuB,CAAC,CAAC;IACtD,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,6DAA6D;YAC3D,iEAAiE,CACpE,CAAC;IACJ,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC;AAMF,MAAM,kBAAkB,GAAG,GAAoB,EAAE;IAC/C,MAAM,QAAQ,GAAG,UAAU,CAAC,sBAAsB,CAAC,CAAC;IACpD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CACb,4DAA4D;YAC1D,iEAAiE,CACpE,CAAC;IACJ,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAGF,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,GACnB,CAAC"}

package/dist/hooks/addresses/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./useWildduckGetAddresses";
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/addresses/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/addresses/index.ts"],"names":[],"mappings":"AAMA,cAAc,2BAA2B,CAAC"}

package/dist/hooks/addresses/index.js

@@ -0,0 +1,2 @@
+export * from "./useWildduckGetAddresses";
+//# sourceMappingURL=index.js.map

package/dist/hooks/addresses/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/hooks/addresses/index.ts"],"names":[],"mappings":"AAMA,cAAc,2BAA2B,CAAC"}

package/dist/hooks/addresses/useWildduckGetAddresses.d.ts

@@ -0,0 +1,232 @@
+import { type NetworkClient } from "@sudobility/di";
+import { type WildduckConfig } from "@sudobility/types";
+import type { WildduckUserAuth } from "@sudobility/types";
+export interface UseWildduckGetAddressesParams {
+    userAuth?: WildduckUserAuth;
+    devMode?: boolean;
+}
+export declare const useWildduckGetAddresses: (networkClient: NetworkClient, config: WildduckConfig, params?: UseWildduckGetAddressesParams) => {
+    data: import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    };
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    }>;
+} | {
+    data: import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    };
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    }>;
+} | {
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    }>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    }>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    }>;
+} | {
+    data: import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    };
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<import("@sudobility/types").WildduckAddressResponse | {
+        success: boolean;
+        results: never[];
+        error: null;
+    }>;
+};
+export type UseWildduckGetAddressesReturn = ReturnType<typeof useWildduckGetAddresses>;
+//# sourceMappingURL=useWildduckGetAddresses.d.ts.map

package/dist/hooks/addresses/useWildduckGetAddresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWildduckGetAddresses.d.ts","sourceRoot":"","sources":["../../../src/hooks/addresses/useWildduckGetAddresses.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAWD,eAAO,MAAM,uBAAuB,GAClC,eAAe,aAAa,EAC5B,QAAQ,cAAc,EACtB,SAAQ,6BAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0C3C,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,UAAU,CACpD,OAAO,uBAAuB,CAC/B,CAAC"}

package/dist/hooks/addresses/useWildduckGetAddresses.js

@@ -0,0 +1,34 @@
+import { useCallback, useMemo } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { WildduckAPI } from "../../network/wildduck-client";
+export const useWildduckGetAddresses = (networkClient, config, params = {}) => {
+    const { userAuth, devMode = false } = params;
+    const api = useMemo(() => new WildduckAPI(networkClient, config), [networkClient, config]);
+    const queryFn = useCallback(async () => {
+        if (!userAuth)
+            throw new Error("userAuth is required");
+        try {
+            return await api.getAddresses(userAuth);
+        }
+        catch (err) {
+            if (devMode) {
+                console.warn("[DevMode] getAddresses failed, returning mock data:", err);
+                return {
+                    success: true,
+                    results: [],
+                    error: null,
+                };
+            }
+            throw err;
+        }
+    }, [userAuth, api, devMode]);
+    const query = useQuery({
+        queryKey: ["wildduck-addresses", userAuth?.userId],
+        queryFn,
+        enabled: !!userAuth,
+    });
+    return useMemo(() => ({
+        ...query,
+    }), [query]);
+};
+//# sourceMappingURL=useWildduckGetAddresses.js.map

package/dist/hooks/addresses/useWildduckGetAddresses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWildduckGetAddresses.js","sourceRoot":"","sources":["../../../src/hooks/addresses/useWildduckGetAddresses.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAmB5D,MAAM,CAAC,MAAM,uBAAuB,GAAG,CACrC,aAA4B,EAC5B,MAAsB,EACtB,SAAwC,EAAE,EAC1C,EAAE;IACF,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,KAAK,EAAE,GAAG,MAAM,CAAC;IAE7C,MAAM,GAAG,GAAG,OAAO,CACjB,GAAG,EAAE,CAAC,IAAI,WAAW,CAAC,aAAa,EAAE,MAAM,CAAC,EAC5C,CAAC,aAAa,EAAE,MAAM,CAAC,CACxB,CAAC;IAEF,MAAM,OAAO,GAAG,WAAW,CAAC,KAAK,IAAI,EAAE;QACrC,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;QAEvD,IAAI,CAAC;YACH,OAAO,MAAM,GAAG,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC1C,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO,CAAC,IAAI,CACV,qDAAqD,EACrD,GAAG,CACJ,CAAC;gBACF,OAAO;oBACL,OAAO,EAAE,IAAI;oBACb,OAAO,EAAE,EAAE;oBACX,KAAK,EAAE,IAAI;iBACZ,CAAC;YACJ,CAAC;YACD,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC;IAE7B,MAAM,KAAK,GAAG,QAAQ,CAAC;QACrB,QAAQ,EAAE,CAAC,oBAAoB,EAAE,QAAQ,EAAE,MAAM,CAAC;QAClD,OAAO;QACP,OAAO,EAAE,CAAC,CAAC,QAAQ;KACpB,CAAC,CAAC;IAEH,OAAO,OAAO,CACZ,GAAG,EAAE,CAAC,CAAC;QACL,GAAG,KAAK;KACT,CAAC,EACF,CAAC,KAAK,CAAC,CACR,CAAC;AACJ,CAAC,CAAC"}