@smart-pay-chain/otp 2.0.0

package/dist/errors.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeyRevokedError = exports.IdempotencyConflictError = exports.BrandPendingApprovalError = exports.BrandNotConfiguredError = exports.InsufficientBalanceError = exports.ServiceUnavailableError = exports.InvalidOtpError = exports.OtpExpiredError = exports.OtpNotFoundError = exports.RateLimitError = exports.ValidationError = exports.AuthenticationError = exports.OtpError = void 0;
+const types_1 = require("./types");
+/**
+ * Base error class for all OTP SDK errors
+ */
+class OtpError extends Error {
+    constructor(message, code, statusCode, retryable, details, requestId) {
+        super(message);
+        this.name = 'OtpError';
+        this.code = code;
+        this.statusCode = statusCode;
+        this.retryable = retryable;
+        this.details = details;
+        this.requestId = requestId;
+        // Maintains proper stack trace for where our error was thrown
+        Error.captureStackTrace(this, this.constructor);
+    }
+    /**
+     * Create an OtpError from an API error response
+     */
+    static fromApiError(response) {
+        return new OtpError(response.error.message, response.error.code, response.error.statusCode, response.error.retryable, response.error.details, response.meta.requestId);
+    }
+    /**
+     * Convert error to a plain object
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            statusCode: this.statusCode,
+            retryable: this.retryable,
+            details: this.details,
+            requestId: this.requestId,
+        };
+    }
+}
+exports.OtpError = OtpError;
+/**
+ * Error thrown when authentication fails
+ */
+class AuthenticationError extends OtpError {
+    constructor(message, requestId) {
+        super(message, types_1.ErrorCode.AUTHENTICATION_FAILED, 401, false, undefined, requestId);
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+/**
+ * Error thrown when validation fails
+ */
+class ValidationError extends OtpError {
+    constructor(message, details, requestId) {
+        super(message, types_1.ErrorCode.VALIDATION_ERROR, 400, false, details, requestId);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Error thrown when rate limit is exceeded
+ */
+class RateLimitError extends OtpError {
+    constructor(message, requestId) {
+        super(message, types_1.ErrorCode.RATE_LIMIT_EXCEEDED, 429, true, undefined, requestId);
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+/**
+ * Error thrown when OTP is not found
+ */
+class OtpNotFoundError extends OtpError {
+    constructor(message, requestId) {
+        super(message, types_1.ErrorCode.OTP_NOT_FOUND, 404, false, undefined, requestId);
+        this.name = 'OtpNotFoundError';
+    }
+}
+exports.OtpNotFoundError = OtpNotFoundError;
+/**
+ * Error thrown when OTP has expired
+ */
+class OtpExpiredError extends OtpError {
+    constructor(message, requestId) {
+        super(message, types_1.ErrorCode.OTP_EXPIRED, 400, false, undefined, requestId);
+        this.name = 'OtpExpiredError';
+    }
+}
+exports.OtpExpiredError = OtpExpiredError;
+/**
+ * Error thrown when OTP code is invalid
+ */
+class InvalidOtpError extends OtpError {
+    constructor(message, requestId) {
+        super(message, types_1.ErrorCode.INVALID_OTP_CODE, 400, false, undefined, requestId);
+        this.name = 'InvalidOtpError';
+    }
+}
+exports.InvalidOtpError = InvalidOtpError;
+/**
+ * Error thrown when service is unavailable
+ */
+class ServiceUnavailableError extends OtpError {
+    constructor(message, requestId) {
+        super(message, types_1.ErrorCode.SERVICE_UNAVAILABLE, 503, true, undefined, requestId);
+        this.name = 'ServiceUnavailableError';
+    }
+}
+exports.ServiceUnavailableError = ServiceUnavailableError;
+/**
+ * Error thrown when account has insufficient balance
+ */
+class InsufficientBalanceError extends OtpError {
+    constructor(message, requestId) {
+        super(message, types_1.ErrorCode.INSUFFICIENT_BALANCE, 402, false, undefined, requestId);
+        this.name = 'InsufficientBalanceError';
+    }
+}
+exports.InsufficientBalanceError = InsufficientBalanceError;
+/**
+ * Error thrown when brand is not configured (Georgian numbers)
+ */
+class BrandNotConfiguredError extends OtpError {
+    constructor(message, requestId) {
+        super(message, types_1.ErrorCode.NO_BRAND_CONFIGURED, 400, false, undefined, requestId);
+        this.name = 'BrandNotConfiguredError';
+    }
+}
+exports.BrandNotConfiguredError = BrandNotConfiguredError;
+/**
+ * Error thrown when brand is pending approval (Georgian numbers)
+ */
+class BrandPendingApprovalError extends OtpError {
+    constructor(message, requestId) {
+        super(message, types_1.ErrorCode.BRAND_PENDING_APPROVAL, 403, false, undefined, requestId);
+        this.name = 'BrandPendingApprovalError';
+    }
+}
+exports.BrandPendingApprovalError = BrandPendingApprovalError;
+/**
+ * Error thrown when idempotency key conflict occurs
+ */
+class IdempotencyConflictError extends OtpError {
+    constructor(message, requestId) {
+        super(message, types_1.ErrorCode.IDEMPOTENCY_KEY_CONFLICT, 409, false, undefined, requestId);
+        this.name = 'IdempotencyConflictError';
+    }
+}
+exports.IdempotencyConflictError = IdempotencyConflictError;
+/**
+ * Error thrown when API key has been revoked
+ */
+class ApiKeyRevokedError extends OtpError {
+    constructor(message, requestId) {
+        super(message, types_1.ErrorCode.API_KEY_REVOKED, 401, false, undefined, requestId);
+        this.name = 'ApiKeyRevokedError';
+    }
+}
+exports.ApiKeyRevokedError = ApiKeyRevokedError;

package/dist/http-client.d.ts

@@ -0,0 +1,33 @@
+import { AxiosRequestConfig } from 'axios';
+import { OtpClientConfig } from './types';
+/**
+ * HTTP client for making requests to the OTP API
+ */
+export declare class HttpClient {
+    private client;
+    private maxRetries;
+    private platform;
+    private language;
+    constructor(config: OtpClientConfig);
+    /**
+     * Make a GET request
+     */
+    get<T>(path: string, config?: AxiosRequestConfig): Promise<T>;
+    /**
+     * Make a POST request with retry logic
+     */
+    post<T>(path: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    /**
+     * Make a PUT request
+     */
+    put<T>(path: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    /**
+     * Make a DELETE request
+     */
+    delete<T>(path: string, config?: AxiosRequestConfig): Promise<T>;
+    /**
+     * Helper method to delay execution
+     */
+    private delay;
+}
+//# sourceMappingURL=http-client.d.ts.map

package/dist/http-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-client.d.ts","sourceRoot":"","sources":["../src/http-client.ts"],"names":[],"mappings":"AAAA,OAAc,EAA6B,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAkE,MAAM,SAAS,CAAC;AAmD1G;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAc;IAC9B,OAAO,CAAC,QAAQ,CAAc;gBAElB,MAAM,EAAE,eAAe;IA+BnC;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;IAKnE;;OAEG;IACG,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;IA0BhF;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;IAK/E;;OAEG;IACG,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;IAKtE;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd"}

package/dist/http-client.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("./errors");
+// SDK version - update this with each release
+const SDK_VERSION = '2.0.0';
+/**
+ * Detect the current platform
+ */
+function detectPlatform() {
+    try {
+        // Check for React Native
+        // @ts-ignore - navigator may not exist in Node.js
+        if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+            return 'react-native';
+        }
+    }
+    catch {
+        // navigator not available
+    }
+    try {
+        // Check for Node.js
+        if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+            return 'node';
+        }
+    }
+    catch {
+        // process not available
+    }
+    try {
+        // Check for browser
+        // @ts-ignore - window/document may not exist in Node.js
+        if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+            return 'browser';
+        }
+    }
+    catch {
+        // window/document not available
+    }
+    return 'unknown';
+}
+/**
+ * Detect the current language
+ */
+function detectLanguage() {
+    // TypeScript files will have TS in the stack trace in dev mode
+    // In production, both are JavaScript
+    return 'typescript'; // Default to TypeScript since SDK is TS-first
+}
+/**
+ * HTTP client for making requests to the OTP API
+ */
+class HttpClient {
+    constructor(config) {
+        this.maxRetries = config.maxRetries || 3;
+        this.platform = config.platform || detectPlatform();
+        this.language = config.language || detectLanguage();
+        this.client = axios_1.default.create({
+            baseURL: config.baseUrl || 'https://otp.smartpaychain.com',
+            timeout: config.timeout || 30000,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-Key': config.apiKey,
+                'X-OTP-SDK-Version': SDK_VERSION,
+                'X-OTP-SDK-Platform': this.platform,
+                'X-OTP-SDK-Language': this.language,
+                ...config.headers,
+            },
+        });
+        // Response interceptor for error handling
+        this.client.interceptors.response.use((response) => response, (error) => {
+            if (error.response?.data) {
+                const apiError = error.response.data;
+                throw errors_1.OtpError.fromApiError(apiError);
+            }
+            throw error;
+        });
+    }
+    /**
+     * Make a GET request
+     */
+    async get(path, config) {
+        const response = await this.client.get(path, config);
+        return response.data.data;
+    }
+    /**
+     * Make a POST request with retry logic
+     */
+    async post(path, data, config) {
+        let lastError;
+        for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+            try {
+                const response = await this.client.post(path, data, config);
+                return response.data.data;
+            }
+            catch (error) {
+                lastError = error;
+                // Only retry if the error is retryable and we have attempts left
+                if (error instanceof errors_1.OtpError && error.retryable && attempt < this.maxRetries) {
+                    // Exponential backoff: 1s, 2s, 4s
+                    const delayMs = Math.pow(2, attempt - 1) * 1000;
+                    await this.delay(delayMs);
+                    continue;
+                }
+                // Non-retryable error or max retries reached
+                throw error;
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Make a PUT request
+     */
+    async put(path, data, config) {
+        const response = await this.client.put(path, data, config);
+        return response.data.data;
+    }
+    /**
+     * Make a DELETE request
+     */
+    async delete(path, config) {
+        const response = await this.client.delete(path, config);
+        return response.data.data;
+    }
+    /**
+     * Helper method to delay execution
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @smartpaychain/otp-sdk
+ *
+ * Official TypeScript SDK for Smart Pay Chain OTP Verification Service
+ *
+ * @packageDocumentation
+ */
+export { OtpClient } from './otp-client';
+export { HttpClient } from './http-client';
+export { OtpError, AuthenticationError, ValidationError, RateLimitError, OtpNotFoundError, OtpExpiredError, InvalidOtpError, ServiceUnavailableError, InsufficientBalanceError, BrandNotConfiguredError, BrandPendingApprovalError, IdempotencyConflictError, ApiKeyRevokedError, } from './errors';
+export { OtpChannel, ErrorCode, OtpClientConfig, SendOtpOptions, SendOtpResponse, VerifyOtpOptions, VerifyOtpResponse, ResendOtpOptions, ApiErrorResponse, ApiSuccessResponse, OtpStatus, OtpStatusWithCode, SdkConfiguration, SdkPlatform, SdkLanguage, TEST_PHONE_NUMBERS, TEST_OTP_CODE, } from './types';
+export { OtpClient as default } from './otp-client';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EACL,QAAQ,EACR,mBAAmB,EACnB,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,uBAAuB,EACvB,wBAAwB,EACxB,uBAAuB,EACvB,yBAAyB,EACzB,wBAAwB,EACxB,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,UAAU,EACV,SAAS,EACT,eAAe,EACf,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,SAAS,EACT,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,kBAAkB,EAClB,aAAa,GACd,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,SAAS,IAAI,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * @smartpaychain/otp-sdk
+ *
+ * Official TypeScript SDK for Smart Pay Chain OTP Verification Service
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.TEST_OTP_CODE = exports.TEST_PHONE_NUMBERS = exports.ErrorCode = exports.OtpChannel = exports.ApiKeyRevokedError = exports.IdempotencyConflictError = exports.BrandPendingApprovalError = exports.BrandNotConfiguredError = exports.InsufficientBalanceError = exports.ServiceUnavailableError = exports.InvalidOtpError = exports.OtpExpiredError = exports.OtpNotFoundError = exports.RateLimitError = exports.ValidationError = exports.AuthenticationError = exports.OtpError = exports.HttpClient = exports.OtpClient = void 0;
+var otp_client_1 = require("./otp-client");
+Object.defineProperty(exports, "OtpClient", { enumerable: true, get: function () { return otp_client_1.OtpClient; } });
+var http_client_1 = require("./http-client");
+Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return http_client_1.HttpClient; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "OtpError", { enumerable: true, get: function () { return errors_1.OtpError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return errors_1.AuthenticationError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_1.ValidationError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });
+Object.defineProperty(exports, "OtpNotFoundError", { enumerable: true, get: function () { return errors_1.OtpNotFoundError; } });
+Object.defineProperty(exports, "OtpExpiredError", { enumerable: true, get: function () { return errors_1.OtpExpiredError; } });
+Object.defineProperty(exports, "InvalidOtpError", { enumerable: true, get: function () { return errors_1.InvalidOtpError; } });
+Object.defineProperty(exports, "ServiceUnavailableError", { enumerable: true, get: function () { return errors_1.ServiceUnavailableError; } });
+Object.defineProperty(exports, "InsufficientBalanceError", { enumerable: true, get: function () { return errors_1.InsufficientBalanceError; } });
+Object.defineProperty(exports, "BrandNotConfiguredError", { enumerable: true, get: function () { return errors_1.BrandNotConfiguredError; } });
+Object.defineProperty(exports, "BrandPendingApprovalError", { enumerable: true, get: function () { return errors_1.BrandPendingApprovalError; } });
+Object.defineProperty(exports, "IdempotencyConflictError", { enumerable: true, get: function () { return errors_1.IdempotencyConflictError; } });
+Object.defineProperty(exports, "ApiKeyRevokedError", { enumerable: true, get: function () { return errors_1.ApiKeyRevokedError; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "OtpChannel", { enumerable: true, get: function () { return types_1.OtpChannel; } });
+Object.defineProperty(exports, "ErrorCode", { enumerable: true, get: function () { return types_1.ErrorCode; } });
+Object.defineProperty(exports, "TEST_PHONE_NUMBERS", { enumerable: true, get: function () { return types_1.TEST_PHONE_NUMBERS; } });
+Object.defineProperty(exports, "TEST_OTP_CODE", { enumerable: true, get: function () { return types_1.TEST_OTP_CODE; } });
+// Default export
+var otp_client_2 = require("./otp-client");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return otp_client_2.OtpClient; } });

package/dist/otp-client.d.ts

@@ -0,0 +1,184 @@
+import { OtpClientConfig, SendOtpOptions, SendOtpResponse, VerifyOtpOptions, VerifyOtpResponse, ResendOtpOptions, OtpStatus, OtpStatusWithCode, SdkConfiguration } from './types';
+/**
+ * Main OTP client for interacting with the OTP verification service
+ *
+ * @example
+ * ```typescript
+ * const client = new OtpClient({ apiKey: 'your-api-key' });
+ *
+ * // Send an OTP
+ * const result = await client.sendOtp({
+ *   phoneNumber: '+995555123456',
+ *   channel: OtpChannel.SMS,
+ * });
+ *
+ * // Verify the OTP
+ * const verification = await client.verifyOtp({
+ *   requestId: result.requestId,
+ *   code: '123456',
+ * });
+ * ```
+ */
+export declare class OtpClient {
+    private http;
+    private serverConfig;
+    private serverConfigFetchedAt;
+    private readonly CONFIG_CACHE_TTL;
+    /**
+     * Create a new OTP client
+     *
+     * @param config - Configuration options
+     */
+    constructor(config: OtpClientConfig);
+    /**
+     * Send an OTP to a phone number
+     *
+     * @param options - Options for sending the OTP
+     * @returns Promise resolving to the OTP request details
+     *
+     * @example
+     * ```typescript
+     * const result = await client.sendOtp({
+     *   phoneNumber: '+995555123456',
+     *   channel: OtpChannel.SMS,
+     *   ttl: 300,
+     *   length: 6,
+     *   metadata: { userId: '12345' }
+     * });
+     *
+     * console.log(result.requestId); // Save this for verification
+     * console.log(result.expiresAt);
+     * ```
+     */
+    sendOtp(options: SendOtpOptions): Promise<SendOtpResponse>;
+    /**
+     * Verify an OTP code
+     *
+     * @param options - Options for verifying the OTP
+     * @returns Promise resolving to the verification result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.verifyOtp({
+     *   requestId: 'req_123456',
+     *   code: '123456',
+     *   ipAddress: '192.168.1.1',
+     *   userAgent: 'Mozilla/5.0...'
+     * });
+     *
+     * if (result.success) {
+     *   console.log('OTP verified successfully!');
+     * }
+     * ```
+     */
+    verifyOtp(options: VerifyOtpOptions): Promise<VerifyOtpResponse>;
+    /**
+     * Resend an OTP (generates a new code for the same phone number)
+     *
+     * @param options - Options for resending the OTP
+     * @returns Promise resolving to the new OTP request details
+     *
+     * @example
+     * ```typescript
+     * const result = await client.resendOtp({
+     *   requestId: 'req_123456'
+     * });
+     *
+     * console.log('New OTP sent:', result.requestId);
+     * ```
+     */
+    resendOtp(options: ResendOtpOptions): Promise<SendOtpResponse>;
+    /**
+     * Get OTP status (authenticated endpoint)
+     *
+     * @param requestId - The request ID from sendOtp()
+     * @returns Promise resolving to the OTP status
+     *
+     * @example
+     * ```typescript
+     * const status = await client.getStatus('req_123456');
+     * console.log(status.status); // 'PENDING' | 'SENT' | 'VERIFIED' | 'EXPIRED' | 'FAILED'
+     * console.log(status.attempts); // Number of verification attempts
+     * console.log(status.isExpired); // Whether OTP is expired
+     * ```
+     */
+    getStatus(requestId: string): Promise<OtpStatus>;
+    /**
+     * Get OTP status with code (public endpoint for testing/development)
+     *
+     * ⚠️ WARNING: This endpoint returns the actual OTP code and should ONLY be used
+     * in development/testing environments! Never use in production client code.
+     *
+     * This method polls for up to 30 seconds waiting for SMS delivery.
+     *
+     * @param requestId - The request ID from sendOtp()
+     * @returns Promise resolving to the OTP status with code
+     *
+     * @example
+     * ```typescript
+     * // For automated testing only!
+     * const status = await client.getStatusWithCode('req_123456');
+     * console.log(status.otpCode); // The actual OTP code
+     * console.log(status.smsProvider); // Which provider was used
+     * ```
+     */
+    getStatusWithCode(requestId: string): Promise<OtpStatusWithCode>;
+    /**
+     * Get SDK configuration from server
+     *
+     * Fetches and caches configuration from the server. The configuration includes
+     * rate limits, supported features, test mode status, and more. Results are
+     * cached for 1 hour.
+     *
+     * @param forceRefresh - Force refresh the cached configuration
+     * @returns Promise resolving to the SDK configuration
+     *
+     * @example
+     * ```typescript
+     * const config = await client.getConfig();
+     * console.log(config.features.testMode); // Check if test mode is enabled
+     * console.log(config.otpConfig.length); // Default OTP length
+     * console.log(config.rateLimits); // Rate limit information
+     * ```
+     */
+    getConfig(forceRefresh?: boolean): Promise<SdkConfiguration>;
+    /**
+     * Test connectivity to the OTP service
+     *
+     * @returns Promise resolving to true if connection is successful
+     *
+     * @example
+     * ```typescript
+     * const isConnected = await client.testConnection();
+     * if (isConnected) {
+     *   console.log('✓ Connected to OTP service');
+     * }
+     * ```
+     */
+    testConnection(): Promise<boolean>;
+    /**
+     * Check if server is in test mode
+     *
+     * @returns Promise resolving to true if test mode is enabled
+     *
+     * @example
+     * ```typescript
+     * const testMode = await client.isTestMode();
+     * if (testMode) {
+     *   console.log('Server is in test mode - use test phone numbers');
+     * }
+     * ```
+     */
+    isTestMode(): Promise<boolean>;
+    /**
+     * Generate a unique idempotency key
+     *
+     * @returns A unique idempotency key in the format `{timestamp}-{random}`
+     */
+    private generateIdempotencyKey;
+    /**
+     * Validate phone number format (E.164)
+     */
+    private validatePhoneNumber;
+}
+//# sourceMappingURL=otp-client.d.ts.map

package/dist/otp-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otp-client.d.ts","sourceRoot":"","sources":["../src/otp-client.ts"],"names":[],"mappings":"AACA,OAAO,EACL,eAAe,EACf,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAEhB,SAAS,EACT,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,YAAY,CAAiC;IACrD,OAAO,CAAC,qBAAqB,CAAuB;IACpD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAW;IAE5C;;;;OAIG;gBACS,MAAM,EAAE,eAAe;IAgBnC;;;;;;;;;;;;;;;;;;;OAmBG;IACG,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;IA0BhE;;;;;;;;;;;;;;;;;;;OAmBG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAmBtE;;;;;;;;;;;;;;OAcG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAuBpE;;;;;;;;;;;;;OAaG;IACG,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAgBtD;;;;;;;;;;;;;;;;;;OAkBG;IACG,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAkBtE;;;;;;;;;;;;;;;;;OAiBG;IACG,SAAS,CAAC,YAAY,UAAQ,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA6BhE;;;;;;;;;;;;OAYG;IACG,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;IASxC;;;;;;;;;;;;OAYG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IASpC;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAM9B;;OAEG;IACH,OAAO,CAAC,mBAAmB;CAQ5B"}