interface MarketStatus {
    isOpen: string;
    asOf: string;
    id: number;
}

interface SecurityDetail {
    id: number;
    symbol: string;
    name: string;
    activeStatus: string;
    listingDate: Date;
    closePrice: number;
    businessDate: Date;
    fiftyTwoWeekHigh: number;
    fiftyTwoWeekLow: number;
    lastTradePrice: number;
}
interface SecurityDetailResponse {
    securityDailyTradeDto: SecurityDailyTradeDto;
    security: Security;
    stockListedShares: number;
    paidUpCapital: number;
    issuedCapital: number;
    marketCapitalization: number;
    publicShares: number;
    publicPercentage: number;
    promoterShares: number;
    promoterPercentage: number;
    updatedDate: Date;
    securityId: number;
}
interface Security {
    id: number;
    symbol: string;
    isin: string;
    permittedToTrade: string;
    listingDate: Date;
    creditRating: null;
    tickSize: number;
    instrumentType: InstrumentType;
    capitalGainBaseDate: Date;
    faceValue: number;
    highRangeDPR: null;
    issuerName: null;
    meInstanceNumber: number;
    parentId: null;
    recordType: number;
    schemeDescription: null;
    schemeName: null;
    secured: null;
    series: null;
    shareGroupId: ShareGroupID;
    activeStatus: string;
    divisor: number;
    cdsStockRefId: number;
    securityName: string;
    tradingStartDate: Date;
    networthBasePrice: number;
    securityTradeCycle: number;
    isPromoter: string;
    companyId: CompanyID;
}
interface CompanyID {
    id: number;
    companyShortName: string;
    companyName: string;
    email: string;
    companyWebsite: string;
    companyContactPerson: string;
    sectorMaster: SectorMaster;
    companyRegistrationNumber: string;
    activeStatus: string;
}
interface SectorMaster {
    id: number;
    sectorDescription: string;
    activeStatus: string;
    regulatoryBody: string;
}
interface InstrumentType {
    id: number;
    code: string;
    description: string;
    activeStatus: string;
}
interface ShareGroupID {
    id: number;
    name: string;
    description: string;
    capitalRangeMin: number;
    modifiedBy: null;
    modifiedDate: null;
    activeStatus: string;
    isDefault: string;
}
interface SecurityDailyTradeDto {
    securityId: string;
    openPrice: number;
    highPrice: number;
    lowPrice: number;
    totalTradeQuantity: number;
    totalTrades: number;
    lastTradedPrice: number;
    previousClose: number;
    businessDate: Date;
    closePrice: number;
    fiftyTwoWeekHigh: number;
    fiftyTwoWeekLow: number;
    lastUpdatedDateTime: Date;
}
interface Summary$1 {
    totalTurnoverRs: number;
    totalTradedShares: number;
    totalTransactions: number;
    totalScripsTraded: number;
    totalMarketCapitalizationRs: number;
    totalFloatMarketCapitalizationRs: number;
}
interface TopTradeScrips {
    symbol: string;
    shareTraded: number;
    closingPrice: number;
    securityName: string;
    securityId: number;
}
interface TopTransaction {
    securityId: number;
    totalTrades: number;
    lastTradedPrice: number;
    securityName: string;
    symbol: string;
}
interface TopTurnover {
    symbol: string;
    turnover: number;
    closingPrice: number;
    securityName: string;
    securityId: number;
}
interface TopGainerLoosers {
    symbol: string;
    ltp: number;
    pointChange: number;
    percentageChange: number;
    securityName: string;
    securityId: number;
}
interface IndexData {
    id: number;
    auditId: number | null;
    exchangeIndexId: number | null;
    generatedTime: string | null;
    index: string;
    close: number;
    high: number;
    low: number;
    previousClose: number;
    change: number;
    perChange: number;
    fiftyTwoWeekHigh: number;
    fiftyTwoWeekLow: number;
    currentValue: number;
}
interface NepseIndex {
    "Sensitive Float Index": IndexData;
    "Float Index": IndexData;
    "Sensitive Index": IndexData;
    "NEPSE Index": IndexData;
    [key: string]: IndexData;
}
type Timestamp = number;
type IndexValue = number;
type IndexDataPoint = [Timestamp, IndexValue];
type IndexIntradayData = IndexDataPoint[];
interface PriceVolumeItem {
    securityId: number;
    securityName: string;
    symbol: string;
    indexId: number;
    totalTradeQuantity: number;
    lastTradedPrice: number;
    percentageChange: number;
    previousClose: number;
}
type PriceVolume = PriceVolumeItem[];
interface SecurityItem {
    id: number;
    symbol: string;
    securityName: string;
    name: string;
    activeStatus: "A" | "I";
}
type SecurityList = SecurityItem[];
type CompanyStatus = "A" | "D" | "S";
type SectorName = "Commercial Banks" | "Hotels And Tourism" | "Others" | "Hydro Power" | "Tradings" | "Development Banks" | "Microfinance" | "Non Life Insurance" | "Life Insurance" | "Manufacturing And Processing" | "Finance" | "Investment" | "Mutual Fund";
type InstrumentTypes = "Equity" | "Mutual Funds" | "Preference Shares" | "Non-Convertible Debentures";
interface Company {
    id: number;
    companyName: string;
    symbol: string;
    securityName: string;
    status: CompanyStatus;
    companyEmail: string;
    website: string;
    sectorName: SectorName;
    regulatoryBody: string;
    instrumentType: InstrumentTypes;
}
type CompanyList = Company[];

