@grabjs/superapp-sdk 1.8.10 → 2.0.0-beta.12

package/dist/index.d.ts

@@ -0,0 +1,3494 @@
+import { DataStream as DataStream_2 } from '@grabjs/mobile-kit-bridge-sdk';
+
+/**
+ * Request parameters for initiating an OAuth2 authorization flow with PKCE.
+ *
+ * @public
+ */
+export declare type AuthorizeRequest = {
+    /** The OAuth2 client ID for your MiniApp. */
+    clientId: string;
+    /** The redirect URI registered for your MiniApp. */
+    redirectUri: string;
+    /** The OAuth2 scopes to request (space-separated string). */
+    scope: string;
+    /** The environment to use for authorization ('staging' or 'production'). */
+    environment: 'staging' | 'production';
+    /**
+     * The response mode for the authorization flow.
+     * - 'redirect': User is redirected to the redirect URI after authorization
+     * - 'in_place': Authorization happens within the current page context
+     * @defaultValue 'redirect'
+     */
+    responseMode?: 'redirect' | 'in_place';
+};
+
+/**
+ * Response when initiating an authorization flow.
+ *
+ * @public
+ */
+export declare type AuthorizeResponse = ConstrainedBridgeResponse<AuthorizeResult, 200 | 302 | 204 | 400>;
+
+/**
+ * Result object for the authorization flow.
+ * Contains the authorization code and state when native in_place flow completes successfully.
+ *
+ * @public
+ */
+export declare type AuthorizeResult = {
+    /** The authorization code returned from the server. */
+    code: string;
+    /** The state parameter returned from the server for CSRF protection. */
+    state: string;
+};
+
+/**
+ * Base class for all JSBridge modules.
+ *
+ * @remarks
+ * On construction, the class wraps the JSBridge module on `window` (e.g., `WrappedContainerModule`).
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @public
+ */
+export declare class BaseModule {
+    /**
+     * The module name used to identify the JSBridge module.
+     */
+    private readonly name;
+    /**
+     * Returns the wrapped JSBridge module from the global `window` object.
+     *
+     * @returns The wrapped module instance with native method bindings.
+     *
+     * @internal
+     */
+    protected get wrappedModule(): WrappedModule;
+    /**
+     * Creates a new module instance and wraps it on the global `window` object.
+     *
+     * @param moduleName - The name of the module (e.g., "ContainerModule", "ProfileModule").
+     * @throws Error when the bridge SDK fails to wrap the module.
+     */
+    constructor(moduleName: string);
+}
+
+/**
+ * Union type representing all client error JSBridge responses (4xx status codes).
+ * Includes: 400 (Bad Request), 403 (Forbidden), 404 (Not Found), and 424 (Failed Dependency).
+ *
+ * @public
+ */
+export declare type BridgeClientErrorResponse = BridgeStatusCode400Response | BridgeStatusCode403Response | BridgeStatusCode404Response | BridgeStatusCode424Response;
+
+/**
+ * Union type representing all error JSBridge responses (4xx and 5xx status codes).
+ * Combines both client errors and server errors.
+ *
+ * @public
+ */
+export declare type BridgeErrorResponse = BridgeClientErrorResponse | BridgeServerErrorResponse;
+
+/**
+ * Union type representing redirect JSBridge responses.
+ * Currently only includes status code 302.
+ *
+ * @public
+ */
+export declare type BridgeRedirectResponse = BridgeStatusCode302Response;
+
+/**
+ * Universal response format for all JSBridge methods.
+ *
+ * @remarks
+ * All JSBridge method calls resolve to this type. After destructuring,
+ * use type guards (e.g., if (error), if (status_code === 200)) to narrow the type.
+ *
+ * @public
+ */
+export declare type BridgeResponse<T> = BridgeSuccessResponse<T> | BridgeRedirectResponse | BridgeClientErrorResponse | BridgeServerErrorResponse;
+
+/**
+ * Union type representing server error JSBridge responses (5xx status codes).
+ * Currently only includes status code 500 (Internal Server Error).
+ *
+ * @public
+ */
+export declare type BridgeServerErrorResponse = BridgeStatusCode500Response;
+
+/**
+ * Success response from the bridge SDK.
+ *
+ * @remarks
+ * Returned when a JSBridge method completes successfully.
+ * The `result` field contains the JSBridge method's data.
+ *
+ * @public
+ */
+export declare type BridgeStatusCode200Response<T> = {
+    /** HTTP-style status code indicating the outcome of the JSBridge method call */
+    status_code: 200;
+    /** The result data from the JSBridge method, or undefined if no result was returned */
+    result: T;
+};
+
+/**
+ * No result response with status code 204.
+ *
+ * @remarks
+ * Returned when a JSBridge method completes with no content (e.g., user cancelled a dialog).
+ * No `result` or `error` data is returned.
+ *
+ * @public
+ */
+export declare type BridgeStatusCode204Response = {
+    /** HTTP-style status code indicating the outcome of the JSBridge method call */
+    status_code: 204;
+};
+
+/**
+ * Redirect response with status code 302.
+ *
+ * @remarks
+ * Returned when a JSBridge method initiates a redirect (e.g., OAuth2 redirect flow).
+ * No `result` or `error` data is returned as the page will navigate away.
+ *
+ * @public
+ */
+export declare type BridgeStatusCode302Response = {
+    /** HTTP-style status code indicating the outcome of the JSBridge method call */
+    status_code: 302;
+};
+
+/**
+ * Error response with status code 400
+ *
+ * @public
+ */
+export declare type BridgeStatusCode400Response = {
+    /** HTTP-style status code indicating the outcome of the JSBridge method call */
+    status_code: 400;
+    /** Error message if the call failed */
+    error: string;
+};
+
+/**
+ * Error response with status code 403
+ *
+ * @public
+ */
+export declare type BridgeStatusCode403Response = {
+    /** HTTP-style status code indicating the outcome of the JSBridge method call */
+    status_code: 403;
+    /** Error message if the call failed */
+    error: string;
+};
+
+/**
+ * Error response with status code 404
+ *
+ * @public
+ */
+export declare type BridgeStatusCode404Response = {
+    /** HTTP-style status code indicating the outcome of the JSBridge method call */
+    status_code: 404;
+    /** Error message if the call failed */
+    error: string;
+};
+
+/**
+ * Error response with status code 424
+ *
+ * @public
+ */
+export declare type BridgeStatusCode424Response = {
+    /** HTTP-style status code indicating the outcome of the JSBridge method call */
+    status_code: 424;
+    /** Error message if the call failed */
+    error: string;
+};
+
+/**
+ * Error response with status code 500
+ *
+ * @public
+ */
+export declare type BridgeStatusCode500Response = {
+    /** HTTP-style status code indicating the outcome of the JSBridge method call */
+    status_code: 500;
+    /** Error message if the call failed */
+    error: string;
+};
+
+/**
+ * Union type representing all successful JSBridge responses.
+ * Includes status codes 200 (with result data) and 204 (no content).
+ *
+ * @public
+ */
+export declare type BridgeSuccessResponse<T> = BridgeStatusCode200Response<T> | BridgeStatusCode204Response;
+
+/**
+ * JSBridge module for accessing the device camera.
+ *
+ * @group Modules
+ *
+ * @remarks
+ * Provides access to native camera functionality including QR code scanning.
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @example
+ * **ES Module:**
+ * ```typescript
+ * import { CameraModule } from '@grabjs/superapp-sdk';
+ * const cameraModule = new CameraModule();
+ * ```
+ *
+ * @example
+ * **CDN (UMD):**
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/@grabjs/superapp-sdk/dist/index.js"></script>
+ * <script>
+ *   const cameraModule = new SuperAppSDK.CameraModule();
+ * </script>
+ * ```
+ *
+ * @public
+ */
+export declare class CameraModule extends BaseModule {
+    constructor();
+    /**
+     * Opens the native camera to scan a QR code.
+     *
+     * @param request - Configuration for the QR code scan.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Successfully scanned QR code
+     * - `204`: User cancelled the QR code scanning
+     * - `400`: Bad request
+     * - `403`: Camera permission is not enabled for the Grab app
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { CameraModule, isResponseOk, isResponseNoContent, isResponseError, isResponseForbidden, isResponseClientError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { CameraModule, isResponseOk, isResponseNoContent, isResponseError, isResponseForbidden, isResponseClientError } = window.SuperAppSDK;
+     *
+     * // Initialize the camera module
+     * const cameraModule = new CameraModule();
+     *
+     * // Scan the QR code
+     * try {
+     *   const response = await cameraModule.scanQRCode({ title: 'Scan Payment QR' });
+     *   if (isResponseError(response)) {
+     *     if (isResponseForbidden(response)) {
+     *       console.log('User has not granted camera permission for the Grab app');
+     *     } else if (isResponseClientError(response)) {
+     *       console.log('Client error:', response.status_code, response.error);
+     *     }
+     *   } else {
+     *     if (isResponseOk(response)) {
+     *       console.log('QR Code scanned:', response.result.qrCode);
+     *     } else if (isResponseNoContent(response)) {
+     *       console.log('User cancelled QR code scanning');
+     *     }
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     * @public
+     */
+    scanQRCode(request: ScanQRCodeRequest): Promise<ScanQRCodeResponse>;
+}
+
+/**
+ * JSBridge module for triggering native payment flows.
+ *
+ * @group Modules
+ *
+ * @remarks
+ * Invokes the native Grab checkout/pay component to process payments.
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @example
+ * **ES Module:**
+ * ```typescript
+ * import { CheckoutModule } from '@grabjs/superapp-sdk';
+ * const checkoutModule = new CheckoutModule();
+ * ```
+ *
+ * @example
+ * **CDN (UMD):**
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/@grabjs/superapp-sdk/dist/index.js"></script>
+ * <script>
+ *   const checkoutModule = new SuperAppSDK.CheckoutModule();
+ * </script>
+ * ```
+ *
+ * @public
+ */
+export declare class CheckoutModule extends BaseModule {
+    constructor();
+    /**
+     * Triggers the native checkout flow for payment processing.
+     *
+     * @param request - The checkout configuration.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Checkout completed
+     * - `400`: Bad request
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { CheckoutModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { CheckoutModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the checkout module
+     * const checkoutModule = new CheckoutModule();
+     *
+     * // Trigger checkout with response params
+     * try {
+     *   const transactionResponse = await createTransaction(); // Call POST /grabpay/partner/v4/charge/init from Grab API to create a transaction
+     *   const response = await checkoutModule.triggerCheckout(transactionResponse);
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Transaction failed:', response.status_code, response.error);
+     *   } else {
+     *     if (isResponseOk(response)) {
+     *       if (response.result.status === 'success') {
+     *         console.log('Transaction successful:', response.result.transactionID);
+     *       } else if (response.result.status === 'failure') {
+     *         console.log('Transaction failed:', response.result.errorMessage, response.result.errorCode);
+     *       } else if (response.result.status === 'pending') {
+     *         console.log('Transaction pending:', response.result.transactionID);
+     *       } else if (response.result.status === 'userInitiatedCancel') {
+     *         console.log('User cancelled the checkout');
+     *       }
+     *     }
+     *   }
+     * } catch (error) {
+     *   console.log('Could not trigger checkout:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    triggerCheckout(request: TriggerCheckoutRequest): Promise<TriggerCheckoutResponse>;
+}
+
+/**
+ * Response when clearing stored authorization artifacts.
+ *
+ * @public
+ */
+export declare type ClearAuthorizationArtifactsResponse = ConstrainedBridgeResponse<ClearAuthorizationArtifactsResult, 204>;
+
+/**
+ * Result object for clearing authorization artifacts.
+ * This operation returns no data on success.
+ *
+ * @public
+ */
+export declare type ClearAuthorizationArtifactsResult = void;
+
+/**
+ * Response when closing the container.
+ *
+ * @public
+ */
+export declare type CloseResponse = ConstrainedBridgeResponse<CloseResult, 200>;
+
+/**
+ * Result when closing the container.
+ *
+ * @public
+ */
+export declare type CloseResult = void;
+
+/**
+ * Create a constrained JSBridge response type with only specific status codes.
+ *
+ * @example
+ * ```typescript
+ * // Only status code 200
+ * type OnlySuccess = ConstrainedBridgeResponse<string, 200>;
+ *
+ * // Only status codes 200 and 500
+ * type SuccessOrServerError = ConstrainedBridgeResponse<string, 200 | 500>;
+ *
+ * // Only error status codes
+ * type OnlyErrors = ConstrainedBridgeResponse<string, 400 | 403 | 424 | 500>;
+ * ```
+ *
+ * @public
+ */
+export declare type ConstrainedBridgeResponse<T, Codes extends keyof StatusCodeMap<T>> = StatusCodeMap<T>[Codes];
+
+/**
+ * Constants for container analytics event data.
+ *
+ * @public
+ */
+export declare const ContainerAnalyticsEventData: {
+    TRANSACTION_AMOUNT: string;
+    TRANSACTION_CURRENCY: string;
+    PAGE: string;
+};
+
+/**
+ * Constants for container analytics event names.
+ *
+ * @public
+ */
+export declare const ContainerAnalyticsEventName: {
+    DEFAULT: string;
+};
+
+/**
+ * Constants for container analytics event states.
+ *
+ * @public
+ */
+export declare const ContainerAnalyticsEventState: {
+    HOMEPAGE: string;
+    CHECKOUT_PAGE: string;
+    BOOKING_COMPLETION: string;
+    CUSTOM: string;
+};
+
+/**
+ * JSBridge module for controlling the webview container.
+ *
+ * @group Modules
+ *
+ * @remarks
+ * Provides methods to interact with the webview container.
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @example
+ * **ES Module:**
+ * ```typescript
+ * import { ContainerModule } from '@grabjs/superapp-sdk';
+ * const containerModule = new ContainerModule();
+ * ```
+ *
+ * @example
+ * **CDN (UMD):**
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/@grabjs/superapp-sdk/dist/index.js"></script>
+ * <script>
+ *   const containerModule = new SuperAppSDK.ContainerModule();
+ * </script>
+ * ```
+ *
+ * @public
+ */
+export declare class ContainerModule extends BaseModule {
+    constructor();
+    /**
+     * Set the background color of the container header.
+     *
+     * @param request - The background color configuration.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Background color set successfully
+     * - `400`: Invalid background color
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Set background color
+     * try {
+     *   const response = await containerModule.setBackgroundColor('#ffffff');
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not set background color:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Background color set successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    setBackgroundColor(request: SetBackgroundColorRequest): Promise<SetBackgroundColorResponse>;
+    /**
+     * Set the title of the container header.
+     *
+     * @param request - The title configuration.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Title set successfully
+     * - `400`: Invalid title parameter
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Set title
+     * try {
+     *   const response = await containerModule.setTitle('Home');
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not set title:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Title set successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    setTitle(request: SetTitleRequest): Promise<SetTitleResponse>;
+    /**
+     * Hide the back button on the container header.
+     *
+     * @returns A promise that resolves to a `200` status code when the back button is hidden.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Hide back button
+     * try {
+     *   const response = await containerModule.hideBackButton();
+     *
+     *   if (isResponseOk(response)) {
+     *     console.log('Back button hidden successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    hideBackButton(): Promise<HideBackButtonResponse>;
+    /**
+     * Show the back button on the container header.
+     *
+     * @returns A promise that resolves to a `200` status code when the back button is shown.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Show back button
+     * try {
+     *   const response = await containerModule.showBackButton();
+     *
+     *   if (isResponseOk(response)) {
+     *     console.log('Back button shown successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    showBackButton(): Promise<ShowBackButtonResponse>;
+    /**
+     * Hide the refresh button on the container header.
+     *
+     * @returns A promise that resolves to a `200` status code when the refresh button is hidden.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Hide refresh button
+     * try {
+     *   const response = await containerModule.hideRefreshButton();
+     *
+     *   if (isResponseOk(response)) {
+     *     console.log('Refresh button hidden successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    hideRefreshButton(): Promise<HideRefreshButtonResponse>;
+    /**
+     * Show the refresh button on the container header.
+     *
+     * @returns A promise that resolves to a `200` status code when the refresh button is shown.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Show refresh button
+     * try {
+     *   const response = await containerModule.showRefreshButton();
+     *
+     *   if (isResponseOk(response)) {
+     *     console.log('Refresh button shown successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    showRefreshButton(): Promise<ShowRefreshButtonResponse>;
+    /**
+     * Close the container and return to the previous screen.
+     *
+     * @returns A promise that resolves to a `200` status code when the container closes.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Close the container
+     * try {
+     *   const response = await containerModule.close();
+     *
+     *   if (isResponseOk(response)) {
+     *     console.log('Container closed successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    close(): Promise<CloseResponse>;
+    /**
+     * Notify the Grab SuperApp that the page content has loaded.
+     *
+     * @returns A promise that resolves to a `200` status code when the notification is sent.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Notify content loaded
+     * try {
+     *   const response = await containerModule.onContentLoaded();
+     *
+     *   if (isResponseOk(response)) {
+     *     console.log('Content loaded notification sent successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    onContentLoaded(): Promise<OnContentLoadedResponse>;
+    /**
+     * Show the full-screen loading indicator.
+     *
+     * @remarks
+     * Remember to call {@link ContainerModule.hideLoader} when the operation completes.
+     *
+     * @returns A promise that resolves to a `200` status code when the loading indicator is displayed.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Show loader
+     * try {
+     *   const response = await containerModule.showLoader();
+     *
+     *   if (isResponseOk(response)) {
+     *     console.log('Loader shown successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    showLoader(): Promise<ShowLoaderResponse>;
+    /**
+     * Hide the full-screen loading indicator.
+     *
+     * @remarks
+     * Should be called when the entry point has finished loading.
+     *
+     * @returns A promise that resolves to a `200` status code when the loading indicator is hidden.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Hide loader
+     * try {
+     *   const response = await containerModule.hideLoader();
+     *
+     *   if (isResponseOk(response)) {
+     *     console.log('Loader hidden successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    hideLoader(): Promise<HideLoaderResponse>;
+    /**
+     * Open a link in the external browser.
+     *
+     * @remarks
+     * Call this method to open the specified URL in an external browser (outside of the Grab app).
+     *
+     * @param request - The URL configuration.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: External link opened successfully
+     * - `400`: URL parameter not found
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Open external link
+     * try {
+     *   const response = await containerModule.openExternalLink('https://grab.com');
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not open external link:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('External link opened successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    openExternalLink(request: OpenExternalLinkRequest): Promise<OpenExternalLinkResponse>;
+    /**
+     * Notify the client that the user has tapped a call-to-action (CTA).
+     *
+     * @param request - The CTA action configuration.
+     *
+     * @returns A promise that resolves to a `200` response when the CTA tap notification is sent.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Notify CTA tap
+     * try {
+     *   const response = await containerModule.onCtaTap('AV_LANDING_PAGE_CONTINUE');
+     *
+     *   if (isResponseOk(response)) {
+     *     console.log('CTA tap notified successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    onCtaTap(request: OnCtaTapRequest): Promise<OnCtaTapResponse>;
+    /**
+     * Use this method to track user interactions and page transitions.
+     *
+     * @remarks
+     * You can use predefined constants to ensure consistency across the platform.
+     *
+     * **Predefined Values:**
+     * - **States:** {@link ContainerAnalyticsEventState}
+     * - **Names:** {@link ContainerAnalyticsEventName}
+     * - **Data Keys:** {@link ContainerAnalyticsEventData}
+     *
+     *   @param request - The analytics event configuration.
+     *
+     * @returns A promise that resolves to a `200` response when the analytics event is sent.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @see {@link ContainerAnalyticsEventState}, {@link ContainerAnalyticsEventName}, {@link ContainerAnalyticsEventData}
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import {
+     *   ContainerModule,
+     *   ContainerAnalyticsEventState,
+     *   ContainerAnalyticsEventName,
+     *   isResponseOk
+     * } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const {
+     *   ContainerModule,
+     *   ContainerAnalyticsEventState,
+     *   ContainerAnalyticsEventName,
+     *   isResponseOk
+     * } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Send analytics event
+     * try {
+     *   const response = await containerModule.sendAnalyticsEvent({
+     *     state: ContainerAnalyticsEventState.HOMEPAGE,
+     *     name: ContainerAnalyticsEventName.DEFAULT,
+     *   });
+     *
+     *   if (isResponseOk(response)) {
+     *     console.log('Analytics event sent successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    sendAnalyticsEvent(request: SendAnalyticsEventRequest): Promise<SendAnalyticsEventResponse>;
+    /**
+     * Check if the web app is connected to the Grab SuperApp via JSBridge.
+     *
+     * @remarks
+     * Call this method to verify the connection status before using other features.
+     *
+     *   @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Connected to Grab SuperApp
+     * - `404`: Not connected to Grab SuperApp
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Check connection status
+     * try {
+     *   const response = await containerModule.isConnected();
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Not connected to Grab SuperApp');
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Connected to Grab SuperApp');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    isConnected(): Promise<IsConnectedResponse>;
+    /**
+     * Get the session parameters from the container.
+     *
+     * @remarks
+     * The native layer returns session parameters as a JSON string.
+     * Parse with `JSON.parse(result.result)` to use as an object.
+     * Session parameters can contain primitives, base64 encoded strings, or nested objects.
+     *
+     * @returns A promise that resolves to a `200` status code with session parameters.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ContainerModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ContainerModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the container module
+     * const containerModule = new ContainerModule();
+     *
+     * // Get session parameters
+     * try {
+     *   const response = await containerModule.getSessionParams();
+     *
+     *   if (isResponseOk(response)) {
+     *     const sessionParams = JSON.parse(response.result?.result || '{}');
+     *     console.log('Session params retrieved:', sessionParams);
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    getSessionParams(): Promise<GetSessionParamsResponse>;
+    /**
+     * Validate the analytics event details.
+     *
+     * @param request - Analytics event details to be validated.
+     * @returns Error message if invalid, `null` if valid.
+     * @internal
+     */
+    private validateAnalyticsEvent;
+}
+
+/**
+ * A stream for receiving continuous data from JSBridge methods (e.g., location updates).
+ *
+ * @remarks
+ * Provides both Observable-like and Promise-like interfaces:
+ * - Use `subscribe()` to receive all values over time
+ * - Use `then()` or `await` to receive only the first value
+ *
+ * Note: Each `subscribe()` call creates a fresh subscription, allowing multiple independent listeners.
+ *
+ * @typeParam T - The type of data emitted by the stream.
+ *
+ * @public
+ */
+export declare type DataStream<T> = Readonly<{
+    /**
+     * Subscribe to receive stream data.
+     * @param handlers - Optional callbacks for data (`next`) and completion (`complete`).
+     * @returns A `Subscription` to terminate the stream when needed.
+     */
+    subscribe: (handlers?: DataStreamHandlers<T>) => Subscription;
+}> & PromiseLike<BridgeResponse<T>>;
+
+/**
+ * Callbacks for handling stream events.
+ *
+ * @remarks
+ * Pass these to `subscribe()` to receive data via `next` and completion via `complete`.
+ *
+ * @typeParam T - The type of data emitted by the stream.
+ *
+ * @public
+ */
+export declare type DataStreamHandlers<T> = Readonly<{
+    /** Called with each new value from the stream. */
+    next?: (data: BridgeResponse<T>) => unknown;
+    /** Called when the stream ends and no more data will arrive. */
+    complete?: () => unknown;
+}>;
+
+/**
+ * DRM content configuration for playback.
+ *
+ * @remarks
+ * Configuration object containing DRM license information, content URLs, and playback settings.
+ * The exact structure depends on the DRM provider (e.g., FairPlay, Widevine).
+ *
+ * @public
+ */
+export declare type DRMContentConfig = Record<string, unknown>;
+
+/**
+ * Result object for DRM playback events.
+ *
+ * @public
+ */
+export declare type DRMPlaybackEvent = {
+    /** The type of playback event (e.g., 'started', 'paused', 'ended', 'error'). */
+    eventType: string;
+    /** Additional event data as key-value pairs. */
+    data?: Record<string, unknown>;
+};
+
+/**
+ * Response when fetching the user's email.
+ *
+ * @public
+ */
+export declare type FetchEmailResponse = ConstrainedBridgeResponse<FetchEmailResult, 200 | 400 | 403>;
+
+/**
+ * Result object containing the user's email address.
+ *
+ * @public
+ */
+export declare type FetchEmailResult = {
+    /** The user's email address. */
+    email: string;
+};
+
+/**
+ * Response when retrieving stored authorization artifacts.
+ *
+ * @public
+ */
+export declare type GetAuthorizationArtifactsResponse = ConstrainedBridgeResponse<GetAuthorizationArtifactsResult, 200 | 204 | 400>;
+
+/**
+ * Result object containing the stored PKCE authorization artifacts.
+ * These are used to complete the OAuth2 authorization code exchange.
+ *
+ * @public
+ */
+export declare type GetAuthorizationArtifactsResult = {
+    /** The state parameter used in the authorization request. */
+    state: string;
+    /** The code verifier for PKCE. */
+    codeVerifier: string;
+    /** The nonce used in the authorization request. */
+    nonce: string;
+    /** The redirect URI used in the authorization request. */
+    redirectUri: string;
+} | null;
+
+/**
+ * Request parameters for getting a boolean value from storage.
+ *
+ * @public
+ */
+export declare type GetBooleanRequest = {
+    /** The key to retrieve the value for. */
+    key: string;
+};
+
+/**
+ * Response when getting a boolean value.
+ *
+ * @public
+ */
+export declare type GetBooleanResponse = ConstrainedBridgeResponse<boolean | null, 200 | 400>;
+
+/**
+ * Result object containing the boolean value.
+ *
+ * @public
+ */
+export declare type GetBooleanResult = {
+    /** The stored boolean value, or null if not found. */
+    value: boolean | null;
+};
+
+/**
+ * Response when getting the device coordinates.
+ *
+ * @public
+ */
+export declare type GetCoordinateResponse = ConstrainedBridgeResponse<GetCoordinateResult, 200 | 424>;
+
+/**
+ * Result object containing the geographic coordinates.
+ *
+ * @public
+ */
+export declare type GetCoordinateResult = {
+    /** Latitude in degrees */
+    lat: number;
+    /** Longitude in degrees */
+    lng: number;
+};
+
+/**
+ * Response when getting the country code.
+ *
+ * @public
+ */
+export declare type GetCountryCodeResponse = ConstrainedBridgeResponse<GetCountryCodeResult, 200 | 424>;
+
+/**
+ * Result object containing the country code.
+ *
+ * @public
+ */
+export declare type GetCountryCodeResult = {
+    /** ISO country code (e.g., "SG", "ID", "MY") */
+    countryCode: string;
+};
+
+/**
+ * Request parameters for getting a double value from storage.
+ *
+ * @public
+ */
+export declare type GetDoubleRequest = {
+    /** The key to retrieve the value for. */
+    key: string;
+};
+
+/**
+ * Response when getting a double value.
+ *
+ * @public
+ */
+export declare type GetDoubleResponse = ConstrainedBridgeResponse<number | null, 200 | 400>;
+
+/**
+ * Result object containing the double value.
+ *
+ * @public
+ */
+export declare type GetDoubleResult = {
+    /** The stored double value, or null if not found. */
+    value: number | null;
+};
+
+/**
+ * Request parameters for getting an integer value from storage.
+ *
+ * @public
+ */
+export declare type GetIntRequest = {
+    /** The key to retrieve the value for. */
+    key: string;
+};
+
+/**
+ * Response when getting an integer value.
+ *
+ * @public
+ */
+export declare type GetIntResponse = ConstrainedBridgeResponse<number | null, 200 | 400>;
+
+/**
+ * Result object containing the integer value.
+ *
+ * @public
+ */
+export declare type GetIntResult = {
+    /** The stored integer value, or null if not found. */
+    value: number | null;
+};
+
+/**
+ * Response when getting the language locale identifier from the device.
+ *
+ * @remarks
+ * The locale identifier is the language and region code of the device's language settings.
+ * Examples:
+ * - "en" (English),
+ * - "id" (Indonesia),
+ * - "zh" (Chinese),
+ * - "ms" (Malaysia),
+ * - "th" (Thai),
+ * - "vi" (Vietnamese),
+ * - "zg" (Burmese Zawgyi),
+ * - "my" (Burmese Unicode),
+ * - "km" (Khmer)
+ *
+ * @public
+ */
+export declare type GetLanguageLocaleIdentifierResponse = ConstrainedBridgeResponse<string, 200>;
+
+/**
+ * Response when getting session parameters.
+ *
+ * @public
+ */
+export declare type GetSessionParamsResponse = ConstrainedBridgeResponse<GetSessionParamsResult, 200>;
+
+/**
+ * Result object containing session parameters as a JSON string.
+ *
+ * @remarks
+ * The `result` field contains a JSON string that must be parsed with `JSON.parse()` to use as an object.
+ * Session parameters can contain primitives, base64 encoded strings, or nested objects depending on the
+ * SuperApp's configuration.
+ *
+ * @public
+ */
+export declare type GetSessionParamsResult = {
+    /** JSON string containing session parameters. */
+    result: string;
+};
+
+/**
+ * Request parameters for getting a string value from storage.
+ *
+ * @public
+ */
+export declare type GetStringRequest = {
+    /** The key to retrieve the value for. */
+    key: string;
+};
+
+/**
+ * Response when getting a string value.
+ *
+ * @public
+ */
+export declare type GetStringResponse = ConstrainedBridgeResponse<string | null, 200 | 400>;
+
+/**
+ * Result object containing the string value.
+ *
+ * @public
+ */
+export declare type GetStringResult = {
+    /** The stored string value, or null if not found. */
+    value: string | null;
+};
+
+/**
+ * Response when checking API access permissions.
+ *
+ * @public
+ */
+export declare type HasAccessToResponse = ConstrainedBridgeResponse<HasAccessToResult, 200 | 400 | 424>;
+
+/**
+ * Result object containing the access check result.
+ *
+ * @public
+ */
+export declare type HasAccessToResult = {
+    /** True if the current client has access to the specified API, false otherwise. */
+    hasAccess: boolean;
+};
+
+/**
+ * Response when hiding the back button.
+ *
+ * @public
+ */
+export declare type HideBackButtonResponse = ConstrainedBridgeResponse<HideBackButtonResult, 200>;
+
+/**
+ * Result when hiding the back button.
+ *
+ * @public
+ */
+export declare type HideBackButtonResult = void;
+
+/**
+ * Response when hiding the loader.
+ *
+ * @public
+ */
+export declare type HideLoaderResponse = ConstrainedBridgeResponse<HideLoaderResult, 200>;
+
+/**
+ * Result when hiding the loader.
+ *
+ * @public
+ */
+export declare type HideLoaderResult = void;
+
+/**
+ * Response when hiding the refresh button.
+ *
+ * @public
+ */
+export declare type HideRefreshButtonResponse = ConstrainedBridgeResponse<HideRefreshButtonResult, 200>;
+
+/**
+ * Result when hiding the refresh button.
+ *
+ * @public
+ */
+export declare type HideRefreshButtonResult = void;
+
+/**
+ * JSBridge module for authenticating users via GrabID.
+ *
+ * @group Modules
+ *
+ * @remarks
+ * Handles OAuth2/OIDC authentication flows with PKCE support, enabling MiniApps to obtain user identity tokens.
+ * Supports both native in-app consent and web-based fallback flows.
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @example
+ * **ES Module:**
+ * ```typescript
+ * import { IdentityModule } from '@grabjs/superapp-sdk';
+ * const identity = new IdentityModule();
+ * ```
+ *
+ * @example
+ * **CDN (UMD):**
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/@grabjs/superapp-sdk/dist/index.js"></script>
+ * <script>
+ *   const identity = new SuperAppSDK.IdentityModule();
+ * </script>
+ * ```
+ *
+ * @public
+ */
+export declare class IdentityModule extends BaseModule {
+    constructor();
+    get NAMESPACE(): string;
+    get CODE_CHALLENGE_METHOD(): string;
+    get NONCE_LENGTH(): number;
+    get STATE_LENGTH(): number;
+    get CODE_VERIFIER_LENGTH(): number;
+    get OPENID_CONFIG_ENDPOINTS(): {
+        staging: string;
+        production: string;
+    };
+    /**
+     * Fetches the authorization endpoint URL from the OpenID configuration.
+     *
+     * @param environment - The environment to fetch configuration for ('staging' or 'production').
+     * @returns The authorization endpoint URL.
+     * @throws Error when the environment is invalid or the configuration cannot be fetched.
+     *
+     * @internal
+     */
+    fetchAuthorizationEndpoint(environment: any): Promise<any>;
+    static generateRandomString(length: any): string;
+    static base64URLEncode(str: any): any;
+    static generateCodeVerifier(len: any): any;
+    static generateCodeChallenge(codeVerifier: any): any;
+    /**
+     * Generates PKCE (Proof Key for Code Exchange) artifacts for the OAuth2 authorization flow.
+     *
+     * @returns An object containing the nonce, state, code verifier, code challenge, and code challenge method.
+     *
+     * @internal
+     */
+    generatePKCEArtifacts(): {
+        nonce: string;
+        state: string;
+        codeVerifier: any;
+        codeChallenge: any;
+        codeChallengeMethod: string;
+    };
+    /**
+     * Stores PKCE artifacts in local storage for later retrieval during token exchange.
+     *
+     * @param artifacts - The PKCE artifacts to store, including nonce, state, code verifier, and redirect URI.
+     *
+     * @internal
+     */
+    storePKCEArtifacts(artifacts: any): void;
+    /**
+     * Retrieves stored PKCE authorization artifacts from local storage.
+     * These artifacts are used to complete the OAuth2 authorization code exchange.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: All artifacts present - proceed with token exchange
+     * - `204`: No artifacts yet - user hasn't authorized
+     * - `400`: Inconsistent state - possible data corruption
+     *
+     * @remarks
+     * **Important:** The `redirectUri` returned by this method is the actual redirect URI
+     * that was sent to the authorization server. This may differ from the `redirectUri`
+     * you provided to `authorize()` if you used `responseMode: 'in_place'` with native flow.
+     * You must use this returned `redirectUri` for token exchange to ensure OAuth compliance.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { IdentityModule, isResponseOk, isResponseNoContent, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { IdentityModule, isResponseOk, isResponseNoContent, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the identity module
+     * const identityModule = new IdentityModule();
+     *
+     * // Retrieve stored authorization artifacts after authorization redirect
+     * try {
+     *   const response = await identityModule.getAuthorizationArtifacts();
+     *
+     *   if (isResponseError(response)) {
+     *     // Inconsistent state - possible data corruption
+     *     console.error('Authorization artifacts error:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     // All artifacts present - proceed with token exchange
+     *     const { state, codeVerifier, nonce, redirectUri } = response.result;
+     *     console.log('State:', state);
+     *     console.log('Code Verifier:', codeVerifier);
+     *     console.log('Nonce:', nonce);
+     *     console.log('Redirect URI:', redirectUri);
+     *   } else if (isResponseNoContent(response)) {
+     *     // No artifacts yet - user hasn't authorized
+     *     console.log('No authorization artifacts found. Authorization has not been initiated.');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    getAuthorizationArtifacts(): Promise<GetAuthorizationArtifactsResponse>;
+    /**
+     * Clears all stored PKCE authorization artifacts from local storage.
+     * This should be called after a successful token exchange or when you need to
+     * reset the authorization state (e.g., on error or logout).
+     *
+     * @returns A promise that resolves to a `204` status code when artifacts are cleared.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { IdentityModule, isResponseNoContent } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { IdentityModule, isResponseNoContent } = window.SuperAppSDK;
+     *
+     * // Initialize the identity module
+     * const identityModule = new IdentityModule();
+     *
+     * // Clear stored authorization artifacts after successful token exchange
+     * try {
+     *   const response = await identityModule.clearAuthorizationArtifacts();
+     *
+     *   if (isResponseNoContent(response)) {
+     *     console.log('Authorization artifacts cleared');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    clearAuthorizationArtifacts(): Promise<ClearAuthorizationArtifactsResponse>;
+    /**
+     * Stores a value in local storage with the GrabID namespace prefix.
+     *
+     * @param key - The storage key (without namespace prefix).
+     * @param value - The value to store.
+     *
+     * @internal
+     */
+    setStorageItem(key: any, value: any): void;
+    /**
+     * Retrieves a value from local storage with the GrabID namespace prefix.
+     *
+     * @param key - The storage key (without namespace prefix).
+     * @returns The stored value or null if not found.
+     *
+     * @internal
+     */
+    getStorageItem(key: any): string;
+    static normalizeUrl(urlString: any): string;
+    static buildAuthorizeUrl(authorizationEndpoint: any, requestMap: any): string;
+    static shouldUseWebConsent(request: any): boolean;
+    /**
+     * Performs web-based OAuth2 authorization by redirecting to the authorization server.
+     *
+     * @param params - The authorization parameters including client ID, redirect URI, scope, and PKCE artifacts.
+     * @returns A promise that resolves to a 302 redirect response or a 400 error response.
+     *
+     * @internal
+     */
+    performWebAuthorization(params: any): Promise<AuthorizeResponse>;
+    /**
+     * Performs native in-app OAuth2 authorization using the JSBridge.
+     *
+     * @param invokeParams - The authorization parameters including client ID, redirect URI, scope, and PKCE artifacts.
+     * @returns A promise that resolves to the native authorization response.
+     *
+     * @internal
+     */
+    performNativeAuthorization(invokeParams: any): Promise<AuthorizeResponse>;
+    /**
+     * Initiates an OAuth2 authorization flow with PKCE (Proof Key for Code Exchange).
+     * This method handles both native in-app consent and web-based fallback flows.
+     *
+     * @param request - The authorization request parameters including client ID, redirect URI,
+     *                  scopes, and environment.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Authorization completed successfully (native in_place flow)
+     * - `302`: Redirect in progress (web redirect flow). The page will
+     *   be redirected to the authorization URL. This response has no result data.
+     * - `400`: Missing required OAuth parameters, redirect mismatch, or no webview URL
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @remarks
+     * **Important Note on redirectUri and responseMode:**
+     *
+     * The actual `redirectUri` used during authorization may differ from the one you provide,
+     * depending on the flow:
+     *
+     * - `responseMode: 'in_place'` when native flow is available: Uses the current page URL
+     *   (normalized) as the `redirectUri`, overriding your provided value
+     * - `responseMode: 'in_place'` falling back to web flow if native flow is not available:
+     *   Uses your provided `redirectUri`
+     * - `responseMode: 'redirect'`: Always uses your provided `redirectUri`
+     *
+     * To ensure successful token exchange (which requires matching `redirectUri` values),
+     * always retrieve the actual `redirectUri` from `getAuthorizationArtifacts()`
+     * after authorization completes.
+     *
+     * **Consent Selection Rules (Native vs Web):**
+     *
+     * - If the user agent does not match the Grab app pattern, the SDK uses web consent
+     * - If the app version in the user agent is below 5.396.0 (iOS or Android),
+     *   the SDK uses web consent
+     * - For supported versions, the SDK attempts native consent first and falls back to
+     *   web on specific native errors (400, 401, 403)
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { IdentityModule, isResponseOk, isResponseError, isResponseRedirect } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { IdentityModule, isResponseOk, isResponseError, isResponseRedirect } = window.SuperAppSDK;
+     *
+     * // Initialize the identity module
+     * const identityModule = new IdentityModule();
+     *
+     * // Initiate authorization with redirect mode
+     * try {
+     *   const response = await identityModule.authorize({
+     *     clientId: 'your-client-id',
+     *     redirectUri: 'https://your-app.com/callback',
+     *     scope: 'openid profile',
+     *     environment: 'production',
+     *     responseMode: 'redirect'
+     *   });
+     *
+     *   if (isResponseError(response)) {
+     *     // Authorization failed
+     *     console.error('Auth error:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     // Authorization successful (in_place mode with native flow)
+     *     console.log('Auth Code:', response.result.code);
+     *     console.log('State:', response.result.state);
+     *   } else if (isResponseRedirect(response)) {
+     *     // Redirect in progress (web flow with responseMode: 'redirect')
+     *     // The page will be redirected to the authorization URL
+     *     console.log('Redirecting to authorization...');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    authorize(request: AuthorizeRequest): Promise<AuthorizeResponse>;
+    static validateRequiredString(value: any, fieldName: any): string;
+    static validateAuthorizeRequest(request: any): string;
+}
+
+/**
+ * Response when checking connection status.
+ *
+ * @public
+ */
+export declare type IsConnectedResponse = ConstrainedBridgeResponse<IsConnectedResult, 200 | 404>;
+
+/**
+ * Result object containing the connection status.
+ *
+ * @public
+ */
+export declare type IsConnectedResult = {
+    /** Whether the MiniApp is connected to the Grab SuperApp. */
+    connected: boolean;
+};
+
+/**
+ * Type guard that checks if the response is a bad request error (status code 400).
+ * Narrows the type to BridgeErrorResponse400.
+ *
+ * @example
+ * ```typescript
+ * const response = await cameraModule.scanQRCode(request);
+ * if (isResponseBadRequest(response)) {
+ *   console.log('Bad request:', response.error);
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isResponseBadRequest<T>(response: BridgeResponse<T>): response is BridgeStatusCode400Response;
+
+/**
+ * Type guard that checks if the response is a client error (status code 400, 403, 404, or 424).
+ * Narrows the type to client error responses.
+ *
+ * @example
+ * ```typescript
+ * const response = await cameraModule.scanQRCode(request);
+ * if (isResponseClientError(response)) {
+ *   console.log('Client error:', response.status_code, response.error);
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isResponseClientError<T>(response: BridgeResponse<T>): response is BridgeClientErrorResponse;
+
+/**
+ * Type guard that checks if the response is an error (status code 4xx or 5xx).
+ * Narrows the type to BridgeErrorResponse, giving access to the error message.
+ *
+ * @example
+ * ```typescript
+ * const response = await cameraModule.scanQRCode(request);
+ * if (isResponseError(response)) {
+ *   console.log('Error:', response.error);
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isResponseError<T>(response: BridgeResponse<T>): response is BridgeErrorResponse;
+
+/**
+ * Type guard that checks if the response is a failed dependency error (status code 424).
+ * Narrows the type to BridgeErrorResponse424.
+ *
+ * @example
+ * ```typescript
+ * const response = await cameraModule.scanQRCode(request);
+ * if (isResponseFailedDependency(response)) {
+ *   console.log('Failed dependency:', response.error);
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isResponseFailedDependency<T>(response: BridgeResponse<T>): response is BridgeStatusCode424Response;
+
+/**
+ * Type guard that checks if the response is a forbidden error (status code 403).
+ * Narrows the type to BridgeErrorResponse403.
+ *
+ * @example
+ * ```typescript
+ * const response = await cameraModule.scanQRCode(request);
+ * if (isResponseForbidden(response)) {
+ *   console.log('Forbidden:', response.error);
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isResponseForbidden<T>(response: BridgeResponse<T>): response is BridgeStatusCode403Response;
+
+/**
+ * Type guard that checks if the response is an internal server error (status code 500).
+ * Narrows the type to BridgeErrorResponse500.
+ *
+ * @example
+ * ```typescript
+ * const response = await cameraModule.scanQRCode(request);
+ * if (isResponseInternalServerError(response)) {
+ *   console.log('Internal server error:', response.error);
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isResponseInternalServerError<T>(response: BridgeResponse<T>): response is BridgeStatusCode500Response;
+
+/**
+ * Type guard that checks if the response has no content (status code 204).
+ * This typically means the operation completed with no content to return.
+ *
+ * @example
+ * ```typescript
+ * const response = await cameraModule.scanQRCode(request);
+ * if (isResponseNoContent(response)) {
+ *   console.log('No content available');
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isResponseNoContent<T>(response: BridgeResponse<T>): response is BridgeStatusCode204Response;
+
+/**
+ * Type guard that checks if the response is a not found error (status code 404).
+ * Narrows the type to BridgeErrorResponse404.
+ *
+ * @example
+ * ```typescript
+ * const response = await cameraModule.scanQRCode(request);
+ * if (isResponseNotFound(response)) {
+ *   console.log('Not found:', response.error);
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isResponseNotFound<T>(response: BridgeResponse<T>): response is BridgeStatusCode404Response;
+
+/**
+ * Type guard that checks if the response is OK (status code 200).
+ * Narrows the type to BridgeSuccessResponse<T>, giving access to the result.
+ *
+ * @example
+ * ```typescript
+ * const response = await cameraModule.scanQRCode(request);
+ * if (isResponseOk(response)) {
+ *   console.log('QR Code:', response.result.qrCode);
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isResponseOk<T>(response: BridgeResponse<T>): response is BridgeStatusCode200Response<T>;
+
+/**
+ * Type guard that checks if the response is a redirect (status code 302).
+ * This typically means a redirect occurred.
+ *
+ * @example
+ * ```typescript
+ * const response = await someModule.someMethod(request);
+ * if (isResponseRedirect(response)) {
+ *   console.log('Redirect occurred');
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isResponseRedirect<T>(response: BridgeResponse<T>): response is BridgeStatusCode302Response;
+
+/**
+ * Type guard that checks if the response is a server error (status code 500).
+ * Narrows the type to server error response.
+ *
+ * @example
+ * ```typescript
+ * const response = await cameraModule.scanQRCode(request);
+ * if (isResponseServerError(response)) {
+ *   console.log('Server error - retry later:', response.error);
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isResponseServerError<T>(response: BridgeResponse<T>): response is BridgeServerErrorResponse;
+
+/**
+ * Type guard that checks if the response is a success (status code 200 or 204).
+ * Narrows the type to BridgeSuccessResponse<T> | BridgeNoResultResponse, excluding errors and redirects.
+ *
+ * @example
+ * ```typescript
+ * const response = await cameraModule.scanQRCode(request);
+ * if (isResponseSuccess(response)) {
+ *   // Response is not an error, check isResponseOk() to access result
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isResponseSuccess<T>(response: BridgeResponse<T>): response is BridgeSuccessResponse<T>;
+
+/**
+ * JSBridge module for accessing device locale settings.
+ *
+ * @group Modules
+ *
+ * @remarks
+ * Provides the user's preferred language and region settings from the native device.
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @example
+ * **ES Module:**
+ * ```typescript
+ * import { LocaleModule } from '@grabjs/superapp-sdk';
+ * const locale = new LocaleModule();
+ * ```
+ *
+ * @example
+ * **CDN (UMD):**
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/@grabjs/superapp-sdk/dist/index.js"></script>
+ * <script>
+ *   const locale = new SuperAppSDK.LocaleModule();
+ * </script>
+ * ```
+ *
+ * @public
+ */
+export declare class LocaleModule extends BaseModule {
+    constructor();
+    /**
+     * Retrieves the current language locale identifier from the device.
+     *
+     * @returns A promise that resolves to a `200` status code with the locale identifier.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { LocaleModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { LocaleModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the locale module
+     * const localeModule = new LocaleModule();
+     *
+     * // Get the current locale
+     * try {
+     *   const response = await localeModule.getLanguageLocaleIdentifier();
+     *
+     *   if (isResponseOk(response)) {
+     *     console.log('Current locale:', response.result);
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    getLanguageLocaleIdentifier(): Promise<GetLanguageLocaleIdentifierResponse>;
+}
+
+/**
+ * JSBridge module for accessing device location services.
+ *
+ * @group Modules
+ *
+ * @remarks
+ * Provides access to the device's geolocation data including coordinates and country code.
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @example
+ * **ES Module:**
+ * ```typescript
+ * import { LocationModule } from '@grabjs/superapp-sdk';
+ * const location = new LocationModule();
+ * ```
+ *
+ * @example
+ * **CDN (UMD):**
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/@grabjs/superapp-sdk/dist/index.js"></script>
+ * <script>
+ *   const location = new SuperAppSDK.LocationModule();
+ * </script>
+ * ```
+ *
+ * @public
+ */
+export declare class LocationModule extends BaseModule {
+    constructor();
+    /**
+     * Get the current geographic coordinates of the device.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Coordinates retrieved successfully
+     * - `424`: GeoKit error
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { LocationModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { LocationModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the location module
+     * const locationModule = new LocationModule();
+     *
+     * // Get current coordinates
+     * try {
+     *   const response = await locationModule.getCoordinate();
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not get coordinates:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Coordinates:', response.result.lat, response.result.lng);
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    getCoordinate(): Promise<GetCoordinateResponse>;
+    /**
+     * Subscribe to location change updates from the device.
+     *
+     * @returns A `DataStream` that emits location updates as the device location changes.
+     * Use `subscribe()` to listen for updates, or `await` to get the first value only.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { LocationModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { LocationModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the location module
+     * const locationModule = new LocationModule();
+     *
+     * // Subscribe to location changes
+     * const subscription = locationModule.observeLocationChange().subscribe({
+     *   next: (response) => {
+     *     if (isResponseOk(response)) {
+     *       console.log('Location updated:', response.result.lat, response.result.lng);
+     *     }
+     *   },
+     *   complete: () => console.log('Location stream completed')
+     * });
+     *
+     * // Later, to stop receiving updates:
+     * subscription.unsubscribe();
+     * ```
+     *
+     * @public
+     */
+    observeLocationChange(): ObserveLocationChangeResponse;
+    /**
+     * Get the country code based on the device's current location.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Country code retrieved successfully
+     * - `424`: GeoKit/Resolver error
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { LocationModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { LocationModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the location module
+     * const locationModule = new LocationModule();
+     *
+     * // Get country code
+     * try {
+     *   const response = await locationModule.getCountryCode();
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not get country code:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Country code:', response.result.countryCode);
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    getCountryCode(): Promise<GetCountryCodeResponse>;
+}
+
+/**
+ * JSBridge module for playing DRM-protected media content.
+ *
+ * @group Modules
+ *
+ * @remarks
+ * Provides access to the native media player with DRM support for secure content playback.
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @example
+ * **ES Module:**
+ * ```typescript
+ * import { MediaModule } from '@grabjs/superapp-sdk';
+ * const media = new MediaModule();
+ * ```
+ *
+ * @example
+ * **CDN (UMD):**
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/@grabjs/superapp-sdk/dist/index.js"></script>
+ * <script>
+ *   const media = new SuperAppSDK.MediaModule();
+ * </script>
+ * ```
+ *
+ * @public
+ */
+export declare class MediaModule extends BaseModule {
+    constructor();
+    /**
+     * Plays DRM-protected media content in the native media player.
+     *
+     * @param data - The DRM content configuration.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Playback initiated (streaming)
+     * - `204`: Invalid parameters
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { MediaModule, isResponseOk, isResponseNoContent } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { MediaModule, isResponseOk, isResponseNoContent } = window.SuperAppSDK;
+     *
+     * // Initialize the media module
+     * const mediaModule = new MediaModule();
+     *
+     * // Play DRM content
+     * try {
+     *   const response = await mediaModule.playDRMContent({
+     *     // DRM content configuration
+     *   });
+     *
+     *   if (isResponseOk(response)) {
+     *     console.log('Playback initiated');
+     *   } else if (isResponseNoContent(response)) {
+     *     console.log('Invalid parameters');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    playDRMContent(data: DRMContentConfig): Promise<PlayDRMContentResponse>;
+    /**
+     * Observes DRM-protected media content playback events.
+     *
+     * @param data - The DRM content configuration.
+     *
+     * @returns A `DataStream` that emits playback events as the media plays.
+     * Emits `200` responses with video player events.
+     * Use `subscribe()` to listen for events.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { MediaModule, isResponseOk } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { MediaModule, isResponseOk } = window.SuperAppSDK;
+     *
+     * // Initialize the media module
+     * const mediaModule = new MediaModule();
+     *
+     * // Observe DRM content playback
+     * const subscription = mediaModule.observePlayDRMContent({
+     *   // DRM content configuration
+     * }).subscribe({
+     *   next: (response) => {
+     *     if (isResponseOk(response)) {
+     *       console.log('Playback event:', response.result);
+     *     }
+     *   },
+     *   complete: () => console.log('Playback completed')
+     * });
+     *
+     * // Later, to stop receiving events:
+     * subscription.unsubscribe();
+     * ```
+     *
+     * @public
+     */
+    observePlayDRMContent(data: DRMContentConfig): ObserveDRMPlaybackResponse;
+}
+
+/**
+ * Response stream for observing DRM playback events.
+ *
+ * @public
+ */
+export declare type ObserveDRMPlaybackResponse = DataStream<DRMPlaybackEvent>;
+
+/**
+ * Response when observing the device coordinates.
+ *
+ * @public
+ */
+export declare type ObserveLocationChangeResponse = DataStream_2<GetCoordinateResult>;
+
+/**
+ * Response when notifying content loaded.
+ *
+ * @public
+ */
+export declare type OnContentLoadedResponse = ConstrainedBridgeResponse<OnContentLoadedResult, 200>;
+
+/**
+ * Result when notifying content loaded.
+ *
+ * @public
+ */
+export declare type OnContentLoadedResult = void;
+
+/**
+ * Request parameters for notifying CTA tap.
+ *
+ * @public
+ */
+export declare type OnCtaTapRequest = string;
+
+/**
+ * Response when notifying CTA tap.
+ *
+ * @public
+ */
+export declare type OnCtaTapResponse = ConstrainedBridgeResponse<OnCtaTapResult, 200>;
+
+/**
+ * Result when notifying CTA tap.
+ *
+ * @public
+ */
+export declare type OnCtaTapResult = void;
+
+/**
+ * Request parameters for opening an external link.
+ *
+ * @public
+ */
+export declare type OpenExternalLinkRequest = string;
+
+/**
+ * Response when opening an external link.
+ *
+ * @public
+ */
+export declare type OpenExternalLinkResponse = ConstrainedBridgeResponse<OpenExternalLinkResult, 200 | 400>;
+
+/**
+ * Result when opening an external link.
+ *
+ * @public
+ */
+export declare type OpenExternalLinkResult = void;
+
+/**
+ * JSBridge module for controlling platform navigation.
+ *
+ * @group Modules
+ *
+ * @remarks
+ * Provides methods to interact with the native platform navigation stack, such as triggering the back action.
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @example
+ * **ES Module:**
+ * ```typescript
+ * import { PlatformModule } from '@grabjs/superapp-sdk';
+ * const platform = new PlatformModule();
+ * ```
+ *
+ * @example
+ * **CDN (UMD):**
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/@grabjs/superapp-sdk/dist/index.js"></script>
+ * <script>
+ *   const platform = new SuperAppSDK.PlatformModule();
+ * </script>
+ * ```
+ *
+ * @public
+ */
+export declare class PlatformModule extends BaseModule {
+    constructor();
+    /**
+     * Triggers the native platform back navigation.
+     * This navigates back in the native navigation stack.
+     *
+     * @returns A promise that resolves to a `204` status code when back navigation is triggered.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { PlatformModule, isResponseNoContent } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { PlatformModule, isResponseNoContent } = window.SuperAppSDK;
+     *
+     * // Initialize the platform module
+     * const platformModule = new PlatformModule();
+     *
+     * // Trigger back navigation
+     * try {
+     *   const response = await platformModule.back();
+     *
+     *   if (isResponseNoContent(response)) {
+     *     console.log('Back navigation triggered');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    back(): Promise<BridgeResponse<unknown>>;
+}
+
+/**
+ * Response when initiating DRM content playback.
+ *
+ * @public
+ */
+export declare type PlayDRMContentResponse = ConstrainedBridgeResponse<PlayDRMContentResult, 200 | 204>;
+
+/**
+ * Result object for DRM content playback initiation.
+ * This operation returns no data on success.
+ *
+ * @public
+ */
+export declare type PlayDRMContentResult = void;
+
+/**
+ * JSBridge module for accessing user profile information.
+ *
+ * @group Modules
+ *
+ * @remarks
+ * Provides access to user profile data such as email verification.
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @example
+ * **ES Module:**
+ * ```typescript
+ * import { ProfileModule } from '@grabjs/superapp-sdk';
+ * const profile = new ProfileModule();
+ * ```
+ *
+ * @example
+ * **CDN (UMD):**
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/@grabjs/superapp-sdk/dist/index.js"></script>
+ * <script>
+ *   const profile = new SuperAppSDK.ProfileModule();
+ * </script>
+ * ```
+ *
+ * @public
+ */
+export declare class ProfileModule extends BaseModule {
+    constructor();
+    static isSupported(): boolean;
+    /**
+     * Fetches the user's email address from their Grab profile.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Email fetched successfully
+     * - `400`: Invalid request
+     * - `403`: Feature requires Grab app version 5.399 or above (returned client-side, not from JSBridge)
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ProfileModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ProfileModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the profile module
+     * const profileModule = new ProfileModule();
+     *
+     * // Fetch the user's email
+     * try {
+     *   const response = await profileModule.fetchEmail();
+     *
+     *   if (isResponseError(response)) {
+     *     // Feature not available or other error
+     *     console.log('Could not fetch email:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('User email:', response.result.email);
+     *   }
+     * } catch (err) {
+     *   console.log(`Could not fetch email${err ? `: ${err}` : ''}`);
+     * }
+     * ```
+     *
+     * @public
+     */
+    fetchEmail(): Promise<FetchEmailResponse>;
+    /**
+     * Verifies the user's email address using a one-time password (OTP).
+     *
+     * @param request - The email verification configuration.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Email verified successfully
+     * - `400`: Invalid request
+     * - `403`: Feature requires Grab app version 5.399 or above (returned client-side, not from JSBridge)
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ProfileModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ProfileModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the profile module
+     * const profileModule = new ProfileModule();
+     *
+     * // Verify email with OTP
+     * try {
+     *   const response = await profileModule.verifyEmail({
+     *     email: 'user@example.com',
+     *     otp: '123456'
+     *   });
+     *
+     *   if (isResponseError(response)) {
+     *     // Feature not available or other error
+     *     console.log('Could not verify email:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Email verified successfully');
+     *   }
+     * } catch (err) {
+     *   console.log(`Could not verify email${err ? `: ${err}` : ''}`);
+     * }
+     * ```
+     *
+     * @public
+     */
+    verifyEmail(request: VerifyEmailRequest): Promise<VerifyEmailResponse>;
+}
+
+/**
+ * Request parameters for redirecting to the system web view.
+ *
+ * @public
+ */
+export declare type RedirectToSystemWebViewRequest = {
+    /** The URL to open in the system web view. */
+    url: string;
+};
+
+/**
+ * Response when redirecting to the system web view.
+ *
+ * @public
+ */
+export declare type RedirectToSystemWebViewResponse = ConstrainedBridgeResponse<RedirectToSystemWebViewResult, 200 | 400 | 424>;
+
+/**
+ * Result object for redirecting to the system web view.
+ * This operation returns no data on success.
+ *
+ * @public
+ */
+export declare type RedirectToSystemWebViewResult = void;
+
+/**
+ * Response when reloading consented scopes.
+ *
+ * @public
+ */
+export declare type ReloadScopesResponse = ConstrainedBridgeResponse<ReloadScopesResult, 200 | 424>;
+
+/**
+ * Result object for reloading scopes.
+ * This operation returns no data on success.
+ *
+ * @public
+ */
+export declare type ReloadScopesResult = void;
+
+/**
+ * Response when removing all values.
+ *
+ * @public
+ */
+export declare type RemoveAllResponse = ConstrainedBridgeResponse<RemoveAllResult, 204>;
+
+/**
+ * Result object for removing all values.
+ * This operation returns no data on success.
+ *
+ * @public
+ */
+export declare type RemoveAllResult = void;
+
+/**
+ * Response when removing a value.
+ *
+ * @public
+ */
+export declare type RemoveResponse = ConstrainedBridgeResponse<RemoveResult, 204 | 400>;
+
+/**
+ * Result object for removing a value.
+ * This operation returns no data on success.
+ *
+ * @public
+ */
+export declare type RemoveResult = void;
+
+/**
+ * Request parameters for scanning QR codes
+ *
+ * @public
+ */
+export declare type ScanQRCodeRequest = {
+    /** Optional title shown in the camera view header. */
+    title?: string;
+};
+
+/**
+ * Response when scanning a QR code
+ *
+ * @public
+ */
+export declare type ScanQRCodeResponse = ConstrainedBridgeResponse<ScanQRCodeResult, 200 | 204 | 400 | 403>;
+
+/**
+ * Result object containing the scanned QR code data
+ *
+ * @public
+ */
+export declare type ScanQRCodeResult = {
+    /** The raw string content decoded from the scanned QR code. */
+    qrCode: string;
+};
+
+/**
+ * JSBridge module for checking and refreshing API access permissions.
+ *
+ * @group Modules
+ *
+ * @remarks
+ * Manages OAuth scope permissions, allowing the MiniApp to check access rights and reload scopes from the server.
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @example
+ * **ES Module:**
+ * ```typescript
+ * import { ScopeModule } from '@grabjs/superapp-sdk';
+ * const scope = new ScopeModule();
+ * ```
+ *
+ * @example
+ * **CDN (UMD):**
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/@grabjs/superapp-sdk/dist/index.js"></script>
+ * <script>
+ *   const scope = new SuperAppSDK.ScopeModule();
+ * </script>
+ * ```
+ *
+ * @public
+ */
+export declare class ScopeModule extends BaseModule {
+    constructor();
+    /**
+     * Checks if the current client has access to a specific JSBridge API method.
+     *
+     * @param module - The name of the bridge module to check access for (e.g., 'CameraModule').
+     * @param method - The method name within the module to check access for (e.g., 'scanQRCode').
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Access check completed successfully
+     * - `400`: Missing required parameters
+     * - `424`: ScopeKit error
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ScopeModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ScopeModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the scope module
+     * const scopeModule = new ScopeModule();
+     *
+     * // Check access to CameraModule.scanQRCode
+     * try {
+     *   const response = await scopeModule.hasAccessTo('CameraModule', 'scanQRCode');
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not check access:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Has access:', response.result.hasAccess);
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    hasAccessTo(module: string, method: string): Promise<HasAccessToResponse>;
+    /**
+     * Requests to reload the consented OAuth scopes for the current client.
+     * This refreshes the permissions from the server.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Scopes reloaded successfully
+     * - `424`: ScopeKit error
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { ScopeModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { ScopeModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the scope module
+     * const scopeModule = new ScopeModule();
+     *
+     * // Reload scopes
+     * try {
+     *   const response = await scopeModule.reloadScopes();
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not reload scopes:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Scopes reloaded successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    reloadScopes(): Promise<ReloadScopesResponse>;
+}
+
+/**
+ * Request parameters for sending analytics events.
+ *
+ * @remarks
+ * Use predefined constants to ensure consistency across the platform:
+ * - **States:** {@link ContainerAnalyticsEventState}
+ * - **Names:** {@link ContainerAnalyticsEventName}
+ *
+ * @public
+ */
+export declare type SendAnalyticsEventRequest = {
+    /** The analytics event state (e.g., "HOMEPAGE", "CHECKOUT_PAGE"). */
+    state: string;
+    /** The analytics event name (e.g., "DEFAULT", "BOOK"). */
+    name: string;
+    /** Optional additional data for the analytics event as key-value pairs. */
+    data?: Record<string, unknown>;
+};
+
+/**
+ * Response when sending analytics events.
+ *
+ * @public
+ */
+export declare type SendAnalyticsEventResponse = ConstrainedBridgeResponse<SendAnalyticsEventResult, 200 | 400>;
+
+/**
+ * Result when sending analytics events.
+ *
+ * @public
+ */
+export declare type SendAnalyticsEventResult = void;
+
+/**
+ * Request parameters for setting the background color.
+ *
+ * @public
+ */
+export declare type SetBackgroundColorRequest = string;
+
+/**
+ * Response when setting the background color.
+ *
+ * @public
+ */
+export declare type SetBackgroundColorResponse = ConstrainedBridgeResponse<SetBackgroundColorResult, 200 | 400>;
+
+/**
+ * Result when setting the background color.
+ *
+ * @public
+ */
+export declare type SetBackgroundColorResult = void;
+
+/**
+ * Response when setting a boolean value.
+ *
+ * @public
+ */
+export declare type SetBooleanResponse = ConstrainedBridgeResponse<SetBooleanResult, 204 | 400>;
+
+/**
+ * Result object for setting a boolean value.
+ * This operation returns no data on success.
+ *
+ * @public
+ */
+export declare type SetBooleanResult = void;
+
+/**
+ * Response when setting a double value.
+ *
+ * @public
+ */
+export declare type SetDoubleResponse = ConstrainedBridgeResponse<SetDoubleResult, 204 | 400>;
+
+/**
+ * Result object for setting a double value.
+ * This operation returns no data on success.
+ *
+ * @public
+ */
+export declare type SetDoubleResult = void;
+
+/**
+ * Response when setting an integer value.
+ *
+ * @public
+ */
+export declare type SetIntResponse = ConstrainedBridgeResponse<SetIntResult, 204 | 400>;
+
+/**
+ * Result object for setting an integer value.
+ * This operation returns no data on success.
+ *
+ * @public
+ */
+export declare type SetIntResult = void;
+
+/**
+ * Response when setting a string value.
+ *
+ * @public
+ */
+export declare type SetStringResponse = ConstrainedBridgeResponse<SetStringResult, 204 | 400>;
+
+/**
+ * Result object for setting a string value.
+ * This operation returns no data on success.
+ *
+ * @public
+ */
+export declare type SetStringResult = void;
+
+/**
+ * Request parameters for setting the title.
+ *
+ * @public
+ */
+export declare type SetTitleRequest = string;
+
+/**
+ * Response when setting the title.
+ *
+ * @public
+ */
+export declare type SetTitleResponse = ConstrainedBridgeResponse<SetTitleResult, 200 | 400>;
+
+/**
+ * Result when setting the title.
+ *
+ * @public
+ */
+export declare type SetTitleResult = void;
+
+/**
+ * Response when showing the back button.
+ *
+ * @public
+ */
+export declare type ShowBackButtonResponse = ConstrainedBridgeResponse<ShowBackButtonResult, 200>;
+
+/**
+ * Result when showing the back button.
+ *
+ * @public
+ */
+export declare type ShowBackButtonResult = void;
+
+/**
+ * Response when showing the loader.
+ *
+ * @public
+ */
+export declare type ShowLoaderResponse = ConstrainedBridgeResponse<ShowLoaderResult, 200>;
+
+/**
+ * Result when showing the loader.
+ *
+ * @public
+ */
+export declare type ShowLoaderResult = void;
+
+/**
+ * Response when showing the refresh button.
+ *
+ * @public
+ */
+export declare type ShowRefreshButtonResponse = ConstrainedBridgeResponse<ShowRefreshButtonResult, 200>;
+
+/**
+ * Result when showing the refresh button.
+ *
+ * @public
+ */
+export declare type ShowRefreshButtonResult = void;
+
+/**
+ * Map of individual status codes to their JSBridge response types.
+ * Used internally by ConstrainedBridgeResponse to select specific response types.
+ *
+ * @public
+ */
+export declare type StatusCodeMap<T> = {
+    200: BridgeStatusCode200Response<T>;
+    204: BridgeStatusCode204Response;
+    302: BridgeStatusCode302Response;
+    400: BridgeStatusCode400Response;
+    403: BridgeStatusCode403Response;
+    404: BridgeStatusCode404Response;
+    424: BridgeStatusCode424Response;
+    500: BridgeStatusCode500Response;
+};
+
+/**
+ * JSBridge module for persisting key-value data to native storage.
+ *
+ * @group Modules
+ *
+ * @remarks
+ * Stores data in the native app's persistent storage, allowing data to survive webview restarts.
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @example
+ * **ES Module:**
+ * ```typescript
+ * import { StorageModule } from '@grabjs/superapp-sdk';
+ * const storage = new StorageModule();
+ * ```
+ *
+ * @example
+ * **CDN (UMD):**
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/@grabjs/superapp-sdk/dist/index.js"></script>
+ * <script>
+ *   const storage = new SuperAppSDK.StorageModule();
+ * </script>
+ * ```
+ *
+ * @public
+ */
+export declare class StorageModule extends BaseModule {
+    constructor();
+    /**
+     * Stores a boolean value in the native storage.
+     *
+     * @param key - The key to store the value under.
+     * @param value - The boolean value to store.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `204`: Value stored successfully
+     * - `400`: Missing required parameters
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { StorageModule, isResponseNoContent, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { StorageModule, isResponseNoContent, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the storage module
+     * const storageModule = new StorageModule();
+     *
+     * // Set a boolean value
+     * try {
+     *   const response = await storageModule.setBoolean('isDarkMode', true);
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not store value:', response.error);
+     *   } else if (isResponseNoContent(response)) {
+     *     console.log('Value stored successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    setBoolean(key: string, value: boolean): Promise<SetBooleanResponse>;
+    /**
+     * Retrieves a boolean value from the native storage.
+     *
+     * @param key - The key to retrieve the value for.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Value retrieved successfully
+     * - `400`: Missing required parameters
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { StorageModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { StorageModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the storage module
+     * const storageModule = new StorageModule();
+     *
+     * // Get a boolean value
+     * try {
+     *   const response = await storageModule.getBoolean('isDarkMode');
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not retrieve value:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Stored value:', response.result);
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    getBoolean(key: string): Promise<GetBooleanResponse>;
+    /**
+     * Stores an integer value in the native storage.
+     *
+     * @param key - The key to store the value under.
+     * @param value - The integer value to store.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `204`: Value stored successfully
+     * - `400`: Missing required parameters
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { StorageModule, isResponseNoContent, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { StorageModule, isResponseNoContent, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the storage module
+     * const storageModule = new StorageModule();
+     *
+     * // Set an integer value
+     * try {
+     *   const response = await storageModule.setInt('userCount', 42);
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not store value:', response.error);
+     *   } else if (isResponseNoContent(response)) {
+     *     console.log('Value stored successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    setInt(key: string, value: number): Promise<SetIntResponse>;
+    /**
+     * Retrieves an integer value from the native storage.
+     *
+     * @param key - The key to retrieve the value for.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Value retrieved successfully
+     * - `400`: Missing required parameters
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { StorageModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { StorageModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the storage module
+     * const storageModule = new StorageModule();
+     *
+     * // Get an integer value
+     * try {
+     *   const response = await storageModule.getInt('userCount');
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not retrieve value:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Stored value:', response.result);
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    getInt(key: string): Promise<GetIntResponse>;
+    /**
+     * Stores a string value in the native storage.
+     *
+     * @param key - The key to store the value under.
+     * @param value - The string value to store.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `204`: Value stored successfully
+     * - `400`: Missing required parameters
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { StorageModule, isResponseNoContent, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { StorageModule, isResponseNoContent, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the storage module
+     * const storageModule = new StorageModule();
+     *
+     * // Set a string value
+     * try {
+     *   const response = await storageModule.setString('username', 'john_doe');
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not store value:', response.error);
+     *   } else if (isResponseNoContent(response)) {
+     *     console.log('Value stored successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    setString(key: string, value: string): Promise<SetStringResponse>;
+    /**
+     * Retrieves a string value from the native storage.
+     *
+     * @param key - The key to retrieve the value for.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Value retrieved successfully
+     * - `400`: Missing required parameters
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { StorageModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { StorageModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the storage module
+     * const storageModule = new StorageModule();
+     *
+     * // Get a string value
+     * try {
+     *   const response = await storageModule.getString('username');
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not retrieve value:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Stored value:', response.result);
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    getString(key: string): Promise<GetStringResponse>;
+    /**
+     * Stores a double (floating point) value in the native storage.
+     *
+     * @param key - The key to store the value under.
+     * @param value - The double value to store.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `204`: Value stored successfully
+     * - `400`: Missing required parameters
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { StorageModule, isResponseNoContent, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { StorageModule, isResponseNoContent, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the storage module
+     * const storageModule = new StorageModule();
+     *
+     * // Set a double value
+     * try {
+     *   const response = await storageModule.setDouble('price', 19.99);
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not store value:', response.error);
+     *   } else if (isResponseNoContent(response)) {
+     *     console.log('Value stored successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    setDouble(key: string, value: number): Promise<SetDoubleResponse>;
+    /**
+     * Retrieves a double (floating point) value from the native storage.
+     *
+     * @param key - The key to retrieve the value for.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Value retrieved successfully
+     * - `400`: Missing required parameters
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { StorageModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { StorageModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the storage module
+     * const storageModule = new StorageModule();
+     *
+     * // Get a double value
+     * try {
+     *   const response = await storageModule.getDouble('price');
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not retrieve value:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Stored value:', response.result);
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    getDouble(key: string): Promise<GetDoubleResponse>;
+    /**
+     * Removes a single value from the native storage by key.
+     *
+     * @param key - The key to remove from storage.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `204`: Value removed successfully
+     * - `400`: Missing required parameters
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { StorageModule, isResponseNoContent, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { StorageModule, isResponseNoContent, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the storage module
+     * const storageModule = new StorageModule();
+     *
+     * // Remove a value
+     * try {
+     *   const response = await storageModule.remove('username');
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not remove value:', response.error);
+     *   } else if (isResponseNoContent(response)) {
+     *     console.log('Value removed successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    remove(key: string): Promise<RemoveResponse>;
+    /**
+     * Removes all values from the native storage.
+     *
+     * @returns A promise that resolves to a `204` status code when all values are removed.
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { StorageModule, isResponseNoContent } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { StorageModule, isResponseNoContent } = window.SuperAppSDK;
+     *
+     * // Initialize the storage module
+     * const storageModule = new StorageModule();
+     *
+     * // Remove all values
+     * try {
+     *   const response = await storageModule.removeAll();
+     *
+     *   if (isResponseNoContent(response)) {
+     *     console.log('All values removed successfully');
+     *   }
+     * } catch (error) {
+     *   console.log('Unexpected error:', error);
+     * }
+     * ```
+     *
+     * @public
+     */
+    removeAll(): Promise<RemoveAllResponse>;
+}
+
+/**
+ * Controls an active stream subscription. Call `unsubscribe()` to stop receiving data.
+ *
+ * @remarks
+ * Returned by `subscribe()`. Use `unsubscribe()` to terminate the stream early.
+ * Use `isUnsubscribed()` to check if already terminated.
+ *
+ * @public
+ */
+export declare type Subscription = Readonly<{
+    /** Returns true if this subscription has been terminated. */
+    isUnsubscribed: () => boolean;
+    /** Terminates the subscription. No further data will be received. */
+    unsubscribe: () => unknown;
+}>;
+
+/**
+ * JSBridge module for opening URLs in the device's system browser.
+ *
+ * @group Modules
+ *
+ * @remarks
+ * Allows MiniApps to redirect users to external content using the native system webview.
+ * This code must run on the Grab SuperApp's webview to function correctly.
+ *
+ * @example
+ * **ES Module:**
+ * ```typescript
+ * import { SystemWebViewKitModule } from '@grabjs/superapp-sdk';
+ * const webViewKit = new SystemWebViewKitModule();
+ * ```
+ *
+ * @example
+ * **CDN (UMD):**
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/@grabjs/superapp-sdk/dist/index.js"></script>
+ * <script>
+ *   const webViewKit = new SuperAppSDK.SystemWebViewKitModule();
+ * </script>
+ * ```
+ *
+ * @public
+ */
+export declare class SystemWebViewKitModule extends BaseModule {
+    constructor();
+    /**
+     * Opens a URL in the device's system web browser or web view.
+     *
+     * @param request - The URL configuration.
+     *
+     * @returns A promise that resolves to a response with one of the following possible status codes:
+     * - `200`: Redirect initiated successfully
+     * - `400`: Invalid URL, domain not whitelisted, or missing callback URL
+     * - `424`: ASWebAuthenticationSession error
+     *
+     * @throws Error when the JSBridge method fails unexpectedly.
+     *
+     * @example
+     * **Simple usage**
+     * ```typescript
+     * // Imports using ES Module built
+     * import { SystemWebViewKitModule, isResponseOk, isResponseError } from '@grabjs/superapp-sdk';
+     * // Imports using UMD built (via CDN)
+     * const { SystemWebViewKitModule, isResponseOk, isResponseError } = window.SuperAppSDK;
+     *
+     * // Initialize the system web view kit module
+     * const systemWebViewKitModule = new SystemWebViewKitModule();
+     *
+     * // Open a URL in system web view
+     * try {
+     *   const response = await systemWebViewKitModule.redirectToSystemWebView({
+     *     url: 'https://www.example.com'
+     *   });
+     *
+     *   if (isResponseError(response)) {
+     *     console.log('Could not redirect:', response.error);
+     *   } else if (isResponseOk(response)) {
+     *     console.log('Redirect initiated successfully');
+     *   }
+     * } catch (err) {
+     *   console.log('Unexpected error:', err);
+     * }
+     * ```
+     *
+     * @public
+     */
+    redirectToSystemWebView(request: RedirectToSystemWebViewRequest): Promise<RedirectToSystemWebViewResponse>;
+}
+
+/**
+ * Request parameters for triggering the checkout flow.
+ *
+ * @remarks
+ * This type is intentionally flexible as the checkout parameters vary depending on the specific payment flow and partner requirements.
+ * Consult the Grab SuperApp SDK documentation for the specific parameters required for your use case.
+ *
+ * @public
+ */
+export declare type TriggerCheckoutRequest = Record<string, unknown>;
+
+/**
+ * Response when triggering the checkout flow.
+ *
+ * @public
+ */
+export declare type TriggerCheckoutResponse = ConstrainedBridgeResponse<TriggerCheckoutResult, 200 | 400>;
+
+/**
+ * Result object containing the checkout transaction details.
+ *
+ * @public
+ */
+export declare type TriggerCheckoutResult = {
+    /** Unique identifier for the transaction at Grab side. */
+    transactionID: string;
+    /** Status of the transaction: "success", "failure", "pending", or "userInitiatedCancel". */
+    status: string;
+    /** Error message if the transaction failed. */
+    errorMessage?: string;
+    /** Error code associated with the failed transaction. */
+    errorCode?: string;
+};
+
+/**
+ * Request parameters for verifying the user's email with an OTP.
+ *
+ * @public
+ */
+export declare type VerifyEmailRequest = {
+    /** The email address to verify. */
+    email: string;
+    /** The one-time password (OTP) entered by the user. */
+    otp: string;
+};
+
+/**
+ * Response when verifying the user's email.
+ *
+ * @public
+ */
+export declare type VerifyEmailResponse = ConstrainedBridgeResponse<VerifyEmailResult, 200 | 400 | 403>;
+
+/**
+ * Result object for verifying the user's email.
+ * This operation returns no data on success.
+ *
+ * @public
+ */
+export declare type VerifyEmailResult = void;
+
+/**
+ * Generic interface for all native JSBridge module wrappers.
+ *
+ * @remarks
+ * This is the base interface that all Wrapped*Module interfaces implement.
+ * Modules can use this directly for generic method invocation, or extend it
+ * with method-specific overloads for stricter typing.
+ *
+ * @example
+ * Using directly (CameraModule, ContainerModule):
+ * ```typescript
+ * invoke<ScanQRCodeResult>('scanQRCode', request)
+ * ```
+ *
+ * @example
+ * Extending with method overloads (ProfileModule, LocationModule):
+ * ```typescript
+ * export interface WrappedProfileModule extends WrappedModule {
+ *   invoke(method: 'fetchEmail', params?: any): Promise<BridgeResponse<string>>;
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare interface WrappedModule {
+    invoke<T, P = unknown, R = BridgeResponse<T>, M extends string = string>(method: M, params?: P): M extends `observe${string}` ? DataStream<T> : Promise<R>;
+}
+
+export { }