@explorins/pers-sdk-react-native 2.2.0-beta.1 → 2.2.0

package/dist/__tests__/PersSDKProvider.test.d.ts

@@ -0,0 +1,2 @@
+import '@testing-library/jest-dom';
+//# sourceMappingURL=PersSDKProvider.test.d.ts.map

package/dist/__tests__/PersSDKProvider.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersSDKProvider.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/PersSDKProvider.test.tsx"],"names":[],"mappings":"AAEA,OAAO,2BAA2B,CAAC"}

package/dist/__tests__/PersSDKProvider.test.js

@@ -0,0 +1,290 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { render, act, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { PersSDKProvider, usePersSDK } from '../providers/PersSDKProvider';
+// Store SDK instances for event emission
+let mockSdkInstance = null;
+// Mock the SDK core module BEFORE any imports use it
+jest.mock('@explorins/pers-sdk/core', () => {
+    const createMockEventEmitter = () => {
+        const subscribers = [];
+        return {
+            subscribe: jest.fn((callback, options) => {
+                subscribers.push({ callback, options });
+                return () => {
+                    const index = subscribers.findIndex(s => s.callback === callback);
+                    if (index > -1)
+                        subscribers.splice(index, 1);
+                };
+            }),
+            emit: (event) => {
+                subscribers.forEach(({ callback, options }) => {
+                    if (!options?.domains || options.domains.includes(event.domain)) {
+                        callback(event);
+                    }
+                });
+            },
+            _subscribers: subscribers
+        };
+    };
+    const MockPersSDK = jest.fn().mockImplementation(() => {
+        const events = createMockEventEmitter();
+        mockSdkInstance = {
+            events,
+            auth: {
+                ensureValidToken: jest.fn().mockResolvedValue(true)
+            },
+            users: {
+                getCurrentUser: jest.fn().mockResolvedValue({ id: 'refreshed-user', email: 'refreshed@test.com' })
+            },
+            restoreSession: jest.fn().mockResolvedValue(null)
+        };
+        return mockSdkInstance;
+    });
+    return {
+        PersSDK: MockPersSDK,
+        DefaultAuthProvider: jest.fn().mockImplementation(() => ({
+            getToken: jest.fn().mockResolvedValue('mock-token')
+        }))
+    };
+});
+// Mock platform-specific providers
+jest.mock('../providers/react-native-http-client', () => ({
+    ReactNativeHttpClient: jest.fn().mockImplementation(() => ({}))
+}));
+jest.mock('../providers/react-native-auth-provider', () => ({
+    createReactNativeAuthProvider: jest.fn().mockReturnValue({
+        getToken: jest.fn().mockResolvedValue('mock-token')
+    })
+}));
+jest.mock('../providers/rn-dpop-provider', () => ({
+    ReactNativeDPoPProvider: jest.fn().mockImplementation(() => ({}))
+}));
+// Helper component to access context
+const TestConsumer = ({ onContext }) => {
+    const context = usePersSDK();
+    React.useEffect(() => {
+        onContext(context);
+    }, [context, onContext]);
+    return _jsx("div", { "data-testid": "consumer", children: "Consumer" });
+};
+// Helper to emit events on the mock SDK
+const emitAuthEvent = (type, details = {}) => {
+    if (mockSdkInstance?.events) {
+        mockSdkInstance.events.emit({
+            type,
+            domain: 'authentication',
+            details
+        });
+    }
+};
+describe('PersSDKProvider', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockSdkInstance = null;
+    });
+    describe('initialization', () => {
+        it('should initialize with null SDK when no config provided', async () => {
+            let capturedContext = null;
+            render(_jsx(PersSDKProvider, { children: _jsx(TestConsumer, { onContext: (ctx) => { capturedContext = ctx; } }) }));
+            await waitFor(() => {
+                expect(capturedContext).not.toBeNull();
+            });
+            expect(capturedContext.sdk).toBeNull();
+            expect(capturedContext.isInitialized).toBe(false);
+            expect(capturedContext.isAuthenticated).toBe(false);
+            expect(capturedContext.user).toBeNull();
+        });
+        it('should auto-initialize when config is provided', async () => {
+            let capturedContext = null;
+            render(_jsx(PersSDKProvider, { config: { apiProjectKey: 'test-project' }, children: _jsx(TestConsumer, { onContext: (ctx) => { capturedContext = ctx; } }) }));
+            await waitFor(() => {
+                expect(capturedContext?.isInitialized).toBe(true);
+            });
+            expect(capturedContext.sdk).not.toBeNull();
+        });
+        it('should prevent multiple initializations', async () => {
+            const { PersSDK } = require('@explorins/pers-sdk/core');
+            let capturedContext = null;
+            render(_jsx(PersSDKProvider, { config: { apiProjectKey: 'test-project' }, children: _jsx(TestConsumer, { onContext: (ctx) => { capturedContext = ctx; } }) }));
+            await waitFor(() => {
+                expect(capturedContext?.isInitialized).toBe(true);
+            });
+            // Try to initialize again - should be ignored
+            await act(async () => {
+                await capturedContext.initialize({ apiProjectKey: 'different-project' });
+            });
+            // Should only have been called once
+            expect(PersSDK).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('event handling', () => {
+        it('should set user on session_restored event', async () => {
+            let capturedContext = null;
+            const mockUser = { id: 'user-123', email: 'test@example.com' };
+            render(_jsx(PersSDKProvider, { config: { apiProjectKey: 'test-project' }, children: _jsx(TestConsumer, { onContext: (ctx) => { capturedContext = ctx; } }) }));
+            await waitFor(() => {
+                expect(capturedContext?.sdk).not.toBeNull();
+            });
+            // Emit session_restored event
+            await act(async () => {
+                emitAuthEvent('session_restored', { user: mockUser });
+            });
+            await waitFor(() => {
+                expect(capturedContext?.isAuthenticated).toBe(true);
+                expect(capturedContext?.user).toEqual(mockUser);
+            });
+        });
+        it('should set user on login_success event', async () => {
+            let capturedContext = null;
+            const mockUser = { id: 'user-456', email: 'login@example.com' };
+            render(_jsx(PersSDKProvider, { config: { apiProjectKey: 'test-project' }, children: _jsx(TestConsumer, { onContext: (ctx) => { capturedContext = ctx; } }) }));
+            await waitFor(() => {
+                expect(capturedContext?.sdk).not.toBeNull();
+            });
+            await act(async () => {
+                emitAuthEvent('login_success', { user: mockUser });
+            });
+            await waitFor(() => {
+                expect(capturedContext?.isAuthenticated).toBe(true);
+                expect(capturedContext?.user).toEqual(mockUser);
+            });
+        });
+        it('should clear user on logout_success event', async () => {
+            let capturedContext = null;
+            const mockUser = { id: 'user-789', email: 'logout@example.com' };
+            render(_jsx(PersSDKProvider, { config: { apiProjectKey: 'test-project' }, children: _jsx(TestConsumer, { onContext: (ctx) => { capturedContext = ctx; } }) }));
+            await waitFor(() => {
+                expect(capturedContext?.sdk).not.toBeNull();
+            });
+            // First, log in
+            await act(async () => {
+                emitAuthEvent('login_success', { user: mockUser });
+            });
+            await waitFor(() => {
+                expect(capturedContext?.isAuthenticated).toBe(true);
+            });
+            // Then logout
+            await act(async () => {
+                emitAuthEvent('logout_success', {});
+            });
+            await waitFor(() => {
+                expect(capturedContext?.isAuthenticated).toBe(false);
+                expect(capturedContext?.user).toBeNull();
+            });
+        });
+        it('should clear user on session_restoration_failed event', async () => {
+            let capturedContext = null;
+            render(_jsx(PersSDKProvider, { config: { apiProjectKey: 'test-project' }, children: _jsx(TestConsumer, { onContext: (ctx) => { capturedContext = ctx; } }) }));
+            await waitFor(() => {
+                expect(capturedContext?.sdk).not.toBeNull();
+            });
+            // Set initial authenticated state
+            await act(async () => {
+                capturedContext.setAuthenticationState({ id: 'temp-user' }, true);
+            });
+            await waitFor(() => {
+                expect(capturedContext?.isAuthenticated).toBe(true);
+            });
+            // Emit session_restoration_failed
+            await act(async () => {
+                emitAuthEvent('session_restoration_failed', { error: 'Token expired' });
+            });
+            await waitFor(() => {
+                expect(capturedContext?.isAuthenticated).toBe(false);
+                expect(capturedContext?.user).toBeNull();
+            });
+        });
+        it('should NOT respond to AUTH_FAILED code (dead code was removed)', async () => {
+            // This test verifies that we no longer check for event.code === 'AUTH_FAILED'
+            // which was dead code that never triggered
+            let capturedContext = null;
+            const mockUser = { id: 'user-stay', email: 'stay@example.com' };
+            render(_jsx(PersSDKProvider, { config: { apiProjectKey: 'test-project' }, children: _jsx(TestConsumer, { onContext: (ctx) => { capturedContext = ctx; } }) }));
+            await waitFor(() => {
+                expect(capturedContext?.sdk).not.toBeNull();
+            });
+            // Log in first
+            await act(async () => {
+                emitAuthEvent('login_success', { user: mockUser });
+            });
+            await waitFor(() => {
+                expect(capturedContext?.isAuthenticated).toBe(true);
+            });
+            // Emit an event with code: 'AUTH_FAILED' - this should NOT clear user
+            // because we removed the dead code that checked for this
+            await act(async () => {
+                if (mockSdkInstance?.events) {
+                    mockSdkInstance.events.emit({
+                        type: 'some_other_event',
+                        code: 'AUTH_FAILED', // This was the dead code path we removed
+                        domain: 'authentication',
+                        details: {}
+                    });
+                }
+            });
+            // User should STILL be authenticated - the code: 'AUTH_FAILED' check is gone
+            expect(capturedContext.isAuthenticated).toBe(true);
+            expect(capturedContext.user).toEqual(mockUser);
+        });
+    });
+    describe('usePersSDK hook', () => {
+        it('should throw error when used outside provider', () => {
+            // Suppress the expected error
+            const spy = jest.spyOn(console, 'error').mockImplementation(() => { });
+            const TestComponent = () => {
+                usePersSDK();
+                return null;
+            };
+            expect(() => render(_jsx(TestComponent, {}))).toThrow('usePersSDK must be used within a PersSDKProvider');
+            spy.mockRestore();
+        });
+    });
+    describe('context methods', () => {
+        it('should allow manual authentication state updates', async () => {
+            let capturedContext = null;
+            const mockUser = { id: 'manual-user', email: 'manual@example.com' };
+            render(_jsx(PersSDKProvider, { config: { apiProjectKey: 'test-project' }, children: _jsx(TestConsumer, { onContext: (ctx) => { capturedContext = ctx; } }) }));
+            await waitFor(() => {
+                expect(capturedContext?.isInitialized).toBe(true);
+            });
+            await act(async () => {
+                capturedContext.setAuthenticationState(mockUser, true);
+            });
+            await waitFor(() => {
+                expect(capturedContext?.isAuthenticated).toBe(true);
+                expect(capturedContext?.user).toEqual(mockUser);
+            });
+        });
+        it('should refresh user data from SDK', async () => {
+            let capturedContext = null;
+            render(_jsx(PersSDKProvider, { config: { apiProjectKey: 'test-project' }, children: _jsx(TestConsumer, { onContext: (ctx) => { capturedContext = ctx; } }) }));
+            await waitFor(() => {
+                expect(capturedContext?.isInitialized).toBe(true);
+            });
+            await act(async () => {
+                await capturedContext.refreshUserData();
+            });
+            await waitFor(() => {
+                expect(capturedContext?.user).toEqual({ id: 'refreshed-user', email: 'refreshed@test.com' });
+            });
+        });
+        it('should throw error when refreshUserData called before init', async () => {
+            let capturedContext = null;
+            render(_jsx(PersSDKProvider, { children: _jsx(TestConsumer, { onContext: (ctx) => { capturedContext = ctx; } }) }));
+            await waitFor(() => {
+                expect(capturedContext).not.toBeNull();
+            });
+            await expect(capturedContext.refreshUserData()).rejects.toThrow('SDK not initialized');
+        });
+        it('should throw error when restoreSession called before init', async () => {
+            let capturedContext = null;
+            render(_jsx(PersSDKProvider, { children: _jsx(TestConsumer, { onContext: (ctx) => { capturedContext = ctx; } }) }));
+            await waitFor(() => {
+                expect(capturedContext).not.toBeNull();
+            });
+            await expect(capturedContext.restoreSession()).rejects.toThrow('SDK not initialized');
+        });
+    });
+});

package/dist/__tests__/__mocks__/pers-sdk-core.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="jest" />
+export interface PersConfig {
+    apiProjectKey?: string;
+    environment?: 'staging' | 'production';
+    captureWalletEvents?: boolean;
+    authProvider?: any;
+    dpop?: {
+        enabled?: boolean;
+        cryptoProvider?: any;
+    };
+}
+export declare const createMockEventEmitter: () => {
+    subscribe: jest.Mock<() => void, [callback: (event: any) => void, options?: any], any>;
+    emit: (event: any) => void;
+    _subscribers: {
+        callback: (event: any) => void;
+        options?: any;
+    }[];
+};
+export declare class PersSDK {
+    events: ReturnType<typeof createMockEventEmitter>;
+    auth: any;
+    users: any;
+    constructor(_httpClient: any, _config: PersConfig);
+    restoreSession: jest.Mock<any, any, any>;
+    _mockEmitEvent(event: any): void;
+}
+export declare class DefaultAuthProvider {
+    constructor(_projectKey?: string, _options?: any);
+}
+export type AuthManager = any;
+export type UserManager = any;
+export type TokenManager = any;
+export type BusinessManager = any;
+export type CampaignManager = any;
+export type RedemptionManager = any;
+export type TransactionManager = any;
+export type PurchaseManager = any;
+export type TenantManager = any;
+export type AnalyticsManager = any;
+export type DonationManager = any;
+//# sourceMappingURL=pers-sdk-core.d.ts.map

package/dist/__tests__/__mocks__/pers-sdk-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pers-sdk-core.d.ts","sourceRoot":"","sources":["../../../src/__tests__/__mocks__/pers-sdk-core.ts"],"names":[],"mappings":";AAEA,MAAM,WAAW,UAAU;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,SAAS,GAAG,YAAY,CAAC;IACvC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,YAAY,CAAC,EAAE,GAAG,CAAC;IACnB,IAAI,CAAC,EAAE;QACL,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,cAAc,CAAC,EAAE,GAAG,CAAC;KACtB,CAAC;CACH;AAGD,eAAO,MAAM,sBAAsB;wDAIO,GAAG,KAAK,IAAI;kBAapC,GAAG;;kBAhBkB,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI;kBAAY,GAAG;;CAyBzE,CAAC;AAGF,qBAAa,OAAO;IAClB,MAAM,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;IAClD,IAAI,EAAE,GAAG,CAAC;IACV,KAAK,EAAE,GAAG,CAAC;gBAEC,WAAW,EAAE,GAAG,EAAE,OAAO,EAAE,UAAU;IAUjD,cAAc,2BAAqC;IAGnD,cAAc,CAAC,KAAK,EAAE,GAAG;CAG1B;AAGD,qBAAa,mBAAmB;gBAClB,WAAW,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG;CACjD;AAGD,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC;AAC9B,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC;AAC9B,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC;AAC/B,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC;AAClC,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC;AAClC,MAAM,MAAM,iBAAiB,GAAG,GAAG,CAAC;AACpC,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC;AACrC,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC;AAClC,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC;AAChC,MAAM,MAAM,gBAAgB,GAAG,GAAG,CAAC;AACnC,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC"}

package/dist/__tests__/__mocks__/pers-sdk-core.js

@@ -0,0 +1,48 @@
+// Mock @explorins/pers-sdk/core
+// Create mock event emitter factory
+export const createMockEventEmitter = () => {
+    const subscribers = [];
+    return {
+        subscribe: jest.fn((callback, options) => {
+            subscribers.push({ callback, options });
+            // Replay immediately if requested
+            if (options?.replay) {
+                // No events to replay in mock
+            }
+            return () => {
+                const index = subscribers.findIndex(s => s.callback === callback);
+                if (index > -1)
+                    subscribers.splice(index, 1);
+            };
+        }),
+        emit: (event) => {
+            subscribers.forEach(({ callback, options }) => {
+                if (!options?.domains || options.domains.includes(event.domain)) {
+                    callback(event);
+                }
+            });
+        },
+        _subscribers: subscribers
+    };
+};
+// Mock PersSDK class
+export class PersSDK {
+    constructor(_httpClient, _config) {
+        this.restoreSession = jest.fn().mockResolvedValue(null);
+        this.events = createMockEventEmitter();
+        this.auth = {
+            ensureValidToken: jest.fn().mockResolvedValue(true)
+        };
+        this.users = {
+            getCurrentUser: jest.fn().mockResolvedValue({ id: 'user-1', email: 'test@test.com' })
+        };
+    }
+    // Helper for tests to emit events
+    _mockEmitEvent(event) {
+        this.events.emit(event);
+    }
+}
+// Mock DefaultAuthProvider
+export class DefaultAuthProvider {
+    constructor(_projectKey, _options) { }
+}

package/dist/__tests__/__mocks__/pers-shared.d.ts

@@ -0,0 +1,15 @@
+export interface UserDTO {
+    id: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    walletAddress?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface AdminDTO {
+    id: string;
+    email?: string;
+    role?: string;
+}
+//# sourceMappingURL=pers-shared.d.ts.map

package/dist/__tests__/__mocks__/pers-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pers-shared.d.ts","sourceRoot":"","sources":["../../../src/__tests__/__mocks__/pers-shared.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/__tests__/__mocks__/pers-shared.js

@@ -0,0 +1,2 @@
+// Mock @explorins/pers-shared
+export {};

package/dist/__tests__/setup.d.ts

@@ -0,0 +1,2 @@
+import '@testing-library/jest-dom';
+//# sourceMappingURL=setup.d.ts.map

package/dist/__tests__/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/__tests__/setup.ts"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,CAAC"}

package/dist/__tests__/setup.js

@@ -0,0 +1,35 @@
+import '@testing-library/jest-dom';
+// Mock React Native modules
+jest.mock('react-native', () => ({
+    Platform: {
+        OS: 'ios',
+        select: jest.fn((obj) => obj.ios || obj.default)
+    },
+    AppState: {
+        addEventListener: jest.fn(() => ({
+            remove: jest.fn()
+        })),
+        currentState: 'active'
+    }
+}));
+// Mock AsyncStorage
+jest.mock('@react-native-async-storage/async-storage', () => ({
+    default: {
+        getItem: jest.fn(),
+        setItem: jest.fn(),
+        removeItem: jest.fn(),
+        clear: jest.fn(),
+        getAllKeys: jest.fn(() => Promise.resolve([]))
+    }
+}));
+// Silence console errors in tests unless explicitly needed
+const originalConsoleError = console.error;
+const originalConsoleWarn = console.warn;
+beforeAll(() => {
+    console.error = jest.fn();
+    console.warn = jest.fn();
+});
+afterAll(() => {
+    console.error = originalConsoleError;
+    console.warn = originalConsoleWarn;
+});

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

@@ -1 +1 @@
-{"version":3,"file":"useRedemptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useRedemptions.ts"],"names":[],"mappings":"AAEA,OAAO,EAA0C,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,KAAK,EACV,0BAA0B,EAC1B,aAAa,EACb,mBAAmB,EACnB,kCAAkC,EAClC,iBAAiB,EACjB,oBAAoB,EACpB,+BAA+B,EAC/B,yBAAyB,EACzB,mBAAmB,EACnB,cAAc,EACd,SAAS,EACV,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,uBAAuB,EAA2B,MAAM,gCAAgC,CAAC;AACvG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAG7D,YAAY,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAEvG;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,oFAAoF;IACpF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,wDAAwD;IACxD,SAAS,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAC1B,uDAAuD;IACvD,OAAO,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IACxB,0CAA0C;IAC1C,OAAO,CAAC,EAAE,yBAAyB,EAAE,CAAC;IACtC,8BAA8B;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uBAAuB;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAAC;IAC5C,qBAAqB;IACrB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB;AAED,eAAO,MAAM,cAAc;+BAqD2B,qBAAqB,KAAG,QAAQ,qBAAqB,aAAa,CAAC,CAAC;mCAyC5G;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,mBAAmB,CAAA;KAAE,YACvD,iBAAiB,YACjB,+BAA+B,EAAE,KAC1C,QAAQ,qBAAqB,mBAAmB,CAAC,CAAC;2BAkErC,MAAM,YACV;QAAE,OAAO,CAAC,EAAE,cAAc,CAAC;QAAC,cAAc,CAAC,EAAE,gBAAgB,CAAA;KAAE,KACxE,QAAQ,kCAAkC,CAAC;8BAmHG,QAAQ,qBAAqB,iBAAiB,CAAC,CAAC;qCA9BrF,uBAAuB,YACvB,+BAA+B,EAAE,KAC1C,QAAQ,qBAAqB,mBAAmB,CAAC,CAAC;uCAcO,0BAA0B,KAAG,QAAQ,aAAa,CAAC;qCA4BrD,MAAM,kBAAkB,0BAA0B,KAAG,QAAQ,aAAa,CAAC;2CAcrE,MAAM,KAAG,QAAQ,aAAa,CAAC;;;;CA4BhG,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}
+{"version":3,"file":"useRedemptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useRedemptions.ts"],"names":[],"mappings":"AAEA,OAAO,EAA0C,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,KAAK,EACV,0BAA0B,EAC1B,aAAa,EACb,mBAAmB,EACnB,kCAAkC,EAClC,iBAAiB,EACjB,oBAAoB,EACpB,+BAA+B,EAC/B,yBAAyB,EACzB,mBAAmB,EACnB,cAAc,EACd,SAAS,EACV,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAG7D,YAAY,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAEvG;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,oFAAoF;IACpF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,wDAAwD;IACxD,SAAS,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAC1B,uDAAuD;IACvD,OAAO,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IACxB,0CAA0C;IAC1C,OAAO,CAAC,EAAE,yBAAyB,EAAE,CAAC;IACtC,8BAA8B;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uBAAuB;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAAC;IAC5C,qBAAqB;IACrB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB;AAED,eAAO,MAAM,cAAc;+BAqD2B,qBAAqB,KAAG,QAAQ,qBAAqB,aAAa,CAAC,CAAC;mCAyC5G;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,mBAAmB,CAAA;KAAE,YACvD,iBAAiB,YACjB,+BAA+B,EAAE,KAC1C,QAAQ,qBAAqB,mBAAmB,CAAC,CAAC;2BAkErC,MAAM,YACV;QAAE,OAAO,CAAC,EAAE,cAAc,CAAC;QAAC,cAAc,CAAC,EAAE,gBAAgB,CAAA;KAAE,KACxE,QAAQ,kCAAkC,CAAC;8BAmHG,QAAQ,qBAAqB,iBAAiB,CAAC,CAAC;qCA9BrF,uBAAuB,YACvB,+BAA+B,EAAE,KAC1C,QAAQ,qBAAqB,mBAAmB,CAAC,CAAC;uCAcO,0BAA0B,KAAG,QAAQ,aAAa,CAAC;qCA4BrD,MAAM,kBAAkB,0BAA0B,KAAG,QAAQ,aAAa,CAAC;2CAcrE,MAAM,KAAG,QAAQ,aAAa,CAAC;;;;CA4BhG,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}