SDK Initialization

/**
 * Initialize the Zoho CRM SDK with comprehensive configuration
 * @returns Promise that resolves when initialization is complete
 */
class InitializeBuilder {
    /** Set the user signature for CRM operations */
    user(user: UserSignature): InitializeBuilder;
    /** Set the data center environment */
    environment(environment: Environment): InitializeBuilder;
    /** Set the authentication token */
    token(token: Token): InitializeBuilder;
    /** Set the token storage mechanism */
    store(store: TokenStore): InitializeBuilder;
    /** Set SDK configuration options */
    SDKConfig(config: SDKConfig): InitializeBuilder;
    /** Set the resource path for storing user-specific files */
    resourcePath(path: string): InitializeBuilder;
    /** Set the logger instance */
    logger(logger: Logger): InitializeBuilder;
    /** Set proxy configuration for API requests */
    requestProxy(proxy: RequestProxy): InitializeBuilder;
    /** Execute the initialization */
    initialize(): Promise<void>;
    /** Switch to a different user configuration */
    switchUser(): Promise<void>;
}

const { InitializeBuilder } = require("@zohocrm/nodejs-sdk-2.0/routes/initialize_builder");
const { UserSignature } = require("@zohocrm/nodejs-sdk-2.0/routes/user_signature");
const { OAuthBuilder } = require("@zohocrm/nodejs-sdk-2.0/models/authenticator/oauth_builder");
const { USDataCenter } = require("@zohocrm/nodejs-sdk-2.0/routes/dc/us_data_center");
const { FileStore } = require("@zohocrm/nodejs-sdk-2.0/models/authenticator/store/file_store");
const { LogBuilder } = require("@zohocrm/nodejs-sdk-2.0/routes/logger/log_builder");
const { Levels } = require("@zohocrm/nodejs-sdk-2.0/routes/logger/logger");
const { SDKConfigBuilder } = require("@zohocrm/nodejs-sdk-2.0/routes/sdk_config_builder");

async function initializeSDK() {
    // Create user signature
    const user = new UserSignature("user@example.com");

    // Set environment
    const environment = USDataCenter.PRODUCTION();

    // Configure OAuth token
    const token = new OAuthBuilder()
        .clientId("your_client_id")
        .clientSecret("your_client_secret")
        .refreshToken("your_refresh_token")
        .redirectURL("your_redirect_url")
        .build();

    // Setup token storage
    const tokenStore = new FileStore("/path/to/tokens.txt");

    // Configure logging
    const logger = new LogBuilder()
        .level(Levels.INFO)
        .filePath("/path/to/sdk_logs.log")
        .build();

    // SDK configuration
    const sdkConfig = new SDKConfigBuilder()
        .autoRefreshFields(true)
        .pickListValidation(true)
        .build();

    // Initialize
    await new InitializeBuilder()
        .user(user)
        .environment(environment)
        .token(token)
        .store(tokenStore)
        .SDKConfig(sdkConfig)
        .resourcePath("/path/to/resources")
        .logger(logger)
        .initialize();
}

/**
 * Represents a user in the CRM system
 */
class UserSignature {
    /** Create a user signature with email */
    constructor(email: string);
    /** Get the user's email address */
    getEmail(): string;
}

/**
 * Switch to a different user configuration
 */
class InitializeBuilder {
    /** Switch to different user context */
    switchUser(): Promise<void>;
}

/**
 * Remove a user's configuration from the SDK
 * @param user - The user to remove
 * @param environment - The environment to remove the user from
 */
class Initializer {
    static removeUserConfiguration(user: UserSignature, environment: Environment): Promise<void>;
}

const { InitializeBuilder } = require("@zohocrm/nodejs-sdk-2.0/routes/initialize_builder");
const { Initializer } = require("@zohocrm/nodejs-sdk-2.0/routes/initializer");

// Initialize first user
const user1 = new UserSignature("user1@example.com");
const token1 = new OAuthBuilder()
    .clientId("client_id_1")
    .clientSecret("client_secret_1")
    .refreshToken("refresh_token_1")
    .redirectURL("redirect_url_1")
    .build();

await new InitializeBuilder()
    .user(user1)
    .environment(USDataCenter.PRODUCTION())
    .token(token1)
    .initialize();

// Perform operations as user1...

// Switch to second user
const user2 = new UserSignature("user2@example.com");
const token2 = new OAuthBuilder()
    .clientId("client_id_2")
    .clientSecret("client_secret_2")
    .refreshToken("refresh_token_2")
    .redirectURL("redirect_url_2")
    .build();

await new InitializeBuilder()
    .user(user2)
    .environment(EUDataCenter.SANDBOX())
    .token(token2)
    .switchUser();

// Perform operations as user2...

// Remove user1 configuration
await Initializer.removeUserConfiguration(user1, USDataCenter.PRODUCTION());

/**
 * SDK configuration options
 */
class SDKConfig {
    /** Whether to auto-refresh module fields in the background */
    autoRefreshFields: boolean;
    /** Whether to validate picklist values */
    pickListValidation: boolean;
}

/**
 * Builder for SDK configuration
 */
class SDKConfigBuilder {
    /** Enable/disable automatic field refresh (default: false) */
    autoRefreshFields(autoRefreshFields: boolean): SDKConfigBuilder;
    /** Enable/disable picklist validation (default: true) */
    pickListValidation(pickListValidation: boolean): SDKConfigBuilder;
    /** Build the configuration */
    build(): SDKConfig;
}

/**
 * Logger configuration builder
 */
class LogBuilder {
    /** Set logging level */
    level(level: LogLevel): LogBuilder;
    /** Set log file path */
    filePath(filePath: string): LogBuilder;
    /** Build the logger */
    build(): Logger;
}

/**
 * Available logging levels
 */
class Levels {
    static ERROR: LogLevel;
    static WARN: LogLevel;
    static INFO: LogLevel;
    static HTTP: LogLevel;
    static VERBOSE: LogLevel;
    static DEBUG: LogLevel;
    static SILLY: LogLevel;
}

/**
 * HTTP proxy configuration
 */
class RequestProxy {
    host: string;
    port: number;
    user?: string;
    password?: string;
}

/**
 * Builder for proxy configuration
 */
class ProxyBuilder {
    /** Set proxy host */
    host(host: string): ProxyBuilder;
    /** Set proxy port */
    port(port: number): ProxyBuilder;
    /** Set proxy username (optional) */
    user(user: string): ProxyBuilder;
    /** Set proxy password (optional) */
    password(password: string): ProxyBuilder;
    /** Build the proxy configuration */
    build(): RequestProxy;
}

const { ProxyBuilder } = require("@zohocrm/nodejs-sdk-2.0/routes/proxy_builder");

const proxy = new ProxyBuilder()
    .host("proxy.company.com")
    .port(8080)
    .user("proxy_user")
    .password("proxy_password")
    .build();

await new InitializeBuilder()
    .user(user)
    .environment(environment)
    .token(token)
    .requestProxy(proxy)
    .initialize();

/**
 * Manages query parameters for API requests
 */
class ParameterMap {
    /** Add a parameter to the map */
    add(param: Param, value: any): Promise<void>;
}

/**
 * Manages HTTP headers for API requests
 */
class HeaderMap {
    /** Add a header to the map */
    add(header: Header, value: any): Promise<void>;
}

/**
 * Represents a query parameter
 */
class Param {
    constructor(name: string, className: string);
}

/**
 * Represents an HTTP header
 */
class Header {
    constructor(name: string, className: string);
}