@temboplus/afloat 0.1.77-beta.1 → 0.1.77-beta.10

package/dist/modules/wallet/narration.model.d.ts

@@ -1,4 +1,5 @@
 import { ContactInfo, MobileContactInfo, BankContactInfo } from "../contact/contact-info.model.js";
+import z from "zod";
 /** Prefix for Ecobank mobile transfer narrations */
 export declare const ECOBANK_PREFIX = "MOBILE TRANSFER ";
 /** V2 format prefix for payout narrations using contact details */
@@ -12,12 +13,19 @@ export declare const MOBILE_NARR_PREFIX: string;
 /** Legacy format prefix for mobile money payout narrations */
 export declare const LEGACY_MOBILE_NARR_PREFIX: string;
 /**
- * Interface for the JSON representation of Narration
+ * Zod schema for Narration JSON serialization
  */
-export interface NarrationJson {
+export declare const NarrationJSONSchema: z.ZodObject<{
+    text: z.ZodString;
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
     text: string;
-    version?: string;
-}
+}, {
+    text: string;
+    version?: string | undefined;
+}>;
+export type NarrationJSON = z.infer<typeof NarrationJSONSchema>;
 /**
  * Handles payout narration generation and parsing for the Afloat platform.
  *
@@ -184,46 +192,34 @@ export declare class Narration {
      */
     getMobileContactDetails: () => MobileContactInfo | undefined;
     /**
-     * Serializes the Narration instance to a JSON-compatible object.
-     *
-     * @returns {NarrationJson} A plain object containing the narration data
+     * Type guard to check if an unknown object is a valid Narration instance.
      *
-     * @example
-     * ```typescript
-     * const narration = new Narration("PAYOUT +255123456789 JOHN DOE");
-     * const json = narration.toJson();
-     * // Returns: { text: "PAYOUT +255123456789 JOHN DOE", version: "2.0" }
-     * ```
+     * @param obj - The object to check
+     * @returns Type predicate indicating if the object is a Narration instance
      */
-    toJson(): NarrationJson;
+    static is(obj: unknown): obj is Narration;
     /**
-     * Creates a Narration instance from a JSON-compatible object.
-     *
-     * @param {NarrationJson | string} json - Either a NarrationJson object or a JSON string
-     * @returns {Narration | undefined} A Narration instance if valid, undefined otherwise
-     *
-     * @example
-     * ```typescript
-     * // From object
-     * const narration = Narration.fromJson({ text: "PAYOUT +255123456789 JOHN DOE" });
-     *
-     * // From JSON string
-     * const narration = Narration.fromJson('{"text":"PAYOUT +255123456789 JOHN DOE"}');
-     * ```
+   * Serializes the Narration instance to a JSON-compatible object
+   */
+    toJSON(): NarrationJSON;
+    /**
+     * Serializes the Narration instance to a JSON string
      */
-    static fromJson(json: NarrationJson | string): Narration | undefined;
+    toJSONString(): string;
     /**
-     * Type guard to check if an object is a valid NarrationJson
-     *
-     * @param obj - The object to validate
-     * @returns True if the object conforms to NarrationJson structure
+     * Creates a Narration instance from a JSON-compatible object or string
      */
-    static isNarrationJson(obj: unknown): obj is NarrationJson;
+    static fromJSON(json: NarrationJSON | string): Narration | undefined;
     /**
-     * Type guard to check if an unknown object is a valid Narration instance.
-     *
-     * @param obj - The object to check
-     * @returns Type predicate indicating if the object is a Narration instance
+     * Type guard using Zod schema validation
      */
-    static is(obj: unknown): obj is Narration;
+    static isNarrationJSON(obj: unknown): obj is NarrationJSON;
+    /**
+     * @deprecated Use toJSON() instead
+     */
+    toJson(): NarrationJSON;
+    /**
+     * @deprecated Use fromJSON() instead
+     */
+    static fromJson(json: NarrationJSON | string): Narration | undefined;
 }

package/dist/modules/wallet/statement-entry.model.d.ts

