@adaptic/utils 0.0.359

package/dist/types/index.d.ts

@@ -0,0 +1,415 @@
+import * as Alpaca from './alpaca-functions';
+import * as pm from './performance-metrics';
+import * as tu from './time-utils';
+import * as mt from './market-time';
+import fetchTradeMetrics from './metrics-calcs';
+import * as pu from './price-utils';
+import * as ft from './format-tools';
+import * as Types from './types';
+import * as misc from './misc-utils';
+import * as polygon from './polygon';
+import * as av from './alphavantage';
+import * as crypto from './crypto';
+import * as ta from './technical-analysis';
+export * from './types';
+export { AlpacaTradingAPI } from './alpaca-trading-api';
+export { AlpacaMarketDataAPI } from './alpaca-market-data-api';
+export declare const createAlpacaTradingAPI: (credentials: Types.AlpacaCredentials) => Types.AlpacaTradingAPI;
+export declare const createAlpacaMarketDataAPI: () => Types.AlpacaMarketDataAPI;
+export declare const adaptic: {
+    types: typeof Types;
+    backend: {
+        fetchAssetOverview: (symbol: string) => Promise<Types.AssetOverviewResponse>;
+        getApolloClient: () => Promise<any>;
+    };
+    alpaca: {
+        TradingAPI: typeof Types.AlpacaTradingAPI;
+        MarketDataAPI: typeof Types.AlpacaMarketDataAPI;
+        makeRequest: typeof Alpaca.makeRequest;
+        accountDetails: typeof Alpaca.fetchAccountDetails;
+        positions: typeof Alpaca.fetchAllPositions;
+        position: {
+            fetch: typeof Alpaca.fetchPosition;
+            close: typeof Alpaca.closePosition;
+            fetchAll: typeof Alpaca.fetchAllPositions;
+            closeAll: typeof Alpaca.closeAllPositions;
+            closeAllAfterHours: typeof Alpaca.closeAllPositionsAfterHours;
+        };
+        portfolioHistory: typeof Alpaca.fetchPortfolioHistory;
+        getConfig: typeof Alpaca.getConfiguration;
+        updateConfig: typeof Alpaca.updateConfiguration;
+        news: typeof Alpaca.fetchNews;
+        orders: {
+            create: typeof Alpaca.createOrder;
+            createLimitOrder: typeof Alpaca.createLimitOrder;
+            get: typeof Alpaca.getOrder;
+            getAll: typeof Alpaca.getOrders;
+            replace: typeof Alpaca.replaceOrder;
+            cancel: typeof Alpaca.cancelOrder;
+            cancelAll: typeof Alpaca.cancelAllOrders;
+        };
+        asset: {
+            get: typeof Alpaca.getAsset;
+        };
+        quote: {
+            getLatest: typeof Alpaca.getLatestQuotes;
+        };
+    };
+    av: {
+        fetchQuote: (ticker: string, options?: {
+            apiKey?: string;
+        }) => Promise<Types.AlphaVantageQuoteResponse>;
+        fetchTickerNews: (ticker: string, options?: {
+            start?: Date;
+            end?: Date;
+            limit?: number;
+            apiKey?: string;
+            sort?: "LATEST" | "EARLIEST" | "RELEVANCE";
+        }) => Promise<Types.AVNewsArticle[]>;
+        convertDateToYYYYMMDDTHHMM: typeof av.convertDateToYYYYMMDDTHHMM;
+        convertYYYYMMDDTHHMMSSToDate: typeof av.convertYYYYMMDDTHHMMSSToDate;
+    };
+    crypto: {
+        fetchBars: typeof crypto.fetchBars;
+        fetchNews: typeof crypto.fetchNews;
+    };
+    format: {
+        capitalize: typeof ft.capitalize;
+        enum: typeof ft.formatEnum;
+        currency: typeof ft.formatCurrency;
+        number: typeof ft.formatNumber;
+        percentage: typeof ft.formatPercentage;
+        date: (dateString: string, updateDate?: boolean) => string;
+        dateToString: (date: Date) => string;
+        dateTimeForGS: typeof ft.dateTimeForGS;
+    };
+    metrics: {
+        trade: typeof fetchTradeMetrics;
+        alphaAndBeta: typeof pm.calculateAlphaAndBeta;
+        maxDrawdown: typeof pm.calculateMaxDrawdown;
+        dailyReturns: typeof pm.calculateDailyReturns;
+        returnsByDate: typeof pm.alignReturnsByDate;
+        beta: typeof pm.calculateBetaFromReturns;
+        infoRatio: typeof pm.calculateInformationRatio;
+        allpm: typeof pm.fetchPerformanceMetrics;
+    };
+    polygon: {
+        fetchTickerInfo: (symbol: string, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonTickerInfo | null>;
+        fetchGroupedDaily: (date: string, options?: {
+            apiKey?: string;
+            adjusted?: boolean;
+            includeOTC?: boolean;
+        }) => Promise<Types.PolygonGroupedDailyResponse>;
+        fetchLastTrade: (symbol: string, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonQuote>;
+        fetchTrades: (symbol: string, options?: {
+            apiKey?: string;
+            timestamp?: string | number;
+            timestampgt?: string | number;
+            timestampgte?: string | number;
+            timestamplt?: string | number;
+            timestamplte?: string | number;
+            order?: "asc" | "desc";
+            limit?: number;
+            sort?: string;
+        }) => Promise<Types.PolygonTradesResponse>;
+        fetchPrices: (params: {
+            ticker: string;
+            start: number;
+            end?: number;
+            multiplier: number;
+            timespan: string;
+            limit?: number;
+        }, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonPriceData[]>;
+        analysePolygonPriceData: typeof polygon.analysePolygonPriceData;
+        formatPriceData: typeof polygon.formatPriceData;
+        fetchDailyOpenClose: (symbol: string, date?: Date, options?: {
+            apiKey?: string;
+            adjusted?: boolean;
+        }) => Promise<Types.PolygonDailyOpenClose>;
+        getPreviousClose: typeof polygon.getPreviousClose;
+    };
+    indices: {
+        fetchAggregates: (params: Types.PolygonIndicesAggregatesParams, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonIndicesAggregatesResponse>;
+        fetchPreviousClose: (indicesTicker: string, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonIndicesPrevCloseResponse>;
+        fetchDailyOpenClose: (indicesTicker: string, date: string, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonIndicesDailyOpenCloseResponse>;
+        fetchSnapshot: (params?: Types.PolygonIndicesSnapshotParams, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonIndicesSnapshotResponse>;
+        fetchUniversalSnapshot: (tickers: string[], options?: {
+            apiKey?: string;
+            type?: string;
+            order?: string;
+            limit?: number;
+            sort?: string;
+        }) => Promise<any>;
+        formatBarData: (data: Types.PolygonIndicesAggregatesResponse) => Array<{
+            date: string;
+            open: number;
+            high: number;
+            low: number;
+            close: number;
+            timestamp: number;
+        }>;
+    };
+    price: {
+        roundUp: typeof pu.roundStockPrice;
+        equityValues: typeof pu.getEquityValues;
+        totalFees: (trade: import("@adaptic/backend-legacy/generated/typegraphql-prisma/models").Trade) => Promise<number>;
+    };
+    ta: {
+        calculateEMA: typeof ta.calculateEMA;
+        calculateMACD: typeof ta.calculateMACD;
+        calculateRSI: typeof ta.calculateRSI;
+        calculateStochasticOscillator: typeof ta.calculateStochasticOscillator;
+        calculateBollingerBands: typeof ta.calculateBollingerBands;
+        calculateSupportAndResistance: typeof ta.calculateSupportAndResistance;
+        calculateFibonacciLevels: typeof ta.calculateFibonacciLevels;
+    };
+    time: {
+        toUnixTimestamp: (ts: string) => number;
+        getTimeAgo: typeof tu.getTimeAgo;
+        timeAgo: (timestamp?: Date) => string;
+        normalizeDate: typeof tu.normalizeDate;
+        getDateInNY: typeof mt.getDateInNY;
+        createMarketTimeUtil: typeof mt.createMarketTimeUtil;
+        getStartAndEndTimestamps: typeof mt.getStartAndEndTimestamps;
+        getStartAndEndDates: typeof mt.getStartAndEndDates;
+        getMarketOpenClose: typeof mt.getMarketOpenClose;
+        calculateTimeRange: typeof tu.calculateTimeRange;
+        calculateDaysLeft: (accountCreationDate: Date) => number;
+        formatDate: (dateString: string, updateDate?: boolean) => string;
+        currentTimeET: () => Date;
+        MarketTimeUtil: typeof mt.MarketTimeUtil;
+        MARKET_TIMES: Types.MarketTimesConfig;
+        getLastTradingDateYYYYMMDD: typeof mt.getLastTradingDateYYYYMMDD;
+        getLastFullTradingDate: typeof mt.getLastFullTradingDate;
+        getNextMarketDay: typeof mt.getNextMarketDay;
+        parseETDateFromAV: (dateString: string) => Date;
+        formatToUSEastern: (date: Date, justDate?: boolean) => string;
+        unixTimetoUSEastern: (timestamp: number) => {
+            date: Date;
+            timeString: string;
+            dateString: string;
+        };
+        getMarketStatus: typeof mt.getMarketStatus;
+        timeDiffString: (milliseconds: number) => string;
+        getNYTimeZone: (date?: Date) => "-04:00" | "-05:00";
+        getTradingDate: typeof mt.getTradingDate;
+    };
+    utils: {
+        logIfDebug: (message: string, data?: unknown, type?: "info" | "warn" | "error" | "debug" | "trace") => void;
+        fetchWithRetry: typeof misc.fetchWithRetry;
+        validatePolygonApiKey: typeof misc.validatePolygonApiKey;
+    };
+};
+export declare const adptc: {
+    types: typeof Types;
+    backend: {
+        fetchAssetOverview: (symbol: string) => Promise<Types.AssetOverviewResponse>;
+        getApolloClient: () => Promise<any>;
+    };
+    alpaca: {
+        TradingAPI: typeof Types.AlpacaTradingAPI;
+        MarketDataAPI: typeof Types.AlpacaMarketDataAPI;
+        makeRequest: typeof Alpaca.makeRequest;
+        accountDetails: typeof Alpaca.fetchAccountDetails;
+        positions: typeof Alpaca.fetchAllPositions;
+        position: {
+            fetch: typeof Alpaca.fetchPosition;
+            close: typeof Alpaca.closePosition;
+            fetchAll: typeof Alpaca.fetchAllPositions;
+            closeAll: typeof Alpaca.closeAllPositions;
+            closeAllAfterHours: typeof Alpaca.closeAllPositionsAfterHours;
+        };
+        portfolioHistory: typeof Alpaca.fetchPortfolioHistory;
+        getConfig: typeof Alpaca.getConfiguration;
+        updateConfig: typeof Alpaca.updateConfiguration;
+        news: typeof Alpaca.fetchNews;
+        orders: {
+            create: typeof Alpaca.createOrder;
+            createLimitOrder: typeof Alpaca.createLimitOrder;
+            get: typeof Alpaca.getOrder;
+            getAll: typeof Alpaca.getOrders;
+            replace: typeof Alpaca.replaceOrder;
+            cancel: typeof Alpaca.cancelOrder;
+            cancelAll: typeof Alpaca.cancelAllOrders;
+        };
+        asset: {
+            get: typeof Alpaca.getAsset;
+        };
+        quote: {
+            getLatest: typeof Alpaca.getLatestQuotes;
+        };
+    };
+    av: {
+        fetchQuote: (ticker: string, options?: {
+            apiKey?: string;
+        }) => Promise<Types.AlphaVantageQuoteResponse>;
+        fetchTickerNews: (ticker: string, options?: {
+            start?: Date;
+            end?: Date;
+            limit?: number;
+            apiKey?: string;
+            sort?: "LATEST" | "EARLIEST" | "RELEVANCE";
+        }) => Promise<Types.AVNewsArticle[]>;
+        convertDateToYYYYMMDDTHHMM: typeof av.convertDateToYYYYMMDDTHHMM;
+        convertYYYYMMDDTHHMMSSToDate: typeof av.convertYYYYMMDDTHHMMSSToDate;
+    };
+    crypto: {
+        fetchBars: typeof crypto.fetchBars;
+        fetchNews: typeof crypto.fetchNews;
+    };
+    format: {
+        capitalize: typeof ft.capitalize;
+        enum: typeof ft.formatEnum;
+        currency: typeof ft.formatCurrency;
+        number: typeof ft.formatNumber;
+        percentage: typeof ft.formatPercentage;
+        date: (dateString: string, updateDate?: boolean) => string;
+        dateToString: (date: Date) => string;
+        dateTimeForGS: typeof ft.dateTimeForGS;
+    };
+    metrics: {
+        trade: typeof fetchTradeMetrics;
+        alphaAndBeta: typeof pm.calculateAlphaAndBeta;
+        maxDrawdown: typeof pm.calculateMaxDrawdown;
+        dailyReturns: typeof pm.calculateDailyReturns;
+        returnsByDate: typeof pm.alignReturnsByDate;
+        beta: typeof pm.calculateBetaFromReturns;
+        infoRatio: typeof pm.calculateInformationRatio;
+        allpm: typeof pm.fetchPerformanceMetrics;
+    };
+    polygon: {
+        fetchTickerInfo: (symbol: string, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonTickerInfo | null>;
+        fetchGroupedDaily: (date: string, options?: {
+            apiKey?: string;
+            adjusted?: boolean;
+            includeOTC?: boolean;
+        }) => Promise<Types.PolygonGroupedDailyResponse>;
+        fetchLastTrade: (symbol: string, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonQuote>;
+        fetchTrades: (symbol: string, options?: {
+            apiKey?: string;
+            timestamp?: string | number;
+            timestampgt?: string | number;
+            timestampgte?: string | number;
+            timestamplt?: string | number;
+            timestamplte?: string | number;
+            order?: "asc" | "desc";
+            limit?: number;
+            sort?: string;
+        }) => Promise<Types.PolygonTradesResponse>;
+        fetchPrices: (params: {
+            ticker: string;
+            start: number;
+            end?: number;
+            multiplier: number;
+            timespan: string;
+            limit?: number;
+        }, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonPriceData[]>;
+        analysePolygonPriceData: typeof polygon.analysePolygonPriceData;
+        formatPriceData: typeof polygon.formatPriceData;
+        fetchDailyOpenClose: (symbol: string, date?: Date, options?: {
+            apiKey?: string;
+            adjusted?: boolean;
+        }) => Promise<Types.PolygonDailyOpenClose>;
+        getPreviousClose: typeof polygon.getPreviousClose;
+    };
+    indices: {
+        fetchAggregates: (params: Types.PolygonIndicesAggregatesParams, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonIndicesAggregatesResponse>;
+        fetchPreviousClose: (indicesTicker: string, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonIndicesPrevCloseResponse>;
+        fetchDailyOpenClose: (indicesTicker: string, date: string, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonIndicesDailyOpenCloseResponse>;
+        fetchSnapshot: (params?: Types.PolygonIndicesSnapshotParams, options?: {
+            apiKey?: string;
+        }) => Promise<Types.PolygonIndicesSnapshotResponse>;
+        fetchUniversalSnapshot: (tickers: string[], options?: {
+            apiKey?: string;
+            type?: string;
+            order?: string;
+            limit?: number;
+            sort?: string;
+        }) => Promise<any>;
+        formatBarData: (data: Types.PolygonIndicesAggregatesResponse) => Array<{
+            date: string;
+            open: number;
+            high: number;
+            low: number;
+            close: number;
+            timestamp: number;
+        }>;
+    };
+    price: {
+        roundUp: typeof pu.roundStockPrice;
+        equityValues: typeof pu.getEquityValues;
+        totalFees: (trade: import("@adaptic/backend-legacy/generated/typegraphql-prisma/models").Trade) => Promise<number>;
+    };
+    ta: {
+        calculateEMA: typeof ta.calculateEMA;
+        calculateMACD: typeof ta.calculateMACD;
+        calculateRSI: typeof ta.calculateRSI;
+        calculateStochasticOscillator: typeof ta.calculateStochasticOscillator;
+        calculateBollingerBands: typeof ta.calculateBollingerBands;
+        calculateSupportAndResistance: typeof ta.calculateSupportAndResistance;
+        calculateFibonacciLevels: typeof ta.calculateFibonacciLevels;
+    };
+    time: {
+        toUnixTimestamp: (ts: string) => number;
+        getTimeAgo: typeof tu.getTimeAgo;
+        timeAgo: (timestamp?: Date) => string;
+        normalizeDate: typeof tu.normalizeDate;
+        getDateInNY: typeof mt.getDateInNY;
+        createMarketTimeUtil: typeof mt.createMarketTimeUtil;
+        getStartAndEndTimestamps: typeof mt.getStartAndEndTimestamps;
+        getStartAndEndDates: typeof mt.getStartAndEndDates;
+        getMarketOpenClose: typeof mt.getMarketOpenClose;
+        calculateTimeRange: typeof tu.calculateTimeRange;
+        calculateDaysLeft: (accountCreationDate: Date) => number;
+        formatDate: (dateString: string, updateDate?: boolean) => string;
+        currentTimeET: () => Date;
+        MarketTimeUtil: typeof mt.MarketTimeUtil;
+        MARKET_TIMES: Types.MarketTimesConfig;
+        getLastTradingDateYYYYMMDD: typeof mt.getLastTradingDateYYYYMMDD;
+        getLastFullTradingDate: typeof mt.getLastFullTradingDate;
+        getNextMarketDay: typeof mt.getNextMarketDay;
+        parseETDateFromAV: (dateString: string) => Date;
+        formatToUSEastern: (date: Date, justDate?: boolean) => string;
+        unixTimetoUSEastern: (timestamp: number) => {
+            date: Date;
+            timeString: string;
+            dateString: string;
+        };
+        getMarketStatus: typeof mt.getMarketStatus;
+        timeDiffString: (milliseconds: number) => string;
+        getNYTimeZone: (date?: Date) => "-04:00" | "-05:00";
+        getTradingDate: typeof mt.getTradingDate;
+    };
+    utils: {
+        logIfDebug: (message: string, data?: unknown, type?: "info" | "warn" | "error" | "debug" | "trace") => void;
+        fetchWithRetry: typeof misc.fetchWithRetry;
+        validatePolygonApiKey: typeof misc.validatePolygonApiKey;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,oBAAoB,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,cAAc,CAAC;AACnC,OAAO,KAAK,EAAE,MAAM,eAAe,CAAC;AACpC,OAAO,iBAAiB,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,eAAe,CAAC;AACpC,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,IAAI,MAAM,cAAc,CAAC;AACrC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAErC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAK3C,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAG/D,eAAO,MAAM,sBAAsB,GAAI,aAAa,KAAK,CAAC,iBAAiB,2BAE1E,CAAC;AAEF,eAAO,MAAM,yBAAyB,iCAErC,CAAC;AAEF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGmB,CAAC;;;iBA8Ea,CAAC;eACjD,CAAC;iBAAa,CAAC;kBAAgB,CAAC;gBAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBArFpB,CAAC;;;kBA4I8tM,CAAC;oBAAsB,CAAC;sBAAyB,CAAC;;;kBAtC7yM,CAAA;;;kBAsCkiZ,CAAC;qBAAuB,CAAC;uBAAkC,CAAC;wBAAmC,CAAC;uBAAkC,CAAC;wBAAmC,CAAC;iBAA4B,CAAC;iBAA2B,CAAC;gBAAkB,CAAC;;;;;eAAz6W,CAAC;;;iBAAiE,CAAC;;kBAAmC,CAAC;;;;;kBAA60Q,CAAC;oBAAsB,CAAC;;;;;;kBA3H9yT,CAAC;;;kBAmDe,CAAC;;;kBAkCkC,CAAC;;;kBAiC/C,CAAC;;;kBAKgoD,CAAC;gBAAkB,CAAC;iBAAmB,CAAC;iBAAmB,CAAC;gBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAHluD,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBArIqB,CAAC;;;iBA8Ea,CAAC;eACjD,CAAC;iBAAa,CAAC;kBAAgB,CAAC;gBAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBArFpB,CAAC;;;kBA4I8tM,CAAC;oBAAsB,CAAC;sBAAyB,CAAC;;;kBAtC7yM,CAAA;;;kBAsCkiZ,CAAC;qBAAuB,CAAC;uBAAkC,CAAC;wBAAmC,CAAC;uBAAkC,CAAC;wBAAmC,CAAC;iBAA4B,CAAC;iBAA2B,CAAC;gBAAkB,CAAC;;;;;eAAz6W,CAAC;;;iBAAiE,CAAC;;kBAAmC,CAAC;;;;;kBAA60Q,CAAC;oBAAsB,CAAC;;;;;;kBA3H9yT,CAAC;;;kBAmDe,CAAC;;;kBAkCkC,CAAC;;;kBAiC/C,CAAC;;;kBAKgoD,CAAC;gBAAkB,CAAC;iBAAmB,CAAC;iBAAmB,CAAC;gBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADvsD,CAAC"}

package/dist/types/logging.d.ts

@@ -0,0 +1,12 @@
+import { LogOptions } from './types/logging-types';
+/**
+ * Logs a message to the console.
+ * @param message The message to log.
+ * @param options Optional options.
+ * @param options.source The source of the message.
+ * @param options.type The type of message to log.
+ * @param options.symbol The trading symbol associated with this log.
+ * @param options.logToFile Force logging to a file even when no symbol is provided.
+ */
+export declare function log(message: string, options?: LogOptions): void;
+//# sourceMappingURL=logging.d.ts.map

package/dist/types/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../src/logging.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEnD;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,UAA+C,GAAG,IAAI,CAGnG"}

package/dist/types/market-hours.d.ts

@@ -0,0 +1,24 @@
+export interface HolidayDetails {
+    date: string;
+}
+export interface MarketHolidaysForYear {
+    [holidayName: string]: HolidayDetails;
+}
+export interface MarketHolidays {
+    [year: number]: MarketHolidaysForYear;
+}
+export interface EarlyCloseDetails {
+    date: string;
+    time: string;
+    optionsTime: string;
+    notes: string;
+}
+export interface EarlyClosesForYear {
+    [date: string]: EarlyCloseDetails;
+}
+export interface MarketEarlyCloses {
+    [year: number]: EarlyClosesForYear;
+}
+export declare const marketHolidays: MarketHolidays;
+export declare const marketEarlyCloses: MarketEarlyCloses;
+//# sourceMappingURL=market-hours.d.ts.map

package/dist/types/market-hours.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"market-hours.d.ts","sourceRoot":"","sources":["../../src/market-hours.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,qBAAqB;IACpC,CAAC,WAAW,EAAE,MAAM,GAAG,cAAc,CAAC;CACvC;AAED,MAAM,WAAW,cAAc;IAC7B,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,CAAC;CACvC;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAAC;CACnC;AAED,MAAM,WAAW,iBAAiB;IAChC,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAAC;CACpC;AAED,eAAO,MAAM,cAAc,EAAE,cAsC5B,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,iBA6D/B,CAAC"}

package/dist/types/market-time.d.ts

@@ -0,0 +1,184 @@
+import { IntradayReporting, PeriodDates, MarketTimeParams, MarketOpenCloseResult, MarketStatus, MarketTimesConfig } from './types/market-time-types';
+/**
+ * Market times for NYSE
+ * Regular market hours are 9:30am-4:00pm
+ * Early market hours are 9:30am-10:00am (first 30 minutes)
+ * Extended market hours are 4:00am to 9:30am and 4:00pm-8:00pm
+ * On days before some holidays, the market closes early at 1:00pm
+ * Early extended market hours are 1:00pm-5:00pm on early close days
+ */
+export declare const MARKET_TIMES: MarketTimesConfig;
+/**
+ * Utility class for handling market time-related operations
+ */
+export declare class MarketTimeUtil {
+    private timezone;
+    private intradayReporting;
+    /**
+     * Creates a new MarketTimeUtil instance
+     * @param {string} [timezone='America/New_York'] - The timezone to use for market time calculations
+     * @param {IntradayReporting} [intradayReporting='market_hours'] - The intraday reporting mode
+     */
+    constructor(timezone?: string, intradayReporting?: IntradayReporting);
+    /**
+     * Validates the provided timezone
+     * @private
+     * @param {string} timezone - The timezone to validate
+     * @throws {Error} If the timezone is invalid
+     */
+    private validateTimezone;
+    private formatDate;
+    private isWeekend;
+    private isHoliday;
+    isEarlyCloseDay(date: Date): boolean;
+    /**
+     * Get the early close time for a given date
+     * @param date - The date to get the early close time for
+     * @returns The early close time in minutes from midnight, or null if there is no early close
+     */
+    getEarlyCloseTime(date: Date): number | null;
+    /**
+     * Check if a given date is a market day
+     * @param date - The date to check
+     * @returns true if the date is a market day, false otherwise
+     */
+    isMarketDay(date: Date): boolean;
+    /**
+     * Check if a given date is within market hours
+     * @param date - The date to check
+     * @returns true if the date is within market hours, false otherwise
+     */
+    isWithinMarketHours(date: Date): boolean;
+    /**
+     * Check if a given date is before market hours
+     * @param date - The date to check
+     * @returns true if the date is before market hours, false otherwise
+     */
+    private isBeforeMarketHours;
+    /**
+     * Get the last trading date, i.e. the last date that was a market day
+     * @param currentDate - The current date
+     * @returns The last trading date
+     */
+    getLastTradingDate(currentDate?: Date): Date;
+    private getLastMarketDay;
+    getLastFullTradingDate(currentDate?: Date): Date;
+    /**
+     * Gets the next market day from a reference date
+     * @param {Object} [options] - Options object
+     * @param {Date} [options.referenceDate] - The reference date (defaults to current date)
+     * @returns {Object} The next market day information
+     * @property {Date} date - The date object (start of day in NY time)
+     * @property {string} yyyymmdd - The date in YYYY-MM-DD format
+     * @property {string} dateISOString - Full ISO date string
+     */
+    getNextMarketDay(date: Date): Date;
+    private getDayBoundaries;
+    private calculatePeriodStartDate;
+    getMarketTimePeriod({ period, end, intraday_reporting, outputFormat, }: MarketTimeParams): PeriodDates;
+    getMarketOpenClose(options?: {
+        date?: Date;
+    }): MarketOpenCloseResult;
+}
+/**
+ * Creates a new MarketTimeUtil instance
+ * @param {string} [timezone] - The timezone to use for market time calculations
+ * @param {IntradayReporting} [intraday_reporting] - The intraday reporting mode
+ * @returns {MarketTimeUtil} A new MarketTimeUtil instance
+ */
+export declare function createMarketTimeUtil(timezone?: string, intraday_reporting?: IntradayReporting): MarketTimeUtil;
+/**
+ * Gets start and end timestamps for a given market time period
+ * @param {MarketTimeParams} [params] - The market time parameters
+ * @returns {PeriodDates} The start and end timestamps
+ */
+export declare function getStartAndEndTimestamps(params?: MarketTimeParams): PeriodDates;
+/**
+ * Gets the market open/close times for a given date
+ * @param {Object} [options] - Options object
+ * @param {Date} [options.date] - The date to check (defaults to current date)
+ * @returns {MarketOpenCloseResult} The market open/close times
+ */
+export declare function getMarketOpenClose(options?: {
+    date?: Date;
+}): MarketOpenCloseResult;
+/**
+ * Gets the start and end dates for a given market time period
+ * @param {MarketTimeParams} [params] - The market time parameters
+ * @returns {Object} The start and end dates
+ * @property {Date} start - The start date
+ * @property {Date} end - The end date
+ */
+export declare function getStartAndEndDates(params?: MarketTimeParams): {
+    start: Date;
+    end: Date;
+};
+/**
+ * Gets the last trading date in YYYY-MM-DD format
+ * @returns {string} The last trading date in YYYY-MM-DD format
+ */
+export declare function getLastTradingDateYYYYMMDD(): string;
+/**
+ * Gets the last full trading date
+ * @param {Date} [currentDate] - The current date (defaults to now)
+ * @returns {Object} The last full trading date
+ * @property {Date} date - The date object
+ * @property {string} YYYYMMDD - The date in YYYY-MM-DD format
+ */
+export declare function getLastFullTradingDate(currentDate?: Date): {
+    date: Date;
+    YYYYMMDD: string;
+};
+/**
+ * Gets the next market day from a reference date
+ * @param {Object} [options] - Options object
+ * @param {Date} [options.referenceDate] - The reference date (defaults to current date)
+ * @returns {Object} The next market day information
+ * @property {Date} date - The date object (start of day in NY time)
+ * @property {string} yyyymmdd - The date in YYYY-MM-DD format
+ * @property {string} dateISOString - Full ISO date string
+ */
+export declare function getNextMarketDay({ referenceDate }?: {
+    referenceDate?: Date;
+}): {
+    date: Date;
+    yyyymmdd: string;
+    dateISOString: string;
+};
+/**
+ * Gets the current time in Eastern Time
+ * @returns {Date} The current time in Eastern Time
+ */
+export declare const currentTimeET: () => Date;
+/**
+ * Gets a date in New York timezone, rezoned using date-fns-tz
+ * @param {number|string|Date} time - The time to convert
+ * @returns {Date} The date in New York timezone
+ */
+export declare function getDateInNY(time: number | string | {
+    year: number;
+    month: number;
+    day: number;
+}): Date;
+/**
+ * Gets the trading date in YYYY-MM-DD format for New York timezone, for grouping of data
+ * @param {string|number|Date} time - The time to convert (string, unix timestamp in ms, or Date object)
+ * @returns {string} The trading date in YYYY-MM-DD format
+ */
+export declare function getTradingDate(time: string | number | Date): string;
+/**
+ * Returns the New York timezone offset based on whether daylight savings is active
+ * @param dateString - The date string to check
+ * @returns "-04:00" during daylight savings (EDT) or "-05:00" during standard time (EST)
+ */
+export declare const getNYTimeZone: (date?: Date) => "-04:00" | "-05:00";
+/**
+ * Gets the current market status
+ * @param {Object} [options] - Options object
+ * @param {Date} [options.date] - The date to check (defaults to current date)
+ * @returns {MarketStatus} The current market status
+ */
+export declare function getMarketStatus(options?: {
+    date?: Date;
+}): MarketStatus;
+//# sourceMappingURL=market-time.d.ts.map

package/dist/types/market-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"market-time.d.ts","sourceRoot":"","sources":["../../src/market-time.ts"],"names":[],"mappings":"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"}

package/dist/types/metrics-calcs.d.ts

@@ -0,0 +1,6 @@
+import { Bar, BenchmarkBar } from "./types/alpaca-types";
+import { types } from "@adaptic/backend-legacy";
+import { CalculateBetaResult, TradeMetrics } from "./types";
+export declare function calculateBetaFromReturns(portfolioReturns: number[], benchmarkReturns: number[]): CalculateBetaResult;
+export default function fetchTradeMetrics(trade: types.Trade, tradeBars: Bar[], benchmarkBars: BenchmarkBar[]): Promise<TradeMetrics>;
+//# sourceMappingURL=metrics-calcs.d.ts.map

package/dist/types/metrics-calcs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics-calcs.d.ts","sourceRoot":"","sources":["../../src/metrics-calcs.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAoI5D,wBAAgB,wBAAwB,CAAC,gBAAgB,EAAE,MAAM,EAAE,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,mBAAmB,CAgFpH;AAwQD,wBAA8B,iBAAiB,CAC7C,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,SAAS,EAAE,GAAG,EAAE,EAChB,aAAa,EAAE,YAAY,EAAE,GAC5B,OAAO,CAAC,YAAY,CAAC,CA6BvB"}