interface Logger {
    log: (message: string) => void;
    warn: (message: string) => void;
    error: (message: string, error?: unknown) => void;
}
interface WorkerPoolOptions {
    minWorkers?: number;
    maxWorkers?: number;
    idleTimeout?: number;
    taskTimeout?: number;
    maxRetries?: number;
    scalingThreshold?: number;
    logger?: Logger;
}
declare class WorkerPool {
    private workers;
    private taskQueue;
    private pendingTasks;
    private logger;
    private readonly minWorkers;
    private readonly maxWorkers;
    private readonly idleTimeout;
    private readonly taskTimeout;
    private readonly maxRetries;
    private readonly scalingThreshold;
    private taskIdCounter;
    private workerIdCounter;
    private availableWorkerIds;
    private cleanupInterval;
    private isShuttingDown;
    constructor(options?: WorkerPoolOptions);
    private initializeWorkers;
    private generateTaskId;
    private generateWorkerId;
    private spawnWorker;
    private handleWorkerMessage;
    private handleWorkerError;
    private getAvailableWorker;
    private shouldScaleUp;
    private processQueue;
    private assignTaskToWorker;
    private handleTaskTimeout;
    private startCleanupInterval;
    private cleanupIdleWorkers;
    private cleanupStaleTask;
    private terminateWorker;
    runTask(action: string, payload?: unknown): Promise<unknown>;
    getStats(): {
        totalWorkers: number;
        busyWorkers: number;
        idleWorkers: number;
        queueLength: number;
        pendingTasks: number;
        totalTasksCompleted: number;
        totalErrors: number;
    };
    shutdown(): Promise<void>;
}

declare const nepseIndexes: readonly ["Banking SubIndex", "Development Bank Ind.", "Finance Index", "Hotels And Tourism", "HydroPower Index", "Investment", "Life Insurance", "Manufacturing And Pr.", "Microfinance Index", "Mutual Fund", "NEPSE Index", "Non Life Insurance", "Others Index", "Trading Index"];
type IndexKey = typeof nepseIndexes[number];