@@ -1,22 +1,137 @@
-import { WalletStatementEntryDTO } from "@/modules/wallet/wallet.dtos.js";
-import { Amount, AmountJson } from "@temboplus/frontend-core";
-import { NarrationJson, Narration } from "./narration.model.js";
+import { Amount } from "@temboplus/frontend-core";
+import { Narration } from "./narration.model.js";
+import z from "zod";
 /**
- * Interface for the JSON representation of WalletStatementEntry
+ * Zod schema for WalletStatementEntry JSON serialization
  */
-export interface WalletStatementEntryJson {
-    accountNo?: string;
+export declare const WalletStatementEntryJSONSchema: z.ZodObject<{
+    accountNo: z.ZodOptional<z.ZodString>;
+    debitOrCredit: z.ZodString;
+    tranRefNo: z.ZodString;
+    narration: z.ZodObject<{
+        text: z.ZodString;
+        version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        text: string;
+    }, {
+        text: string;
+        version?: string | undefined;
+    }>;
+    txnDate: z.ZodString;
+    valueDate: z.ZodString;
+    amountCredited: z.ZodObject<{
+        value: z.ZodNumber;
+        text: z.ZodString;
+        currencyCode: z.ZodString;
+        version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        value: number;
+        text: string;
+        currencyCode: string;
+    }, {
+        value: number;
+        text: string;
+        currencyCode: string;
+        version?: string | undefined;
+    }>;
+    amountDebited: z.ZodObject<{
+        value: z.ZodNumber;
+        text: z.ZodString;
+        currencyCode: z.ZodString;
+        version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        value: number;
+        text: string;
+        currencyCode: string;
+    }, {
+        value: number;
+        text: string;
+        currencyCode: string;
+        version?: string | undefined;
+    }>;
+    balance: z.ZodObject<{
+        value: z.ZodNumber;
+        text: z.ZodString;
+        currencyCode: z.ZodString;
+        version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        value: number;
+        text: string;
+        currencyCode: string;
+    }, {
+        value: number;
+        text: string;
+        currencyCode: string;
+        version?: string | undefined;
+    }>;
+    currencyCode: z.ZodString;
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    currencyCode: string;
     debitOrCredit: string;
     tranRefNo: string;
-    narration: NarrationJson;
+    narration: {
+        version: string;
+        text: string;
+    };
     txnDate: string;
     valueDate: string;
-    amountCredited: AmountJson;
-    amountDebited: AmountJson;
-    balance: AmountJson;
+    amountCredited: {
+        version: string;
+        value: number;
+        text: string;
+        currencyCode: string;
+    };
+    amountDebited: {
+        version: string;
+        value: number;
+        text: string;
+        currencyCode: string;
+    };
+    balance: {
+        version: string;
+        value: number;
+        text: string;
+        currencyCode: string;
+    };
+    accountNo?: string | undefined;
+}, {
     currencyCode: string;
-    version?: string;
-}
+    debitOrCredit: string;
+    tranRefNo: string;
+    narration: {
+        text: string;
+        version?: string | undefined;
+    };
+    txnDate: string;
+    valueDate: string;
+    amountCredited: {
+        value: number;
+        text: string;
+        currencyCode: string;
+        version?: string | undefined;
+    };
+    amountDebited: {
+        value: number;
+        text: string;
+        currencyCode: string;
+        version?: string | undefined;
+    };
+    balance: {
+        value: number;
+        text: string;
+        currencyCode: string;
+        version?: string | undefined;
+    };
+    accountNo?: string | undefined;
+    version?: string | undefined;
+}>;
+export type WalletStatementEntryJSON = z.infer<typeof WalletStatementEntryJSONSchema>;
 /**
  * Represents a single entry in a Wallet's statement history.
  *
@@ -38,18 +153,18 @@ export declare class WalletStatementEntry {
     /**
      * Gets the statement entry schema used for validation.
      */
