import * as p_safe from 'p-safe';
import { SafeReturn } from 'p-safe';
import { AxiosRequestConfig } from 'axios';

type RequestOptions = Omit<AxiosRequestConfig, 'url'>;

interface GetDayDetailsCommonParams {
    insId: string;
    dEven: number;
}

declare function getPriceOverviewData(params: GetDayDetailsCommonParams, options?: RequestOptions): Promise<p_safe.SafeReturn<PriceOverviewData, Error>>;
interface PriceOverviewData {
    priceChange: number;
    low: number;
    high: number;
    yesterday: number;
    open: number;
    close: number;
    last: number;
    count: number;
    volume: number;
    value: number;
}

declare function getOrderBook(params: GetDayDetailsCommonParams, options?: RequestOptions): Promise<p_safe.SafeReturn<OrderBookDataRow[], Error>>;
interface OrderBookData$1 {
    time: Date;
    count: number;
    price: number;
    volume: number;
}
interface OrderBookDataRow {
    time: Date;
    buyRows: OrderBookData$1[];
    sellRows: OrderBookData$1[];
}

declare function getPriceData(params: GetDayDetailsCommonParams, options?: RequestOptions): Promise<p_safe.SafeReturn<PriceDataRow[], Error>>;
interface PriceDataRow {
    time: Date;
    close: number;
    last: number;
    value: number;
    volume: number;
    count: number;
}

declare function getTrades(params: GetTradesParams, options?: RequestOptions): Promise<SafeReturn<TradeDataRow>>;
interface GetTradesParams extends GetDayDetailsCommonParams {
    summarize: boolean;
}
interface TradeDataRow {
    time: Date;
    price: number;
    volume: number;
}

declare function getTradersType(params: GetDayDetailsCommonParams, options?: RequestOptions): Promise<p_safe.SafeReturn<TradersTypeData, Error>>;
interface TradersTypeData {
    legal: TradersTypeInfo;
    real: TradersTypeInfo;
}
interface TradersTypeInfo {
    buy: TradersTypeSubInfo;
    sell: TradersTypeSubInfo;
}
interface TradersTypeSubInfo {
    count: number;
    volume: number;
    value: number;
}

type SupervisionDetail = {
    status: string;
    reason: string;
    description: string;
    date: Date;
};
declare function getSupervisionDetail(insId: string, options?: RequestOptions): Promise<p_safe.SafeReturn<SupervisionDetail, Error>>;

declare function getShareholders(params: GetDayDetailsCommonParams, options?: RequestOptions): Promise<SafeReturn<ShareHolderDataRow[]>>;
interface ShareHolder {
    id: string;
    name: string;
}
interface ShareHolderDataRow {
    id: string;
    date: Date;
    shareholder: ShareHolder;
    count: number;
    percentage: number;
}

declare function getThresholds(params: GetDayDetailsCommonParams, options?: RequestOptions): Promise<p_safe.SafeReturn<ThresholdsData, Error>>;
interface ThresholdsData {
    rangeMax: number;
    rangeMin: number;
}

declare const DayDetails_getOrderBook: typeof getOrderBook;
declare const DayDetails_getPriceData: typeof getPriceData;
declare const DayDetails_getShareholders: typeof getShareholders;
declare const DayDetails_getSupervisionDetail: typeof getSupervisionDetail;
declare const DayDetails_getThresholds: typeof getThresholds;
declare const DayDetails_getTradersType: typeof getTradersType;
declare const DayDetails_getTrades: typeof getTrades;
declare namespace DayDetails {
  export { DayDetails_getOrderBook as getOrderBook, DayDetails_getPriceData as getPriceData, getPriceOverviewData as getPriceOverview, DayDetails_getShareholders as getShareholders, DayDetails_getSupervisionDetail as getSupervisionDetail, DayDetails_getThresholds as getThresholds, DayDetails_getTradersType as getTradersType, DayDetails_getTrades as getTrades };
}

declare function getAllGroups(options?: RequestOptions): Promise<SafeReturn<GroupData[]>>;
declare enum GroupType {
    PAPER = "PAPER",
    INDUSTRY = "INDUSTRIAL"
}
interface GroupData {
    id: number;
    code: number;
    name: string;
    description: string;
    type: GroupType;
}

declare const Group_getAllGroups: typeof getAllGroups;
declare namespace Group {
  export { Group_getAllGroups as getAllGroups };
}

declare function getMarketMap(params: GetMarketMapParams, options?: RequestOptions): Promise<SafeReturn<MapDataRow[]>>;
declare enum MapType {
    MarketValue = 1,
    MarketVolume = 2
}
interface GetMarketMapParams {
    mapType: MapType;
    hEven?: number;
    sector?: number;
    market?: number;
    size?: number;
}
interface MapDataRow {
    id: string;
    shortName: string;
    longName: string;
    close: number;
    last: number;
    volume: number;
    value: number;
    count: number;
    groupName: string;
    color: string;
    priceChangePercent: number;
    percent: number;
}