interface TopTransactions {
    symbol: string;
    name: string;
    ltp: number;
    transactions: number;
}
declare const INDEX_URL_MAP: Record<IndexKey, string>;
interface StockData {
    symbol: string;
    ltp: number;
    pointchange: number;
    percentchange: number;
    open: number;
    high: number;
    low: number;
    volume: number;
    previousclose: number;
}
interface AdvanceDecline {
    advance: number;
    decline: number;
    neutral: number;
}
interface SectorAdvanceDecline {
    advance: number;
    decline: number;
    neutral: number;
}
type AdvanceDeclineResult = {
    [K in IndexKey]: SectorAdvanceDecline;
};
type IndexHighLow = {
    [key in IndexKey]?: {
        high: number;
        low: number;
    };
};
type DashboardData = {
    gainers: Array<{
        symbol: string;
        name: string;
        ltp: number;
        pointchange: number;
        percentchange: number;
    }>;
    losers: Array<{
        symbol: string;
        name: string;
        ltp: number;
        pointchange: number;
        percentchange: number;
    }>;
    transactions: Array<{
        symbol: string;
        name: string;
        ltp: number;
        transactions: number;
    }>;
    turnovers: Array<{
        symbol: string;
        name: string;
        ltp: number;
        turnover: number;
    }>;
    traded: Array<{
        symbol: string;
        name: string;
        ltp: number;
        shareTraded: number;
    }>;
};
interface TopCompany {
    ticker: string;
    name: string;
    impact: number;
}
declare enum NepseSources {
    AbhiyanDaily = "Abhiyan Daily",
    Arthasarokar = "Arthasarokar",
    KarobarDaily = "Karobar Daily",
    Bizmandu = "Bizmandu",
    Arthapath = "Arthapath",
    Clickmandu = "Clickmandu",
    CapitalNepal = "Capital Nepal",
    BizKhabar = "BizKhabar",
    ArthaKendraNepali = "ArthaKendra Nepali",
    ArthaKendraEnglish = "ArthaKendra English",
    ShareSansar = "Share Sansar",
    MeroLagani = "Mero Lagani"
}
interface RestartResponse {
    success: boolean;
    message: string;
    statusCode?: number;
}
interface TopGainersApiResponse {
    symbol: string;
    securityName: string;
    ltp: number;
    pointChange: number;
    percentageChange: number;
}
interface Summary {
    "Total Turnover Rs:": number;
    "Total Traded Shares": number;
    "Total Transactions": number;
    "Total Scrips Traded": number;
}
interface TopTurnoversApiResponse {
    symbol: string;
    securityName: string;
    closingPrice: number;
    turnover: number;
}
interface SecurityDailyChart {
    contractRate: number;
    time: number;
}
interface PriceVolumeHistory$1 {
    businessDate: string;
    totalTrades: number;
    totalTradedQuantity: number;
    totalTradedValue: number;
    highPrice: number;
    lowPrice: number;
    closePrice: number;
}
interface LiveMarket {
    securityId: string;
    securityName: string;
    symbol: string;
    indexId: number;
    openPrice: number;
    highPrice: number;
    lowPrice: number;
    totalTradeQuantity: number;
    totalTradeValue: number;
    lastTradedPrice: number;
    percentageChange: number;
    lastUpdatedDateTime: string;
    lastTradedVolume: number;
    previousClose: number;
    averageTradedPrice: number;
    totalTradedVolume: number;
    numberOfTrades: number;
}
interface IndexHistoricalData$1 {
    id: number;
    businessDate: string;
    exchangeIndexId: number;
    closingIndex: number;
    openIndex: number;
    highIndex: number;
    lowIndex: number;
    fiftyTwoWeekHigh: number;
    fiftyTwoWeekLow: number;
    turnoverValue: number;
    turnoverVolume: number;
    totalTransaction: number;
    absChange: number;
    percentageChange: number;
}
type IndexHistoricalDataArray$1 = IndexHistoricalData$1[];
interface DisclosureResponse {
    exchangeMessages: ExchangeMessage[];
    companyNews: CompanyNewsItem[];
}
interface ExchangeMessage {
    id: number;
    messageTitle: string;
    messageBody: string;
    encryptedId: string | null;
    expiryDate: string;
    filePath: string | null;
    remarks: string | null;
    addedDate: string | null;
    modifiedDate: string | null;
    approvedDate: string | null;
}
interface CompanyNewsDocument {
    id: number;
    activeStatus: string;
    modifiedBy: string;
    modifiedDate: string;
    application: number;
    documentType: number;
    submittedDate: string;
    filePath: string;
    encryptedId: string;
}
interface CompanyNewsItem {
    id: number;
    newsHeadline: string;
    newsBody: string;
    newsSource: string;
    addedDate: string;
    modifiedDate: string;
    approvedDate: string | null;
    applicationDocumentDetailsList: CompanyNewsDocument[];
}

interface MarketDepthItem {
    stockId: number;
    orderBookOrderPrice: number;
    quantity: number;
    orderCount: number;
    isBuy: 1 | 2;
    buy: boolean;
    sell: boolean;
}
interface MarketDepth {
    buyMarketDepthList: MarketDepthItem[];
    sellMarketDepthList: MarketDepthItem[];
}
interface MarketDepthResponse {
    symbol: string;
    totalBuyQty: number;
    marketDepth: MarketDepth;
    totalSellQty: number;
    timeStamp: number;
    version: string;
}

