@temboplus/afloat 0.1.54 → 0.1.55

package/dist/features/payout/payout.dtos.d.ts

@@ -0,0 +1,365 @@
+import { z } from "zod";
+/**
+ * Represents the available channels through which payouts can be processed.
+ * @enum {string}
+ * @readonly
+ */
+export declare enum PayoutChannel {
+    /** Payment processed through mobile money services */
+    MOBILE = "Mobile",
+    /** Payment processed through traditional banking channels */
+    BANK = "Bank"
+}
+/**
+ * Represents the current status of a payout transaction.
+ * @enum {string}
+ * @readonly
+ */
+export declare enum PayoutStatus {
+    /** Payout has been initially created but not yet processed */
+    CREATED = "CREATED",
+    /** Payout is awaiting processing */
+    PENDING = "PENDING",
+    /** Payout has been successfully processed */
+    PAID = "PAID",
+    /** Payout processing has failed */
+    FAILED = "FAILED",
+    /** Payout has been rejected */
+    REJECTED = "REJECTED",
+    /** Payout has been reversed */
+    REVERSED = "REVERSED"
+}
+/**
+ * Represents the approval status for payouts that require authorization.
+ * @enum {string}
+ * @readonly
+ */
+export declare enum PayoutApprovalStatus {
+    /** Payout is awaiting approval decision */
+    PENDING = "Pending",
+    /** Payout has been approved */
+    APPROVED = "Approved",
+    /** Payout has been rejected during approval process */
+    REJECTED = "Rejected"
+}
+/**
+ * Schema for identifying users in the payout process
+ * Used to track who created or actioned a payout
+ */
+declare const AuthorizerSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    identity: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    identity: string;
+}, {
+    name: string;
+    id: string;
+    identity: string;
+}>;
+/**
+ * Schema for creating a new payout
+ * Extends base payout schema with payee information
+ */
+declare const PayoutInputDTOSchema: z.ZodObject<{
+    channel: z.ZodString;
+    msisdn: z.ZodString;
+    amount: z.ZodNumber;
+    description: z.ZodString;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+} & {
+    payeeName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    channel: string;
+    msisdn: string;
+    amount: number;
+    description: string;
+    payeeName: string;
+    notes?: string | null | undefined;
+}, {
+    channel: string;
+    msisdn: string;
+    amount: number;
+    description: string;
+    payeeName: string;
+    notes?: string | null | undefined;
+}>;
+/**
+ * Schema for complete payout record
+ * Extends base payout schema with additional fields for:
+ * - Identification (id, profileId)
+ * - Status tracking
+ * - Timestamps
+ * - Approval information
+ * - User tracking (created by, actioned by)
+ */
+declare const PayoutDTOSchema: z.ZodObject<{
+    msisdn: z.ZodString;
+    amount: z.ZodNumber;
+    description: z.ZodString;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+} & {
+    id: z.ZodString;
+    profileId: z.ZodString;
+    payeeName: z.ZodString;
+    countryCode: z.ZodEffects<z.ZodDefault<z.ZodString>, import("@temboplus/frontend-core").ISO2CountryCode, string | undefined>;
+    currencyCode: z.ZodEffects<z.ZodDefault<z.ZodString>, import("@temboplus/frontend-core").CurrencyCode, string | undefined>;
+    channel: z.ZodString;
+    status: z.ZodNativeEnum<typeof PayoutStatus>;
+    statusMessage: z.ZodString;
+    partnerReference: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    actionedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    approvalStatus: z.ZodOptional<z.ZodNullable<z.ZodNativeEnum<typeof PayoutApprovalStatus>>>;
+    createdBy: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        identity: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        identity: string;
+    }, {
+        name: string;
+        id: string;
+        identity: string;
+    }>>>;
+    actionedBy: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        identity: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        identity: string;
+    }, {
+        name: string;
+        id: string;
+        identity: string;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    status: PayoutStatus;
+    id: string;
+    channel: string;
+    msisdn: string;
+    amount: number;
+    description: string;
+    payeeName: string;
+    profileId: string;
+    countryCode: import("@temboplus/frontend-core").ISO2CountryCode;
+    currencyCode: import("@temboplus/frontend-core").CurrencyCode;
+    statusMessage: string;
+    createdAt: Date;
+    updatedAt: Date;
+    notes?: string | null | undefined;
+    partnerReference?: string | null | undefined;
+    actionedAt?: Date | null | undefined;
+    approvalStatus?: PayoutApprovalStatus | null | undefined;
+    createdBy?: {
+        name: string;
+        id: string;
+        identity: string;
+    } | null | undefined;
+    actionedBy?: {
+        name: string;
+        id: string;
+        identity: string;
+    } | null | undefined;
+}, {
+    status: PayoutStatus;
+    id: string;
+    channel: string;
+    msisdn: string;
+    amount: number;
+    description: string;
+    payeeName: string;
+    profileId: string;
+    statusMessage: string;
+    createdAt: Date;
+    updatedAt: Date;
+    notes?: string | null | undefined;
+    countryCode?: string | undefined;
+    currencyCode?: string | undefined;
+    partnerReference?: string | null | undefined;
+    actionedAt?: Date | null | undefined;
+    approvalStatus?: PayoutApprovalStatus | null | undefined;
+    createdBy?: {
+        name: string;
+        id: string;
+        identity: string;
+    } | null | undefined;
+    actionedBy?: {
+        name: string;
+        id: string;
+        identity: string;
+    } | null | undefined;
+}>;
+/**
+ * Type definition inferred from AuthorizerSchema
+ * Represents the structure of a user who actions the payout
+ */
+type PayoutAuthorizerDTO = z.infer<typeof AuthorizerSchema>;
+/**
+ * Type definition inferred from PayoutInputDTOSchema
+ * Represents the structure of data required to create a new payout
+ */
+type PayoutInputDTO = z.infer<typeof PayoutInputDTOSchema>;
+/**
+ * Type definition inferred from PayoutDTOSchema
+ * Represents the complete payout record structure
+ */
+type PayoutDTO = z.infer<typeof PayoutDTOSchema>;
+/**
+ * Export object containing all payout-related schemas
+ * Used for validation and type checking throughout the application
+ */
+export declare const PayoutDTOSchemas: {
+    readonly PayoutDTO: z.ZodObject<{
+        msisdn: z.ZodString;
+        amount: z.ZodNumber;
+        description: z.ZodString;
+        notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    } & {
+        id: z.ZodString;
+        profileId: z.ZodString;
+        payeeName: z.ZodString;
+        countryCode: z.ZodEffects<z.ZodDefault<z.ZodString>, import("@temboplus/frontend-core").ISO2CountryCode, string | undefined>;
+        currencyCode: z.ZodEffects<z.ZodDefault<z.ZodString>, import("@temboplus/frontend-core").CurrencyCode, string | undefined>;
+        channel: z.ZodString;
+        status: z.ZodNativeEnum<typeof PayoutStatus>;
+        statusMessage: z.ZodString;
+        partnerReference: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        actionedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+        approvalStatus: z.ZodOptional<z.ZodNullable<z.ZodNativeEnum<typeof PayoutApprovalStatus>>>;
+        createdBy: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            identity: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            id: string;
+            identity: string;
+        }, {
+            name: string;
+            id: string;
+            identity: string;
+        }>>>;
+        actionedBy: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            identity: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            id: string;
+            identity: string;
+        }, {
+            name: string;
+            id: string;
+            identity: string;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        status: PayoutStatus;
+        id: string;
+        channel: string;
+        msisdn: string;
+        amount: number;
+        description: string;
+        payeeName: string;
+        profileId: string;
+        countryCode: import("@temboplus/frontend-core").ISO2CountryCode;
+        currencyCode: import("@temboplus/frontend-core").CurrencyCode;
+        statusMessage: string;
+        createdAt: Date;
+        updatedAt: Date;
+        notes?: string | null | undefined;
+        partnerReference?: string | null | undefined;
+        actionedAt?: Date | null | undefined;
+        approvalStatus?: PayoutApprovalStatus | null | undefined;
+        createdBy?: {
+            name: string;
+            id: string;
+            identity: string;
+        } | null | undefined;
+        actionedBy?: {
+            name: string;
+            id: string;
+            identity: string;
+        } | null | undefined;
+    }, {
+        status: PayoutStatus;
+        id: string;
+        channel: string;
+        msisdn: string;
+        amount: number;
+        description: string;
+        payeeName: string;
+        profileId: string;
+        statusMessage: string;
+        createdAt: Date;
+        updatedAt: Date;
+        notes?: string | null | undefined;
+        countryCode?: string | undefined;
+        currencyCode?: string | undefined;
+        partnerReference?: string | null | undefined;
+        actionedAt?: Date | null | undefined;
+        approvalStatus?: PayoutApprovalStatus | null | undefined;
+        createdBy?: {
+            name: string;
+            id: string;
+            identity: string;
+        } | null | undefined;
+        actionedBy?: {
+            name: string;
+            id: string;
+            identity: string;
+        } | null | undefined;
+    }>;
+    readonly PayoutInputDTO: z.ZodObject<{
+        channel: z.ZodString;
+        msisdn: z.ZodString;
+        amount: z.ZodNumber;
+        description: z.ZodString;
+        notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    } & {
+        payeeName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        channel: string;
+        msisdn: string;
+        amount: number;
+        description: string;
+        payeeName: string;
+        notes?: string | null | undefined;
+    }, {
+        channel: string;
+        msisdn: string;
+        amount: number;
+        description: string;
+        payeeName: string;
+        notes?: string | null | undefined;
+    }>;
+    readonly PayoutStatus: z.ZodNativeEnum<typeof PayoutStatus>;
+    readonly PayoutApprovalStatus: z.ZodNativeEnum<typeof PayoutApprovalStatus>;
+    readonly PayoutAuthorizer: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        identity: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        identity: string;
+    }, {
+        name: string;
+        id: string;
+        identity: string;
+    }>;
+};
+/**
+ * Export types for use in other parts of the application
+ * These types can be used for type checking and documentation
+ */
+export type { PayoutAuthorizerDTO as PayoutAuthorizer, PayoutDTO, PayoutInputDTO };

