@finspringinnovations/fdsdk 0.0.1

package/lib/config/apiConfig.d.ts

@@ -0,0 +1,34 @@
+import 'react-native-get-random-values';
+export declare const logEnvLoaderValues: () => void;
+export type Environment = 'development' | 'staging' | 'production';
+export interface ApiConfig {
+    baseUrl: string;
+    timeout: number;
+    retryAttempts: number;
+    enableEncryption: boolean;
+    enableLogging: boolean;
+    headers: Record<string, string>;
+    allowEncryptionToggle?: boolean;
+}
+export declare const getEnvironment: () => Environment;
+export declare const getApiConfig: (env?: Environment) => ApiConfig;
+export declare const getSecureHeaders: (env?: Environment) => Record<string, string>;
+export declare const validateApiConfig: (config: ApiConfig) => boolean;
+export declare const getEnvironmentConfig: () => {
+    environment: Environment;
+    config: ApiConfig;
+    isProduction: boolean;
+    isDevelopment: boolean;
+    isStaging: boolean;
+};
+export declare const debugApiConfig: () => void;
+export declare const debugApiCall: (endpoint: string, method?: string) => {
+    url: string;
+    headers: Record<string, string>;
+    environment: Environment;
+    encryptionEnabled: boolean;
+    hasApiKey: boolean;
+};
+export declare const logEnvironmentInfo: () => void;
+export declare const logEnvironmentDetails: () => void;
+export default getApiConfig;

