@tigeropenapi/tigeropen 0.5.5 → 0.5.7

package/dist/esm/auth/oauth2/token-store.js

@@ -0,0 +1,214 @@
+/**
+ * File-backed OAuth 2.0 authorization state.
+ *
+ * Storage layout:
+ *
+ *     ~/.tiger/openapi/
+ *       tokens/{clientId}.json                authorization state, mode 0600, removed on logout
+ *       clients/{issuerHash}-{surface}.json   dynamic registration, retained across logout
+ *
+ * Registration files are keyed by issuer because the client ID is not yet available
+ * during lookup, and by surface so that each entry point registers its own client.
+ * Without the surface, whichever entry point ran first would own the registration and
+ * every other one would silently inherit its identity: one name on the user's
+ * authorization page, one revocation switch for all of them, and one shared token file
+ * whose refresh-token rotation they would race over.
+ *
+ * Token files need no surface: each surface registers a distinct client ID, so their
+ * token files are already distinct. A manually configured client ID is shared on
+ * purpose -- one client ID means one application.
+ *
+ * Storage root precedence is: explicit argument, `TIGEROPEN_HOME`, then
+ * `~/.tiger/openapi`. The format is shared with the Java and Python SDKs.
+ */
+import { createHash } from 'crypto';
+import * as fs from 'fs';
+import { homedir } from 'os';
+import * as path from 'path';
+import { OAuth2ClientRegistration } from './client-registration.js';
+import { OAuth2Category, OAuth2Error } from './errors.js';
+import { OAuth2Token, TOKEN_SCHEMA_VERSION } from './token.js';
+export const ENV_HOME = 'TIGEROPEN_HOME';
+/**
+ * Entry point owning a registration. Tools built on this SDK must pass their own value,
+ * otherwise they would be filed as the TypeScript SDK and share its client. Keep in
+ * step with the Java SDK's `sdk-java` and the Python SDK's `sdk-python`.
+ */
+export const DEFAULT_SURFACE = 'sdk-typescript';
+const SAFE_CHARS = /[^a-zA-Z0-9\-_.]/g;
+/**
+ * Surfaces become part of a file name, so they are restricted rather than sanitised: a
+ * silently rewritten surface would file two entry points under one name.
+ */
+const SURFACE_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+export class OAuth2TokenStore {
+    /**
+     * @param home storage root; defaults to `TIGEROPEN_HOME` then `~/.tiger/openapi`
+     * @param surface entry point owning the registration, e.g. `sdk-typescript`, `cli`.
+     *   Lowercase alphanumerics and hyphens only
+     */
+    constructor(home, surface = DEFAULT_SURFACE) {
+        const base = home || process.env[ENV_HOME] || path.join(homedir(), '.tiger', 'openapi');
+        this.home = path.resolve(expandHome(base));
+        this.surface = validateSurface(surface);
+    }
+    /** Load a token, treating a missing file or issuer mismatch as a cache miss. */
+    loadToken(clientId, expectedIssuer) {
+        const file = this.tokenFile(clientId);
+        if (!fs.existsSync(file))
+            return null;
+        let token;
+        try {
+            token = OAuth2Token.fromJSON(JSON.parse(fs.readFileSync(file, 'utf-8')));
+        }
+        catch (e) {
+            // A corrupt file tells us nothing; treat it as no authorization rather than crash.
+            console.error(`[TigerOpen] read token file fail: ${file}`, e);
+            return null;
+        }
+        if (!token)
+            return null;
+        if (token.schemaVersion !== TOKEN_SCHEMA_VERSION) {
+            // Unknown schema versions are not interpreted.
+            throw new OAuth2Error(OAuth2Category.StorageFailed, `unsupported token schema_version: ${token.schemaVersion}`);
+        }
+        if (expectedIssuer !== undefined && expectedIssuer !== token.issuer) {
+            return null;
+        }
+        return token;
+    }
+    saveToken(token) {
+        if (!token || !token.clientId) {
+            throw new OAuth2Error(OAuth2Category.StorageFailed, 'token or clientId is empty, cannot save');
+        }
+        writeAtomic(this.tokenFile(token.clientId), JSON.stringify(token.toJSON(), null, 2));
+    }
+    /**
+     * Delete authorization state while retaining client registration.
+     *
+     * @returns the path removed, or null when there was nothing to remove. A clientId is
+     *   not its own file name, so a caller reporting what it deleted has to be told rather
+     *   than build the path itself
+     */
+    deleteToken(clientId) {
+        if (!clientId)
+            return null;
+        const file = this.tokenFile(clientId);
+        return deleteFile(file) ? file : null;
+    }
+    loadClientId(issuer) {
+        return this.loadClientRegistration(issuer)?.clientId ?? null;
+    }
+    loadClientRegistration(issuer) {
+        const file = this.clientFile(issuer);
+        if (!fs.existsSync(file))
+            return null;
+        try {
+            return OAuth2ClientRegistration.fromJSON(JSON.parse(fs.readFileSync(file, 'utf-8')));
+        }
+        catch (e) {
+            console.error(`[TigerOpen] read client registration file fail: ${file}`, e);
+            return null;
+        }
+    }
+    saveClientRegistration(registration) {
+        if (!registration || !registration.issuer) {
+            throw new OAuth2Error(OAuth2Category.StorageFailed, 'registration or issuer is empty, cannot save');
+        }
+        writeAtomic(this.clientFile(registration.issuer), JSON.stringify(registration.toJSON(), null, 2));
+    }
+    /** Delete registration state after an `invalid_client` response. */
+    deleteClientRegistration(issuer) {
+        if (!issuer)
+            return;
+        deleteFile(this.clientFile(issuer));
+    }
+    tokenFile(clientId) {
+        return path.join(this.home, 'tokens', `${safeFileName(clientId)}.json`);
+    }
+    clientFile(issuer) {
+        return path.join(this.home, 'clients', `${hashIssuer(issuer)}-${this.surface}.json`);
+    }
+}
+/** Return the Java-compatible 32-character SHA-256 issuer file key. */
+export function hashIssuer(issuer) {
+    return createHash('sha256').update(issuer || '', 'utf-8').digest('hex').slice(0, 32);
+}
+/** Sanitize an untrusted client ID for use as a file name. */
+function safeFileName(raw) {
+    let name = (raw || '').replace(SAFE_CHARS, '_');
+    while (name.includes('..')) {
+        name = name.replace(/\.\./g, '__');
+    }
+    return name || '_';
+}
+/** Reject a surface that cannot be used verbatim as part of a file name. */
+function validateSurface(surface) {
+    if (typeof surface !== 'string' || !SURFACE_PATTERN.test(surface)) {
+        throw new OAuth2Error(OAuth2Category.StorageFailed, `invalid surface '${surface}': expected lowercase alphanumerics and hyphens, e.g. 'cli'`);
+    }
+    return surface;
+}
+function expandHome(value) {
+    if (value === '~')
+        return homedir();
+    if (value.startsWith('~/') || value.startsWith(`~${path.sep}`)) {
+        return path.join(homedir(), value.slice(2));
+    }
+    return value;
+}
+/** @returns true when the file was there and is now gone */
+function deleteFile(file) {
+    try {
+        if (fs.existsSync(file)) {
+            fs.unlinkSync(file);
+            return true;
+        }
+    }
+    catch (e) {
+        console.error(`[TigerOpen] delete file fail: ${file}`, e);
+    }
+    return false;
+}
+/**
+ * Atomically replace a file through a same-directory temporary file.
+ *
+ * Same-filesystem replacement prevents partial JSON writes. Directories and files are
+ * restricted to modes 0700 and 0600 where supported.
+ */
+function writeAtomic(file, content) {
+    const dir = path.dirname(file);
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        restrict(dir, 0o700);
+        // Same directory, so the rename below stays on one filesystem and is atomic.
+        const tmp = path.join(dir, `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+        try {
+            fs.writeFileSync(tmp, content, { encoding: 'utf-8', mode: 0o600 });
+            restrict(tmp, 0o600);
+            fs.renameSync(tmp, file);
+        }
+        catch (e) {
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch {
+                // The temporary file was never created; nothing to clean up.
+            }
+            throw e;
+        }
+        restrict(file, 0o600);
+    }
+    catch (e) {
+        throw new OAuth2Error(OAuth2Category.StorageFailed, `write file fail: ${file}`, e);
+    }
+}
+/** Restrict a credential file or directory where the platform supports it. */
+function restrict(target, mode) {
+    try {
+        fs.chmodSync(target, mode);
+    }
+    catch {
+        // Windows and some network filesystems have no POSIX modes; the write still stands.
+    }
+}

package/dist/esm/auth/oauth2/token.js

@@ -0,0 +1,71 @@
+/**
+ * Persisted OAuth 2.0 authorization state.
+ *
+ * The `issuer` and `clientId` bind credentials to an authorization server and client,
+ * preventing credential reuse across environments. The on-disk field names are
+ * snake_case and shared with the Java and Python SDKs.
+ */
+/** On-disk format version. An unrecognised version is an error, not a guess. */
+export const TOKEN_SCHEMA_VERSION = 1;
+export function currentMillis() {
+    return Date.now();
+}
+/** An access token and its metadata. */
+export class OAuth2Token {
+    constructor(init = {}) {
+        this.schemaVersion = init.schemaVersion ?? TOKEN_SCHEMA_VERSION;
+        this.issuer = init.issuer;
+        this.clientId = init.clientId;
+        this.accessToken = init.accessToken;
+        this.refreshToken = init.refreshToken;
+        this.tokenType = init.tokenType || 'Bearer';
+        this.scope = init.scope;
+        this.expiresAt = init.expiresAt ?? 0;
+    }
+    /** Time until expiry; negative once already expired. */
+    remainingMillis() {
+        return this.expiresAt - currentMillis();
+    }
+    /**
+     * @param aheadMillis how early to refresh. The window exists because time passes
+     *   between sending a request and the server validating it, so using a token right up
+     *   to its expiry produces intermittent 401s
+     */
+    needsRefresh(aheadMillis) {
+        return this.remainingMillis() <= aheadMillis;
+    }
+    hasRefreshToken() {
+        return !!this.refreshToken;
+    }
+    toJSON() {
+        return {
+            schema_version: this.schemaVersion,
+            issuer: this.issuer,
+            client_id: this.clientId,
+            access_token: this.accessToken,
+            refresh_token: this.refreshToken,
+            token_type: this.tokenType,
+            scope: this.scope,
+            expires_at: this.expiresAt,
+        };
+    }
+    static fromJSON(data) {
+        if (!data)
+            return null;
+        return new OAuth2Token({
+            schemaVersion: data.schema_version ?? TOKEN_SCHEMA_VERSION,
+            issuer: data.issuer,
+            clientId: data.client_id,
+            accessToken: data.access_token,
+            refreshToken: data.refresh_token,
+            tokenType: data.token_type || 'Bearer',
+            scope: data.scope,
+            expiresAt: data.expires_at ?? 0,
+        });
+    }
+    /** Prints no token values. */
+    toString() {
+        return `OAuth2Token{clientId=${this.clientId}, issuer=${this.issuer}, scope=${this.scope}, `
+            + `expiresAt=${this.expiresAt}, hasRefreshToken=${this.hasRefreshToken()}}`;
+    }
+}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/push/pb/Request.js

@@ -200,7 +200,7 @@ export const Request_Connect = {
     },
 };
 function createBaseRequest_Subscribe() {
-    return { dataType: 0, symbols: undefined, account: undefined, market: undefined };
+    return { dataType: 0, symbols: undefined, account: undefined, market: undefined, assetQuoteType: undefined };
 }
 export const Request_Subscribe = {
     encode(message, writer = new BinaryWriter()) {
@@ -216,6 +216,9 @@ export const Request_Subscribe = {
         if (message.market !== undefined) {
             writer.uint32(34).string(message.market);
         }
+        if (message.assetQuoteType !== undefined) {
+            writer.uint32(42).string(message.assetQuoteType);
+        }
         return writer;
     },
     decode(input, length) {
@@ -253,6 +256,13 @@ export const Request_Subscribe = {
                     message.market = reader.string();
                     continue;
                 }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.assetQuoteType = reader.string();
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -270,6 +280,7 @@ export const Request_Subscribe = {
         message.symbols = object.symbols ?? undefined;
         message.account = object.account ?? undefined;
         message.market = object.market ?? undefined;
+        message.assetQuoteType = object.assetQuoteType ?? undefined;
         return message;
     },
 };

package/dist/esm/push/proto-message.js

@@ -45,8 +45,11 @@ export function buildHeartBeatMessage() {
 }
 /**
  * 构建 SUBSCRIBE 请求消息
+ *
+ * @param assetQuoteType 资产行情类型枚举名（ETH / RTH / OVERNIGHT），
+ *   仅对 Asset / Position 两种订阅有意义，其余场景传 undefined
  */
-export function buildSubscribeMessage(dataType, symbols, account, market) {
+export function buildSubscribeMessage(dataType, symbols, account, market, assetQuoteType) {
     return Request.fromPartial({
         command: SocketCommon_Command.SUBSCRIBE,
         id: nextRequestId(),
@@ -55,6 +58,7 @@ export function buildSubscribeMessage(dataType, symbols, account, market) {
             symbols,
             account,
             market,
+            assetQuoteType,
         }),
     });
 }

package/dist/esm/push/push-client.js

@@ -59,6 +59,8 @@ export class PushClient {
         this.subscriptions = new Map();
         /** Account-level subscriptions: subject -> account string used at subscribe time */
         this.accountSubs = new Map();
+        /** Account-level subscriptions: subject -> assetQuoteType used at subscribe time (reconnect replay) */
+        this.accountSubQuoteTypes = new Map();
         this.heartbeatTimer = null;
         this.reconnectTimer = null;
         this.stopped = false;
@@ -319,7 +321,7 @@ export class PushClient {
             this.doSubscribe(subject, Array.from(symbols));
         }
         for (const [subject, account] of this.accountSubs) {
-            this.doSubscribe(subject, undefined, account);
+            this.doSubscribe(subject, undefined, account, undefined, this.accountSubQuoteTypes.get(subject));
         }
     }
     /** Dispatch push data to the appropriate callback based on dataType */
@@ -389,10 +391,10 @@ export class PushClient {
         }
     }
     /** Internal subscribe method */
-    doSubscribe(subject, symbols, account, market) {
+    doSubscribe(subject, symbols, account, market, assetQuoteType) {
         const dataType = subjectToDataType(subject);
         const symbolsStr = symbols ? symbols.join(',') : undefined;
-        const req = buildSubscribeMessage(dataType, symbolsStr, account, market);
+        const req = buildSubscribeMessage(dataType, symbolsStr, account, market, assetQuoteType);
         this.sendMessage(req);
     }
     /** Internal unsubscribe method */
@@ -552,27 +554,41 @@ export class PushClient {
         this.removeSubscription(SubjectType.Market, [market]);
     }
     // ===== Account push subscribe/unsubscribe =====
-    /** Subscribe to asset changes */
-    subscribeAsset(account) {
-        const acct = account || this.config.account;
-        this.doSubscribe(SubjectType.Asset, undefined, acct);
-        this.accountSubs.set(SubjectType.Asset, acct);
+    /**
+     * Shared implementation for the account/options overloads of
+     * subscribeAsset / subscribePosition.
+     */
+    subscribeAccount(subject, accountOrOptions) {
+        const opts = typeof accountOrOptions === 'string'
+            ? { account: accountOrOptions }
+            : (accountOrOptions ?? {});
+        const acct = opts.account || this.config.account;
+        this.doSubscribe(subject, undefined, acct, undefined, opts.assetQuoteType);
+        this.accountSubs.set(subject, acct);
+        if (opts.assetQuoteType) {
+            this.accountSubQuoteTypes.set(subject, opts.assetQuoteType);
+        }
+        else {
+            this.accountSubQuoteTypes.delete(subject);
+        }
+    }
+    subscribeAsset(accountOrOptions) {
+        this.subscribeAccount(SubjectType.Asset, accountOrOptions);
     }
     /** Unsubscribe from asset changes */
     unsubscribeAsset() {
         this.doUnsubscribe(SubjectType.Asset);
         this.accountSubs.delete(SubjectType.Asset);
+        this.accountSubQuoteTypes.delete(SubjectType.Asset);
     }
-    /** Subscribe to position changes */
-    subscribePosition(account) {
-        const acct = account || this.config.account;
-        this.doSubscribe(SubjectType.Position, undefined, acct);
-        this.accountSubs.set(SubjectType.Position, acct);
+    subscribePosition(accountOrOptions) {
+        this.subscribeAccount(SubjectType.Position, accountOrOptions);
     }
     /** Unsubscribe from position changes */
     unsubscribePosition() {
         this.doUnsubscribe(SubjectType.Position);
         this.accountSubs.delete(SubjectType.Position);
+        this.accountSubQuoteTypes.delete(SubjectType.Position);
     }
     /** Subscribe to order status */
     subscribeOrder(account) {

package/dist/esm/trade/trade-client.js

@@ -221,11 +221,17 @@ export class TradeClient {
     async getPositions(req) {
         return this.callIntoItems('positions', withAccount(req, this.account));
     }
-    /** Query assets. v0.4.0: supports sub-account list and aggregation options. */
+    /**
+     * Query assets. v0.4.0: supports sub-account list and aggregation options.
+     * `assetQuoteType`(ETH / RTH / OVERNIGHT) 选择资产行情口径。
+     */
     async getAssets(req) {
         return this.callIntoItems('assets', withAccount(req, this.account));
     }
-    /** Query prime assets. v0.4.0: takes AssetsRequest for filters. */
+    /**
+     * Query prime assets. v0.4.0: takes AssetsRequest for filters.
+     * `assetQuoteType`(ETH / RTH / OVERNIGHT) 选择资产行情口径。
+     */
     async getPrimeAssets(req) {
         return this.callInto('prime_assets', withAccount(req, this.account));
     }
@@ -246,7 +252,10 @@ export class TradeClient {
     async getAnalyticsAsset(req) {
         return this.callIntoItems('analytics_asset', withAccount(req, this.account));
     }
-    /** Aggregate assets (prime) by base currency. */
+    /**
+     * Aggregate assets (prime) by base currency.
+     * `assetQuoteType`(ETH / RTH / OVERNIGHT) 选择资产行情口径。
+     */
     async getAggregateAssets(req) {
         return this.callInto('aggregate_assets', withAccount(req, this.account));
     }

package/dist/esm/version.js

@@ -1 +1 @@
-export const SDK_VERSION = '0.4.8';
+export const SDK_VERSION = '0.5.7';

package/dist/types/auth/authentication.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Request authentication interfaces.
+ *
+ * Implementations attach credentials, handle authentication retries, and release
+ * resources. OAuth 2.0 authorization flows live in `OAuth2SessionManager`; this module
+ * is the data plane and knows nothing about login.
+ */
+/** Which kind of authentication. */
+export declare enum AuthenticationType {
+    /** tigerId + RSA private key signature */
+    Signature = "SIGNATURE",
+    /** `Authorization: Bearer <access_token>` */
+    OAuth2 = "OAUTH2"
+}
+/**
+ * Per-request authentication context.
+ *
+ * Business parameters (`method`, `version`, `biz_content`, `timestamp`) are filled in by
+ * the client and must not be modified by an authentication implementation.
+ */
+export declare class RequestAuthContext {
+    /** Request body parameters. Read-only as far as authentication is concerned. */
+    readonly params: Record<string, string>;
+    /**
+     * Whether a request may be retried with a new credential after a 401.
+     *
+     * Order placement, modification, and cancellation are not retryable because a 401
+     * does not prove that the operation was not executed.
+     */
+    readonly retryable: boolean;
+    /** Full `Authorization` header value; undefined means do not send the header. */
+    authorizationHeader?: string;
+    constructor(params: Record<string, string>, retryable?: boolean);
+}
+/**
+ * Credential snapshot used to coordinate authentication retries.
+ *
+ * Comparing the failed credential with current state detects rotation completed
+ * elsewhere and avoids duplicate refresh requests.
+ */
+export declare class AuthenticationAttempt {
+    readonly authType: AuthenticationType;
+    /**
+     * Credential used by the request, including a raw OAuth 2.0 access token.
+     *
+     * This value is restricted to equality comparisons and must not be logged or exposed.
+     */
+    readonly credential: string | undefined;
+    constructor(authType: AuthenticationType, credential: string | undefined);
+    /** Never prints the credential value. */
+    toString(): string;
+}
+/**
+ * Authentication retry decision.
+ *
+ * A retry always supplies a new full `Authorization` header value, including the
+ * `Bearer ` prefix. There is deliberately no "retry with the same credential" option:
+ * that only collects the same 401 twice.
+ */
+export declare class RetryDecision {
+    private static readonly NO_RETRY;
+    readonly shouldRetry: boolean;
+    readonly authorizationHeader: string | undefined;
+    private constructor();
+    static noRetry(): RetryDecision;
+    /** @param authorizationHeader full new header value, including `Bearer ` */
+    static retry(authorizationHeader: string): RetryDecision;
+    /** Never prints the header value. */
+    toString(): string;
+}
+/** Authentication interface. */
+export interface Authentication {
+    /**
+     * Which kind of authentication. For logging and assertions; business logic should not
+     * branch on it.
+     */
+    readonly authType: AuthenticationType;
+    /**
+     * Write the credential into the request and return a snapshot of which credential was
+     * used.
+     *
+     * The OAuth2 implementation may refresh here, so this may reject with an
+     * `OAuth2Error`.
+     *
+     * @returns snapshot, passed back to {@link onUnauthorized}
+     */
+    apply(context: RequestAuthContext): Promise<AuthenticationAttempt>;
+    /**
+     * Return the retry decision for an unauthorized response.
+     *
+     * Refresh applies only to HTTP 401 credential failures, never to HTTP 403, server
+     * errors, or timeouts. Authentication retries occur at most once per request and
+     * require a different credential.
+     */
+    onUnauthorized(attempt: AuthenticationAttempt | undefined, statusCode: number): Promise<RetryDecision>;
+    /** Release resources. Must be called when switching authentication method. */
+    close(): void;
+}

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

@@ -0,0 +1,4 @@
+/** Authentication layer: the request-level data plane plus the OAuth 2.0 control plane. */
+export { AuthenticationAttempt, AuthenticationType, RequestAuthContext, RetryDecision, } from './authentication';
+export type { Authentication } from './authentication';
+export * from './oauth2';

package/dist/types/auth/oauth2/client-registration.d.ts

@@ -0,0 +1,32 @@
+/**
+ * OAuth 2.0 dynamic client registration state (RFC 7591).
+ *
+ * Registration state is stored separately from tokens and retained across logout.
+ * `registeredScopes` records the granted scope set; scope expansion requires a new
+ * registration to avoid `invalid_scope`.
+ */
+/** Raw on-disk shape, shared with the Java and Python SDKs. */
+export interface OAuth2ClientRegistrationJson {
+    issuer?: string;
+    client_id?: string;
+    client_name?: string;
+    registered_scopes?: string;
+    client_id_issued_at?: number;
+}
+export declare class OAuth2ClientRegistration {
+    issuer?: string;
+    clientId?: string;
+    clientName?: string;
+    registeredScopes?: string;
+    clientIdIssuedAt: number;
+    constructor(init?: {
+        issuer?: string;
+        clientId?: string;
+        clientName?: string;
+        registeredScopes?: string;
+        clientIdIssuedAt?: number;
+    });
+    toJSON(): OAuth2ClientRegistrationJson;
+    static fromJSON(data: OAuth2ClientRegistrationJson | null | undefined): OAuth2ClientRegistration | null;
+    toString(): string;
+}

package/dist/types/auth/oauth2/device-authorization.d.ts

@@ -0,0 +1,40 @@
+/** Device authorization response (RFC 8628). */
+/**
+ * Default polling interval per RFC 8628 §3.5. Tiger's authorization server does not
+ * return `interval`, so this default applies in practice.
+ */
+export declare const DEFAULT_DEVICE_INTERVAL_SECONDS = 5;
+/** Raw shape of the device authorization response. */
+export interface OAuth2DeviceAuthorizationJson {
+    device_code?: string;
+    user_code?: string;
+    verification_uri?: string;
+    verification_uri_complete?: string;
+    expires_in?: number;
+    interval?: number;
+}
+export declare class OAuth2DeviceAuthorization {
+    /** Credential used to redeem the token; it must not be displayed or logged. */
+    deviceCode?: string;
+    /** Short code presented to the resource owner. */
+    userCode?: string;
+    /** Verification URI presented to the resource owner. */
+    verificationUri?: string;
+    /** Verification URI with the user code included. */
+    verificationUriComplete?: string;
+    expiresIn: number;
+    /** Polling interval in seconds; 0 means the server sent none */
+    interval: number;
+    constructor(init?: {
+        deviceCode?: string;
+        userCode?: string;
+        verificationUri?: string;
+        verificationUriComplete?: string;
+        expiresIn?: number;
+        interval?: number;
+    });
+    effectiveIntervalSeconds(): number;
+    static fromJSON(data: OAuth2DeviceAuthorizationJson | null | undefined): OAuth2DeviceAuthorization | null;
+    /** Prints no deviceCode. */
+    toString(): string;
+}