package/dist/features/payout/payout.repository.d.ts

@@ -0,0 +1,193 @@
+import { BaseRepository } from "@/lib/api";
+import { type PayoutAPI } from "./payout.api-contract";
+import { Payout } from "../../models/payout.model";
+import { Amount, CurrencyCode } from "@temboplus/frontend-core";
+import { PayoutChannel } from "./payout.dtos";
+import { ContactInfo } from "../../models/contact-info.model";
+/**
+ * Arguments for retrieving payouts from the API.
+ *
+ * @interface GetPayoutsAPIArgs
+ *
+ * @property {number} [rangeStart] - The starting index for pagination. Defaults to 0.
+ * @property {number} [rangeEnd] - The ending index for pagination. Defaults to 10.
+ * @property {boolean} [pending] - Filter for pending payouts only. If true, returns only pending payouts.
+ * @property {string} [msisdn] - Filter for msisdn. Should be properly formatted. {country_code}{compact_number} for phone numbers and {SWIFT_CODE}:{account_no}
+ *
+ * @example
+ * ```typescript
+ * // Get first 10 payouts
+ * const args: GetPayoutsAPIArgs = {
+ *   rangeStart: 0,
+ *   rangeEnd: 10
+ * };
+ *
+ * // Get only pending payouts
+ * const pendingArgs: GetPayoutsAPIArgs = {
+ *   pending: true
+ * };
+ * ```
+ */
+export interface GetPayoutsAPIArgs {
+    rangeStart?: number;
+    rangeEnd?: number;
+    pending?: boolean;
+    msisdn?: string;
+}
+/**
+ * Repository class for managing payout operations including creation, approval,
+ * rejection, and retrieval of payouts.
+ *
+ * This repository handles pure API communication without permission checking.
+ * Permission validation should be handled at the service layer or route handlers.
+ *
+ * @extends {BaseRepository<PayoutAPI>}
+ *
+ * @example
+ * ```typescript
+ * const repo = new PayoutRepository({ token: userToken });
+ * const payouts = await repo.getAll();
+ * ```
+ */
+export declare class PayoutRepository extends BaseRepository<PayoutAPI> {
+    /**
+     * Creates an instance of PayoutRepository initialized with the payout contract.
+     *
+     * @param options - Optional configuration
+     * @param options.token - Authentication token for API calls
+     * @param options.root - Custom API root URL
+     *
+     * @example
+     * ```typescript
+     * const repo = new PayoutRepository({
+     *   token: "user-auth-token"
+     * });
+     * ```
+     */
+    constructor(options?: {
+        token?: string;
+        root?: string;
+    });
+    /**
+     * Retrieves a paginated list of payouts with optional filtering for pending status.
+     *
+     * @param args - Optional arguments for filtering and pagination
+     * @param args.rangeStart - Starting index for pagination (default: 0)
+     * @param args.rangeEnd - Ending index for pagination (default: 10)
+     * @param args.pending - Filter for pending payouts only
+     * @param args.msisdn - Filter by MSISDN
+     * @returns Promise that resolves to paginated payout results and total count
+     * @throws {APIError} If range is invalid or if the fetch operation fails
+     *
+     * @example
+     * ```typescript
+     * // Get first 20 payouts
+     * const result = await repo.getAll({
+     *   rangeStart: 0,
+     *   rangeEnd: 20
+     * });
+     *
+     * // Get only pending payouts
+     * const pendingResult = await repo.getAll({ pending: true });
+     * ```
+     */
+    getAll(args?: GetPayoutsAPIArgs): Promise<{
+        results: Payout[];
+        total: number;
+    }>;
+    /**
+     * Creates a new payout with the provided input data.
+     *
+     * @param args - The payout creation data
+     * @param args.channel - The payout channel to use
+     * @param args.receiver - Contact information for the payout receiver
+     * @param args.amount - The amount to pay out
+     * @param args.notes - Optional notes for the payout
+     * @returns Promise that resolves to the created payout
+     * @throws {APIError} If the input is invalid or if the creation operation fails
+     *
+     * @example
+     * ```typescript
+     * const payout = await repo.pay({
+     *   channel: PayoutChannel.MOBILE_MONEY,
+     *   receiver: { name: "John Doe", phone: "+255123456789" },
+     *   amount: Amount.from(10000, "TZS"),
+     *   notes: "Payment for services"
+     * });
+     * ```
+     */
+    pay(args: {
+        channel: PayoutChannel;
+        receiver: ContactInfo;
+        amount: Amount;
+        notes?: string;
+    }): Promise<Payout>;
+    /**
+     * Approves a payout with optional notes.
+     *
+     * @param id - The ID of the payout to approve
+     * @param args - Optional arguments
+     * @param args.notes - Optional notes for the approval
+     * @returns Promise that resolves to the approved payout
+     * @throws {APIError} If payout is not found, already approved, or if the operation fails
+     *
+     * @example
+     * ```typescript
+     * const approvedPayout = await repo.approve("payout-id", {
+     *   notes: "Approved after verification"
+     * });
+     * ```
+     */
+    approve(id: string, args?: {
+        notes?: string;
+    }): Promise<Payout>;
+    /**
+     * Rejects a payout with optional notes.
+     *
+     * @param id - The ID of the payout to reject
+     * @param args - Optional arguments
+     * @param args.notes - Optional notes for the rejection
+     * @returns Promise that resolves to the rejected payout
+     * @throws {APIError} If payout is not found, already rejected, or if the operation fails
+     *
+     * @example
+     * ```typescript
+     * const rejectedPayout = await repo.reject("payout-id", {
+     *   notes: "Insufficient documentation"
+     * });
+     * ```
+     */
+    reject(id: string, args?: {
+        notes?: string;
+    }): Promise<Payout>;
+    /**
+     * Retrieves a payout by its ID.
+     *
+     * @param id - The ID of the payout to retrieve
+     * @returns Promise that resolves to the payout instance if found
+     * @throws {APIError} If the payout is not found or another error occurs
+     *
+     * @example
+     * ```typescript
+     * const payout = await repo.getByID("payout-id");
+     * console.log(`Payout status: ${payout.status}`);
+     * ```
+     */
+    getByID(id: string): Promise<Payout>;
+}
+/**
+ * Helper function to get default amount constraints based on currency.
+ *
+ * @param currency - The currency code
+ * @returns Object containing default minimum and maximum amounts
+ *
+ * @example
+ * ```typescript
+ * const { defaultMin, defaultMax } = getDefaultConstraints("TZS");
+ * console.log(`TZS limits: ${defaultMin} - ${defaultMax}`);
+ * ```
+ */
+export declare const getDefaultConstraints: (currency: CurrencyCode) => {
+    defaultMin: number;
+    defaultMax: number;
+};