package/lib/config/apiConfig.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logEnvironmentDetails = exports.logEnvironmentInfo = exports.debugApiCall = exports.debugApiConfig = exports.getEnvironmentConfig = exports.validateApiConfig = exports.getSecureHeaders = exports.getApiConfig = exports.getEnvironment = exports.logEnvLoaderValues = void 0;
+// API Configuration with values from main app
+require("react-native-get-random-values");
+const appDataConfig_1 = require("./appDataConfig");
+const logEnvLoaderValues = () => {
+    // Environment values logging removed for security
+};
+exports.logEnvLoaderValues = logEnvLoaderValues;
+// Environment detection - using hardcoded default
+const getEnvironment = () => {
+    // Default to development for hardcoded configuration
+    return 'development';
+};
+exports.getEnvironment = getEnvironment;
+// Common configuration shared by all environments
+const COMMON_CONFIG = {
+    timeout: 60000,
+    retryAttempts: 3,
+    enableEncryption: true,
+    enableLogging: true,
+    allowEncryptionToggle: true,
+    headersBase: {
+        'X-Client-Version': '1.0.0',
+    },
+};
+const API_ENDPOINTS = {
+    development: Object.assign(Object.assign({}, COMMON_CONFIG), { baseUrl: '', headers: Object.assign(Object.assign({}, COMMON_CONFIG.headersBase), { 'X-Environment': 'development', 'X-API-Key': '' }) })
+};
+// Get API configuration for current environment
+const getApiConfig = (env) => {
+    // Get environment data from main app first
+    const environmentData = (0, appDataConfig_1.getEnvironmentData)();
+    // Use environment from EnvironmentData if available, otherwise use parameter or default
+    // const currentEnv = env || environmentData?.environment || getEnvironment();
+    const config = API_ENDPOINTS.development;
+    // Create a new config object to avoid read-only issues
+    let finalConfig = Object.assign({}, config);
+    // Override configuration with values from main app if available
+    if (environmentData) {
+        // Override base URL if provided by main app
+        if (environmentData.apiBaseUrl) {
+            // finalConfig.baseUrl = environmentData.apiBaseUrl as any;
+            finalConfig = Object.assign(Object.assign({}, finalConfig), { baseUrl: environmentData.apiBaseUrl });
+        }
+        // Override API key if provided by main app
+        if (environmentData.apiKey) {
+            finalConfig.headers = Object.assign(Object.assign({}, finalConfig.headers), { 'X-API-Key': environmentData.apiKey });
+        }
+        // Override environment if provided by main app
+        if (environmentData.environment) {
+            finalConfig.headers = Object.assign(Object.assign({}, finalConfig.headers), { 'X-Environment': environmentData.environment });
+        }
+    }
+    // Use secure logger for API configuration logging
+    // Validate configuration
+    if (!finalConfig.baseUrl) {
+        throw new Error(`Missing API base URL `);
+    }
+    return Object.assign(Object.assign({}, finalConfig), { baseUrl: sanitizeUrl(finalConfig.baseUrl) });
+};
+exports.getApiConfig = getApiConfig;
+// Sanitize and validate URL
+const sanitizeUrl = (url) => {
+    if (!url || typeof url !== 'string') {
+        throw new Error(`Invalid API URL: ${url}`);
+    }
+    // Trim leading and trailing spaces
+    let sanitized = url.trim();
+    // Basic URL validation - check if it starts with http:// or https://
+    if (!sanitized.match(/^https?:\/\//)) {
+        throw new Error(`Invalid API URL format: ${sanitized}`);
+    }
+    // Ensure HTTPS in production
+    if ((0, exports.getEnvironment)() === 'production' && !sanitized.startsWith('https://')) {
+        throw new Error('Production API must use HTTPS');
+    }
+    // Remove trailing slash
+    return sanitized.replace(/\/$/, '');
+};
+// Get secure headers for API requests
+const getSecureHeaders = (env) => {
+    const config = (0, exports.getApiConfig)(env);
+    //const currentEnv = env || getEnvironment();
+    return Object.assign(Object.assign({}, config.headers), { 'Content-Type': 'application/json', 'Accept': 'application/json', 'User-Agent': `ShriramSDK/'1.0.0'`, 'X-Timestamp': Date.now().toString(), 'X-Request-ID': generateRequestId() });
+};
+exports.getSecureHeaders = getSecureHeaders;
+// Generate unique request ID
+const generateRequestId = () => {
+    return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+};
+// Validate environment configuration
+const validateApiConfig = (config) => {
+    const errors = [];
+    if (!config.baseUrl) {
+        errors.push('Base URL is required');
+    }
+    if (config.timeout < 5000) {
+        errors.push('Timeout should be at least 5 seconds');
+    }
+    if (config.retryAttempts < 0 || config.retryAttempts > 5) {
+        errors.push('Retry attempts should be between 0 and 5');
+    }
+    // Validate URL format without using new URL (React Native compatible)
+    if (config.baseUrl && !config.baseUrl.match(/^https?:\/\//)) {
+        errors.push('Invalid base URL format - must start with http:// or https://');
+    }
+    if (errors.length > 0) {
+        return false;
+    }
+    return true;
+};
+exports.validateApiConfig = validateApiConfig;
+// Get environment-specific configuration
+const getEnvironmentConfig = () => {
+    const env = (0, exports.getEnvironment)();
+    const config = (0, exports.getApiConfig)(env);
+    return {
+        environment: env,
+        config,
+        isProduction: env === 'production',
+        isDevelopment: env === 'development',
+        isStaging: env === 'staging',
+    };
+};
+exports.getEnvironmentConfig = getEnvironmentConfig;
+// Debug configuration (works in all environments now)
+const debugApiConfig = () => {
+    // API Configuration debug complete
+};
+exports.debugApiConfig = debugApiConfig;
+// New utility to help clients debug 403 errors
+const debugApiCall = (endpoint, method = 'GET') => {
+    const config = (0, exports.getApiConfig)();
+    const headers = (0, exports.getSecureHeaders)();
+    // API Call debug complete
+    return {
+        url: `${config.baseUrl || ''}/${endpoint}`,
+        headers,
+        environment: (0, exports.getEnvironment)(),
+        encryptionEnabled: config.enableEncryption,
+        hasApiKey: !!headers['X-API-Key']
+    };
+};
+exports.debugApiCall = debugApiCall;
+// Environment logging utility
+const logEnvironmentInfo = () => {
+    // Environment logging removed for security
+};
+exports.logEnvironmentInfo = logEnvironmentInfo;
+// Function to log environment details (can be called from anywhere)
+const logEnvironmentDetails = () => {
+    // Environment details logging removed for security
+};
+exports.logEnvironmentDetails = logEnvironmentDetails;
+// Export default configuration
+exports.default = exports.getApiConfig;

package/lib/config/appDataConfig.d.ts

@@ -0,0 +1,114 @@
+export interface EnvironmentData {
+    environment: string;
+    apiBaseUrl?: string;
+    apiKey?: string;
+    encryptionKey?: string;
+    enableLogging?: boolean;
+}
+export interface AppData {
+    id: string;
+    name: string;
+    dob: string;
+    gender: string;
+    mobNo: string;
+    email: string;
+    panNumber: string;
+    address?: string;
+    area?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    pinCode?: string;
+    accountNo?: string;
+    nameOfBank?: string;
+    ifsc?: string;
+    typeOfAccount?: string;
+    maritalStatus?: string;
+    userReferenceId?: string;
+    eventNotifyUrl?: string;
+}
+/**
+ * Initialize the SDK with app data from the main application
+ * This should be called when the SDK starts
+ */
+export declare const initializeSDK: (appData: AppData, onValidationError?: (errors: string[]) => void) => void;
+/**
+ * Initialize the SDK with environment configuration from the main application
+ * This should be called to configure SDK environment settings
+ */
+export declare const initializeEnvironment: (environmentData: EnvironmentData) => void;
+/**
+ * Get the current app data
+ */
+export declare const getAppData: () => AppData | null;
+/**
+ * Get the current environment data
+ */
+export declare const getEnvironmentData: () => EnvironmentData | null;
+/**
+ * Check if SDK is initialized with app data
+ */
+export declare const isSDKInitialized: () => boolean;
+/**
+ * Check if environment is initialized
+ */
+export declare const isEnvironmentInitialized: () => boolean;
+/**
+ * Get specific user information for API requests
+ */
+export declare const getUserInfoForAPI: () => {
+    id: string;
+    name: string;
+    dob: string;
+    gender: string;
+    panNumber: string;
+    mobileNumber: string;
+    email: string;
+    eventNotifyUrl: string | undefined;
+    userReferenceId: string;
+    address: {
+        line1: string | undefined;
+        area: string | undefined;
+        city: string | undefined;
+        state: string | undefined;
+        country: string | undefined;
+        pinCode: string | undefined;
+    };
+    bankDetails: {
+        accountNumber: string | undefined;
+        bankName: string | undefined;
+        ifsc: string | undefined;
+        accountType: string | undefined;
+    };
+    maritalStatus: string | undefined;
+};
+/**
+ * Get user demographics for interest rate calculations
+ */
+export declare const getUserDemographics: () => {
+    age: number;
+    isSeniorCitizen: boolean;
+    isWomenDepositor: boolean;
+    gender: string;
+    maritalStatus: string | undefined;
+    dob: string;
+};
+/**
+ * Validate app data
+ */
+export declare const validateAppData: (appData: AppData) => {
+    isValid: boolean;
+    errors: string[];
+};
+/**
+ * Clear app data (for testing or logout scenarios)
+ */
+export declare const clearAppData: () => void;
+/**
+ * Clear environment data (for testing or logout scenarios)
+ */
+export declare const clearEnvironmentData: () => void;
+/**
+ * Clear all data (app data and environment data)
+ */
+export declare const clearAllData: () => void;

package/lib/config/appDataConfig.js

@@ -0,0 +1,264 @@
+"use strict";
+// AppData Configuration - Data received from main app when SDK starts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearAllData = exports.clearEnvironmentData = exports.clearAppData = exports.validateAppData = exports.getUserDemographics = exports.getUserInfoForAPI = exports.isEnvironmentInitialized = exports.isSDKInitialized = exports.getEnvironmentData = exports.getAppData = exports.initializeEnvironment = exports.initializeSDK = void 0;
+// Global app data storage
+let globalAppData = null;
+// Global environment data storage
+let globalEnvironmentData = null;
+/**
+ * Initialize the SDK with app data from the main application
+ * This should be called when the SDK starts
+ */
+const initializeSDK = (appData, onValidationError) => {
+    // Validate required user identification fields
+    const requiredFields = [
+        { field: 'id', label: 'User ID' },
+        { field: 'name', label: 'User Name' },
+        { field: 'dob', label: 'Date of Birth' },
+        { field: 'gender', label: 'Gender' },
+        { field: 'mobNo', label: 'Mobile Number' },
+        { field: 'email', label: 'Email' },
+        { field: 'panNumber', label: 'PAN Number' },
+    ];
+    const missingFields = [];
+    requiredFields.forEach(({ field, label }) => {
+        const value = appData[field];
+        if (!value || (typeof value === 'string' && !value.trim())) {
+            missingFields.push(label);
+        }
+    });
+    // If required fields are missing, call error handler
+    if (missingFields.length > 0) {
+        const errorMessage = `Missing required user information from main app:\n${missingFields.join(', ')}`;
+        if (onValidationError) {
+            onValidationError(missingFields);
+        }
+        throw new Error(errorMessage);
+    }
+    // Validate all fields
+    const validation = (0, exports.validateAppData)(appData);
+    if (!validation.isValid) {
+        if (onValidationError) {
+            onValidationError(validation.errors);
+        }
+        throw new Error(`App data validation failed: ${validation.errors.join(', ')}`);
+    }
+    globalAppData = appData;
+    // SDK initialization started
+    try {
+        // logging removed
+    }
+    catch (_a) { }
+    // Import and call environment logging
+    Promise.resolve().then(() => __importStar(require('./apiConfig'))).then(({ logEnvironmentInfo }) => {
+        logEnvironmentInfo();
+    });
+};
+exports.initializeSDK = initializeSDK;
+/**
+ * Initialize the SDK with environment configuration from the main application
+ * This should be called to configure SDK environment settings
+ */
+const initializeEnvironment = (environmentData) => {
+    globalEnvironmentData = environmentData;
+    // Environment initialization started
+    try {
+        // logging removed
+    }
+    catch (_a) { }
+    // Environment initialized
+};
+exports.initializeEnvironment = initializeEnvironment;
+/**
+ * Get the current app data
+ */
+const getAppData = () => {
+    return globalAppData;
+};
+exports.getAppData = getAppData;
+/**
+ * Get the current environment data
+ */
+const getEnvironmentData = () => {
+    return globalEnvironmentData;
+};
+exports.getEnvironmentData = getEnvironmentData;
+/**
+ * Check if SDK is initialized with app data
+ */
+const isSDKInitialized = () => {
+    return globalAppData !== null;
+};
+exports.isSDKInitialized = isSDKInitialized;
+/**
+ * Check if environment is initialized
+ */
+const isEnvironmentInitialized = () => {
+    return globalEnvironmentData !== null;
+};
+exports.isEnvironmentInitialized = isEnvironmentInitialized;
+/**
+ * Get specific user information for API requests
+ */
+const getUserInfoForAPI = () => {
+    if (!globalAppData) {
+        throw new Error('SDK not initialized. Call initializeSDK() first.');
+    }
+    return {
+        id: globalAppData.id,
+        name: globalAppData.name,
+        dob: globalAppData.dob,
+        gender: globalAppData.gender,
+        panNumber: globalAppData.panNumber,
+        mobileNumber: globalAppData.mobNo,
+        email: globalAppData.email,
+        eventNotifyUrl: globalAppData.eventNotifyUrl,
+        userReferenceId: globalAppData.id, // Use userReferenceId or fallback to id
+        address: {
+            line1: globalAppData.address,
+            area: globalAppData.area,
+            city: globalAppData.city,
+            state: globalAppData.state,
+            country: globalAppData.country,
+            pinCode: globalAppData.pinCode,
+        },
+        bankDetails: {
+            accountNumber: globalAppData.accountNo,
+            bankName: globalAppData.nameOfBank,
+            ifsc: globalAppData.ifsc,
+            accountType: globalAppData.typeOfAccount,
+        },
+        maritalStatus: globalAppData.maritalStatus,
+    };
+};
+exports.getUserInfoForAPI = getUserInfoForAPI;
+/**
+ * Get user demographics for interest rate calculations
+ */
+const getUserDemographics = () => {
+    if (!globalAppData) {
+        throw new Error('SDK not initialized. Call initializeSDK() first.');
+    }
+    // Calculate age from DOB
+    const calculateAge = (dob) => {
+        const today = new Date();
+        const birthDate = new Date(dob);
+        let age = today.getFullYear() - birthDate.getFullYear();
+        const monthDiff = today.getMonth() - birthDate.getMonth();
+        if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birthDate.getDate())) {
+            age--;
+        }
+        return age;
+    };
+    const age = calculateAge(globalAppData.dob);
+    const isSeniorCitizen = age >= 60;
+    const isWomenDepositor = globalAppData.gender === 'Female' || globalAppData.gender === 'female';
+    return {
+        age,
+        isSeniorCitizen,
+        isWomenDepositor,
+        gender: globalAppData.gender,
+        maritalStatus: globalAppData.maritalStatus,
+        dob: globalAppData.dob,
+    };
+};
+exports.getUserDemographics = getUserDemographics;
+/**
+ * Validate app data
+ */
+const validateAppData = (appData) => {
+    var _a, _b, _c, _d, _e, _f;
+    const errors = [];
+    // Required fields validation
+    if (!((_a = appData.id) === null || _a === void 0 ? void 0 : _a.trim()))
+        errors.push('ID is required');
+    if (!((_b = appData.name) === null || _b === void 0 ? void 0 : _b.trim()))
+        errors.push('Name is required');
+    if (!((_c = appData.dob) === null || _c === void 0 ? void 0 : _c.trim()))
+        errors.push('Date of birth is required');
+    if (!appData.gender)
+        errors.push('Gender is required');
+    if (!((_d = appData.mobNo) === null || _d === void 0 ? void 0 : _d.trim()))
+        errors.push('Mobile number is required');
+    if (!((_e = appData.email) === null || _e === void 0 ? void 0 : _e.trim()))
+        errors.push('Email is required');
+    if (!((_f = appData.panNumber) === null || _f === void 0 ? void 0 : _f.trim()))
+        errors.push('PAN number is required');
+    // Format validation (only if fields are provided)
+    if (appData.dob && !/^\d{4}-\d{2}-\d{2}$/.test(appData.dob)) {
+        errors.push('Date of birth must be in YYYY-MM-DD format');
+    }
+    if (appData.panNumber && !/^[A-Z]{5}[0-9]{4}[A-Z]{1}$/.test(appData.panNumber)) {
+        errors.push('PAN number must be in valid format (e.g., ABCDE1234F)');
+    }
+    if (appData.mobNo && !/^[6-9]\d{9}$/.test(appData.mobNo)) {
+        errors.push('Mobile number must be 10 digits starting with 6-9');
+    }
+    if (appData.email && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(appData.email)) {
+        errors.push('Email must be in valid format');
+    }
+    if (appData.ifsc && appData.ifsc.trim() && !/^[A-Z]{4}0[A-Z0-9]{6}$/.test(appData.ifsc)) {
+        errors.push('IFSC code must be in valid format (e.g., SBIN0001234)');
+    }
+    return {
+        isValid: errors.length === 0,
+        errors,
+    };
+};
+exports.validateAppData = validateAppData;
+/**
+ * Clear app data (for testing or logout scenarios)
+ */
+const clearAppData = () => {
+    globalAppData = null;
+};
+exports.clearAppData = clearAppData;
+/**
+ * Clear environment data (for testing or logout scenarios)
+ */
+const clearEnvironmentData = () => {
+    globalEnvironmentData = null;
+};
+exports.clearEnvironmentData = clearEnvironmentData;
+/**
+ * Clear all data (app data and environment data)
+ */
+const clearAllData = () => {
+    globalAppData = null;
+    globalEnvironmentData = null;
+};
+exports.clearAllData = clearAllData;

