@mathieuc/tradingview 3.5.1 → 4.0.0-beta.0

package/dist/http/account.js

@@ -0,0 +1,127 @@
+import { platform, arch, release } from 'node:os';
+import { TradingViewError } from '../errors.js';
+import { getSetCookies, request, } from './request.js';
+/**
+ * Signs in with a username/email and password and returns the account with
+ * its session cookies. Accounts with 2FA or captcha challenges are not supported.
+ */
+export async function loginUser(options) {
+    const remember = options.remember ?? true;
+    const userAgent = options.userAgent ?? 'TWAPI/4.0';
+    const { data, headers } = await request('https://www.tradingview.com/accounts/signin/', {
+        method: 'POST',
+        form: { username: options.username, password: options.password, remember: remember ? 'on' : undefined },
+        headers: {
+            referer: 'https://www.tradingview.com',
+            'user-agent': `${userAgent} (${release()}; ${platform()}; ${arch()})`,
+        },
+    }, options);
+    if (!data || typeof data !== 'object') {
+        throw new TradingViewError('AUTH_ERROR', 'Unexpected sign-in response');
+    }
+    if (data.error)
+        throw new TradingViewError('AUTH_ERROR', String(data.error), { details: data });
+    if (!data.user)
+        throw new TradingViewError('AUTH_ERROR', 'Sign-in response has no user', { details: data });
+    return userFromLogin(data.user, headers);
+}
+function cookieValue(headers, name) {
+    for (const line of getSetCookies(headers)) {
+        const found = new RegExp(`(?:^|[;\\s])${name}=([^;]*)`).exec(line);
+        if (found)
+            return found[1];
+    }
+    return '';
+}
+function textOrEmpty(value) {
+    return String(value ?? '');
+}
+function numberOrZero(value) {
+    return Number(value ?? 0);
+}
+function userFromLogin(user, headers) {
+    return {
+        id: numberOrZero(user.id),
+        username: user.username,
+        firstName: textOrEmpty(user.first_name),
+        lastName: textOrEmpty(user.last_name),
+        reputation: numberOrZero(user.reputation),
+        following: numberOrZero(user.following),
+        followers: numberOrZero(user.followers),
+        notifications: {
+            user: numberOrZero(user.notification_count?.user),
+            following: numberOrZero(user.notification_count?.following),
+        },
+        session: cookieValue(headers, 'sessionid'),
+        signature: cookieValue(headers, 'sessionid_sign'),
+        sessionHash: textOrEmpty(user.session_hash),
+        privateChannel: textOrEmpty(user.private_channel),
+        authToken: textOrEmpty(user.auth_token),
+        joinDate: new Date(user.date_joined),
+    };
+}
+function match(page, pattern) {
+    return pattern.exec(page)?.[1];
+}
+function pageNumber(page, pattern) {
+    return parseFloat(match(page, pattern) ?? '0') || 0;
+}
+function pageText(page, pattern) {
+    return match(page, pattern) ?? '';
+}
+function trustedAccountLocation(location) {
+    let url;
+    try {
+        url = new URL(location);
+    }
+    catch {
+        throw new TradingViewError('AUTH_ERROR', 'Invalid account page URL');
+    }
+    if (url.protocol !== 'https:' || !/(^|\.)tradingview\.com$/i.test(url.hostname)) {
+        throw new TradingViewError('AUTH_ERROR', 'Account page redirects outside TradingView');
+    }
+    return url.toString();
+}
+/** Parses the account embedded in a TradingView HTML page. */
+export function parseUserPage(page, credentials) {
+    return {
+        id: pageNumber(page, /"id":([0-9]{1,10}),/),
+        username: pageText(page, /"username":"(.*?)"/),
+        firstName: pageText(page, /"first_name":"(.*?)"/),
+        lastName: pageText(page, /"last_name":"(.*?)"/),
+        reputation: pageNumber(page, /"reputation":(.*?),/),
+        following: pageNumber(page, /,"following":([0-9]*?),/),
+        followers: pageNumber(page, /,"followers":([0-9]*?),/),
+        notifications: {
+            following: pageNumber(page, /"notification_count":\{"following":([0-9]*),/),
+            user: pageNumber(page, /"notification_count":\{"following":[0-9]*,"user":([0-9]*)/),
+        },
+        session: credentials.session,
+        signature: credentials.signature ?? '',
+        sessionHash: pageText(page, /"session_hash":"(.*?)"/),
+        privateChannel: pageText(page, /"private_channel":"(.*?)"/),
+        authToken: pageText(page, /"auth_token":"(.*?)"/),
+        joinDate: new Date(pageText(page, /"date_joined":"(.*?)"/) || 0),
+    };
+}
+/** Loads the account behind `sessionid` (and `sessionid_sign`) cookies. */
+export async function getUser(credentials, options = {}) {
+    if (!credentials?.session)
+        throw new TradingViewError('INVALID_ARGUMENT', 'A session cookie is required');
+    const maxRedirects = options.maxRedirects ?? 5;
+    let location = trustedAccountLocation(options.location ?? 'https://www.tradingview.com/chart/');
+    for (let redirects = 0;; redirects += 1) {
+        const { status, text, headers } = await request(location, { credentials, redirect: 'manual' }, options);
+        if (text.includes('auth_token'))
+            return parseUserPage(text, credentials);
+        const next = headers.get('location');
+        const resolved = status >= 300 && status < 400 && next ? new URL(next, location).toString() : undefined;
+        if (!resolved || resolved === location) {
+            throw new TradingViewError('AUTH_ERROR', 'Wrong or expired sessionid/signature');
+        }
+        if (redirects >= maxRedirects) {
+            throw new TradingViewError('AUTH_ERROR', 'Too many redirects (possible WAF or geo-restriction)');
+        }
+        location = trustedAccountLocation(resolved);
+    }
+}

package/dist/http/index.d.ts

@@ -0,0 +1,11 @@
+export type { AuthHttpOptions, Credentials, HttpOptions } from './request.js';
+export { getUser, loginUser } from './account.js';
+export type { GetUserOptions, LoginOptions, User } from './account.js';
+export { getTechnicalAnalysis, searchMarkets } from './market.js';
+export type { MarketSearchResult, MarketType, SearchMarketsOptions, TechnicalAnalysis, TechnicalAnalysisPeriod, TechnicalRating, } from './market.js';
+export { clearIndicatorCache, getIndicator, getPrivateIndicators, parseIndicatorDefinition, searchIndicators, } from './indicators.js';
+export type { GetIndicatorOptions, IndicatorAccess, IndicatorSearchResult } from './indicators.js';
+export { getChartToken, getDrawings } from './layouts.js';
+export type { Drawing, DrawingPoint, GetDrawingsOptions, LayoutOptions, } from './layouts.js';
+export { PinePermissionManager } from './pine-permissions.js';
+export type { AuthorizedUser, AuthorizedUserOrder, PinePermissionOptions } from './pine-permissions.js';

package/dist/http/index.js

@@ -0,0 +1,5 @@
+export { getUser, loginUser } from './account.js';
+export { getTechnicalAnalysis, searchMarkets } from './market.js';
+export { clearIndicatorCache, getIndicator, getPrivateIndicators, parseIndicatorDefinition, searchIndicators, } from './indicators.js';
+export { getChartToken, getDrawings } from './layouts.js';
+export { PinePermissionManager } from './pine-permissions.js';

package/dist/http/indicators.d.ts

@@ -0,0 +1,37 @@
+import { PineIndicator } from '../indicators/pine-indicator.js';
+import { type AuthHttpOptions, type Credentials, type HttpOptions } from './request.js';
+export type IndicatorAccess = 'open_source' | 'closed_source' | 'invite_only' | 'private' | 'other';
+/** An indicator returned by `searchIndicators` or `getPrivateIndicators`. */
+export interface IndicatorSearchResult {
+    /** Script ID to pass to `getIndicator`. */
+    id: string;
+    version: string;
+    name: string;
+    author: {
+        id: number;
+        username: string;
+    };
+    /** Chart image ID: `https://www.tradingview.com/i/<image>`. */
+    image: string;
+    /** Pine source, when public. */
+    source: string;
+    type: 'study' | 'strategy' | (string & {});
+    access: IndicatorAccess;
+}
+/** Clears the in-memory list of built-in indicators used by `searchIndicators`. */
+export declare function clearIndicatorCache(): void;
+/** Searches built-in and community indicators. */
+export declare function searchIndicators(query?: string, options?: HttpOptions): Promise<IndicatorSearchResult[]>;
+export interface GetIndicatorOptions extends AuthHttpOptions {
+    /** Script version. Default: `last`. */
+    version?: string;
+}
+/** Converts a `pine-facade/translate` result into a `PineIndicator`. */
+export declare function parseIndicatorDefinition(result: any, id: string, version: string): PineIndicator;
+/**
+ * Loads an indicator definition (`STD;RSI`, `PUB;xxxx`, `USER;xxxx`...).
+ * Private and invite-only scripts need credentials with access.
+ */
+export declare function getIndicator(id: string, options?: GetIndicatorOptions): Promise<PineIndicator>;
+/** Lists the private (saved) indicators of an account. */
+export declare function getPrivateIndicators(credentials: Credentials, options?: HttpOptions): Promise<IndicatorSearchResult[]>;

package/dist/http/indicators.js

@@ -0,0 +1,144 @@
+import { TradingViewError } from '../errors.js';
+import { PineIndicator } from '../indicators/pine-indicator.js';
+import { request, } from './request.js';
+let builtInCache;
+async function loadBuiltIns(options) {
+    const lists = await Promise.all(['standard', 'candlestick', 'fundamental'].map(async (filter) => {
+        const { data } = await request('https://pine-facade.tradingview.com/pine-facade/list', { query: { filter } }, options);
+        return Array.isArray(data) ? data : [];
+    }));
+    return lists.flat();
+}
+/** Clears the in-memory list of built-in indicators used by `searchIndicators`. */
+export function clearIndicatorCache() {
+    builtInCache = undefined;
+}
+const normalise = (value = '') => value.toUpperCase().replace(/[^A-Z]/g, '');
+/** Searches built-in and community indicators. */
+export async function searchIndicators(query = '', options = {}) {
+    // Custom fetch implementations (tests, proxies) must not share the process-wide cache.
+    const builtInsPromise = options.fetch ? loadBuiltIns(options) : (builtInCache ??= loadBuiltIns(options));
+    const [builtIns, community] = await Promise.all([
+        builtInsPromise.catch((error) => {
+            if (!options.fetch)
+                builtInCache = undefined;
+            throw error;
+        }),
+        request('https://www.tradingview.com/pubscripts-suggest-json', { query: { search: query } }, options),
+    ]);
+    const needle = normalise(query);
+    const kind = (ind) => ind.extra?.kind ?? 'study';
+    return [
+        ...builtIns
+            .filter((ind) => normalise(ind.scriptName).includes(needle)
+            || normalise(ind.extra?.shortDescription).includes(needle))
+            .map((ind) => ({
+            id: ind.scriptIdPart,
+            version: String(ind.version),
+            name: ind.scriptName,
+            author: { id: Number(ind.userId ?? -1), username: '@TRADINGVIEW@' },
+            image: '',
+            source: '',
+            type: kind(ind),
+            access: 'closed_source',
+        })),
+        ...(community.data?.results ?? []).map((ind) => ({
+            id: ind.scriptIdPart,
+            version: String(ind.version),
+            name: ind.scriptName,
+            author: { id: Number(ind.author?.id ?? -1), username: ind.author?.username ?? '' },
+            image: ind.imageUrl ?? '',
+            source: ind.scriptSource ?? '',
+            type: kind(ind),
+            access: ['open_source', 'closed_source', 'invite_only'][ind.access - 1] ?? 'other',
+        })),
+    ];
+}
+const sanitise = (value) => value.replace(/ /g, '_').replace(/[^a-zA-Z0-9_]/g, '');
+function parseInputs(items) {
+    const inputs = {};
+    for (const input of items) {
+        if (['text', 'pineId', 'pineVersion'].includes(input.id))
+            continue;
+        const inlineName = sanitise(String(input.name ?? input.id));
+        inputs[input.id] = {
+            name: input.name,
+            inline: input.inline || inlineName,
+            internalID: input.internalID || inlineName,
+            tooltip: input.tooltip,
+            type: input.type,
+            value: input.defval,
+            isHidden: !!input.isHidden,
+            isFake: !!input.isFake,
+            ...(input.options ? { options: input.options } : {}),
+        };
+    }
+    return inputs;
+}
+function parsePlots(styles, items) {
+    const plots = {};
+    for (const [plotId, style] of Object.entries(styles)) {
+        const title = sanitise(String(style.title ?? plotId));
+        const titles = Object.values(plots);
+        if (titles.includes(title)) {
+            let i = 2;
+            while (titles.includes(`${title}_${i}`))
+                i += 1;
+            plots[plotId] = `${title}_${i}`;
+        }
+        else
+            plots[plotId] = title;
+    }
+    for (const plot of items) {
+        if (!plot.target)
+            continue;
+        plots[plot.id] = `${plots[plot.target] ?? plot.target}_${plot.type}`;
+    }
+    return plots;
+}
+/** Converts a `pine-facade/translate` result into a `PineIndicator`. */
+export function parseIndicatorDefinition(result, id, version) {
+    const meta = result.metaInfo;
+    return new PineIndicator({
+        id: meta.scriptIdPart || id,
+        version: meta.pine?.version || version,
+        description: meta.description,
+        shortDescription: meta.shortDescription,
+        inputs: parseInputs(meta.inputs),
+        plots: parsePlots(meta.styles ?? {}, meta.plots ?? []),
+        script: result.ilTemplate,
+    });
+}
+/**
+ * Loads an indicator definition (`STD;RSI`, `PUB;xxxx`, `USER;xxxx`...).
+ * Private and invite-only scripts need credentials with access.
+ */
+export async function getIndicator(id, options = {}) {
+    const version = options.version ?? 'last';
+    const encodedId = id.replace(/ |%/g, '%25');
+    const { data } = await request(`https://pine-facade.tradingview.com/pine-facade/translate/${encodedId}/${version}`, { credentials: options.credentials }, options);
+    if (!data?.success || !data.result?.metaInfo?.inputs) {
+        throw new TradingViewError('NOT_FOUND', `Inexistent or unsupported indicator: "${data?.reason}"`, { details: data });
+    }
+    return parseIndicatorDefinition(data.result, encodedId, version);
+}
+/** Lists the private (saved) indicators of an account. */
+export async function getPrivateIndicators(credentials, options = {}) {
+    const { data } = await request('https://pine-facade.tradingview.com/pine-facade/list', {
+        query: { filter: 'saved' },
+        credentials,
+    }, options);
+    if (!Array.isArray(data)) {
+        throw new TradingViewError('AUTH_ERROR', 'Unable to list private indicators (check credentials)', { details: data });
+    }
+    return data.map((ind) => ({
+        id: ind.scriptIdPart,
+        version: String(ind.version),
+        name: ind.scriptName,
+        author: { id: -1, username: '@ME@' },
+        image: ind.imageUrl ?? '',
+        source: ind.scriptSource ?? '',
+        type: ind.extra?.kind ?? 'study',
+        access: 'private',
+    }));
+}

package/dist/http/layouts.d.ts

@@ -0,0 +1,36 @@
+import { type AuthHttpOptions } from './request.js';
+export interface LayoutOptions extends AuthHttpOptions {
+    /** Account ID (`User.id`), required with credentials for private layouts. */
+    userId?: number;
+}
+/** Gets a chart-storage token for a layout (the ID in `tradingview.com/chart/<ID>/`). */
+export declare function getChartToken(layoutId: string, options?: LayoutOptions): Promise<string>;
+export interface DrawingPoint {
+    time_t: number;
+    price: number;
+    offset: number;
+    [key: string]: unknown;
+}
+/** A user drawing stored in a layout. State properties are merged at the top level. */
+export interface Drawing {
+    id: string;
+    symbol: string;
+    ownerSource: string;
+    serverUpdateTime: string;
+    currencyId: string;
+    unitId: unknown;
+    type: string;
+    points: DrawingPoint[];
+    zorder: number;
+    linkKey: string;
+    state: Record<string, any>;
+    [key: string]: unknown;
+}
+export interface GetDrawingsOptions extends LayoutOptions {
+    /** Only returns drawings for this symbol. */
+    symbol?: string;
+    /** Chart ID inside the layout. Default: `_shared`. */
+    chartId?: string;
+}
+/** Lists the drawings of a layout. */
+export declare function getDrawings(layoutId: string, options?: GetDrawingsOptions): Promise<Drawing[]>;

package/dist/http/layouts.js

@@ -0,0 +1,24 @@
+import { TradingViewError } from '../errors.js';
+import { request } from './request.js';
+/** Gets a chart-storage token for a layout (the ID in `tradingview.com/chart/<ID>/`). */
+export async function getChartToken(layoutId, options = {}) {
+    const authenticated = Boolean(options.credentials?.session && options.userId);
+    const { data } = await request('https://www.tradingview.com/chart-token', {
+        query: { image_url: layoutId, user_id: authenticated ? options.userId : -1 },
+        credentials: authenticated ? options.credentials : undefined,
+    }, options);
+    if (!data?.token)
+        throw new TradingViewError('NOT_FOUND', 'Wrong layout or credentials', { details: data });
+    return data.token;
+}
+/** Lists the drawings of a layout. */
+export async function getDrawings(layoutId, options = {}) {
+    const token = await getChartToken(layoutId, options);
+    const { data } = await request(`https://charts-storage.tradingview.com/charts-storage/get/layout/${layoutId}/sources`, {
+        query: { chart_id: options.chartId ?? '_shared', jwt: token, symbol: options.symbol ?? '' },
+    }, options);
+    if (!data?.payload) {
+        throw new TradingViewError('NOT_FOUND', 'Wrong layout, user credentials, or chart id', { details: data });
+    }
+    return Object.values(data.payload.sources ?? {}).map((drawing) => ({ ...drawing, ...drawing.state }));
+}

package/dist/http/market.d.ts

@@ -0,0 +1,45 @@
+import { type HttpOptions } from './request.js';
+export type MarketType = 'stock' | 'futures' | 'forex' | 'cfd' | 'crypto' | 'index' | 'economic' | 'bond' | 'fund' | (string & {});
+/** One market returned by `searchMarkets`. */
+export interface MarketSearchResult {
+    /** Exchange-qualified symbol, usable everywhere in this library (`BINANCE:BTCEUR`). */
+    id: string;
+    /** Short exchange name (`BINANCE`). */
+    exchange: string;
+    /** Exchange name as sent by TradingView. */
+    fullExchange: string;
+    symbol: string;
+    description: string;
+    type: string;
+    currency?: string;
+    country?: string;
+}
+export interface SearchMarketsOptions extends HttpOptions {
+    /** Restricts results to a market type. */
+    type?: MarketType;
+    /** Pagination offset. */
+    offset?: number;
+    /** Restricts results to an exchange. `searchMarkets('BINANCE:BTC')` sets it too. */
+    exchange?: string;
+}
+/** Searches markets by keywords, `EXCHANGE:` prefix or `EXCHANGE:SYMBOL`. */
+export declare function searchMarkets(query: string, options?: SearchMarketsOptions): Promise<MarketSearchResult[]>;
+/**
+ * TradingView technical ratings, from -1 (strong sell) to 1 (strong buy).
+ * `All` is the summary, `MA` the moving averages and `Other` the oscillators.
+ */
+export interface TechnicalRating {
+    Other: number;
+    All: number;
+    MA: number;
+}
+export type TechnicalAnalysisPeriod = '1' | '5' | '15' | '60' | '240' | '1D' | '1W' | '1M';
+export type TechnicalAnalysis = Record<TechnicalAnalysisPeriod, TechnicalRating>;
+/**
+ * Gets technical ratings for every period from the TradingView scanner.
+ * Returns `null` when the scanner has no data for the symbol.
+ *
+ * Values are scaled like the historical API: `round(raw * 1000) / 500`,
+ * which maps the scanner range [-1, 1] to [-2, 2].
+ */
+export declare function getTechnicalAnalysis(symbol: string, options?: HttpOptions): Promise<TechnicalAnalysis | null>;

package/dist/http/market.js

@@ -0,0 +1,59 @@
+import { TradingViewError } from '../errors.js';
+import { request } from './request.js';
+const ORIGIN = { origin: 'https://www.tradingview.com' };
+/** Searches markets by keywords, `EXCHANGE:` prefix or `EXCHANGE:SYMBOL`. */
+export async function searchMarkets(query, options = {}) {
+    const parts = query.toUpperCase().split(':');
+    const text = parts.length === 2 ? parts[1] : query.toUpperCase();
+    const exchange = options.exchange ?? (parts.length === 2 ? parts[0] : undefined);
+    const { data, status } = await request('https://symbol-search.tradingview.com/symbol_search/v3/', {
+        query: {
+            text, exchange, search_type: options.type ?? '', start: options.offset ?? 0,
+        },
+        headers: ORIGIN,
+    }, options);
+    if (!data || !Array.isArray(data.symbols)) {
+        throw new TradingViewError('HTTP_ERROR', `Unexpected market search response (HTTP ${status})`, { details: data });
+    }
+    return data.symbols.map((s) => {
+        const shortExchange = String(s.exchange ?? '').split(' ')[0];
+        const symbol = String(s.symbol ?? '').replace(/<\/?em>/g, '');
+        return {
+            id: s.prefix ? `${s.prefix}:${symbol}` : `${shortExchange.toUpperCase()}:${symbol}`,
+            exchange: shortExchange,
+            fullExchange: s.exchange,
+            symbol,
+            description: String(s.description ?? '').replace(/<\/?em>/g, ''),
+            type: s.type,
+            currency: s.currency_code,
+            country: s.country,
+        };
+    });
+}
+const TA_PERIODS = ['1', '5', '15', '60', '240', '1D', '1W', '1M'];
+const TA_INDICATORS = ['Recommend.Other', 'Recommend.All', 'Recommend.MA'];
+/**
+ * Gets technical ratings for every period from the TradingView scanner.
+ * Returns `null` when the scanner has no data for the symbol.
+ *
+ * Values are scaled like the historical API: `round(raw * 1000) / 500`,
+ * which maps the scanner range [-1, 1] to [-2, 2].
+ */
+export async function getTechnicalAnalysis(symbol, options = {}) {
+    const columns = TA_PERIODS.flatMap((period) => TA_INDICATORS.map((name) => (period === '1D' ? name : `${name}|${period}`)));
+    const { data } = await request('https://scanner.tradingview.com/global/scan', {
+        method: 'POST',
+        json: { symbols: { tickers: [symbol] }, columns },
+    }, options);
+    const values = data?.data?.[0]?.d;
+    if (!values)
+        return null;
+    const result = {};
+    values.forEach((value, index) => {
+        const [name, period = '1D'] = columns[index].split('|');
+        const key = name.split('.').pop();
+        result[period] ??= {};
+        result[period][key] = Math.round(Number(value) * 1000) / 500;
+    });
+    return result;
+}

package/dist/http/pine-permissions.d.ts

@@ -0,0 +1,29 @@
+import { type Credentials, type HttpOptions } from './request.js';
+/** A user allowed to use an invite-only script. */
+export interface AuthorizedUser {
+    id: number;
+    username: string;
+    userpic: string;
+    /** ISO date, or null when the access does not expire. */
+    expiration: string | null;
+    created: string;
+    [key: string]: unknown;
+}
+export type AuthorizedUserOrder = 'user__username' | '-user__username' | 'created' | '-created' | 'expiration,user__username' | '-expiration,user__username';
+export interface PinePermissionOptions extends HttpOptions {
+    credentials: Credentials;
+}
+/** Manages who can use an invite-only Pine script you own. */
+export declare class PinePermissionManager {
+    #private;
+    readonly pineId: string;
+    constructor(pineId: string, options: PinePermissionOptions);
+    /** Lists authorized users. */
+    getUsers(limit?: number, order?: AuthorizedUserOrder): Promise<AuthorizedUser[]>;
+    /** Authorizes a user, optionally until a date. */
+    addUser(username: string, expiration?: Date): Promise<'ok' | 'exists' | (string & {})>;
+    /** Changes (or removes, without date) the expiration of a user's access. */
+    modifyExpiration(username: string, expiration?: Date): Promise<'ok' | (string & {})>;
+    /** Revokes a user's access. */
+    removeUser(username: string): Promise<'ok' | (string & {})>;
+}

package/dist/http/pine-permissions.js

@@ -0,0 +1,56 @@
+import { TradingViewError } from '../errors.js';
+import { request } from './request.js';
+/** Manages who can use an invite-only Pine script you own. */
+export class PinePermissionManager {
+    pineId;
+    #credentials;
+    #options;
+    constructor(pineId, options) {
+        if (!pineId)
+            throw new TradingViewError('INVALID_ARGUMENT', 'A Pine ID is required');
+        if (!options?.credentials?.session)
+            throw new TradingViewError('INVALID_ARGUMENT', 'A session cookie is required');
+        if (!options.credentials.signature)
+            throw new TradingViewError('INVALID_ARGUMENT', 'A session signature is required');
+        this.pineId = pineId;
+        this.#credentials = options.credentials;
+        this.#options = { fetch: options.fetch, signal: options.signal, headers: options.headers };
+    }
+    async #post(path, form, query) {
+        const { status, data } = await request(`https://www.tradingview.com/pine_perm/${path}`, {
+            method: 'POST',
+            query,
+            form: { pine_id: this.pineId, ...form },
+            credentials: this.#credentials,
+            headers: { origin: 'https://www.tradingview.com' },
+        }, this.#options);
+        if (status >= 400) {
+            throw new TradingViewError(status === 404 ? 'NOT_FOUND' : 'HTTP_ERROR', data?.detail ?? 'Wrong credentials or pineId', {
+                details: data,
+            });
+        }
+        return data;
+    }
+    /** Lists authorized users. */
+    async getUsers(limit = 10, order = '-created') {
+        const data = await this.#post('list_users/', {}, { limit, order_by: order });
+        return data?.results ?? [];
+    }
+    /** Authorizes a user, optionally until a date. */
+    async addUser(username, expiration) {
+        const data = await this.#post('add/', { username_recip: username, expiration: expiration?.toISOString() });
+        return data?.status;
+    }
+    /** Changes (or removes, without date) the expiration of a user's access. */
+    async modifyExpiration(username, expiration) {
+        const data = await this.#post('modify_user_expiration/', {
+            username_recip: username, expiration: expiration?.toISOString(),
+        });
+        return data?.status;
+    }
+    /** Revokes a user's access. */
+    async removeUser(username) {
+        const data = await this.#post('remove/', { username_recip: username });
+        return data?.status;
+    }
+}