package/dist/features/wallet/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./wallet.repository";
+export * from "./wallet-manager.session";
+export * from "./wallet.dtos";
+export * from "./wallet.utils";

package/dist/features/wallet/wallet-manager.session.d.ts

@@ -0,0 +1,143 @@
+import { Country, type CountryCode } from "@temboplus/frontend-core";
+import { Wallet } from "../../models/wallet.model";
+import { User } from "../../models/user.model";
+/**
+ * Defines the shape of the persisted wallet session state.
+ * IMPORTANT: Properties like selectedWalletId/selectedCountryCode are guaranteed
+ * non-nullable and valid ONLY when isInitialized is true.
+ */
+interface WalletSession {
+    userId: string;
+    wallets: Wallet[];
+    selectedWalletId: string;
+    selectedCountryCode: CountryCode;
+    lastSynced: Date | string;
+    isInitialized: boolean;
+}
+/**
+ * Defines the complete state shape including actions and internal getters.
+ */
+interface WalletState extends WalletSession {
+    setWallets: (wallets: Wallet[]) => void;
+    setSelectedWallet: (wallet: Wallet) => void;
+    setSelectedCountry: (countryCode: CountryCode) => void;
+    reset: () => void;
+    _getWalletsByCountry: (countryCode: CountryCode) => Wallet[];
+    _getSelectedWallet: () => Wallet;
+}
+export declare const walletsStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<WalletState>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<WalletState, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: WalletState) => void) => () => void;
+        onFinishHydration: (fn: (state: WalletState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<WalletState, unknown>>;
+    };
+}>;
+/**
+ * WalletSessionManager handles wallet-related operations and state management coordination.
+ * It uses a Zustand store (`useWalletStore`) for state and interacts with WalletRepo.
+ *
+ * IMPORTANT: This manager enforces the invariant that an initialized user session
+ * always has at least one wallet and a valid selection. Methods that return selected
+ * data (`getSelectedWallet`, `getSelectedCountry`, etc.) will THROW AN ERROR if called
+ * before the session is initialized via the `initialize()` method.
+ */
+export declare class WalletSessionManager {
+    private repo;
+    private static _instance;
+    /**
+     * @private
+     */
+    private constructor();
+    /**
+     * Gets the singleton instance of WalletSessionManager.
+     * @returns {WalletSessionManager} The singleton instance.
+     */
+    static get instance(): WalletSessionManager;
+    /**
+     * Checks if the wallet session is initialized.
+     * @returns {boolean} True if initialized, false otherwise.
+     */
+    isInitialized(): boolean;
+    /**
+     * Initializes the wallet manager for the current user.
+     * Fetches wallets if the store isn't already initialized.
+     * Throws an error if the user is not authenticated or if the user is found to have no wallets.
+     * @async
+     * @returns {Promise<void>} Resolves when initialization is complete.
+     * @throws {Error} If user not authenticated or user has no wallets.
+     */
+    initialize(user: User): Promise<void>;
+    /**
+     * Fetches the latest wallet data from the server and updates the store.
+     * Throws an error if the user has no wallets or if the fetch fails.
+     * Ensures the store is updated and marked as initialized.
+     * @async
+     * @returns {Promise<void>} Resolves when refresh is complete.
+     * @throws {Error} If fetch fails or user has no wallets.
+     */
+    refreshWallets(): Promise<void>;
+    /**
+     * Gets all available wallets. Guaranteed non-empty after successful initialization.
+     * @returns {Wallet[]} Non-empty array of Wallet instances.
+     * @throws {Error} If called before initialization is complete.
+     */
+    getWallets(): Wallet[];
+    /**
+     * Gets unique available country codes based on current wallets.
+     * @returns {CountryCode[]} Array of CountryCodes. Guaranteed non-empty after initialization.
+     * @throws {Error} If called before initialization is complete.
+     */
+    getCountries(): CountryCode[];
+    /**
+     * Gets wallets for a specific country.
+     * @param {CountryCode} countryCode The country code to filter by.
+     * @returns {Wallet[]} Array of Wallet instances for the country. May be empty if no wallets match the code, but the overall list isn't empty.
+     * @throws {Error} If called before initialization is complete.
+     */
+    getWalletsByCountry(countryCode: CountryCode): Wallet[];
+    /**
+     * Gets the currently selected wallet instance.
+     * @returns {Wallet} The selected Wallet instance (guaranteed non-nullable).
+     * @throws {Error} If called before initialization is complete or if state is inconsistent.
+     */
+    getSelectedWallet(): Wallet;
+    /**
+     * Gets the currently selected country code.
+     * @returns {CountryCode} The selected CountryCode (guaranteed non-nullable).
+     * @throws {Error} If called before initialization is complete.
+     */
+    getSelectedCountryCode(): CountryCode;
+    /**
+     * Gets the currently selected Country object.
+     * @returns {Country} The selected Country object (guaranteed non-nullable).
+     * @throws {Error} If called before initialization or if Country.fromCode fails for the selected code.
+     */
+    getSelectedCountry(): Country;
+    /**
+     * Changes the selected wallet in the store.
+     * Throws error if the provided walletId is not found in the current list.
+     * @param {string} walletId - The ID of the wallet to select.
+     * @returns {void}
+     * @throws {Error} If wallet with given ID is not found or if called before initialization.
+     */
+    changeWallet(walletId: string): void;
+    /**
+     * Changes the selected country in the store.
+     * Automatically selects the first available wallet for that country.
+     * Throws error if no wallets exist for the given countryCode or if called before initialization.
+     * @param {CountryCode} countryCode - The country code to select.
+     * @returns {void}
+     * @throws {Error} If no wallets found for the country code or if called before initialization.
+     */
+    changeCountry(countryCode: CountryCode): void;
+    /**
+     * Resets the wallet store to  initial (uninitialized) state.
+     * Typically used during user logout.
+     */
+    reset(): void;
+}
+export {};