package/lib/config/encryptionConfig.d.ts

@@ -0,0 +1,21 @@
+import { EncryptionConfig } from '../utils/encryption';
+export declare const getEncryptionConfig: () => EncryptionConfig;
+export declare const getEncryptionConfigs: () => {
+    development: {
+        secretKey: string;
+        algorithm: "AES";
+        ivLength: number;
+    };
+    staging: {
+        secretKey: string;
+        algorithm: "AES";
+        ivLength: number;
+    };
+    production: {
+        secretKey: string;
+        algorithm: "AES";
+        ivLength: number;
+    };
+};
+export declare const getEnvironmentConfig: (env?: "development" | "staging" | "production") => EncryptionConfig;
+export declare const validateEncryptionConfig: (config: EncryptionConfig) => boolean;

package/lib/config/encryptionConfig.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEncryptionConfig = exports.getEnvironmentConfig = exports.getEncryptionConfigs = exports.getEncryptionConfig = void 0;
+const appDataConfig_1 = require("./appDataConfig");
+//Encryption configuration from environment data
+const getEncryptionConfig = () => {
+    const environmentData = (0, appDataConfig_1.getEnvironmentData)();
+    // Use environment data if available
+    if (environmentData === null || environmentData === void 0 ? void 0 : environmentData.encryptionKey) {
+        return {
+            secretKey: environmentData.encryptionKey,
+            algorithm: 'AES',
+            ivLength: 16,
+        };
+    }
+    // If no environment data, throw error to ensure proper initialization
+    throw new Error('Environment data not initialized. Call initializeEnvironment() first.');
+};
+exports.getEncryptionConfig = getEncryptionConfig;
+// Configuration for different environments - using environment data
+const getEncryptionConfigs = () => {
+    const environmentData = (0, appDataConfig_1.getEnvironmentData)();
+    if (!(environmentData === null || environmentData === void 0 ? void 0 : environmentData.encryptionKey)) {
+        throw new Error('Environment data not initialized. Call initializeEnvironment() first.');
+    }
+    return {
+        development: {
+            secretKey: environmentData.encryptionKey,
+            algorithm: 'AES',
+            ivLength: 16,
+        },
+        staging: {
+            secretKey: environmentData.encryptionKey,
+            algorithm: 'AES',
+            ivLength: 16,
+        },
+        production: {
+            secretKey: environmentData.encryptionKey,
+            algorithm: 'AES',
+            ivLength: 16,
+        },
+    };
+};
+exports.getEncryptionConfigs = getEncryptionConfigs;
+// Get configuration based on environment
+const getEnvironmentConfig = (env = 'development') => {
+    const configs = (0, exports.getEncryptionConfigs)();
+    return configs[env];
+};
+exports.getEnvironmentConfig = getEnvironmentConfig;
+// Validate encryption configuration
+const validateEncryptionConfig = (config) => {
+    if (!config.secretKey || config.secretKey.length < 16) {
+        return false;
+    }
+    if (config.ivLength && (config.ivLength < 8 || config.ivLength > 32)) {
+        return false;
+    }
+    return true;
+};
+exports.validateEncryptionConfig = validateEncryptionConfig;