declare const MarketMap_getMarketMap: typeof getMarketMap;
declare namespace MarketMap {
  export { MarketMap_getMarketMap as getMarketMap };
}

type WatchTradersType = {
    legal: TraderTypeData;
    real: TraderTypeData;
};
type TraderTypeData = {
    buy: {
        volume: number;
        count: number;
    };
    sell: {
        volume: number;
        count: number;
    };
};
type TraderType = 'legal' | 'real';
type WatchTradersTypeData = {
    [symbolId: string]: WatchTradersType;
};
declare function getClientTypeAll(): Promise<SafeReturn<WatchTradersTypeData>>;

type GetWatchPriceParams = {
    refId: string;
    hEven: string;
};
declare function getWatchPrice(params?: GetWatchPriceParams, options?: RequestOptions): Promise<p_safe.SafeReturn<WatchPrice[], Error>>;
type WatchPrice = {
    symbolId: string;
    isin: string;
    shortName: string;
    fullName: string;
    heven: number;
    open: number;
    close: number;
    last: number;
    count: number;
    volume: number;
    value: number;
    low: number;
    high: number;
    yesterday: number;
    eps: number | null;
    baseVolume: number;
    visitCount: number;
    flow: number;
    group: number;
    rangeMax: number;
    rangeMin: number;
    z: number;
    yval: number;
    orderbook: {
        buyRows: OrderBookData[];
        sellRows: OrderBookData[];
    };
};
interface OrderBookData {
    count: number;
    price: number;
    volume: number;
}

type WatchStats = {
    trades: State;
    negative_days: State;
    no_trade_days: State;
    positive_days: State;
    with_trade_days: State;
    company_value: State;
    open_days: State;
    closed_days: State;
    client_type: State;
};
type State = Record<string, number> | null;
type WatchStatsData = {
    [symbolId: string]: WatchStats;
};
declare function getWatchStats(options?: RequestOptions): Promise<p_safe.SafeReturn<WatchStatsData, Error>>;

declare const MarketWatch_getClientTypeAll: typeof getClientTypeAll;
declare const MarketWatch_getWatchStats: typeof getWatchStats;
declare namespace MarketWatch {
  export { MarketWatch_getClientTypeAll as getClientTypeAll, getWatchPrice as getPriceData, MarketWatch_getWatchStats as getWatchStats };
}

type GetBoardMembersParams = {
    symbol: string;
};
type BoardMember = {
    PreviousMemberName: string;
    MemberName: string;
    NationalCode_RegisterNumber: string;
    PreviuosAgent: string;
    Agent: string;
    AgentNationalCode: string | null;
    Designation: string;
    Charged: boolean;
    EducationDegree: string;
};
type BoardMembersHistory = {
    type: 'BoardMembers';
    AssemblyDate: string;
    SessionDate: string;
    BoardMembers: BoardMember[];
} | {
    type: 'DirectorManager';
    MeetingDate: string;
    SessionDate: string;
    DirectorManager: {
        Name: string;
        NationalCode: string;
        EducationDegree: string;
    };
};
declare function getBoardMembersHistory(params: GetBoardMembersParams, options?: RequestOptions): Promise<p_safe.SafeReturn<BoardMembersHistory[], Error>>;

type GetDPSDataParams = {
    symbol: string;
};
type DPSData = {
    publishDate: string;
    meetingDate: string;
    fiscalYear: string;
    profitAfterTax: string;
    profitToAllocate: string;
    profitAccumulated: string;
    cashProfitPerShare: string;
};
declare function getDPSData(params: GetDPSDataParams, options?: RequestOptions): Promise<p_safe.SafeReturn<DPSData[], Error>>;

type InstrumentInfo = {
    eps: InstrumentEPS;
    sector: InstrumentSector;
    staticThreshold: InstrumentStaticThreshold;
    minWeek: number;
    maxWeek: number;
    minYear: number;
    maxYear: number;
    qTotTran5JAvg: number;
    kAjCapValCpsIdx: string;
    dEven: number;
    topInst: number;
    faraDesc: string;
    contractSize: number;
    nav: number;
    underSupervision: number;
    cValMne: string;
    lVal18: string;
    cSocCSAC: string;
    lSoc30: string;
    yMarNSC: string;
    yVal: string;
    insCode: string;
    lVal30: string;
    lVal18AFC: string;
    flow: number;
    cIsin: string;
    zTitad: number;
    baseVol: number;
    instrumentID: string;
    cgrValCot: string;
    cComVal: string;
    lastDate: number;
    sourceID: number;
    flowTitle: string;
    cgrValCotTitle: string;
};
type InstrumentEPS = {
    epsValue: number | null;
    estimatedEPS: string;
    sectorPE: number;
    psr: number;
};
type InstrumentSector = {
    dEven: number;
    cSecVal: string;
    lSecVal: string;
};
type InstrumentStaticThreshold = {
    insCode: string | null;
    dEven: number;
    hEven: number;
    psGelStaMax: number;
    psGelStaMin: number;
};
type GetInstrumentInfoParams = {
    insId: string;
};
declare function getInstrumentInfo(params: GetInstrumentInfoParams, options?: RequestOptions): Promise<SafeReturn<InstrumentInfo>>;

