ggez-banking-sdk 0.4.3 → 0.4.5

package/dist/account.d.ts

@@ -1,4 +1,4 @@
-export { AccountClient } from "./api/client/account";
+export { AccountProxy } from "./api/proxy/account";
 export { AccountService } from "./api/service/account";
 export * from "./api/data/account";
 export type * from "./types/api/data/account";

package/dist/account.js

@@ -1,5 +1,5 @@
 // Account-related exports - Complete account domain
-export { AccountClient } from "./api/client/account";
+export { AccountProxy } from "./api/proxy/account";
 export { AccountService } from "./api/service/account";
 // Account data exports
 export * from "./api/data/account";

package/dist/api/api.d.ts

@@ -1,41 +1,21 @@
-import { AccountClient, AuthClient, BlockchainClient, IPAddressAndLocationClient, LimitedClient, OrderClient, OrganizationClient, ProgramClient, PromotionClient, TransactionClient, UserClient } from "./client";
+import { AccountProxy, AuthProxy, BlockchainProxy, IPAddressAndLocationProxy, LimitedProxy, OrderProxy, OrganizationProxy, ProgramProxy, PromotionProxy, TransactionProxy, UserProxy } from "./proxy";
 import type { ClientData, ErrorHandler } from "../types";
 import type { ClientContextProvider } from "../types/api/context/clientContext";
-/**
- * SDK entry point. Constructs the full dependency graph in one shot:
- *
- *   ClientContext + CookiesHelper
- *     → Services (axios transport)
- *       → Proxies (read context to build per-call axios config; cross-entity
- *         orchestration like AuthProxy → UserProxy)
- *         → Clients (consumer-facing payload/response shaping)
- *
- * Consumers interact with `api.<client>` methods only. Credentials and
- * language are mutated via the exposed `context` setters. Session
- * invalidation (token expiry detection, device-credential refresh,
- * redirect to login) is the consumer's responsibility — the SDK is
- * stateless about session lifecycle.
- */
 declare class API {
     readonly context: ClientContextProvider;
-    readonly account: AccountClient;
-    readonly auth: AuthClient;
-    readonly blockchain: BlockchainClient;
-    readonly ipAddress: IPAddressAndLocationClient;
-    readonly limited: LimitedClient;
-    readonly order: OrderClient;
-    readonly organization: OrganizationClient;
-    readonly program: ProgramClient;
-    readonly promotion: PromotionClient;
-    readonly transaction: TransactionClient;
-    readonly user: UserClient;
+    readonly account: AccountProxy;
+    readonly auth: AuthProxy;
+    readonly blockchain: BlockchainProxy;
+    readonly ipAddress: IPAddressAndLocationProxy;
+    readonly limited: LimitedProxy;
+    readonly order: OrderProxy;
+    readonly organization: OrganizationProxy;
+    readonly program: ProgramProxy;
+    readonly promotion: PromotionProxy;
+    readonly transaction: TransactionProxy;
+    readonly user: UserProxy;
     private readonly cookiesHelper;
-    private readonly authProxy;
     constructor(clientData: ClientData, errorHandler: ErrorHandler);
-    /**
-     * Clear session state on explicit user logout: zero the in-memory
-     * context, then drop the cookies.
-     */
     logout(): Promise<void>;
 }
 export { API };

package/dist/api/api.js

@@ -1,24 +1,7 @@
-import { AxiosHelper } from "../helper/api/axiosHelper";
 import { CookiesHelper } from "../helper/storage/cookiesHelper";
-import { AccountClient, AuthClient, BlockchainClient, IPAddressAndLocationClient, LimitedClient, OrderClient, OrganizationClient, ProgramClient, PromotionClient, TransactionClient, UserClient, } from "./client";
-import { AccountService, AuthService, BlockchainService, IPAddressAndLocationService, LimitedService, OrderService, OrganizationService, ProgramService, PromotionService, TransactionService, UserService, } from "./service";
 import { AccountProxy, AuthProxy, BlockchainProxy, IPAddressAndLocationProxy, LimitedProxy, OrderProxy, OrganizationProxy, ProgramProxy, PromotionProxy, TransactionProxy, UserProxy, } from "./proxy";
