@kkkermit/trading212.js 0.1.0 → 0.1.2

package/dist/client-BSQXqdxj.d.ts

@@ -0,0 +1,1684 @@
+/**
+ * Where the client keeps the instrument and exchange lists. Implement it over a file, Redis or anything else to share
+ * them between processes; each method may return a promise, and values are plain JSON.
+ */
+interface CacheStore {
+    /** `undefined` or `null` means a miss. */
+    get(key: string): unknown;
+    set(key: string, value: unknown, ttlMs: number): unknown;
+    delete?(key: string): unknown;
+}
+interface LoadOptions<T> {
+    readonly ttlMs: number;
+    /** Skip the cache and load afresh. */
+    readonly refresh?: boolean;
+    /** Stops this caller waiting; a load other callers share carries on. */
+    readonly signal?: AbortSignal | undefined;
+    /** Rejects a cached value of the wrong shape, which is then reported and loaded afresh. */
+    readonly accept?: (value: unknown) => value is T;
+}
+/** The default store: a `Map` with expiry, private to one client. */
+declare class MemoryCache implements CacheStore {
+    #private;
+    get(key: string): unknown;
+    set(key: string, value: unknown, ttlMs: number): void;
+    delete(key: string): void;
+    clear(): void;
+}
+/**
+ * Loads a value through the cache, sharing one in-flight load between concurrent callers. A cache store that fails is
+ * reported and bypassed, so a broken cache costs a download rather than the call.
+ */
+declare class CachedLoader {
+    #private;
+    constructor(store: CacheStore, onError?: (error: unknown, key: string) => void);
+    /**
+     * The shared load is started without any caller's signal, so one caller giving up never fails the others; each
+     * caller stops waiting when its own `signal` aborts.
+     */
+    load<T>(key: string, options: LoadOptions<T>, loader: () => Promise<T>): Promise<T>;
+}
+
+/** `demo` is paper trading; `live` is real money. A key works in exactly one of them. */
+type Environment = "demo" | "live";
+declare const BASE_URLS: Readonly<Record<Environment, string>>;
+
+type HttpMethod = "GET" | "POST" | "DELETE";
+/**
+ * How an endpoint may be treated. `read` is safe to retry; `write` changes something harmless such as requesting a
+ * report; `trade` moves money or holdings and is never retried and refused on live unless trading is enabled.
+ */
+type EndpointKind = "read" | "write" | "trade";
+interface EndpointRateLimit {
+    readonly requests: number;
+    readonly periodMs: number;
+}
+interface EndpointDefinition {
+    readonly id: string;
+    readonly method: HttpMethod;
+    readonly path: string;
+    /** The API key permission the endpoint needs, or `null` where the spec does not name one. */
+    readonly scope: string | null;
+    readonly rateLimit: EndpointRateLimit;
+    readonly kind: EndpointKind;
+    readonly deprecated: boolean;
+    readonly summary: string;
+}
+
+/** What the `x-ratelimit-*` headers said about an endpoint's budget. Absent headers leave fields undefined. */
+interface RateLimitInfo {
+    /** Requests allowed per period. */
+    readonly limit?: number;
+    /** Length of the period, in milliseconds. */
+    readonly periodMs?: number;
+    /** Requests left in this period. */
+    readonly remaining?: number;
+    /** Requests already made in this period. */
+    readonly used?: number;
+    /** When the budget fully resets, as epoch milliseconds. */
+    readonly resetAt?: number;
+}
+
+/**
+ * - `pace` (default) spreads calls evenly over each period, as Trading 212 recommends, so 429s should not happen.
+ * - `burst` spends a period's whole allowance at once, then waits for the reset.
+ * - `off` sends immediately; a read that meets a 429 is still retried after the reset.
+ */
+type RateLimitMode = "pace" | "burst" | "off";
+/** What is known about one endpoint's budget right now. */
+interface EndpointBudget {
+    readonly limit: number;
+    readonly periodMs: number;
+    /** From the last response's headers; undefined until the endpoint has been called. */
+    readonly remaining: number | undefined;
+    readonly resetAt: Date | undefined;
+}
+/** How long a call must wait for its slot, and whether the slot was taken. */
+interface Reservation {
+    readonly waitMs: number;
+    readonly booked: boolean;
+}
+declare class RateLimiter {
+    #private;
+    constructor(accountKey: string, mode: RateLimitMode);
+    /**
+     * Books the next slot for a call. When the wait would be longer than `maxWaitMs`, nothing is booked, so a refused
+     * call never delays the ones after it.
+     */
+    reserve(endpoint: EndpointDefinition, now: number, maxWaitMs?: number): Reservation;
+    /** Corrects the budget from what Trading 212's headers said, which beats the documented figures. */
+    update(endpoint: EndpointDefinition, info: RateLimitInfo, now: number): void;
+    /** How long the endpoint is closed for after a 429 or an empty budget, in milliseconds. */
+    blockedFor(endpoint: EndpointDefinition, now: number): number;
+    /** Records a 429: nothing more is sent to the endpoint until the reset. */
+    markLimited(endpoint: EndpointDefinition, resetAt: number | undefined, now: number): void;
+    snapshot(endpoints: readonly EndpointDefinition[]): Record<string, EndpointBudget>;
+}
+
+/** Retries apply to reads only. Orders, cancellations and pie changes are never retried. */
+interface RetryOptions {
+    /** Total tries, including the first. Default 3. */
+    maxAttempts?: number;
+    /** The first backoff, doubled on each retry, with full jitter. Default 500 ms. */
+    baseDelayMs?: number;
+    /** The longest backoff. Default 10 s. */
+    maxDelayMs?: number;
+}
+interface ResolvedRetry {
+    readonly maxAttempts: number;
+    readonly baseDelayMs: number;
+    readonly maxDelayMs: number;
+}
+
+/** A stable, machine-readable name for what went wrong. */
+type ErrorCode = "configuration" | "authentication" | "missing_scope" | "not_available_in_demo" | "permission" | "validation" | "order_rejected" | "not_found" | "instrument_not_found" | "rate_limited" | "timeout" | "outcome_unknown" | "trading_disabled" | "network" | "server" | "http_error" | "unexpected_response";
+/** The request an error came from. Never holds headers or credentials. */
+interface RequestDescription {
+    readonly method: string;
+    readonly path: string;
+    /** The library's name for the endpoint, such as `placeLimitOrder`. */
+    readonly endpoint?: string;
+}
+interface ErrorDetails {
+    hint?: string;
+    status?: number;
+    request?: RequestDescription;
+    rateLimit?: RateLimitInfo;
+    /** The response body, parsed when it was JSON and always redacted. */
+    body?: unknown;
+    /** The error code Trading 212 put in the body, such as `min-quantity-exceeded`. */
+    apiCode?: string;
+    /** Trading 212's reference for the failed request, worth quoting if you contact its support. */
+    traceId?: string;
+    cause?: unknown;
+}
+/**
+ * The base of every error this library throws. `instanceof` works on it and on every subclass even when two copies
+ * of the package are loaded (ESM beside CJS), because the check reads a brand rather than the prototype chain.
+ */
+declare class Trading212Error extends Error {
+    static readonly kind: string;
+    readonly code: ErrorCode;
+    /** What to do about it, in plain English. */
+    readonly hint: string | undefined;
+    readonly status: number | undefined;
+    readonly request: RequestDescription | undefined;
+    readonly rateLimit: RateLimitInfo | undefined;
+    readonly body: unknown;
+    readonly apiCode: string | undefined;
+    /** Trading 212's reference for the failed request, worth quoting if you contact its support. */
+    readonly traceId: string | undefined;
+    /** Set when a paginated read failed part-way: pass it as `cursor` to carry on from where it stopped. */
+    resumeCursor: string | undefined;
+    constructor(message: string, code: ErrorCode, details?: ErrorDetails);
+    static [Symbol.hasInstance](value: unknown): boolean;
+    /** A plain, redacted object for structured logs: every field that has a value, plus the cause's message. */
+    toLog(): Record<string, unknown>;
+    toJSON(): Record<string, unknown>;
+}
+/** True for any error this library threw, from any copy of the package. */
+declare function isTrading212Error(value: unknown): value is Trading212Error;
+/** The options passed to the client, or the environment variables behind them, are wrong. No request was made. */
+declare class ConfigurationError extends Trading212Error {
+    static readonly kind = "ConfigurationError";
+    /** The option at fault, such as `apiKey`. */
+    readonly field: string | undefined;
+    constructor(message: string, details?: ErrorDetails & {
+        field?: string;
+    });
+}
+/** 401: Trading 212 did not accept the key and secret. */
+declare class AuthenticationError extends Trading212Error {
+    static readonly kind = "AuthenticationError";
+    readonly environment: Environment;
+    constructor(message: string, details: ErrorDetails & {
+        environment: Environment;
+    });
+}
+/** 403 with a missing permission: the key exists but was not given this scope. */
+declare class MissingScopeError extends Trading212Error {
+    static readonly kind = "MissingScopeError";
+    /** The permission the key lacks, such as `orders:execute`. */
+    readonly scope: string;
+    constructor(message: string, details: ErrorDetails & {
+        scope: string;
+    });
+}
+/** 403 for a feature that only exists on live, such as CSV exports. */
+declare class NotAvailableInDemoError extends Trading212Error {
+    static readonly kind = "NotAvailableInDemoError";
+    constructor(message: string, details?: ErrorDetails);
+}
+/** Any other 403, for example a key restricted to IP addresses this machine is not on. */
+declare class PermissionError extends Trading212Error {
+    static readonly kind = "PermissionError";
+    constructor(message: string, details?: ErrorDetails);
+}
+interface ValidationIssue {
+    readonly field: string;
+    readonly message: string;
+}
+/** The request was invalid: caught here before sending, or refused by Trading 212 with a 400. */
+declare class ValidationError extends Trading212Error {
+    static readonly kind: string;
+    readonly issues: readonly ValidationIssue[];
+    constructor(message: string, details?: ErrorDetails & {
+        issues?: readonly ValidationIssue[];
+    }, code?: ErrorCode);
+}
+/** Why Trading 212 refused an order, spelt as its error bodies spell it; an unknown reason arrives as its raw code. */
+type OrderRejectionReason = "min-quantity-exceeded" | "max-quantity-exceeded" | "insufficient-free-for-stocks-buy" | "selling-equity-not-owned" | "market-closed" | "quantity-precision-mismatch" | (string & {});
+/** Trading 212 refused an order for a business reason, such as not enough cash. Nothing was traded. */
+declare class OrderRejectedError extends ValidationError {
+    static readonly kind = "OrderRejectedError";
+    readonly reason: OrderRejectionReason;
+    /** The smallest quantity Trading 212 accepts for this order, read from a `min-quantity-exceeded` refusal. */
+    readonly minQuantity: number | undefined;
+    /** The largest quantity it accepts in one order, read from a `max-quantity-exceeded` refusal. */
+    readonly maxQuantity: number | undefined;
+    /** The most decimal places a quantity may have, read from a `quantity-precision-mismatch` refusal. */
+    readonly maxDecimals: number | undefined;
+    /** How many shares Trading 212 says the account owns, read from a `selling-equity-not-owned` refusal. */
+    readonly ownedQuantity: number | undefined;
+    constructor(message: string, details: ErrorDetails & {
+        reason: OrderRejectionReason;
+        minQuantity?: number;
+        maxQuantity?: number;
+        maxDecimals?: number;
+        ownedQuantity?: number;
+    });
+}
+/** 404: the order, pie or other resource does not exist (any more). */
+declare class NotFoundError extends Trading212Error {
+    static readonly kind: string;
+    constructor(message: string, details?: ErrorDetails, code?: ErrorCode);
+}
+interface InstrumentSuggestion {
+    readonly ticker: string;
+    readonly name: string | undefined;
+}
+/** No instrument matched, or several did equally well. `suggestions` lists the closest. */
+declare class InstrumentNotFoundError extends NotFoundError {
+    static readonly kind = "InstrumentNotFoundError";
+    readonly query: string;
+    readonly suggestions: readonly InstrumentSuggestion[];
+    constructor(message: string, details: ErrorDetails & {
+        query: string;
+        suggestions: readonly InstrumentSuggestion[];
+    });
+}
+/** 429, or a client-side wait for budget that would have been longer than allowed. */
+declare class RateLimitError extends Trading212Error {
+    static readonly kind = "RateLimitError";
+    /** How long to wait before the next try. */
+    readonly retryAfterMs: number | undefined;
+    /** When the budget resets. */
+    readonly resetAt: Date | undefined;
+    constructor(message: string, details: ErrorDetails & {
+        retryAfterMs?: number;
+        resetAt?: number;
+    });
+}
+/** The request took too long: a 408 from Trading 212, or the client's own `timeoutMs`. */
+declare class TimeoutError extends Trading212Error {
+    static readonly kind = "TimeoutError";
+    constructor(message: string, details?: ErrorDetails);
+}
+/** An order, cancellation or pie change may or may not have happened. Check `orders.list()` before resending. */
+declare class OrderOutcomeUnknownError extends Trading212Error {
+    static readonly kind = "OrderOutcomeUnknownError";
+    /** What was sent, so it can be looked for. */
+    readonly sent: unknown;
+    constructor(message: string, details: ErrorDetails & {
+        sent?: unknown;
+    });
+}
+/** A trade was refused before sending because trading is off for this client, the default on live. */
+declare class TradingDisabledError extends Trading212Error {
+    static readonly kind = "TradingDisabledError";
+    constructor(message: string, details?: ErrorDetails);
+}
+/** The connection failed. `sent` is false when it failed before reaching Trading 212, such as a DNS failure. */
+declare class NetworkError extends Trading212Error {
+    static readonly kind = "NetworkError";
+    readonly sent: boolean;
+    constructor(message: string, details: ErrorDetails & {
+        sent: boolean;
+    });
+}
+/** 5xx: Trading 212 had a problem of its own. */
+declare class ServerError extends Trading212Error {
+    static readonly kind = "ServerError";
+    constructor(message: string, details?: ErrorDetails);
+}
+/** Any other non-success status. */
+declare class HttpError extends Trading212Error {
+    static readonly kind = "HttpError";
+    constructor(message: string, details?: ErrorDetails);
+}
+/** A success response this library could not read, or a redirect it refused to follow with your credentials. */
+declare class UnexpectedResponseError extends Trading212Error {
+    static readonly kind = "UnexpectedResponseError";
+    constructor(message: string, details?: ErrorDetails);
+}
+
+type LogLevel = "debug" | "info" | "warn" | "error";
+type LogFields = Record<string, unknown>;
+/**
+ * Anything with these four methods. `console` fits as it is; for pino or bunyan, whose methods take the fields
+ * first, wrap them with {@link fieldsFirst}.
+ */
+interface Logger {
+    debug(message: string, fields?: LogFields): void;
+    info(message: string, fields?: LogFields): void;
+    warn(message: string, fields?: LogFields): void;
+    error(message: string, fields?: LogFields): void;
+}
+/** The default: says nothing. */
+declare const silentLogger: Logger;
+/** The console methods `consoleLogger` writes to. */
+interface ConsoleLike {
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+/**
+ * Writes one line per event, such as `[trading212] WARN  Retrying GET … in 500 ms. endpoint=getAccountSummary`, and
+ * drops anything below `level` (default `info`).
+ */
+declare function consoleLogger(options?: {
+    level?: LogLevel;
+    console?: ConsoleLike;
+}): Logger;
+/** A pino- or bunyan-style log method. */
+type FieldsFirstMethod = (fields: LogFields, message: string) => void;
+/** Adapts a pino- or bunyan-style logger, whose methods take `(fields, message)`. */
+declare function fieldsFirst(target: {
+    debug: FieldsFirstMethod;
+    info: FieldsFirstMethod;
+    warn: FieldsFirstMethod;
+    error: FieldsFirstMethod;
+}): Logger;
+
+type Redactor = (value: unknown) => unknown;
+
+interface RequestEvent {
+    readonly endpoint: string;
+    readonly method: string;
+    readonly path: string;
+    readonly attempt: number;
+}
+interface ResponseEvent extends RequestEvent {
+    readonly status: number;
+    readonly durationMs: number;
+    readonly rateLimit: RateLimitInfo | undefined;
+}
+interface RetryEvent extends RequestEvent {
+    readonly delayMs: number;
+    readonly error: Trading212Error;
+}
+interface RateLimitWaitEvent {
+    readonly endpoint: string;
+    readonly waitMs: number;
+}
+/** Callbacks for metrics and tracing. They receive no credentials, and an exception in one is ignored. */
+interface Hooks {
+    onRequest?(event: RequestEvent): void;
+    onResponse?(event: ResponseEvent): void;
+    onRetry?(event: RetryEvent): void;
+    onRateLimitWait?(event: RateLimitWaitEvent): void;
+}
+type FetchLike = (input: string, init: RequestInit) => Promise<Response>;
+interface TransportConfig {
+    readonly environment: Environment;
+    readonly origin: string;
+    readonly authorization: string;
+    readonly fetch: FetchLike;
+    readonly timeoutMs: number;
+    readonly retry: ResolvedRetry | null;
+    readonly rateLimiter: RateLimiter;
+    readonly maxRateLimitWaitMs: number;
+    readonly logger: Logger;
+    readonly hooks: Hooks;
+    readonly redact: Redactor;
+    /** For success bodies: removes the credentials without touching text that only looks like one. */
+    readonly removeSecrets: (text: string) => string;
+    readonly userAgent: string;
+    readonly trading: "enabled" | "disabled";
+}
+interface CallOptions {
+    /** Cancels the call. A trade aborted after it was sent throws `OrderOutcomeUnknownError`. */
+    signal?: AbortSignal;
+    /** Overrides the client's `timeoutMs` for this call. */
+    timeoutMs?: number;
+}
+interface RequestOptions extends CallOptions {
+    params?: Record<string, string | number>;
+    query?: Record<string, string | number | boolean | undefined>;
+    /** An already-validated query string, used to follow pagination. */
+    rawQuery?: string;
+    body?: unknown;
+    /** The endpoint always answers with a body, so an empty success is an error. */
+    expectBody?: boolean;
+}
+interface TransportResponse<T> {
+    readonly data: T;
+    readonly status: number;
+    readonly rateLimit: RateLimitInfo | undefined;
+}
+/** Sends every request the client makes: authentication, budget, timeouts, retries, logging and errors. */
+declare class Transport {
+    #private;
+    constructor(config: TransportConfig);
+    get origin(): string;
+    get tradingEnabled(): boolean;
+    rateLimitSnapshot(): Record<string, EndpointBudget>;
+    /** Builds a request's URL and description without sending it. */
+    describe(endpoint: EndpointDefinition, options?: RequestOptions): RequestDescription & {
+        url: string;
+    };
+    request<T>(endpoint: EndpointDefinition, given?: RequestOptions): Promise<TransportResponse<T>>;
+}
+
+interface Trading212Options {
+    /** Required, with no default: `demo` for paper trading or `live` for real money. */
+    environment: Environment;
+    /** The API key from the Trading 212 app, under Settings > API (Beta). */
+    apiKey: string;
+    /** The secret shown once when the key was made. */
+    apiSecret: string;
+    /**
+     * Whether this client may place or cancel orders and change pies. Defaults to `enabled` on Trading 212's demo host and
+     * `disabled` everywhere else, so a live client, or one behind a custom `baseUrl`, only reads until you say otherwise.
+     * `disabled` is honoured on demo too.
+     */
+    trading?: "enabled" | "disabled";
+    /** Per-request timeout. Default 15 s. */
+    timeoutMs?: number;
+    /** How reads are retried, or `false` for never. Trades are never retried. */
+    retry?: RetryOptions | false;
+    /** How to stay within Trading 212's per-endpoint limits. Default `pace`. */
+    rateLimit?: RateLimitMode;
+    /** The longest the client will wait for rate-limit budget before throwing `RateLimitError`. Default 60 s. */
+    maxRateLimitWaitMs?: number;
+    /** Where to send log lines. Default: nowhere. Every field is redacted first. */
+    logger?: Logger;
+    /** Callbacks for metrics and tracing. */
+    hooks?: Hooks;
+    /** Where to keep the instrument and exchange lists. Default: in memory, per client. */
+    cache?: CacheStore;
+    /** How long the instrument and exchange lists are kept. Default 1 hour; Trading 212 refreshes them every 10 minutes. */
+    metadataTtlMs?: number;
+    /** A `fetch` to use instead of the global one, for proxies and tests. */
+    fetch?: FetchLike;
+    /** Only for tests and proxies: must be `https://`, or `http://localhost`. */
+    baseUrl?: string;
+    /** Appended to the `User-Agent` this client sends. */
+    userAgent?: string;
+    /**
+     * The client refuses to start in a browser, because Trading 212 rejects browser requests and a key in a page is
+     * public. Set this only if you understand both.
+     */
+    dangerouslyAllowBrowser?: boolean;
+}
+type EnvSource = Record<string, string | undefined>;
+
+declare const SPEC_VERSION = "v0";
+declare const DEFINITIONS: {
+    readonly cancelOrder: {
+        readonly id: "cancelOrder";
+        readonly method: "DELETE";
+        readonly path: "/api/v0/equity/orders/{id}";
+        readonly scope: "orders:execute";
+        readonly rateLimit: {
+            readonly requests: 50;
+            readonly periodMs: 60000;
+        };
+        readonly kind: "trade";
+        readonly deprecated: false;
+        readonly summary: "Cancel a pending order";
+    };
+    readonly createPie: {
+        readonly id: "createPie";
+        readonly method: "POST";
+        readonly path: "/api/v0/equity/pies";
+        readonly scope: "pies:write";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 5000;
+        };
+        readonly kind: "trade";
+        readonly deprecated: true;
+        readonly summary: "Create pie";
+    };
+    readonly deletePie: {
+        readonly id: "deletePie";
+        readonly method: "DELETE";
+        readonly path: "/api/v0/equity/pies/{id}";
+        readonly scope: "pies:write";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 5000;
+        };
+        readonly kind: "trade";
+        readonly deprecated: true;
+        readonly summary: "Delete pie";
+    };
+    readonly duplicatePie: {
+        readonly id: "duplicatePie";
+        readonly method: "POST";
+        readonly path: "/api/v0/equity/pies/{id}/duplicate";
+        readonly scope: "pies:write";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 5000;
+        };
+        readonly kind: "trade";
+        readonly deprecated: true;
+        readonly summary: "Duplicate pie";
+    };
+    readonly getAccountSummary: {
+        readonly id: "getAccountSummary";
+        readonly method: "GET";
+        readonly path: "/api/v0/equity/account/summary";
+        readonly scope: "account";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 5000;
+        };
+        readonly kind: "read";
+        readonly deprecated: false;
+        readonly summary: "Get account summary";
+    };
+    readonly getOrder: {
+        readonly id: "getOrder";
+        readonly method: "GET";
+        readonly path: "/api/v0/equity/orders/{id}";
+        readonly scope: "orders:read";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 1000;
+        };
+        readonly kind: "read";
+        readonly deprecated: false;
+        readonly summary: "Get a pending order by ID";
+    };
+    readonly getPie: {
+        readonly id: "getPie";
+        readonly method: "GET";
+        readonly path: "/api/v0/equity/pies/{id}";
+        readonly scope: "pies:read";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 5000;
+        };
+        readonly kind: "read";
+        readonly deprecated: true;
+        readonly summary: "Fetch a pie";
+    };
+    readonly listDividends: {
+        readonly id: "listDividends";
+        readonly method: "GET";
+        readonly path: "/api/v0/equity/history/dividends";
+        readonly scope: "history:dividends";
+        readonly rateLimit: {
+            readonly requests: 20;
+            readonly periodMs: 60000;
+        };
+        readonly kind: "read";
+        readonly deprecated: false;
+        readonly summary: "Get paid out dividends";
+    };
+    readonly listExchanges: {
+        readonly id: "listExchanges";
+        readonly method: "GET";
+        readonly path: "/api/v0/equity/metadata/exchanges";
+        readonly scope: "metadata";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 30000;
+        };
+        readonly kind: "read";
+        readonly deprecated: false;
+        readonly summary: "Get exchanges metadata";
+    };
+    readonly listHistoricalOrders: {
+        readonly id: "listHistoricalOrders";
+        readonly method: "GET";
+        readonly path: "/api/v0/equity/history/orders";
+        readonly scope: "history:orders";
+        readonly rateLimit: {
+            readonly requests: 20;
+            readonly periodMs: 60000;
+        };
+        readonly kind: "read";
+        readonly deprecated: false;
+        readonly summary: "Get historical orders data";
+    };
+    readonly listInstruments: {
+        readonly id: "listInstruments";
+        readonly method: "GET";
+        readonly path: "/api/v0/equity/metadata/instruments";
+        readonly scope: "metadata";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 50000;
+        };
+        readonly kind: "read";
+        readonly deprecated: false;
+        readonly summary: "Get all available instruments";
+    };
+    readonly listOrders: {
+        readonly id: "listOrders";
+        readonly method: "GET";
+        readonly path: "/api/v0/equity/orders";
+        readonly scope: "orders:read";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 5000;
+        };
+        readonly kind: "read";
+        readonly deprecated: false;
+        readonly summary: "Get all pending orders";
+    };
+    readonly listPies: {
+        readonly id: "listPies";
+        readonly method: "GET";
+        readonly path: "/api/v0/equity/pies";
+        readonly scope: "pies:read";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 30000;
+        };
+        readonly kind: "read";
+        readonly deprecated: true;
+        readonly summary: "Fetch all pies";
+    };
+    readonly listPositions: {
+        readonly id: "listPositions";
+        readonly method: "GET";
+        readonly path: "/api/v0/equity/positions";
+        readonly scope: "portfolio";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 1000;
+        };
+        readonly kind: "read";
+        readonly deprecated: false;
+        readonly summary: "Fetch all open positions";
+    };
+    readonly listReports: {
+        readonly id: "listReports";
+        readonly method: "GET";
+        readonly path: "/api/v0/equity/history/exports";
+        readonly scope: null;
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 60000;
+        };
+        readonly kind: "read";
+        readonly deprecated: false;
+        readonly summary: "List generated reports";
+    };
+    readonly listTransactions: {
+        readonly id: "listTransactions";
+        readonly method: "GET";
+        readonly path: "/api/v0/equity/history/transactions";
+        readonly scope: "history:transactions";
+        readonly rateLimit: {
+            readonly requests: 20;
+            readonly periodMs: 60000;
+        };
+        readonly kind: "read";
+        readonly deprecated: false;
+        readonly summary: "Get transactions";
+    };
+    readonly placeLimitOrder: {
+        readonly id: "placeLimitOrder";
+        readonly method: "POST";
+        readonly path: "/api/v0/equity/orders/limit";
+        readonly scope: "orders:execute";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 2000;
+        };
+        readonly kind: "trade";
+        readonly deprecated: false;
+        readonly summary: "Place a Limit order";
+    };
+    readonly placeMarketOrder: {
+        readonly id: "placeMarketOrder";
+        readonly method: "POST";
+        readonly path: "/api/v0/equity/orders/market";
+        readonly scope: "orders:execute";
+        readonly rateLimit: {
+            readonly requests: 50;
+            readonly periodMs: 60000;
+        };
+        readonly kind: "trade";
+        readonly deprecated: false;
+        readonly summary: "Place a Market order";
+    };
+    readonly placeStopLimitOrder: {
+        readonly id: "placeStopLimitOrder";
+        readonly method: "POST";
+        readonly path: "/api/v0/equity/orders/stop_limit";
+        readonly scope: "orders:execute";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 2000;
+        };
+        readonly kind: "trade";
+        readonly deprecated: false;
+        readonly summary: "Place a StopLimit order";
+    };
+    readonly placeStopOrder: {
+        readonly id: "placeStopOrder";
+        readonly method: "POST";
+        readonly path: "/api/v0/equity/orders/stop";
+        readonly scope: "orders:execute";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 2000;
+        };
+        readonly kind: "trade";
+        readonly deprecated: false;
+        readonly summary: "Place a Stop order";
+    };
+    readonly requestReport: {
+        readonly id: "requestReport";
+        readonly method: "POST";
+        readonly path: "/api/v0/equity/history/exports";
+        readonly scope: null;
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 30000;
+        };
+        readonly kind: "write";
+        readonly deprecated: false;
+        readonly summary: "Request a CSV report";
+    };
+    readonly updatePie: {
+        readonly id: "updatePie";
+        readonly method: "POST";
+        readonly path: "/api/v0/equity/pies/{id}";
+        readonly scope: "pies:write";
+        readonly rateLimit: {
+            readonly requests: 1;
+            readonly periodMs: 5000;
+        };
+        readonly kind: "trade";
+        readonly deprecated: true;
+        readonly summary: "Update pie";
+    };
+};
+/** Every endpoint in the spec, frozen so nothing at run time can turn a trade into a read. */
+declare const ENDPOINTS: typeof DEFINITIONS;
+type EndpointId = keyof typeof ENDPOINTS;
+
+interface AccountBucketDetailedResponse {
+    /** ISO 8601 date and time. */
+    creationDate?: string | null;
+    dividendCashAction?: "REINVEST" | "TO_ACCOUNT_CASH" | (string & {}) | null;
+    /** ISO 8601 date and time. */
+    endDate?: string | null;
+    goal?: number | null;
+    icon?: string | null;
+    /** 64-bit integer. */
+    id?: number | null;
+    initialInvestment?: number | null;
+    instrumentShares?: Record<string, number> | null;
+    name?: string | null;
+    publicUrl?: string | null;
+}
+interface AccountBucketInstrumentResult {
+    currentShare?: number | null;
+    expectedShare?: number | null;
+    issues?: InstrumentIssue[] | null;
+    ownedQuantity?: number | null;
+    result?: InvestmentResult | null;
+    ticker?: string | null;
+}
+interface AccountBucketInstrumentsDetailedResponse {
+    instruments?: AccountBucketInstrumentResult[] | null;
+    settings?: AccountBucketDetailedResponse | null;
+}
+interface AccountBucketResultResponse {
+    /** Amount of money put into the pie in account currency */
+    cash?: number | null;
+    dividendDetails?: DividendDetails | null;
+    /** 64-bit integer. */
+    id?: number | null;
+    /** Progress of the pie based on the set goal */
+    progress?: number | null;
+    result?: InvestmentResult | null;
+    /** Status of the pie based on the set goal */
+    status?: "AHEAD" | "ON_TRACK" | "BEHIND" | (string & {}) | null;
+}
+interface AccountSummary {
+    cash?: Cash | null;
+    /** Primary account currency in ISO 4217 format. */
+    currency?: string | null;
+    /** Primary trading account number. This is the same account ID you would see in the Trading 212 web or mobile application. */
+    id?: number | null;
+    investments?: Investments | null;
+    /** Investments value in your account's primary currency. */
+    totalValue?: number | null;
+}
+interface Cash {
+    /** Funds available for investing. */
+    availableToTrade?: number | null;
+    /** It’s the sum of the cash inside of all pies that is not yet invested. */
+    inPies?: number | null;
+    /** The amount of cash reserved for pending orders. This cash is not available for placing new trades. */
+    reservedForOrders?: number | null;
+}
+interface DividendDetails {
+    gained?: number | null;
+    inCash?: number | null;
+    reinvested?: number | null;
+}
+interface DuplicateBucketRequest {
+    icon?: string | null;
+    name?: string | null;
+}
+interface EnqueuedReportResponse {
+    /** 64-bit integer. */
+    reportId?: number | null;
+}
+interface Exchange {
+    /** 64-bit integer. */
+    id?: number | null;
+    name?: string | null;
+    workingSchedules?: WorkingSchedule[] | null;
+}
+interface Fill {
+    /** ISO 8601 date and time. */
+    filledAt?: string | null;
+    /** 64-bit integer. */
+    id?: number | null;
+    price?: number | null;
+    quantity?: number | null;
+    tradingMethod?: "TOTV" | "OTC" | (string & {}) | null;
+    type?: "TRADE" | "STOCK_SPLIT" | "STOCK_DISTRIBUTION" | "FOP" | "FOP_CORRECTION" | "CUSTOM_STOCK_DISTRIBUTION" | "EQUITY_RIGHTS" | "SCRIP_STOCK_DIVIDENDS" | "STOCK_DIVIDENDS" | "STOCK_ACQUISITION" | "CASH_AND_STOCK_ACQUISITION" | "SPIN_OFF" | (string & {}) | null;
+    walletImpact?: FillWalletImpact | null;
+}
+interface FillWalletImpact {
+    currency?: string | null;
+    fxRate?: number | null;
+    netValue?: number | null;
+    realisedProfitLoss?: number | null;
+    taxes?: Tax[] | null;
+}
+interface HistoricalOrder {
+    fill?: Fill | null;
+    order?: Order | null;
+}
+interface HistoryDividendItem {
+    /** In account's primary currency. */
+    amount?: number | null;
+    amountInEuro?: number | null;
+    /** The account's primary currency. */
+    currency?: string | null;
+    /** In instrument currency */
+    grossAmountPerShare?: number | null;
+    instrument?: Instrument$1 | null;
+    /** ISO 8601 date and time. */
+    paidOn?: string | null;
+    quantity?: number | null;
+    reference?: string | null;
+    ticker?: string | null;
+    tickerCurrency?: string | null;
+    type?: "ORDINARY" | "BONUS" | "PROPERTY_INCOME" | "RETURN_OF_CAPITAL_NON_US" | "DEMERGER" | "INTEREST" | "CAPITAL_GAINS_DISTRIBUTION_NON_US" | "INTERIM_LIQUIDATION" | "ORDINARY_MANUFACTURED_PAYMENT" | "BONUS_MANUFACTURED_PAYMENT" | "PROPERTY_INCOME_MANUFACTURED_PAYMENT" | "RETURN_OF_CAPITAL_NON_US_MANUFACTURED_PAYMENT" | "DEMERGER_MANUFACTURED_PAYMENT" | "INTEREST_MANUFACTURED_PAYMENT" | "CAPITAL_GAINS_DISTRIBUTION_NON_US_MANUFACTURED_PAYMENT" | "INTERIM_LIQUIDATION_MANUFACTURED_PAYMENT" | "INTEREST_PAID_BY_US_OBLIGORS" | "INTEREST_PAID_BY_FOREIGN_CORPORATIONS" | "DIVIDENDS_PAID_BY_US_CORPORATIONS" | "DIVIDENDS_PAID_BY_FOREIGN_CORPORATIONS" | "CAPITAL_GAINS" | "REAL_PROPERTY_INCOME_AND_NATURAL_RESOURCES_ROYALTIES" | "OTHER_INCOME" | "QUALIFIED_INVESTMENT_ENTITY" | "TRUST_DISTRIBUTION" | "PUBLICLY_TRADED_PARTNERSHIP_DISTRIBUTION" | "CAPITAL_GAINS_DISTRIBUTION" | "RETURN_OF_CAPITAL" | "OTHER_DIVIDEND_EQUIVALENT" | "TAX_EVENT_1446F_FOR_PUBLICLY_TRADED_SECURITIES" | "PTP_UNCHARACTERISED_INCOME" | "MULTIPLE_1042S_TAX_COMPONENTS" | "DIVIDEND" | "SHORT_TERM_CAPITAL_GAINS" | "LONG_TERM_CAPITAL_GAINS" | "PROPERTY_INCOME_DISTRIBUTION" | "TAX_EXEMPTED" | "INTEREST_PAID_BY_US_OBLIGORS_MANUFACTURED_PAYMENT" | "INTEREST_PAID_BY_FOREIGN_CORPORATIONS_MANUFACTURED_PAYMENT" | "DIVIDENDS_PAID_BY_US_CORPORATIONS_MANUFACTURED_PAYMENT" | "DIVIDENDS_PAID_BY_FOREIGN_CORPORATIONS_MANUFACTURED_PAYMENT" | "CAPITAL_GAINS_MANUFACTURED_PAYMENT" | "REAL_PROPERTY_INCOME_AND_NATURAL_RESOURCES_ROYALTIES_MANUFACTURED_PAYMENT" | "OTHER_INCOME_MANUFACTURED_PAYMENT" | "QUALIFIED_INVESTMENT_ENTITY_MANUFACTURED_PAYMENT" | "TRUST_DISTRIBUTION_MANUFACTURED_PAYMENT" | "PUBLICLY_TRADED_PARTNERSHIP_DISTRIBUTION_MANUFACTURED_PAYMENT" | "CAPITAL_GAINS_DISTRIBUTION_MANUFACTURED_PAYMENT" | "RETURN_OF_CAPITAL_MANUFACTURED_PAYMENT" | "OTHER_DIVIDEND_EQUIVALENT_MANUFACTURED_PAYMENT" | "TAX_EVENT_1446F_FOR_PUBLICLY_TRADED_SECURITIES_MANUFACTURED_PAYMENT" | "PTP_UNCHARACTERISED_INCOME_MANUFACTURED_PAYMENT" | "MULTIPLE_1042S_TAX_COMPONENTS_MANUFACTURED_PAYMENT" | "DIVIDEND_MANUFACTURED_PAYMENT" | "SHORT_TERM_CAPITAL_GAINS_MANUFACTURED_PAYMENT" | "LONG_TERM_CAPITAL_GAINS_MANUFACTURED_PAYMENT" | "PROPERTY_INCOME_DISTRIBUTION_MANUFACTURED_PAYMENT" | "TAX_EXEMPTED_MANUFACTURED_PAYMENT" | (string & {}) | null;
+}
+interface HistoryTransactionItem {
+    /** Amount in the currency of the transaction */
+    amount?: number | null;
+    /** Currency of the transaction */
+    currency?: string | null;
+    /** ISO 8601 date and time. */
+    dateTime?: string | null;
+    /** ID */
+    reference?: string | null;
+    type?: "WITHDRAW" | "DEPOSIT" | "FEE" | "TRANSFER" | "INTEREST_ON_FREE_CASH" | "LENDING_INTEREST" | (string & {}) | null;
+}
+/** Instrument information as given by /instruments endpoint. */
+interface Instrument$1 {
+    /** Instrument currency in ISO 4217 format. */
+    currency?: string | null;
+    /** ISIN of the instrument. */
+    isin?: string | null;
+    /** Name of the instrument. */
+    name?: string | null;
+    /** Unique instrument identifier. */
+    ticker?: string | null;
+}
+interface InstrumentIssue {
+    name?: "DELISTED" | "SUSPENDED" | "NO_LONGER_TRADABLE" | "MAX_POSITION_SIZE_REACHED" | "APPROACHING_MAX_POSITION_SIZE" | "COMPLEX_INSTRUMENT_APP_TEST_REQUIRED" | "PRICE_TOO_LOW" | (string & {}) | null;
+    severity?: "IRREVERSIBLE" | "REVERSIBLE" | "INFORMATIVE" | (string & {}) | null;
+}
+interface InvestmentResult {
+    priceAvgInvestedValue?: number | null;
+    priceAvgResult?: number | null;
+    priceAvgResultCoef?: number | null;
+    priceAvgValue?: number | null;
+}
+interface Investments {
+    /** Current value of all the investments. */
+    currentValue?: number | null;
+    /** The all-time realised profit loss from all of the trades executed. */
+    realizedProfitLoss?: number | null;
+    /** The cost basis of your current investments. The total amount of funds you've invested in the shares you currently own. */
+    totalCost?: number | null;
+    /** The potential profit/loss of your current investments, showing how much you could gain or lose if you were to sell them now. */
+    unrealizedProfitLoss?: number | null;
+}
+interface LimitRequest {
+    limitPrice?: number | null;
+    quantity?: number | null;
+    ticker?: string | null;
+    /** Expiration */
+    timeValidity?: TimeValidity | null;
+}
+interface MarketRequest {
+    extendedHours?: boolean | null;
+    quantity?: number | null;
+    ticker?: string | null;
+}
+interface Order {
+    /**
+     * The ISO 8601 formatted date of when the order was created.
+     *
+     * ISO 8601 date and time.
+     */
+    createdAt?: string | null;
+    /** The currency used for the order in ISO 4217 format. */
+    currency?: string | null;
+    /** If true, the order is eligible for execution outside regular trading hours. */
+    extendedHours?: boolean | null;
+    /** The number of shares that have been successfully executed. Applicable to quantity orders. */
+    filledQuantity?: number | null;
+    /** The total monetary value of the executed portion of the order. Applicable to orders placed by value.Note: Placing orders by value is not currently supported via the API but can be done through other Trading 212 platforms. */
+    filledValue?: number | null;
+    /** A unique, system-generated identifier for the order. */
+    id?: number | null;
+    /** How the order was initiated. */
+    initiatedFrom?: "API" | "IOS" | "ANDROID" | "WEB" | "SYSTEM" | "AUTOINVEST" | "INSTRUMENT_AUTOINVEST" | (string & {}) | null;
+    instrument?: Instrument$1 | null;
+    /** Applicable to LIMIT and STOP_LIMIT orders. */
+    limitPrice?: number | null;
+    /** The total number of shares requested. Applicable to quantity orders. */
+    quantity?: number | null;
+    /** Indicates whether the order is BUY or SELL. */
+    side?: "BUY" | "SELL" | (string & {}) | null;
+    /** The current state of the order in its lifecycle. */
+    status?: "LOCAL" | "UNCONFIRMED" | "CONFIRMED" | "NEW" | "CANCELLING" | "CANCELLED" | "PARTIALLY_FILLED" | "FILLED" | "REJECTED" | "REPLACING" | "REPLACED" | (string & {}) | null;
+    /** Applicable to STOP and STOP_LIMIT orders. */
+    stopPrice?: number | null;
+    /** The strategy used to place the order, either by QUANTITY or VALUE. The API currently only supports placing orders by QUANTITY. */
+    strategy?: "QUANTITY" | "VALUE" | (string & {}) | null;
+    /** Unique instrument identifier. Get from the /instruments endpoint */
+    ticker?: string | null;
+    timeInForce?: TimeValidity | null;
+    type?: "LIMIT" | "STOP" | "MARKET" | "STOP_LIMIT" | (string & {}) | null;
+    /** The total monetary value of the order. Applicable to value orders. */
+    value?: number | null;
+}
+interface PaginatedResponseHistoricalOrder {
+    items?: HistoricalOrder[] | null;
+    nextPagePath?: string | null;
+}
+interface PaginatedResponseHistoryDividendItem {
+    items?: HistoryDividendItem[] | null;
+    nextPagePath?: string | null;
+}
+interface PaginatedResponseHistoryTransactionItem {
+    items?: HistoryTransactionItem[] | null;
+    nextPagePath?: string | null;
+}
+interface PieRequest {
+    dividendCashAction?: "REINVEST" | "TO_ACCOUNT_CASH" | (string & {}) | null;
+    /** ISO 8601 date and time. */
+    endDate?: string | null;
+    /** Total desired value of the pie in account currency */
+    goal?: number | null;
+    icon?: string | null;
+    instrumentShares?: Record<string, number> | null;
+    name?: string | null;
+}
+interface Position {
+    /** Average price paid, in instrument currency, per share. */
+    averagePricePaid?: number | null;
+    /**
+     * The ISO 8601 formatted date of when the position was opened.
+     *
+     * ISO 8601 date and time.
+     */
+    createdAt?: string | null;
+    /** Current price, in instrument currency, of a single share. */
+    currentPrice?: number | null;
+    instrument?: Instrument$1 | null;
+    /** Total quantity of shares owned. */
+    quantity?: number | null;
+    /** Quantity of shares available for trading. */
+    quantityAvailableForTrading?: number | null;
+    /** Quantity of shares currently used in pie. */
+    quantityInPies?: number | null;
+    /** Collects the financial impact of the position on the user's wallet. */
+    walletImpact?: PositionWalletImpact | null;
+}
+interface PositionWalletImpact {
+    /** The currency code used to represent all the wallet impact information. */
+    currency?: string | null;
+    /** The current market value of the position. */
+    currentValue?: number | null;
+    /** The positive or negative impact on the position's value due to currency rate changes. Only applies to positions with instrument currency that differs from the accounts. */
+    fxImpact?: number | null;
+    /** The total cost paid for the position. */
+    totalCost?: number | null;
+    /** The unrealized profit & loss for the position. Calculated as currentValue - totalCost. */
+    unrealizedProfitLoss?: number | null;
+}
+interface PublicReportRequest {
+    dataIncluded?: ReportDataIncluded | null;
+    /** ISO 8601 date and time. */
+    timeFrom?: string | null;
+    /** ISO 8601 date and time. */
+    timeTo?: string | null;
+}
+interface ReportDataIncluded {
+    includeDividends?: boolean | null;
+    includeInterest?: boolean | null;
+    includeOrders?: boolean | null;
+    includeTransactions?: boolean | null;
+}
+interface ReportResponse {
+    dataIncluded?: ReportDataIncluded | null;
+    downloadLink?: string | null;
+    /** 64-bit integer. */
+    reportId?: number | null;
+    status?: "Queued" | "Processing" | "Running" | "Canceled" | "Failed" | "Finished" | (string & {}) | null;
+    /** ISO 8601 date and time. */
+    timeFrom?: string | null;
+    /** ISO 8601 date and time. */
+    timeTo?: string | null;
+}
+interface StopLimitRequest {
+    limitPrice?: number | null;
+    quantity?: number | null;
+    stopPrice?: number | null;
+    ticker?: string | null;
+    /** Expiration */
+    timeValidity?: TimeValidity | null;
+}
+interface StopRequest {
+    quantity?: number | null;
+    stopPrice?: number | null;
+    ticker?: string | null;
+    /** Expiration */
+    timeValidity?: TimeValidity | null;
+}
+interface Tax {
+    /** ISO 8601 date and time. */
+    chargedAt?: string | null;
+    currency?: string | null;
+    name?: "COMMISSION_TURNOVER" | "CURRENCY_CONVERSION_FEE" | "FINRA_FEE" | "FRENCH_TRANSACTION_TAX" | "PTM_LEVY" | "STAMP_DUTY" | "STAMP_DUTY_RESERVE_TAX" | "TRANSACTION_FEE" | (string & {}) | null;
+    quantity?: number | null;
+}
+interface TimeEvent {
+    /** ISO 8601 date and time. */
+    date?: string | null;
+    type?: "OPEN" | "CLOSE" | "BREAK_START" | "BREAK_END" | "PRE_MARKET_OPEN" | "AFTER_HOURS_OPEN" | "AFTER_HOURS_CLOSE" | "OVERNIGHT_OPEN" | (string & {}) | null;
+}
+/**
+ * Specifies how long the order remains active:
+ * * DAY: The order will automatically expire if not executed by midnight in the time zone of the instrument's exchange.
+ * * GOOD_TILL_CANCEL: The order remains active indefinitely until it is either filled or explicitly cancelled by you.
+ */
+type TimeValidity = "DAY" | "GOOD_TILL_CANCEL" | (string & {});
+interface TradableInstrument {
+    /**
+     * On the platform since
+     *
+     * ISO 8601 date and time.
+     */
+    addedOn?: string | null;
+    /** ISO 4217 */
+    currencyCode?: string | null;
+    extendedHours?: boolean | null;
+    isin?: string | null;
+    maxOpenQuantity?: number | null;
+    name?: string | null;
+    shortName?: string | null;
+    /** Unique identifier */
+    ticker?: string | null;
+    type?: "CRYPTOCURRENCY" | "ETF" | "FOREX" | "FUTURES" | "INDEX" | "STOCK" | "WARRANT" | "CRYPTO" | "CVR" | "CORPACT" | (string & {}) | null;
+    /** Get items in the /exchanges endpoint */
+    workingScheduleId?: number | null;
+}
+interface WorkingSchedule {
+    /** 64-bit integer. */
+    id?: number | null;
+    timeEvents?: TimeEvent[] | null;
+}
+
+/** What every resource shares with the client that created it. */
+interface ResourceContext {
+    readonly transport: Transport;
+    readonly cache: CachedLoader;
+    /** Prefixes cache keys so different accounts and environments never share entries. */
+    readonly cacheNamespace: string;
+    readonly metadataTtlMs: number;
+    /** For downloads that must not carry credentials, such as signed report links. */
+    readonly fetch: FetchLike;
+    readonly timeoutMs: number;
+}
+
+declare class AccountResource {
+    #private;
+    constructor(context: ResourceContext);
+    /**
+     * Cash, invested capital, profit and loss, and total value, in the account's primary currency.
+     *
+     * Scope `account` · 1 request / 5 s.
+     *
+     * @example
+     * const { totalValue, currency } = await t212.account.summary();
+     */
+    summary(options?: CallOptions): Promise<AccountSummary>;
+}
+
+/** An instrument the account can trade, from `instruments.list()`, `search()`, `find()` and `resolve()`. */
+type Instrument = TradableInstrument & {
+    ticker: string;
+};
+/** A dividend payment, from `history.dividends`. */
+type Dividend = HistoryDividendItem;
+/** A deposit, withdrawal, fee or interest payment, from `history.transactions`. */
+type Transaction = HistoryTransactionItem;
+/** A requested CSV export and its status. */
+type Report = ReportResponse;
+/** A pie as listed by `pies.list()`. */
+type Pie = AccountBucketResultResponse;
+/** A pie with its instruments and settings, from `pies.get()`. */
+type PieDetails = AccountBucketInstrumentsDetailedResponse;
+/** What `pies.create()` and `pies.update()` take. */
+type PieInput = PieRequest;
+
+/** The list is shared between callers, so it is fetched with the client's own timeout rather than a per-call one. */
+interface ListOptions {
+    /** Ignore the cache and fetch afresh. */
+    refresh?: boolean;
+    /** Stops this caller waiting; a download other callers share carries on. */
+    signal?: AbortSignal;
+}
+interface SearchOptions extends ListOptions {
+    /** Most results to return. Default 10. */
+    limit?: number;
+    /** Only this instrument type, such as `STOCK` or `ETF`. */
+    type?: string;
+    /** Only instruments traded in this currency, such as `USD` or `GBX`. */
+    currency?: string;
+}
+interface ResolveOptions extends ListOptions {
+    type?: string;
+    currency?: string;
+}
+declare class InstrumentsResource {
+    #private;
+    constructor(context: ResourceContext);
+    /**
+     * Every instrument the account can trade: about 5 MB, so it is cached (one hour by default) and concurrent callers
+     * share one download.
+     *
+     * Scope `metadata` · 1 request / 50 s.
+     */
+    list(options?: ListOptions): Promise<Instrument[]>;
+    /**
+     * Finds instruments by ticker, ISIN, short name or name, best match first. Searches the cached list, so it costs
+     * no request after the first.
+     *
+     * @example
+     * const [apple] = await t212.instruments.search("Apple", { currency: "USD" });
+     */
+    search(query: string, options?: SearchOptions): Promise<Instrument[]>;
+    /** The instrument with exactly this Trading 212 ticker, or `undefined`. */
+    find(ticker: string, options?: ListOptions): Promise<Instrument | undefined>;
+    /**
+     * Turns what a person would type (`AAPL`, `Apple`, an ISIN) into exactly one instrument, or throws
+     * `InstrumentNotFoundError` listing the closest matches when none or several fit.
+     *
+     * @example
+     * const apple = await t212.instruments.resolve("AAPL", { currency: "USD" }); // AAPL_US_EQ
+     */
+    resolve(query: string, options?: ResolveOptions): Promise<Instrument>;
+}
+
+/** Where an instrument's market is in its day. Pre-market, after-hours and overnight are extended-hours sessions. */
+type MarketSession = "regular" | "preMarket" | "afterHours" | "overnight" | "closed" | "unknown";
+interface MarketStatus {
+    readonly ticker: string;
+    /** The exchange's name, when Trading 212 listed it. */
+    readonly exchange: string | undefined;
+    readonly session: MarketSession;
+    /** True during regular trading hours. */
+    readonly open: boolean;
+    /** True during a pre-market, after-hours or overnight session. */
+    readonly extendedHours: boolean;
+    /** When the current session began. */
+    readonly since: Date | undefined;
+    /** The next scheduled change, such as the close. */
+    readonly next: {
+        readonly event: string;
+        readonly at: Date;
+    } | undefined;
+    /** When regular trading next starts, including the end of a break, if the schedule reaches that far. */
+    readonly nextOpen: Date | undefined;
+}
+/** Works out the session at `at` from a working schedule. Pure, so it can be tested and reused offline. */
+declare function sessionAt(events: readonly TimeEvent[], at: Date): Pick<MarketStatus, "session" | "since" | "next" | "nextOpen">;
+declare class ExchangesResource {
+    #private;
+    constructor(context: ResourceContext, instruments: InstrumentsResource);
+    /**
+     * Every exchange and its working schedules, cached like the instrument list.
+     *
+     * Scope `metadata` · 1 request / 30 s.
+     */
+    list(options?: ListOptions): Promise<Exchange[]>;
+    /**
+     * Whether an instrument's market is open, read from Trading 212's working schedules, so you can check before an
+     * order is refused with `market-closed`. The schedules cover a limited window ahead, so `nextOpen` can be undefined.
+     *
+     * @example
+     * const { open, next } = await t212.exchanges.status("AAPL_US_EQ");
+     */
+    status(ticker: string | TradableInstrument, at?: Date, options?: ListOptions): Promise<MarketStatus>;
+}
+
+/** One page of a history list. */
+interface Page<T> {
+    readonly items: T[];
+    /** Pass as `cursor` to fetch the next page later, or `null` on the last page. */
+    readonly nextCursor: string | null;
+    readonly hasMore: boolean;
+    /** Fetches the next page, or resolves to `null` on the last one. */
+    next(options?: CallOptions): Promise<Page<T> | null>;
+}
+interface PageOptions extends CallOptions {
+    /** Items per page, 1 to 50. Default 20. */
+    limit?: number;
+    /** A `nextCursor` from an earlier page, to carry on from there. */
+    cursor?: string;
+}
+interface IterateOptions extends Omit<PageOptions, "limit"> {
+    /** Items per request, 1 to 50. Default 50, the fewest requests. */
+    pageSize?: number;
+    /** Stop after this many pages. */
+    maxPages?: number;
+    /** Stop after this many items. */
+    maxItems?: number;
+}
+/** A history list: one page at a time, or every item with `for await`. */
+declare class PagedList<T, F extends object = object> {
+    #private;
+    constructor(transport: Transport, endpoint: EndpointDefinition);
+    list(options?: PageOptions & F): Promise<Page<T>>;
+    /**
+     * Every item, newest first, fetching pages as the loop asks for them. If a request fails part-way, the error's
+     * `resumeCursor` says where to carry on.
+     */
+    all(options?: IterateOptions & F): AsyncGenerator<T, void, undefined>;
+}
+
+/** Your account's past: filled and cancelled orders, dividends, and cash movements. Newest first. */
+declare class HistoryResource {
+    /**
+     * Orders that have finished, with their fills.
+     *
+     * Scope `history:orders` · 20 requests / minute.
+     *
+     * @example
+     * for await (const { order, fill } of t212.history.orders.all({ ticker: "AAPL_US_EQ" })) console.log(order?.status, fill?.price);
+     */
+    readonly orders: PagedList<HistoricalOrder, {
+        ticker?: string;
+    }>;
+    /**
+     * Dividends paid out.
+     *
+     * Scope `history:dividends` · 20 requests / minute.
+     */
+    readonly dividends: PagedList<HistoryDividendItem, {
+        ticker?: string;
+    }>;
+    /**
+     * Deposits, withdrawals, fees, transfers and interest. `time` starts the list from that moment.
+     *
+     * Scope `history:transactions` · 20 requests / minute.
+     */
+    readonly transactions: PagedList<HistoryTransactionItem, {
+        time?: Date | string;
+    }>;
+    constructor(context: ResourceContext);
+}
+
+declare const TIME_VALIDITIES: readonly ["DAY", "GOOD_TILL_CANCEL"];
+/** `DAY` expires at midnight in the exchange's time zone; `GOOD_TILL_CANCEL` stays until it fills or you cancel it. */
+type OrderTimeValidity = (typeof TIME_VALIDITIES)[number];
+type OrderType = "market" | "limit" | "stop" | "stopLimit";
+
+declare class PositionsResource {
+    #private;
+    constructor(context: ResourceContext);
+    /**
+     * Every open position, or just one ticker's.
+     *
+     * Scope `portfolio` · 1 request / 1 s.
+     */
+    list(options?: CallOptions & {
+        ticker?: string;
+    }): Promise<Position[]>;
+    /** One ticker's position, or `undefined` when you hold none. */
+    get(ticker: string, options?: CallOptions): Promise<Position | undefined>;
+}
+
+interface MarketOrderRequest {
+    /** The Trading 212 ticker, such as `AAPL_US_EQ`. */
+    ticker: string;
+    /** Shares to trade, at most 4 decimal places. Positive buys, negative sells. */
+    quantity: number;
+    /** Allow the order to fill outside regular hours. Market orders only. */
+    extendedHours?: boolean;
+}
+interface LimitOrderRequest {
+    ticker: string;
+    quantity: number;
+    /** Buys fill at this price or lower; sells at this price or higher. */
+    limitPrice: number;
+    timeValidity: OrderTimeValidity;
+}
+interface StopOrderRequest {
+    ticker: string;
+    quantity: number;
+    /** When the price reaches this, a market order is placed. */
+    stopPrice: number;
+    timeValidity: OrderTimeValidity;
+}
+interface StopLimitOrderRequest {
+    ticker: string;
+    quantity: number;
+    stopPrice: number;
+    /** The limit order placed once `stopPrice` is reached. */
+    limitPrice: number;
+    timeValidity: OrderTimeValidity;
+}
+/** An order for `buy()` or `sell()`: the quantity is always positive and the method sets the direction. */
+type OrderInput = ({
+    type?: "market";
+} & MarketOrderRequest) | ({
+    type: "limit";
+} & LimitOrderRequest) | ({
+    type: "stop";
+} & StopOrderRequest) | ({
+    type: "stopLimit";
+} & StopLimitOrderRequest);
+interface PlaceOptions extends CallOptions {
+    /** Validate the order and return the request it would send, without sending it. */
+    dryRun?: boolean;
+}
+/** What `dryRun` returns instead of an order. */
+interface DryRunResult {
+    readonly dryRun: true;
+    readonly method: "POST";
+    readonly url: string;
+    readonly endpoint: string;
+    readonly body: Readonly<Record<string, unknown>>;
+    /** False when trading is off for this client, so a real call would be refused before sending. */
+    readonly wouldSend: boolean;
+}
+/** An `Order`, a `DryRunResult` for `{ dryRun: true }`, or either when `dryRun` is only known at run time. */
+type Placed<O extends PlaceOptions | undefined> = O extends {
+    dryRun: true;
+} ? DryRunResult : O extends undefined ? Order : "dryRun" extends keyof O ? true extends NonNullable<O["dryRun"]> ? Order | DryRunResult : Order : Order;
+interface NoDryRun {
+    dryRun?: false;
+}
+interface WaitOptions extends CallOptions {
+    /** Give up after this long. Default 60 s. */
+    timeoutMs?: number;
+    /** Time between checks. Default 1 s, the endpoint's limit. */
+    intervalMs?: number;
+}
+interface SellAllOptions extends PlaceOptions {
+    extendedHours?: boolean;
+}
+/** The statuses an order does not leave. */
+declare const FINAL_ORDER_STATUSES: ReadonlySet<string>;
+declare class OrdersResource {
+    #private;
+    constructor(context: ResourceContext, positions: PositionsResource, history: PagedList<HistoricalOrder, {
+        ticker?: string;
+    }>);
+    /**
+     * Orders that are still working: not yet filled, cancelled or expired.
+     *
+     * Scope `orders:read` · 1 request / 5 s.
+     */
+    list(options?: CallOptions): Promise<Order[]>;
+    /**
+     * One pending order. Throws `NotFoundError` once it has filled or been cancelled.
+     *
+     * Scope `orders:read` · 1 request / 1 s.
+     */
+    get(id: number, options?: CallOptions): Promise<Order>;
+    /**
+     * Asks Trading 212 to cancel a pending order. Success means the request was accepted; the order may still fill
+     * first. Never retried.
+     *
+     * Scope `orders:execute` · 50 requests / minute.
+     */
+    cancel(id: number, options?: CallOptions): Promise<void>;
+    /**
+     * Trades at the next available price. A negative quantity sells. Never retried.
+     *
+     * Scope `orders:execute` · 50 requests / minute.
+     */
+    market<O extends PlaceOptions = NoDryRun>(request: MarketOrderRequest, options?: O): Promise<Placed<O>>;
+    /**
+     * Trades at `limitPrice` or better. A negative quantity sells. Never retried.
+     *
+     * Scope `orders:execute` · 1 request / 2 s.
+     */
+    limit<O extends PlaceOptions = NoDryRun>(request: LimitOrderRequest, options?: O): Promise<Placed<O>>;
+    /**
+     * Places a market order once the price reaches `stopPrice`: a negative quantity makes a stop-loss. Never retried.
+     *
+     * Scope `orders:execute` · 1 request / 2 s.
+     */
+    stop<O extends PlaceOptions = NoDryRun>(request: StopOrderRequest, options?: O): Promise<Placed<O>>;
+    /**
+     * Places a limit order at `limitPrice` once the price reaches `stopPrice`. Never retried.
+     *
+     * Scope `orders:execute` · 1 request / 2 s.
+     */
+    stopLimit<O extends PlaceOptions = NoDryRun>(request: StopLimitOrderRequest, options?: O): Promise<Placed<O>>;
+    /**
+     * Buys. The quantity is positive; `type` defaults to `market`.
+     *
+     * @example
+     * await t212.orders.buy({ ticker: "AAPL_US_EQ", quantity: 0.5 });
+     * await t212.orders.buy({ type: "limit", ticker: "AAPL_US_EQ", quantity: 1, limitPrice: 180, timeValidity: "DAY" });
+     */
+    buy<O extends PlaceOptions = NoDryRun>(input: OrderInput, options?: O): Promise<Placed<O>>;
+    /**
+     * Sells. The quantity is positive and the sign is set for you, so a slip cannot turn a sale into a purchase.
+     *
+     * @example
+     * await t212.orders.sell({ type: "stop", ticker: "AAPL_US_EQ", quantity: 1, stopPrice: 150, timeValidity: "GOOD_TILL_CANCEL" });
+     */
+    sell<O extends PlaceOptions = NoDryRun>(input: OrderInput, options?: O): Promise<Placed<O>>;
+    /**
+     * Sells everything you can of one holding at market: `quantityAvailableForTrading`, cut to 4 decimal places so it
+     * never exceeds what you own. Shares held in pies or reserved by pending orders are left alone.
+     */
+    sellAll<O extends SellAllOptions = NoDryRun>(ticker: string, options?: O): Promise<Placed<O>>;
+    /**
+     * Waits until an order is filled, cancelled or rejected, and returns it in its final state. It polls the pending
+     * order, and once that is gone looks the order up in the history, so the key needs `history:orders` as well.
+     * `timeoutMs` bounds the whole wait, including any wait for rate-limit budget.
+     */
+    waitFor(order: Order | number, options?: WaitOptions): Promise<Order>;
+}
+
+/**
+ * Pies. Trading 212 has deprecated these endpoints: they still work but will not be updated, and may be removed. The
+ * first call logs a warning. Changes count as trades, so a live client needs `trading: "enabled"`.
+ */
+declare class PiesResource {
+    #private;
+    constructor(context: ResourceContext);
+    /** Every pie, with its progress. Scope `pies:read` · 1 request / 30 s. */
+    list(options?: CallOptions): Promise<AccountBucketResultResponse[]>;
+    /** One pie with its instruments and settings. Scope `pies:read` · 1 request / 5 s. */
+    get(id: number, options?: CallOptions): Promise<AccountBucketInstrumentsDetailedResponse>;
+    /** Creates a pie. Scope `pies:write` · 1 request / 5 s. */
+    create(pie: PieRequest, options?: CallOptions): Promise<AccountBucketInstrumentsDetailedResponse>;
+    /** Changes a pie's settings or instruments. Scope `pies:write` · 1 request / 5 s. */
+    update(id: number, pie: PieRequest, options?: CallOptions): Promise<AccountBucketInstrumentsDetailedResponse>;
+    /** Deletes a pie. Scope `pies:write` · 1 request / 5 s. */
+    delete(id: number, options?: CallOptions): Promise<void>;
+    /** Copies a pie under a new name. Scope `pies:write` · 1 request / 5 s. */
+    duplicate(id: number, copy?: {
+        name?: string;
+        icon?: string;
+    }, options?: CallOptions): Promise<AccountBucketInstrumentsDetailedResponse>;
+}
+
+interface HoldingSnapshot {
+    readonly ticker: string;
+    readonly name: string | undefined;
+    readonly quantity: number;
+    /** Current value in the account's currency. */
+    readonly value: number;
+    /** What it cost, in the account's currency. */
+    readonly cost: number;
+    readonly profitLoss: number;
+    /** Profit or loss as a fraction of cost: 0.1 is 10%. */
+    readonly profitLossRatio: number | undefined;
+    /** Share of the invested total: 0.25 is a quarter. */
+    readonly weight: number;
+}
+interface PortfolioSnapshot {
+    readonly currency: string | undefined;
+    readonly totalValue: number;
+    readonly cash: number;
+    readonly invested: number;
+    readonly unrealisedProfitLoss: number;
+    readonly realisedProfitLoss: number;
+    /** Largest holding first. */
+    readonly holdings: readonly HoldingSnapshot[];
+    readonly takenAt: Date;
+}
+/**
+ * Combines an account summary and its positions: the totals, and each holding's value, profit and
+ * share of the portfolio. Pure, so you can call it on data you already have.
+ */
+declare function buildPortfolioSnapshot(summary: AccountSummary, positions: readonly Position[], takenAt?: Date): PortfolioSnapshot;
+declare class PortfolioResource {
+    #private;
+    constructor(account: AccountResource, positions: PositionsResource);
+    /**
+     * The account's totals and every holding's value, profit and weight, from two requests.
+     *
+     * @example
+     * const { totalValue, holdings } = await t212.portfolio.snapshot();
+     */
+    snapshot(options?: CallOptions): Promise<PortfolioSnapshot>;
+}
+
+interface ReportRequest {
+    /** Start of the period. */
+    from: Date | string;
+    /** End of the period. */
+    to: Date | string;
+    /** What to include. Everything, unless you say otherwise. */
+    include?: {
+        dividends?: boolean;
+        interest?: boolean;
+        orders?: boolean;
+        transactions?: boolean;
+    };
+}
+interface ReportWaitOptions extends CallOptions {
+    /** Give up after this long. Default 10 minutes. */
+    timeoutMs?: number;
+    /** Time between checks. Default 60 s, the endpoint's limit. */
+    intervalMs?: number;
+    /** Called each time the status is checked. */
+    onStatus?: (report: ReportResponse) => void;
+}
+interface ExportResult {
+    readonly report: ReportResponse;
+    readonly csv: string;
+}
+/** CSV exports of your history. Trading 212 offers them on live only. */
+declare class ReportsResource {
+    #private;
+    constructor(context: ResourceContext);
+    /**
+     * Every report you have asked for, with its status and, once finished, its download link.
+     *
+     * 1 request / minute.
+     */
+    list(options?: CallOptions): Promise<ReportResponse[]>;
+    /**
+     * Asks Trading 212 to build a CSV report, and returns its ID.
+     *
+     * 1 request / 30 s.
+     */
+    request(request: ReportRequest, options?: CallOptions): Promise<number>;
+    /** Checks a report until it is finished, and returns it. Throws if it failed or was cancelled. */
+    waitFor(reportId: number, options?: ReportWaitOptions): Promise<ReportResponse>;
+    /**
+     * Downloads a finished report's CSV. The link is signed, so your API credentials are never sent with it.
+     */
+    download(report: ReportResponse | string, options?: CallOptions): Promise<string>;
+    /**
+     * Requests a report, waits for it and downloads it, in one call. Waiting respects the one-request-a-minute limit,
+     * so expect at least a minute.
+     *
+     * @example
+     * const { csv } = await t212.reports.export({ from: "2026-01-01", to: "2026-06-30" });
+     */
+    export(request: ReportRequest, options?: ReportWaitOptions): Promise<ExportResult>;
+}
+
+/** What `verify()` learnt about the key. */
+interface VerifyResult {
+    readonly environment: Environment;
+    /** The account number shown in the Trading 212 app. */
+    readonly accountId: number | undefined;
+    /** The account's primary currency, such as `GBP`. */
+    readonly currency: string | undefined;
+    /** Whether this client may place orders. */
+    readonly trading: "enabled" | "disabled";
+}
+declare const INSPECT: unique symbol;
+/**
+ * A client for one Trading 212 account in one environment.
+ *
+ * @example
+ * const t212 = new Trading212({ environment: "demo", apiKey, apiSecret });
+ * const { totalValue } = await t212.account.summary();
+ */
+declare class Trading212 {
+    #private;
+    readonly environment: Environment;
+    /** Cash and totals. */
+    readonly account: AccountResource;
+    /** Open positions. */
+    readonly positions: PositionsResource;
+    /** Everything you can trade, cached, with search and ticker lookup. */
+    readonly instruments: InstrumentsResource;
+    /** Exchanges, their schedules, and whether a market is open. */
+    readonly exchanges: ExchangesResource;
+    /** Place, inspect, cancel and wait for orders. */
+    readonly orders: OrdersResource;
+    /** Past orders, dividends and transactions, paginated. */
+    readonly history: HistoryResource;
+    /** CSV exports. */
+    readonly reports: ReportsResource;
+    /** The account summary and positions combined. */
+    readonly portfolio: PortfolioResource;
+    /**
+     * Pies.
+     *
+     * @deprecated Trading 212 has deprecated the pies endpoints; they may be removed.
+     */
+    readonly pies: PiesResource;
+    constructor(options: Trading212Options);
+    /**
+     * Builds a client from `T212_ENV`, `T212_API_KEY` and `T212_API_SECRET` (or `T212_DEMO_*` / `T212_LIVE_*`).
+     * `overrides` sets any other option.
+     *
+     * @example
+     * const t212 = Trading212.fromEnv({ logger: consoleLogger() });
+     */
+    static fromEnv(overrides?: Partial<Trading212Options>, env?: EnvSource): Trading212;
+    /** Whether this client may place or cancel orders and change pies. */
+    get trading(): "enabled" | "disabled";
+    /**
+     * Checks the key works, with one request, and says which account it belongs to. A wrong key or environment fails
+     * here with an `AuthenticationError` that explains which.
+     */
+    verify(options?: CallOptions): Promise<VerifyResult>;
+    /** What is known about every endpoint's rate-limit budget, shared by every client using this key. */
+    rateLimits(): Record<EndpointId, EndpointBudget>;
+    toJSON(): Record<string, unknown>;
+    [INSPECT](): string;
+}
+
+export { BASE_URLS as B, ENDPOINTS as E, FINAL_ORDER_STATUSES as F, HistoryResource as M, HttpError as Q, InstrumentNotFoundError as U, InstrumentsResource as W, MemoryCache as a8, MissingScopeError as a9, PositionsResource as aD, RateLimitError as aF, ReportsResource as aO, SPEC_VERSION as aV, ServerError as aY, NetworkError as aa, NotAvailableInDemoError as ab, NotFoundError as ac, OrderOutcomeUnknownError as af, OrderRejectedError as ag, OrdersResource as ak, PagedList as an, PermissionError as ar, PiesResource as aw, PortfolioResource as az, TIME_VALIDITIES as b1, TimeoutError as b5, Trading212 as b7, Trading212Error as b8, TradingDisabledError as ba, UnexpectedResponseError as bc, ValidationError as bd, buildPortfolioSnapshot as bi, consoleLogger as bj, fieldsFirst as bk, isTrading212Error as bl, sessionAt as bm, silentLogger as bn, AccountResource as d, AuthenticationError as f, ConfigurationError as i, ExchangesResource as y };
+export type { LimitRequest as $, AccountBucketDetailedResponse as A, CacheStore as C, Dividend as D, FetchLike as G, FieldsFirstMethod as H, Fill as I, FillWalletImpact as J, HistoricalOrder as K, HistoryDividendItem as L, HistoryTransactionItem as N, HoldingSnapshot as O, Hooks as P, HttpMethod as R, Instrument as S, InstrumentIssue as T, InstrumentSuggestion as V, InvestmentResult as X, Investments as Y, IterateOptions as Z, LimitOrderRequest as _, AccountBucketInstrumentResult as a, StopOrderRequest as a$, ListOptions as a0, LogFields as a1, LogLevel as a2, Logger as a3, MarketOrderRequest as a4, MarketRequest as a5, MarketSession as a6, MarketStatus as a7, PortfolioSnapshot as aA, Position as aB, PositionWalletImpact as aC, PublicReportRequest as aE, RateLimitInfo as aG, RateLimitMode as aH, RateLimitWaitEvent as aI, Report as aJ, ReportDataIncluded as aK, ReportRequest as aL, ReportResponse as aM, ReportWaitOptions as aN, RequestDescription as aP, RequestEvent as aQ, ResolveOptions as aR, ResponseEvent as aS, RetryEvent as aT, RetryOptions as aU, SearchOptions as aW, SellAllOptions as aX, StopLimitOrderRequest as aZ, StopLimitRequest as a_, Order as ad, OrderInput as ae, OrderRejectionReason as ah, OrderTimeValidity as ai, OrderType as aj, Page as al, PageOptions as am, PaginatedResponseHistoricalOrder as ao, PaginatedResponseHistoryDividendItem as ap, PaginatedResponseHistoryTransactionItem as aq, Pie as as, PieDetails as at, PieInput as au, PieRequest as av, PlaceOptions as ax, Placed as ay, AccountBucketInstrumentsDetailedResponse as b, StopRequest as b0, Tax as b2, TimeEvent as b3, TimeValidity as b4, TradableInstrument as b6, Trading212Options as b9, Transaction as bb, ValidationIssue as be, VerifyResult as bf, WaitOptions as bg, WorkingSchedule as bh, AccountBucketResultResponse as c, AccountSummary as e, CallOptions as g, Cash as h, ConsoleLike as j, DividendDetails as k, DryRunResult as l, DuplicateBucketRequest as m, EndpointBudget as n, EndpointDefinition as o, EndpointId as p, EndpointKind as q, EndpointRateLimit as r, EnqueuedReportResponse as s, EnvSource as t, Environment as u, ErrorCode as v, ErrorDetails as w, Exchange as x, ExportResult as z };