type InstrumentSupervisorMsg = {
    id: number;
    dEven: number;
    hEven: number;
    title: string;
    description: string;
    flow: number;
};
type GetSupervisorMessagesParams = {
    insId: string;
};
declare function getSupervisorMsg(params: GetSupervisorMessagesParams, options?: RequestOptions): Promise<SafeReturn<InstrumentSupervisorMsg[]>>;

type GetIntraDayPriceChartParams = {
    insId: string;
};
type IntraDayPriceChart = {
    time: Date;
    high: number;
    low: number;
    open: number;
    close: number;
    volume: number;
};
declare function getIntraDayPriceChart(params: GetIntraDayPriceChartParams, options?: RequestOptions): Promise<p_safe.SafeReturn<IntraDayPriceChart[], Error>>;

declare const Instrument_getBoardMembersHistory: typeof getBoardMembersHistory;
declare const Instrument_getDPSData: typeof getDPSData;
declare const Instrument_getInstrumentInfo: typeof getInstrumentInfo;
declare const Instrument_getIntraDayPriceChart: typeof getIntraDayPriceChart;
declare const Instrument_getSupervisorMsg: typeof getSupervisorMsg;
declare namespace Instrument {
  export { Instrument_getBoardMembersHistory as getBoardMembersHistory, Instrument_getDPSData as getDPSData, Instrument_getInstrumentInfo as getInstrumentInfo, Instrument_getIntraDayPriceChart as getIntraDayPriceChart, Instrument_getSupervisorMsg as getSupervisorMsg };
}

declare function deepUpdate(d1: Record<string, any>, d2: Record<string, any>): Record<string, any>;
declare function omitNulls<T extends Record<string, any> = any>(obj: T): OmitNulls<T>;
type OmitNulls<T extends Record<string, any>> = {
    [K in keyof T]: T[K] extends null ? never : T[K];
};

declare function hEven2Time(heven: number): string;
declare function dEven2Date(deven: number): string;
declare function even2JDate(dEven: number, hEven: number): Date;
declare function hEvenValidation(hEven: number): boolean;
declare function dEvenValidation(dEven: number): boolean;

declare function fakeBrowserHeaders(): Record<string, string>;

declare const faToAr: (value: string) => string;

declare const index_dEven2Date: typeof dEven2Date;
declare const index_dEvenValidation: typeof dEvenValidation;
declare const index_deepUpdate: typeof deepUpdate;
declare const index_even2JDate: typeof even2JDate;
declare const index_faToAr: typeof faToAr;
declare const index_fakeBrowserHeaders: typeof fakeBrowserHeaders;
declare const index_hEven2Time: typeof hEven2Time;
declare const index_hEvenValidation: typeof hEvenValidation;
declare const index_omitNulls: typeof omitNulls;
declare namespace index {
  export { index_dEven2Date as dEven2Date, index_dEvenValidation as dEvenValidation, index_deepUpdate as deepUpdate, index_even2JDate as even2JDate, index_faToAr as faToAr, index_fakeBrowserHeaders as fakeBrowserHeaders, index_hEven2Time as hEven2Time, index_hEvenValidation as hEvenValidation, index_omitNulls as omitNulls };
}

declare const TseTmc: {
    DayDetails: typeof DayDetails;
    Group: typeof Group;
    MarketMap: typeof MarketMap;
    MarketWatch: typeof MarketWatch;
    Instrument: typeof Instrument;
};

export { type BoardMember, type DPSData, DayDetails, type GetWatchPriceParams, Group, type GroupData, GroupType, Instrument, type InstrumentEPS, type InstrumentInfo, type InstrumentSector, type InstrumentStaticThreshold, type InstrumentSupervisorMsg, type IntraDayPriceChart, type MapDataRow, MapType, MarketMap, MarketWatch, type PriceDataRow, type PriceOverviewData, type ShareHolder, type ShareHolderDataRow, type SupervisionDetail, type ThresholdsData, type TradeDataRow, type TraderType, type TradersTypeData, type TradersTypeInfo, type TradersTypeSubInfo, TseTmc, type WatchPrice, type WatchStats, type WatchStatsData, type WatchTradersType, type WatchTradersTypeData, TseTmc as default, index as utils };