+import { AuthService } from "./service";
 import { DefaultClientContextProvider } from "./context";
-/**
- * SDK entry point. Constructs the full dependency graph in one shot:
- *
- *   ClientContext + CookiesHelper
- *     → Services (axios transport)
- *       → Proxies (read context to build per-call axios config; cross-entity
- *         orchestration like AuthProxy → UserProxy)
- *         → Clients (consumer-facing payload/response shaping)
- *
- * Consumers interact with `api.<client>` methods only. Credentials and
- * language are mutated via the exposed `context` setters. Session
- * invalidation (token expiry detection, device-credential refresh,
- * redirect to login) is the consumer's responsibility — the SDK is
- * stateless about session lifecycle.
- */
 class API {
     context;
     account;
@@ -33,7 +16,6 @@ class API {
     transaction;
     user;
     cookiesHelper;
-    authProxy;
     constructor(clientData, errorHandler) {
         this.context = new DefaultClientContextProvider({
             baseUrl: clientData.baseUrl,
@@ -43,69 +25,19 @@ class API {
             installationId: clientData.installationId,
         });
         this.cookiesHelper = new CookiesHelper(String(clientData.programId), clientData.domain ?? "", errorHandler);
-        // axios baseURL is sticky per-instance, so we build one config per
-        // base-URL variant from clientData. Per-call headers (Authorization,
-        // Source_Id, Time_Zone) are written by the proxy layer at call time.
-        const authConfig = AxiosHelper.getAuthAxiosConfig(clientData.baseUrl, clientData.lang, "");
-        const sessionConfig = AxiosHelper.getAxiosConfig("", clientData.baseUrl, clientData.lang, clientData.installationId);
-        const promotionConfig = AxiosHelper.getAuthAxiosConfig(clientData.nodeUrl, clientData.lang, "");
-        const shared = { context: this.context };
-        const authService = new AuthService({ config: authConfig, ...shared });
-        const userService = new UserService({ config: sessionConfig, ...shared });
-        const accountService = new AccountService({ config: sessionConfig, ...shared });
-        const blockchainService = new BlockchainService({ config: sessionConfig, ...shared });
-        const ipAddressAndLocationService = new IPAddressAndLocationService({
-            config: sessionConfig,
-            ...shared,
-        });
-        const limitedService = new LimitedService({ config: sessionConfig, ...shared });
-        const orderService = new OrderService({ config: sessionConfig, ...shared });
-        const organizationService = new OrganizationService({
-            config: sessionConfig,
-            ...shared,
-        });
-        const programService = new ProgramService({ config: sessionConfig, ...shared });
-        const promotionService = new PromotionService({
-            config: promotionConfig,
-            ...shared,
-        });
-        const transactionService = new TransactionService({
-            config: sessionConfig,
-            ...shared,
-        });
-        // AuthProxy and UserProxy reference each other (α2 login → getUser).
-        // Build AuthProxy first, then UserProxy, then wire via setUserProxy.
-        // AuthProxy and LimitedProxy are pre-session (mint their own auth) and
-        // don't extend BaseProxy. Every other proxy takes context so it can
-        // build session-authenticated configs.
-        this.authProxy = new AuthProxy(authService, this.context, this.cookiesHelper);
-        const userProxy = new UserProxy(this.context, userService, this.authProxy);
-        this.authProxy.setUserProxy(userProxy);
-        const accountProxy = new AccountProxy(this.context, accountService);
-        const blockchainProxy = new BlockchainProxy(this.context, blockchainService);
-        const ipAddressAndLocationProxy = new IPAddressAndLocationProxy(this.context, ipAddressAndLocationService);
-        const limitedProxy = new LimitedProxy(limitedService, this.authProxy, this.context);
-        const orderProxy = new OrderProxy(this.context, orderService);
-        const organizationProxy = new OrganizationProxy(this.context, organizationService);
-        const programProxy = new ProgramProxy(this.context, programService);
-        const promotionProxy = new PromotionProxy(this.context, promotionService);
-        const transactionProxy = new TransactionProxy(this.context, transactionService);
-        this.auth = new AuthClient(this.authProxy, this.context, errorHandler);
-        this.user = new UserClient(userProxy, errorHandler);
-        this.account = new AccountClient(accountProxy, errorHandler);
-        this.blockchain = new BlockchainClient(blockchainProxy, errorHandler);
-        this.ipAddress = new IPAddressAndLocationClient(ipAddressAndLocationProxy, errorHandler);
-        this.limited = new LimitedClient(limitedProxy, errorHandler);
-        this.order = new OrderClient(orderProxy, errorHandler);
-        this.organization = new OrganizationClient(organizationProxy, this.context, errorHandler);
-        this.program = new ProgramClient(programProxy, errorHandler);
-        this.promotion = new PromotionClient(promotionProxy, errorHandler);
-        this.transaction = new TransactionClient(transactionProxy, errorHandler);
+        const authService = new AuthService({ context: this.context, errorHandler });
+        this.auth = new AuthProxy(this.context, authService, this.cookiesHelper);
+        this.account = new AccountProxy(this.context, errorHandler);
+        this.blockchain = new BlockchainProxy(this.context, errorHandler);
+        this.order = new OrderProxy(this.context, errorHandler);
+        this.limited = new LimitedProxy(this.context, errorHandler);
+        this.organization = new OrganizationProxy(this.context, errorHandler);
+        this.program = new ProgramProxy(this.context, errorHandler);
+        this.promotion = new PromotionProxy(this.context, errorHandler);
+        this.ipAddress = new IPAddressAndLocationProxy(this.context, errorHandler);
+        this.transaction = new TransactionProxy(this.context, errorHandler);
+        this.user = new UserProxy(this.context, errorHandler);
     }
-    /**
-     * Clear session state on explicit user logout: zero the in-memory
-     * context, then drop the cookies.
-     */
     async logout() {
         this.context.setToken("");
         this.context.setUserId(0);

package/dist/api/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./api";
-export * from "./client";
+export * from "./proxy";
 export * from "./context";
 export * from "./data";
-export * from "./proxy";
 export * from "./service";

package/dist/api/index.js

@@ -1,6 +1,5 @@
 export * from "./api";
-export * from "./client";
+export * from "./proxy";
 export * from "./context";
 export * from "./data";
-export * from "./proxy";
 export * from "./service";

package/dist/api/proxy/account.d.ts

@@ -1,10 +1,10 @@
-import type { AccountService } from "../service/account";
+import type { ErrorHandler } from "../../types";
 import type { ClientContextProvider } from "../../types/api/context/clientContext";
 import { BaseProxy } from "./base";
 declare class AccountProxy extends BaseProxy {
     private accountService;
-    constructor(context: ClientContextProvider, accountService: AccountService);
-    get(accountId: number): Promise<import("axios").AxiosResponse<import("../..").AccountData, any, {}>>;
-    getLimits(accountId: number): Promise<import("axios").AxiosResponse<import("../..").AccountData, any, {}>>;
+    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    get: (accountId: number) => Promise<import("axios").AxiosResponse<import("../..").AccountData, any, {}>>;
+    getLimits: (accountId: number) => Promise<import("axios").AxiosResponse<import("../..").AccountData, any, {}>>;
 }
 export { AccountProxy };

package/dist/api/proxy/account.js

@@ -1,17 +1,17 @@
+import { AccountService } from "../service/account";
 import { BaseProxy } from "./base";
 class AccountProxy extends BaseProxy {
     accountService;
-    constructor(context, accountService) {
-        super(context);
-        this.accountService = accountService;
-    }
-    async get(accountId) {
-        const config = this.buildSessionConfig();
-        return this.accountService.get(accountId, config);
-    }
-    async getLimits(accountId) {
-        const config = this.buildSessionConfig();
-        return this.accountService.getLimits(accountId, config);
+    constructor(context, errorHandler) {
+        super(errorHandler);
+        this.accountService = new AccountService({ context, errorHandler });
     }
+    // #region "GET"
+    get = async (accountId) => {
+        return this.accountService.get(accountId);
+    };
+    getLimits = async (accountId) => {
+        return this.accountService.getLimits(accountId);
+    };
 }
 export { AccountProxy };

package/dist/api/proxy/auth.d.ts

@@ -1,42 +1,17 @@
-import type { AxiosResponse } from "axios";
 import type { AuthService } from "../service/auth";
-import type { UserProxy } from "./user";
 import type { ClientContextProvider } from "../../types/api/context/clientContext";
 import type { IGenerateLimitedTokenData } from "../../types/api/data/auth";
-import type { LoginResult } from "../../types/api/proxy/auth";
-import type { AxiosRequestConfig } from "axios";
-import type { CookiesHelper } from "../../helper/storage/cookiesHelper";
-/**
- * AuthProxy owns the post-login cross-entity orchestration (α2): after a
- * successful credential exchange it updates the context with the new session
- * token + user id, then asks UserProxy for the user record. The result is
- * fused into a single `LoginResult` so the Client can shape one response.
- *
- * `userProxy` is wired via `setUserProxy` after construction — AuthProxy and
- * UserProxy reference each other and cannot both be constructor-injected.
- */
+import type { ILoginDeviceCredentialsData, ILoginGoogleCredentialsData, ILoginUserCredentialsData } from "../../types";
+import { CookiesHelper } from "../../helper/storage/cookiesHelper";
 declare class AuthProxy {
-    private authService;
     private context;
+    private authService;
     private cookiesHelper;
-    private userProxy;
-    constructor(authService: AuthService, context: ClientContextProvider, cookiesHelper: CookiesHelper);
-    setUserProxy(userProxy: UserProxy): void;
-    /**
-     * Raw credential exchange with no user fetch. Used internally by the
-     * refresh flow (device-credential relogin under Option Y), where adding a
-     * user fetch would slow every retry for no consumer benefit.
-     */
-    login(data: string, config?: AxiosRequestConfig): Promise<AxiosResponse<import("../..").TokenData, any, {}>>;
-    /**
-     * Credential exchange fused with a post-login user fetch. Used by the
-     * Client's three initial-login entry points (user, device, google).
-     *
-     * On rare race (another login invalidates the just-minted token before
-     * getUser lands) userData is `null`; the next user-scoped call self-heals
-     * through the refresh interceptor.
-     */
-    loginAndFetchUser(data: string, config?: AxiosRequestConfig): Promise<LoginResult>;
-    generateLimitedToken(data: IGenerateLimitedTokenData, config?: AxiosRequestConfig): Promise<AxiosResponse<import("../..").NodeTokenData, any, {}>>;
+    constructor(context: ClientContextProvider, authService: AuthService, cookiesHelper: CookiesHelper);
+    private login;
+    loginUserCredentials(data: ILoginUserCredentialsData): Promise<import("axios").AxiosResponse<import("../..").TokenData, any, {}>>;
+    loginDeviceCredentials(data: ILoginDeviceCredentialsData): Promise<import("axios").AxiosResponse<import("../..").TokenData, any, {}>>;
+    loginGoogleCredentials(data: ILoginGoogleCredentialsData): Promise<import("axios").AxiosResponse<import("../..").TokenData, any, {}>>;
+    generateLimitedToken(data: IGenerateLimitedTokenData): Promise<import("axios").AxiosResponse<import("../..").NodeTokenData, any, {}>>;
 }
 export { AuthProxy };

package/dist/api/proxy/auth.js

@@ -1,65 +1,37 @@
 import { ResultHelper } from "../../helper/api/resultHelper";
-/**
- * AuthProxy owns the post-login cross-entity orchestration (α2): after a
- * successful credential exchange it updates the context with the new session
- * token + user id, then asks UserProxy for the user record. The result is
- * fused into a single `LoginResult` so the Client can shape one response.
- *
- * `userProxy` is wired via `setUserProxy` after construction — AuthProxy and
- * UserProxy reference each other and cannot both be constructor-injected.
- */
+import { fillLoginDeviceCredentialsData, fillLoginGoogleCredentialsData, fillLoginUserCredentialsData, } from "../data";
 class AuthProxy {
-    authService;
     context;
+    authService;
     cookiesHelper;
-    userProxy = null;
-    constructor(authService, context, cookiesHelper) {
-        this.authService = authService;
+    constructor(context, authService, cookiesHelper) {
         this.context = context;
+        this.authService = authService;
         this.cookiesHelper = cookiesHelper;
     }
-    setUserProxy(userProxy) {
-        this.userProxy = userProxy;
+    async login(data) {
+        const response = await this.authService.login(data);
+        if (ResultHelper.isApproved(response?.data?.result)) {
+            this.context.setToken(response.data.access_token);
+            this.context.setUserId(Number(response.data.user_id));
+            await this.cookiesHelper.setCredentialCookiesByTokenData(response.data);
+        }
+        return response;
     }
-    /**
-     * Raw credential exchange with no user fetch. Used internally by the
-     * refresh flow (device-credential relogin under Option Y), where adding a
-     * user fetch would slow every retry for no consumer benefit.
-     */
-    login(data, config) {
-        return this.authService.login(data, config);
+    loginUserCredentials(data) {
+        const credentials = fillLoginUserCredentialsData(this.context.getProgramId(), data);
+        return this.login(credentials);
     }
-    /**
-     * Credential exchange fused with a post-login user fetch. Used by the
-     * Client's three initial-login entry points (user, device, google).
-     *
-     * On rare race (another login invalidates the just-minted token before
-     * getUser lands) userData is `null`; the next user-scoped call self-heals
-     * through the refresh interceptor.
-     */
-    async loginAndFetchUser(data, config) {
-        const tokenResp = await this.authService.login(data, config);
-        if (!ResultHelper.isApproved(tokenResp.data.result)) {
-            return { tokenData: tokenResp, userData: null };
-        }
-        this.context.setToken(tokenResp.data.access_token);
-        this.context.setUserId(Number(tokenResp.data.user_id));
-        await this.cookiesHelper.setCredentialCookiesByTokenData(tokenResp.data);
-        let userData = null;
-        try {
-            if (!this.userProxy) {
-                throw new Error("AuthProxy.userProxy not wired");
-            }
-            const userResp = await this.userProxy.getUser();
-            userData = ResultHelper.isApproved(userResp.data.result) ? userResp : null;
-        }
-        catch {
-            userData = null;
-        }
-        return { tokenData: tokenResp, userData };
+    loginDeviceCredentials(data) {
+        const credentials = fillLoginDeviceCredentialsData(this.context.getProgramId(), data);
+        return this.login(credentials);
+    }
+    loginGoogleCredentials(data) {
+        const credentials = fillLoginGoogleCredentialsData(this.context.getProgramId(), data);
+        return this.login(credentials);
     }
-    generateLimitedToken(data, config) {
-        return this.authService.generateLimitedToken(data, config);
+    generateLimitedToken(data) {
+        return this.authService.generateLimitedToken(data);
     }
 }
 export { AuthProxy };

package/dist/api/proxy/base.d.ts

@@ -1,17 +1,6 @@
-import type { AxiosRequestConfig } from "axios";
-import type { ClientContextProvider } from "../../types/api/context/clientContext";
-/**
- * Common base for proxies that issue session-authenticated calls. The
- * proxy is the layer that reads `ClientContextProvider` to assemble
- * per-call axios config — Service is pure transport, the request
- * interceptor only handles body-property injection.
- *
- * Proxies that mint their own auth (LimitedProxy, UserProxy's createUser
- * path) build their config inline and do not call this helper.
- */
+import type { ErrorHandler } from "../../types";
 declare abstract class BaseProxy {
-    protected context: ClientContextProvider;
-    constructor(context: ClientContextProvider);
-    protected buildSessionConfig(showSensitive?: boolean): AxiosRequestConfig;
+    protected errorHandler: ErrorHandler;
+    constructor(errorHandler: ErrorHandler);
 }
 export { BaseProxy };

package/dist/api/proxy/base.js

@@ -1,32 +1,7 @@
-import { AxiosHeaders } from "axios";
-import { HeaderKeys } from "../../constant/constant";
-import { DateTimeHelper } from "../../helper/dateTimeHelper";
-import { generateSourceID } from "../../utils/data/generation";
-/**
- * Common base for proxies that issue session-authenticated calls. The
- * proxy is the layer that reads `ClientContextProvider` to assemble
- * per-call axios config — Service is pure transport, the request
- * interceptor only handles body-property injection.
- *
- * Proxies that mint their own auth (LimitedProxy, UserProxy's createUser
- * path) build their config inline and do not call this helper.
- */
 class BaseProxy {
-    context;
-    constructor(context) {
-        this.context = context;
-    }
-    buildSessionConfig(showSensitive) {
-        const headers = new AxiosHeaders();
-        headers.set(HeaderKeys.Authorization, `Bearer ${this.context.getToken()}`);
-        headers.set(HeaderKeys.SourceID, generateSourceID(this.context.getUserId()));
-        headers.set(HeaderKeys.TimeZone, DateTimeHelper.getClientTimeZone());
-        if (showSensitive) {
-            headers.set(HeaderKeys.ShowSensitiveData, "1");
-        }
-        return {
-            headers,
-        };
+    errorHandler;
+    constructor(errorHandler) {
+        this.errorHandler = errorHandler;
     }
 }
 export { BaseProxy };

package/dist/api/proxy/blockchain.d.ts

@@ -1,13 +1,12 @@
-import type { BlockchainService } from "../service/blockchain";
-import type { BlockchainData } from "../../types";
+import type { ErrorHandler, IBlockchainDelegateRequestData, IBlockchainMultiSendRequestData, IBlockchainSendRequestData, IBlockchainUndelegateRequestData } from "../../types";
 import type { ClientContextProvider } from "../../types/api/context/clientContext";
 import { BaseProxy } from "./base";
 declare class BlockchainProxy extends BaseProxy {
     private blockchainService;
-    constructor(context: ClientContextProvider, blockchainService: BlockchainService);
-    send(payload: BlockchainData): Promise<import("axios").AxiosResponse<BlockchainData, any, {}>>;
-    multiSend(payload: BlockchainData): Promise<import("axios").AxiosResponse<BlockchainData, any, {}>>;
-    delegate(payload: BlockchainData): Promise<import("axios").AxiosResponse<BlockchainData, any, {}>>;
-    undelegate(payload: BlockchainData): Promise<import("axios").AxiosResponse<BlockchainData, any, {}>>;
+    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    send: (data: IBlockchainSendRequestData) => Promise<import("axios").AxiosResponse<import("../..").BlockchainData, any, {}>>;
+    multiSend: (data: IBlockchainMultiSendRequestData) => Promise<import("axios").AxiosResponse<import("../..").BlockchainData, any, {}>>;
+    delegate: (data: IBlockchainDelegateRequestData) => Promise<import("axios").AxiosResponse<import("../..").BlockchainData, any, {}>>;
+    undelegate: (data: IBlockchainUndelegateRequestData) => Promise<import("axios").AxiosResponse<import("../..").BlockchainData, any, {}>>;
 }
 export { BlockchainProxy };

package/dist/api/proxy/blockchain.js

@@ -1,25 +1,24 @@
+import { fillBlockchainDelegateData, fillBlockchainMultiSendData, fillBlockchainSendData, fillBlockchainUndelegateData, } from "../data";
+import { BlockchainService } from "../service/blockchain";
 import { BaseProxy } from "./base";
 class BlockchainProxy extends BaseProxy {
     blockchainService;
-    constructor(context, blockchainService) {
-        super(context);
-        this.blockchainService = blockchainService;
-    }
-    async send(payload) {
-        const config = this.buildSessionConfig();
-        return this.blockchainService.send(payload, config);
-    }
-    async multiSend(payload) {
-        const config = this.buildSessionConfig();
-        return this.blockchainService.multiSend(payload, config);
-    }
-    async delegate(payload) {
-        const config = this.buildSessionConfig();
-        return this.blockchainService.delegate(payload, config);
-    }
-    async undelegate(payload) {
-        const config = this.buildSessionConfig();
-        return this.blockchainService.undelegate(payload, config);
+    constructor(context, errorHandler) {
+        super(errorHandler);
+        this.blockchainService = new BlockchainService({ context, errorHandler });
     }
+    // #region "POST"
+    send = async (data) => {
+        return this.blockchainService.send(fillBlockchainSendData(data));
+    };
+    multiSend = async (data) => {
+        return this.blockchainService.multiSend(fillBlockchainMultiSendData(data));
+    };
+    delegate = async (data) => {
+        return this.blockchainService.delegate(fillBlockchainDelegateData(data));
+    };
+    undelegate = async (data) => {
+        return this.blockchainService.undelegate(fillBlockchainUndelegateData(data));
+    };
 }
 export { BlockchainProxy };

package/dist/api/proxy/ipAddressAndLocation.d.ts

@@ -1,9 +1,14 @@
-import type { IPAddressAndLocationService } from "../service/ipAddressAndLocation";
+import type { ErrorHandler } from "../../types";
 import type { ClientContextProvider } from "../../types/api/context/clientContext";
 import { BaseProxy } from "./base";
 declare class IPAddressAndLocationProxy extends BaseProxy {
     private ipAddressAndLocationService;
-    constructor(context: ClientContextProvider, ipAddressAndLocationService: IPAddressAndLocationService);
-    getIPAddressAndLocation(): Promise<import("axios").AxiosResponse<string, any, {}>>;
+    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    getGeoCoordinates: () => Promise<import("../..").GeoCoordinates>;
+    getIPAddress: () => Promise<string>;
+    getGeoCoordinatesAndIPAddress: () => Promise<{
+        geo_coordinates: import("../..").GeoCoordinates;
+        ip_address: string;
+    }>;
 }
 export { IPAddressAndLocationProxy };

package/dist/api/proxy/ipAddressAndLocation.js

@@ -1,13 +1,27 @@
+import { GeoHelper } from "../../helper/geoHelper";
+import { IPAddressAndLocationService } from "../service/ipAddressAndLocation";
 import { BaseProxy } from "./base";
 class IPAddressAndLocationProxy extends BaseProxy {
     ipAddressAndLocationService;
-    constructor(context, ipAddressAndLocationService) {
-        super(context);
-        this.ipAddressAndLocationService = ipAddressAndLocationService;
-    }
-    async getIPAddressAndLocation() {
-        const config = this.buildSessionConfig();
-        return this.ipAddressAndLocationService.getIPAddressAndLocation(config);
+    constructor(context, errorHandler) {
+        super(errorHandler);
+        this.ipAddressAndLocationService = new IPAddressAndLocationService({ context, errorHandler });
     }
+    // #region "GET"
+    getGeoCoordinates = () => {
+        return GeoHelper.getGeoCoordinates({
+            getIPAddressAndLocation: () => this.ipAddressAndLocationService.getIPAddressAndLocation(),
+        });
+    };
+    getIPAddress = () => {
+        return GeoHelper.getIPAddress({
+            getIPAddressAndLocation: () => this.ipAddressAndLocationService.getIPAddressAndLocation(),
+        });
+    };
+    getGeoCoordinatesAndIPAddress = () => {
+        return GeoHelper.getGeoCoordinatesAndIPAddress({
+            getIPAddressAndLocation: () => this.ipAddressAndLocationService.getIPAddressAndLocation(),
+        });
+    };
 }
 export { IPAddressAndLocationProxy };

package/dist/api/proxy/limited.d.ts

@@ -1,25 +1,17 @@
-import type { LimitedService } from "../service/limited";
-import type { AuthProxy } from "./auth";
+import type { IConfirmEmailData, IConfirmPhoneData, IValidateEmailData, IValidatePhoneData, IVerifyEmailData, IVerifyPhoneData, IValidateForgetPasswordData, IConfirmForgetPasswordData, ErrorHandler, ICheckForgetPasswordData } from "../../types";
 import type { ClientContextProvider } from "../../types/api/context/clientContext";
-import type { ConfirmUserSecurity, ForgetSecurityData, ValidateLimitedSecurity, VerifyUserSecurity } from "../../types";
-/**
- * LimitedProxy mints a fresh limited token via AuthProxy and sets it as
- * `Authorization` directly on each call. BaseService's request interceptor
- * treats a pre-set `Authorization` header as "caller owns auth," so it
- * skips the session-token injection and the refresh gate — limited calls
- * are orthogonal to the session lifecycle.
- */
-declare class LimitedProxy {
+import { BaseProxy } from "./base";
+declare class LimitedProxy extends BaseProxy {
     private limitedService;
-    private authProxy;
-    private context;
-    constructor(limitedService: LimitedService, authProxy: AuthProxy, context: ClientContextProvider);
-    private buildLimitedAuthConfig;
-    validateSecurityData(data: ValidateLimitedSecurity): Promise<import("axios").AxiosResponse<ValidateLimitedSecurity, any, {}>>;
-    verifySecurityData(data: VerifyUserSecurity): Promise<import("axios").AxiosResponse<VerifyUserSecurity, any, {}>>;
-    confirmSecurityData(data: ConfirmUserSecurity): Promise<import("axios").AxiosResponse<ConfirmUserSecurity, any, {}>>;
-    checkForgetSecurityData(data: ForgetSecurityData): Promise<import("axios").AxiosResponse<ForgetSecurityData, any, {}>>;
-    validateForgetSecurityData(data: ForgetSecurityData): Promise<import("axios").AxiosResponse<ForgetSecurityData, any, {}>>;
-    confirmForgetSecurityData(data: ForgetSecurityData): Promise<import("axios").AxiosResponse<ForgetSecurityData, any, {}>>;
+    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    checkForgetPassword: (data: ICheckForgetPasswordData) => Promise<import("axios").AxiosResponse<import("../..").ForgetSecurityData, any, {}>>;
+    validateForgetPassword: (data: IValidateForgetPasswordData) => Promise<import("axios").AxiosResponse<import("../..").ForgetSecurityData, any, {}>>;
+    confirmForgetPassword: (data: IConfirmForgetPasswordData) => Promise<import("axios").AxiosResponse<import("../..").ForgetSecurityData, any, {}>>;
+    validateEmail: (data: IValidateEmailData) => Promise<import("axios").AxiosResponse<import("../..").ValidateLimitedSecurity, any, {}>>;
+    validatePhone: (data: IValidatePhoneData) => Promise<import("axios").AxiosResponse<import("../..").ValidateLimitedSecurity, any, {}>>;
+    verifyEmail: (data: IVerifyEmailData) => Promise<import("axios").AxiosResponse<import("../..").VerifyUserSecurity, any, {}>>;
+    verifyPhone: (data: IVerifyPhoneData) => Promise<import("axios").AxiosResponse<import("../..").VerifyUserSecurity, any, {}>>;
+    confirmEmail: (data: IConfirmEmailData) => Promise<import("axios").AxiosResponse<import("../..").ConfirmUserSecurity, any, {}>>;
+    confirmPhone: (data: IConfirmPhoneData) => Promise<import("axios").AxiosResponse<import("../..").ConfirmUserSecurity, any, {}>>;
 }
 export { LimitedProxy };