interface SupplyDemand {
    symbol: string;
    totalOrder: number;
    totalQuantity: number;
    quantityPerOrder?: number;
    orderSide?: string;
    securityId?: string;
}
interface HighestOrderWithSupplyDemandData extends SupplyDemand {
    totalBuyOrder?: number;
    totalBuyQuantity?: number;
    totalSellOrder?: number;
    totalSellQuantity?: number;
    buyQuantityPerOrder?: number;
    sellQuantityPerOrder?: number;
    buyToSellOrderRatio?: number;
    buyToSellQuantityRatio?: number;
}
interface SupplyDemandData {
    supplyList: SupplyDemand[];
    demandList: SupplyDemand[];
}
interface SupplyDemandResponse {
    highestQuantityperOrder: HighestOrderWithSupplyDemandData[];
    highestSupply: SupplyDemand[];
    highestDemand: SupplyDemand[];
    version: string;
    time: string;
    date: string;
}

interface StockDailyPrice {
    businessDate: string;
    openPrice: number;
    highPrice: number;
    lowPrice: number;
    previousDayClosePrice: number;
    fiftyTwoWeekHigh: number;
    lastTradedPrice: number;
    totalTradedQuantity: number;
    closePrice: number;
}
type StockDailyPriceArray = StockDailyPrice[];

/**
 * Get or create the worker pool instance
 */
declare function getWorkerPool(): WorkerPool;
/**
 * Shutdown the worker pool
 */
declare function shutdownWorkerPool(): Promise<void>;
/**
 * Get worker pool statistics
 */
declare function getWorkerPoolStats(): {
    totalWorkers: number;
    busyWorkers: number;
    idleWorkers: number;
    queueLength: number;
    pendingTasks: number;
    totalTasksCompleted: number;
    totalErrors: number;
} | null;
declare function get_market_status(): Promise<MarketStatus | null>;
declare function getSummary(): Promise<Summary$1 | null>;
declare function getTopTenTradeScrips(): Promise<TopTradeScrips | null>;
declare function getTopTenTransactions(): Promise<TopTransaction | null>;
declare function getTopTenTurnover(): Promise<TopTurnover | null>;
declare function getTopGainers(): Promise<TopGainerLoosers | null>;
declare function getTopLoosers(): Promise<TopGainerLoosers | null>;
declare function getNepseIndex(): Promise<NepseIndex | null>;
declare function getNepseIndexIntraday(index?: IndexKey): Promise<IndexIntradayData | null>;
declare function stockIntraday(stock?: string): Promise<SecurityDailyChart | null>;
declare function getPriceVolume(): Promise<PriceVolume | null>;
declare function getSecurityList(): Promise<SecurityList | null>;
declare function getCompaniesList(): Promise<CompanyList | null>;
declare function getMarket_depth(symbol: string): Promise<MarketDepthResponse | null>;
declare function getSupplyDemand(): Promise<SupplyDemandData | null>;
declare function getPriceVolumeHistory(symbol: string, size?: number): Promise<PriceVolumeHistory$1 | null>;
declare function getIndexPriceVolumeHistory(index: IndexKey, size?: number): Promise<IndexHistoricalDataArray$1 | null>;
declare function getStockDailyPrice(symbol: string): Promise<StockDailyPriceArray | null>;
declare function liveMarketData(): Promise<LiveMarket | null>;
declare function disclosure(): Promise<DisclosureResponse | null>;
declare function get_security_detail(symbol: string): Promise<SecurityDetailResponse | null>;

interface Prove {
    accessToken: string;
    refreshToken: string;
    salt: string;
    salt1: number;
    salt2: number;
    salt3: number;
    salt4: number;
    salt5: number;
    serverTime: number;
    tokenType: string | null;
    isDisplayActive: boolean;
    popupDocFor: string;
}
interface ProveExtra {
    serverTime: number;
    clientTime: number;
    validAccessToken: string;
}

interface SecurityBrief {
    activeStatus: string;
    id: number;
    name: string;
    securityName: string;
    symbol: string;
}