package/lib/config/workflowConstants.d.ts

@@ -0,0 +1,37 @@
+export declare const WORKFLOW_STATES: {
+    readonly INITIATION: 404;
+    readonly START: 405;
+    readonly KYC: 406;
+    readonly OCCUPATION: 409;
+    readonly NOMINEE: 407;
+    readonly BANK_DETAILS: 408;
+    readonly CREATE_FD: 411;
+    readonly PAYMENT: 410;
+    readonly END: 403;
+};
+export declare const WORKFLOW_TASKS: {
+    readonly RESEND_OTP: 11045;
+    readonly VALIDATE_OTP: 11047;
+};
+export type WorkflowState = typeof WORKFLOW_STATES[keyof typeof WORKFLOW_STATES];
+export type WorkflowTask = typeof WORKFLOW_TASKS[keyof typeof WORKFLOW_TASKS];
+export declare const getWorkflowStateName: (stateId: number) => string | undefined;
+export declare const getWorkflowTaskName: (taskId: number) => string | undefined;
+export declare const WORKFLOW_CONSTANTS: {
+    readonly STATES: {
+        readonly INITIATION: 404;
+        readonly START: 405;
+        readonly KYC: 406;
+        readonly OCCUPATION: 409;
+        readonly NOMINEE: 407;
+        readonly BANK_DETAILS: 408;
+        readonly CREATE_FD: 411;
+        readonly PAYMENT: 410;
+        readonly END: 403;
+    };
+    readonly TASKS: {
+        readonly RESEND_OTP: 11045;
+        readonly VALIDATE_OTP: 11047;
+    };
+};
+export default WORKFLOW_CONSTANTS;