-    static get schema(): import("zod").ZodObject<{
-        accountNo: import("zod").ZodEffects<import("zod").ZodOptional<import("zod").ZodString>, string | undefined, string | undefined>;
-        debitOrCredit: import("zod").ZodString;
-        tranRefNo: import("zod").ZodString;
-        narration: import("zod").ZodString;
-        txnDate: import("zod").ZodDate;
-        valueDate: import("zod").ZodDate;
-        amountCredited: import("zod").ZodNumber;
-        amountDebited: import("zod").ZodNumber;
-        balance: import("zod").ZodNumber;
-        currencyCode: import("zod").ZodDefault<import("zod").ZodEffects<import("zod").ZodOptional<import("zod").ZodString>, string | undefined, string | undefined>>;
-    }, "strip", import("zod").ZodTypeAny, {
+    static get schema(): z.ZodObject<{
+        accountNo: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+        debitOrCredit: z.ZodString;
+        tranRefNo: z.ZodString;
+        narration: z.ZodString;
+        txnDate: z.ZodDate;
+        valueDate: z.ZodDate;
+        amountCredited: z.ZodNumber;
+        amountDebited: z.ZodNumber;
+        balance: z.ZodNumber;
+        currencyCode: z.ZodDefault<z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>>;
+    }, "strip", z.ZodTypeAny, {
         currencyCode: string;
         debitOrCredit: string;
         tranRefNo: string;
@@ -108,28 +223,6 @@ export declare class WalletStatementEntry {
     get amountDebited(): Amount;
     get balance(): Amount;
     get currencyCode(): string;
-    /**
-     * Serializes the WalletStatementEntry instance to a JSON-compatible object.
-     * Dates are converted to ISO strings, amounts are serialized using Amount.toJson(),
-     * and narration is serialized using Narration.toJson().
-     *
-     * @returns {WalletStatementEntryJson} A plain object containing all necessary data
-     */
-    toJson(): WalletStatementEntryJson;
-    /**
-     * Creates a WalletStatementEntry instance from a JSON-compatible object.
-     *
-     * @param {WalletStatementEntryJson | string} json - Either a WalletStatementEntryJson object or a JSON string
-     * @returns {WalletStatementEntry | undefined} A WalletStatementEntry instance if valid, undefined otherwise
-     */
-    static fromJson(json: WalletStatementEntryJson | string): WalletStatementEntry | undefined;
-    /**
-     * Type guard to check if an object is a valid WalletStatementEntryJson
-     *
-     * @param obj - The object to validate
-     * @returns True if the object conforms to WalletStatementEntryJson structure
-     */
-    static isWalletStatementEntryJson(obj: unknown): obj is WalletStatementEntryJson;
     /**
      * Validates the current statement entry instance data against the schema.
      * @returns True if the statement entry instance data is valid, false otherwise.
@@ -159,42 +252,48 @@ export declare class WalletStatementEntry {
      */
     toString(): string;
     /**
-     * Serializes an array of WalletStatementEntry instances to JSON-compatible objects
-     *
-     * @param entries - Array of WalletStatementEntry instances to serialize
-     * @returns Array of WalletStatementEntryJson objects
+     * Legacy method for backwards compatibility - creates from plain object
+     * @deprecated Use fromJson() for serialized data or create() for raw data
      */
-    static toJsonArray(entries: WalletStatementEntry[]): WalletStatementEntryJson[];
+    static from(data: any): WalletStatementEntry | undefined;
     /**
-     * Creates WalletStatementEntry instances from an array of JSON-compatible objects
-     *
-     * @param jsonArray - Array of WalletStatementEntryJson objects or JSON string
-     * @returns Array of WalletStatementEntry instances (invalid items are filtered out)
+   * Serializes the WalletStatementEntry instance to a JSON-compatible object
+   */
+    toJSON(): WalletStatementEntryJSON;
+    /**
+     * Serializes the WalletStatementEntry instance to a JSON string
      */
-    static fromJsonArray(jsonArray: WalletStatementEntryJson[] | string): WalletStatementEntry[];
+    toJSONString(): string;
     /**
-     * Legacy method for backwards compatibility - creates object representation
-     * @deprecated Use toJson() instead for proper serialization
+     * Creates a WalletStatementEntry instance from a JSON-compatible object or string
      */
-    toObject(): Omit<WalletStatementEntryDTO, "amountCredited" | "amountDebited" | "balance" | "narration"> & {
-        amountCredited: AmountJson;
-        amountDebited: AmountJson;
-        balance: AmountJson;
-        narration: string;
-    };
+    static fromJSON(json: WalletStatementEntryJSON | string): WalletStatementEntry | undefined;
     /**
-     * Legacy method for backwards compatibility - converts to JSON string
-     * @deprecated Use JSON.stringify(entry.toJson()) instead
+     * Type guard using Zod schema validation
      */
-    toJSON(): string;
+    static isWalletStatementEntryJSON(obj: unknown): obj is WalletStatementEntryJSON;
     /**
-     * Legacy method for backwards compatibility
-     * @deprecated Use fromJson() instead
+     * Creates WalletStatementEntry instances from a JSON array
      */
-    static fromJSON(jsonString: string): WalletStatementEntry | undefined;
+    static fromJSONArray(jsonArray: WalletStatementEntryJSON[] | string): WalletStatementEntry[];
     /**
-     * Legacy method for backwards compatibility - creates from plain object
-     * @deprecated Use fromJson() for serialized data or create() for raw data
+     * Serializes an array of WalletStatementEntry instances to JSON
      */
-    static from(data: any): WalletStatementEntry | undefined;
+    static toJSONArray(entries: WalletStatementEntry[]): WalletStatementEntryJSON[];
+    /**
+     * @deprecated Use toJSON() instead
+     */
+    toJson(): WalletStatementEntryJSON;
+    /**
+     * @deprecated Use fromJSON() instead
+     */
+    static fromJson(json: WalletStatementEntryJSON | string): WalletStatementEntry | undefined;
+    /**
+     * @deprecated Use fromJSONArray() instead
+     */
+    static fromJsonArray(jsonArray: WalletStatementEntryJSON[] | string): WalletStatementEntry[];
+    /**
+     * @deprecated Use toJSONArray() instead
+     */
+    static toJsonArray(entries: WalletStatementEntry[]): WalletStatementEntryJSON[];
 }

package/dist/modules/wallet/wallet.model.d.ts

@@ -1,5 +1,44 @@
 import { type CurrencyCode, type ISO2CountryCode } from "@temboplus/frontend-core";
-import { WalletDTO, WalletDTOSchemas } from "@/modules/wallet/wallet.dtos.js";
+import { WalletDTOSchemas } from "@/modules/wallet/wallet.dtos.js";
+import z from "zod";
+/**
+ * Zod schema for Wallet JSON serialization
+ */
+export declare const WalletJSONSchema: z.ZodObject<{
+    id: z.ZodString;
+    profileId: z.ZodString;
+    accountNo: z.ZodString;
+    accountName: z.ZodString;
+    channel: z.ZodString;
+    countryCode: z.ZodString;
+    currencyCode: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    accountNo: string;
+    version: string;
+    profileId: string;
+    createdAt: string;
+    updatedAt: string;
+    accountName: string;
+    channel: string;
+    countryCode: string;
+    currencyCode: string;
+}, {
+    id: string;
+    accountNo: string;
+    profileId: string;
+    createdAt: string;
+    updatedAt: string;
+    accountName: string;
+    channel: string;
+    countryCode: string;
+    currencyCode: string;
+    version?: string | undefined;
+}>;
+export type WalletJSON = z.infer<typeof WalletJSONSchema>;
 /**
  * Represents a digital Wallet entity.
  *
@@ -63,30 +102,12 @@ export declare class Wallet {
      * @returns The last update Date object.
      */
     get updatedAtDate(): Date;
-    /**
-     * Creates a plain data object representation of the Wallet instance.
-     * Suitable for serialization or validation.
-     * @returns A plain object conforming to the WalletDataType structure.
-     */
-    toObject(): WalletDTO;
-    /**
-     * Serializes the Wallet instance into a JSON string.
-     * @returns A JSON string representation of the wallet data.
-     */
-    toJSON(): string;
     /**
      * Validates the Wallet instance's current data against the defined schema.
      * This includes checking the countryCode against ISO2CountryCodesSet.
      * @returns True if the current instance data is valid, otherwise false.
      */
     validate(): boolean;
-    /**
-     * Creates a Wallet instance from a JSON string.
-     * Performs parsing and validation, including the countryCode runtime check.
-     * @param jsonString - A JSON string containing wallet data.
-     * @returns A new Wallet instance if parsing and validation succeed, otherwise undefined.
-     */
-    static fromJSON(jsonString: string): Wallet | undefined;
     /**
      * Creates a Wallet instance from a plain JavaScript object.
      * Validates the input object using the Wallet schema, including the countryCode runtime check.
@@ -101,4 +122,20 @@ export declare class Wallet {
      * @returns True if the object resembles a Wallet instance, false otherwise.
      */
     static is(obj: unknown): obj is Wallet;
+    /**
+   * Serializes the Wallet instance to a JSON-compatible object
+   */
+    toJSON(): WalletJSON;
+    /**
+     * Serializes the Wallet instance to a JSON string
+     */
+    toJSONString(): string;
+    /**
+     * Creates a Wallet instance from a JSON-compatible object or string
+     */
+    static fromJSON(json: WalletJSON | string): Wallet | undefined;
+    /**
+     * Type guard using Zod schema validation
+     */
+    static isWalletJSON(obj: unknown): obj is WalletJSON;
 }

package/dist/modules/wallet/wallet.query.d.ts

@@ -0,0 +1,95 @@
+import { QueryBuilder } from "@/lib/query/index.js";
+import { WalletQueryDTO } from "./wallet.dtos.js";
+/**
+ * Wallet-specific query builder that extends the base QueryBuilder
+ * and handles all possible input conversions (DTOs, URL params, etc.)
+ */
+export declare class WalletQuery extends QueryBuilder {
+    /**
+     * Create empty wallet query with defaults
+     */
+    static create(): WalletQuery;
+    /**
+     * Create from typed DTO/filters object
+     */
+    static fromFilters(filters: WalletQueryDTO): WalletQuery;
+    /**
+     * Create from URL search parameters (strings)
+     */
+    static fromUrlParams(params: Record<string, string>): WalletQuery;
+    /**
+     * Create from URLSearchParams object
+     */
+    static fromSearchParams(searchParams: URLSearchParams): WalletQuery;
+    /**
+     * Create from Next.js Request object
+     */
+    static fromRequest(request: Request): WalletQuery;
+    /**
+     * Create from any supported input type
+     */
+    static from(input: QueryBuilder | WalletQueryDTO | Record<string, string> | URLSearchParams | null | undefined): WalletQuery;
+    /**
+     * Type guard for string records
+     */
+    private static isStringRecord;
+    whereId(id: string): this;
+    whereProfileId(profileId: string): this;
+    whereAccountNo(accountNo: string): this;
+    whereAccountName(accountName: string): this;
+    whereChannel(channel: string): this;
+    whereCountryCode(countryCode: string): this;
+    whereCurrencyCode(currencyCode: string): this;
+    /**
+     * Apply all filters from WalletQueryDTO object
+     */
+    private applyFilters;
+    /**
+     * Convert to WalletQueryDTO
+     */
+    toFilters(): WalletQueryDTO;
+    /**
+     * Convert to URL-safe string parameters
+     */
+    toUrlParams(): Record<string, string>;
+    /**
+     * Convert to URLSearchParams
+     */
+    toSearchParams(): URLSearchParams;
+    /**
+     * Convert to query string
+     */
+    toQueryString(): string;
+    /**
+     * Create new instance with wallet ID filter
+     */
+    withId(id: string): WalletQuery;
+    /**
+     * Create new instance with profile ID filter
+     */
+    withProfileId(profileId: string): WalletQuery;
+    /**
+     * Create new instance with account number filter
+     */
+    withAccountNo(accountNo: string): WalletQuery;
+    /**
+     * Create new instance with country code filter
+     */
+    withCountryCode(countryCode: string): WalletQuery;
+    /**
+     * Create new instance with currency code filter
+     */
+    withCurrencyCode(currencyCode: string): WalletQuery;
+    /**
+     * Check if any filters are applied
+     */
+    hasFilters(): boolean;
+    /**
+     * Get human-readable filter descriptions
+     */
+    getActiveFilters(): string[];
+    /**
+     * Extract filter values from QueryBuilder options
+     */
+    private extractFilterValues;
+}

package/dist/modules/wallet/wallet.repository.d.ts

@@ -1,10 +1,14 @@
 import { Amount } from "@temboplus/frontend-core";
 import { WalletStatementEntry } from "./statement-entry.model.js";
 import { Wallet } from "./wallet.model.js";
-import { WalletDTOSchemas } from "./wallet.dtos.js";
-import { z } from "zod";
 import { contract } from "./wallet.contract.js";
 import { BaseRepository } from "@/lib/api/base-repository.js";
+import { WalletQuery } from "./wallet.query.js";
+import { WalletQueryDTO } from "./wallet.dtos.js";
+/**
+ * Flexible query input type - supports the class, filters interface, URL params, etc.
+ */
+export type WalletQueryInput = WalletQuery | WalletQueryDTO | Record<string, string> | URLSearchParams | null | undefined;
 /**
  * Repository class for managing wallet operations including balance checking,
  * statement generation, and wallet information retrieval.
@@ -87,13 +91,9 @@ export declare class WalletRepository extends BaseRepository<typeof contract> {
     /**
      * Retrieves all wallets associated with the authenticated user.
      *
-     * Supports optional filtering through query parameters such as accountNo,
-     * status, or currency filtering.
+     * Supports flexible filtering through WalletQuery or plain filter objects.
      *
      * @param query - Optional query parameters for filtering wallets
-     * @param query.accountNo - Filter by specific account number
-     * @param query.status - Filter by wallet status (active, inactive, etc.)
-     * @param query.currencyCode - Filter by currency code
      * @returns Promise that resolves to an array of validated Wallet instances
      * @throws {Error} If the wallet fetch operation fails or data is invalid
      *
@@ -105,14 +105,38 @@ export declare class WalletRepository extends BaseRepository<typeof contract> {
      * // Get specific wallet by account number
      * const specificWallet = await repo.getWallets({ accountNo: '123456789' });
      *
-     * // Get wallets with multiple filters
-     * const activeUSDWallets = await repo.getWallets({
-     *   status: 'active',
-     *   currencyCode: 'USD'
-     * });
+     * // Get wallets with multiple filters using WalletQuery
+     * const query = WalletQuery.create()
+     *   .whereCountryCode('TZ')
+     *   .whereCurrencyCode('TZS');
+     * const tzWallets = await repo.getWallets(query);
+     *
+     * // Get wallets with filters object
+     * const usdWallets = await repo.getWallets({ currencyCode: 'USD' });
      * ```
      */
-    getWallets(query?: z.infer<typeof WalletDTOSchemas.walletQuery>): Promise<Wallet[]>;
+    getWallets(query?: WalletQueryInput): Promise<Wallet[]>;
+    /**
+     * Retrieves a single wallet by its ID.
+     *
+     * Since the API doesn't have a dedicated /id endpoint, this method queries
+     * the list endpoint with the ID filter and returns the first result.
+     *
+     * @param id - The unique identifier of the wallet to retrieve
+     * @returns Promise that resolves to the wallet if found, undefined otherwise
+     * @throws {Error} If the fetch operation fails
+     *
+     * @example
+     * ```typescript
+     * const wallet = await repo.getByID("wallet-id");
+     * if (wallet) {
+     *   console.log(`Wallet: ${wallet.accountName}`);
+     * } else {
+     *   console.log('Wallet not found');
+     * }
+     * ```
+     */
+    getByID(id: string): Promise<Wallet | undefined>;
     /**
      * Retrieves wallet statement entries for a specified date range.
      *
@@ -170,4 +194,12 @@ export declare class WalletRepository extends BaseRepository<typeof contract> {
         wallet?: Wallet;
         accountNo?: string;
     }): Promise<WalletStatementEntry[]>;
+    /**
+     * Check if a wallet exists with the given query
+     */
+    exists(query?: WalletQueryInput): Promise<boolean>;
+    /**
+     * Get count of wallets matching a query
+     */
+    count(query?: WalletQueryInput): Promise<number>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temboplus/afloat",
-  "version": "0.1.77-beta.1",
+  "version": "0.1.77-beta.10",
   "description": "A foundational library for Temboplus-Afloat projects.",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.esm.js",
@@ -58,6 +58,6 @@
     "typescript": "^5.8.3"
   },
   "dependencies": {
-    "@temboplus/frontend-core": "^0.2.19"
+    "@temboplus/frontend-core": "^0.2.20-beta.2"
   }
 }