package/dist/http/request.d.ts

@@ -0,0 +1,44 @@
+/** TradingView account cookies. Keep them secret. */
+export interface Credentials {
+    /** Value of the `sessionid` cookie. */
+    session: string;
+    /** Value of the `sessionid_sign` cookie. */
+    signature?: string;
+}
+/** Options accepted by every HTTP function. */
+export interface HttpOptions {
+    /** Custom `fetch` implementation (tests, proxies). Defaults to the global `fetch`. */
+    fetch?: typeof fetch;
+    /** Cancels the request. */
+    signal?: AbortSignal;
+    /** Extra request headers. */
+    headers?: Record<string, string>;
+}
+/** HTTP options for endpoints that can use an account. */
+export interface AuthHttpOptions extends HttpOptions {
+    credentials?: Credentials;
+}
+export declare const DEFAULT_USER_AGENT: string;
+/** Builds the `cookie` header value for credentials. */
+export declare function authCookies(credentials?: Credentials | null): string;
+export interface RequestInit {
+    method?: 'GET' | 'POST';
+    query?: Record<string, string | number | boolean | undefined | null>;
+    form?: Record<string, string | number | undefined | null>;
+    json?: unknown;
+    credentials?: Credentials | null;
+    headers?: Record<string, string>;
+    redirect?: 'follow' | 'manual';
+}
+export interface HttpResponse {
+    status: number;
+    headers: Headers;
+    url: string;
+    text: string;
+    /** Parsed JSON body, or `undefined` when the body is not JSON. */
+    data: any;
+}
+/** Performs a request. Like the historical client, 5xx statuses throw. */
+export declare function request(url: string, init: RequestInit, options?: HttpOptions): Promise<HttpResponse>;
+/** Reads every `set-cookie` header, across runtimes. */
+export declare function getSetCookies(headers: Headers): string[];