declare class TokenManager {
    private static instance;
    private static wasm_instantiated;
    private accessToken;
    private refreshToken;
    private tokenTimestamp;
    private proveObject;
    private marketStatus;
    private readonly MAX_TOKEN_AGE;
    private isUpdating;
    private updatePromise;
    private security_brief_cache;
    private security_symbol_id_keymap;
    private static cdx;
    private static rdx;
    private static bdx;
    private static ndx;
    private static mdx;
    private constructor();
    static initializeWasm(): Promise<void>;
    static getInstance(): Promise<TokenManager>;
    private updateToken;
    private refreshAccessToken;
    get_valid_token(): string;
    get_valid_body_id(): number;
    getPOSTPayloadID(): number;
    getPOSTPayloadIDForFloorSheet(): number;
    private get_raw_access_object;
    private fetchMarketStatus;
    private isTokenValid;
    getAccessToken(): Promise<string>;
    getProveObject(): Prove | null;
    get_security_briefs(): Promise<SecurityBrief[]>;
    getSalts(): number[] | null;
    getMarketId(): number | null;
    getSecurityBrief(): Promise<SecurityBrief[]>;
    getSecuritySymbolIdMap(): Promise<Record<string, number>>;
    getMarketStatus(): MarketStatus | null;
}
declare const tokenManager: Promise<TokenManager>;

declare const BASE_URL: string;

declare function createNepseHeaders(token: string): Record<string, string>;

declare function createNepseError(message: string): NepseError;
type NepseError = Error & {
    message: string;
};

/**
 * Logger utility for NEPSE API
 */
declare const logger: {
    info(message: string, meta?: unknown): void;
    warn(message: string, meta?: unknown): void;
    error(message: string, meta?: unknown): void;
};

interface PriceVolumeHistory {
    businessDate: string;
    totalTrades: number;
    totalTradedQuantity: number;
    totalTradedValue: number;
    highPrice: number;
    lowPrice: number;
    closePrice: number;
}
type PriceVolumeHistoryArray = PriceVolumeHistory[];

interface IndexHistoricalData {
    id: number;
    businessDate: string;
    exchangeIndexId: number;
    closingIndex: number;
    openIndex: number;
    highIndex: number;
    lowIndex: number;
    fiftyTwoWeekHigh: number;
    fiftyTwoWeekLow: number;
    turnoverValue: number;
    turnoverVolume: number;
    totalTransaction: number;
    absChange: number;
    percentageChange: number;
}
type IndexHistoricalDataArray = IndexHistoricalData[];

export { type AdvanceDecline, type AdvanceDeclineResult, BASE_URL, type CompanyList, type CompanyNewsDocument, type CompanyNewsItem, type DashboardData, type DisclosureResponse, type ExchangeMessage, type HighestOrderWithSupplyDemandData, INDEX_URL_MAP, type IndexDataPoint, type IndexHighLow, type IndexHistoricalData, type IndexHistoricalDataArray, type IndexIntradayData, type IndexKey, type LiveMarket, type MarketDepthResponse, type MarketStatus, type NepseError, type NepseIndex, NepseSources, type PriceVolume, type PriceVolumeHistory, type PriceVolumeHistoryArray, type Prove, type ProveExtra, type Summary as RawSummary, type RestartResponse, type SectorAdvanceDecline, type SecurityBrief, type SecurityDailyChart, type SecurityDetail, type SecurityDetailResponse, type SecurityList, type StockDailyPrice, type StockDailyPriceArray, type StockData, type Summary$1 as Summary, type SupplyDemand, type SupplyDemandData, type SupplyDemandResponse, TokenManager, type TopCompany, type TopGainerLoosers, type TopGainersApiResponse, type TopTradeScrips, type TopTransaction, type TopTransactions, type TopTurnover, type TopTurnoversApiResponse, WorkerPool, type WorkerPoolOptions, createNepseError, createNepseHeaders, disclosure, getCompaniesList, getIndexPriceVolumeHistory, getMarket_depth, getNepseIndex, getNepseIndexIntraday, getPriceVolume, getPriceVolumeHistory, getSecurityList, getStockDailyPrice, getSummary, getSupplyDemand, getTopGainers, getTopLoosers, getTopTenTradeScrips, getTopTenTransactions, getTopTenTurnover, getWorkerPool, getWorkerPoolStats, get_market_status, get_security_detail, liveMarketData, logger, nepseIndexes, shutdownWorkerPool, stockIntraday, tokenManager };