@jd-data-limited/easy-fm 4.0.16 → 4.1.0

package/src/connection/database.js

@@ -1,13 +1,17 @@
 /*
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
-import { EventEmitter } from "events";
-import { generateAuthorizationHeaders } from "./generateAuthorizationHeaders.js";
-import { FMError } from "../FMError.js";
-import { Layout } from "../layouts/layout.js";
-import HTTP_REDIRECT from "follow-redirects";
+import { EventEmitter } from 'events';
+import { generateAuthorizationHeaders } from './generateAuthorizationHeaders.js';
+import { FMError } from '../FMError.js';
+import { Layout } from '../layouts/layout.js';
+import HTTP_REDIRECT from 'follow-redirects';
+/**
+ * Represents a database connection.
+ * @template T - The structure of the database.
+ */
 export class Database extends EventEmitter {
-    _token;
+    _token = '';
     host;
     connection_details;
     cookies = {};
@@ -18,11 +22,12 @@ export class Database extends EventEmitter {
         this.host = host;
         this.name = conn.database;
         this.connection_details = conn;
-        this.debug = !!conn.debug;
+        this.debug = conn.debug ?? false;
     }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
     generateExternalSourceLogin(data) {
-        if (data.credentials.method === "filemaker") {
-            let _data = data.credentials;
+        if (data.credentials.method === 'filemaker') {
+            const _data = data.credentials;
             return {
                 database: data.database,
                 username: _data.username,
@@ -30,50 +35,66 @@ export class Database extends EventEmitter {
             };
         }
         else {
-            throw "Not yet supported login method";
+            throw new Error('Not yet supported login method');
         }
     }
+    /**
+     * Logs out the user by deleting the current session token.
+     * Throws an error if the user is not logged in.
+     *
+     * @returns {Promise<void>} A promise that resolves with no value once the logout is successful.
+     * @throws {Error} Throws an error if the user is not logged in.
+     */
     async logout() {
-        if (!this.token)
-            throw new Error("Not logged in");
-        let _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
-            method: "DELETE",
+        if (this.token === '')
+            throw new Error('Not logged in');
+        const _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
+            method: 'DELETE',
             headers: {
-                "content-type": "application/json"
+                'content-type': 'application/json'
             }
         });
-        let data = await _fetch.json();
+        await _fetch.json();
         // console.log(data)
-        this._token = null;
+        this._token = '';
     }
+    /**
+     * Logs in to the database. Not required, as this is often done automatically
+     *
+     * @param {boolean} [forceLogin=false] - Whether to force login even if already logged in.
+     * @throws {Error} - Throws an error if already logged in and forceLogin is false.
+     * @throws {FMError} - Throws an FMError if login fails.
+     * @return {Promise<string>} - Returns a promise that resolves to the access token upon successful login.
+     */
     async login(forceLogin = false) {
+        // console.trace()
         // Reset cookies
         this.cookies = {};
         await this.host.getMetadata();
-        if (this.token && !forceLogin)
-            throw new Error("Already logged in. Run logout() first");
-        if (this.connection_details.credentials.method === "token") {
-            this._token = this.connection_details.credentials.token;
+        if (this.token !== '' && !forceLogin)
+            throw new Error('Already logged in. Run logout() first');
+        if (this.connection_details.credentials.method === 'token') {
+            this._token = (this.connection_details.credentials).token;
             return this.token;
         }
         else {
             console.time();
-            let url = new URL(`${this.endpoint}/sessions`);
+            const url = new URL(`${this.endpoint}/sessions`);
             url.hostname = this.host.hostname;
-            let res = await fetch(url, {
-                method: "POST",
+            const res = await fetch(url, {
+                method: 'POST',
                 headers: generateAuthorizationHeaders(this.connection_details.credentials),
                 body: JSON.stringify({
                     fmDataSource: this.connection_details.externalSources.map(i => {
-                        let _i = i;
+                        const _i = i;
                         return this.generateExternalSourceLogin(_i);
                     })
                 })
             });
             console.time();
-            let _res = (await res.json());
+            const _res = (await res.json());
             if (res.status === 200) {
-                this._token = res.headers.get('x-fm-data-access-token');
+                this._token = res.headers.get('x-fm-data-access-token') ?? '';
                 return this._token;
             }
             else {
@@ -84,54 +105,65 @@ export class Database extends EventEmitter {
     get token() {
         return this._token;
     }
+    /**
+     * Returns the endpoint URL for the database connection.
+     *
+     * @returns {string} The endpoint URL.
+     */
     get endpoint() {
         return `${this.host.hostname}/fmi/data/v2/databases/${this.name}`;
     }
-    async apiRequestRaw(url, options = {}, autoRelogin = true) {
+    async _apiRequestRaw(url, options = {}, autoRelogin = true) {
         if (this.debug)
-            console.log(`EASYFM DEBUG: ${options.method?.toString().toUpperCase() || "GET"} ${url instanceof Request ? url.url : url}`);
-        if (!this.token)
+            console.log(`EASYFM DEBUG: ${JSON.stringify(options)} ${url instanceof Request ? url.url : url}`);
+        if (this.token === '')
             await this.login(true);
         if (!options.headers)
             options.headers = {};
-        options.headers["authorization"] = "Bearer " + this._token;
-        options.rejectUnauthorized = this.host.verify;
-        let _fetch = await fetch(url, options);
+        options.headers.authorization = 'Bearer ' + this._token;
+        // options.rejectUnauthorized = this.host.verify
+        const _fetch = await fetch(url, options);
         if (_fetch.headers.get('set-cookie')) {
-            for (let cookie of _fetch.headers.get('set-cookie') || []) {
-                let cookie_split = cookie.split("=");
-                this.cookies[cookie_split[0]] = cookie_split[1];
+            for (const cookie of _fetch.headers.get('set-cookie') ?? []) {
+                const cookieSplit = cookie.split('=');
+                this.cookies[cookieSplit[0]] = cookieSplit[1];
             }
         }
         if (_fetch.status === 401 && autoRelogin) {
             await this.login(true);
-            return await this.apiRequestRaw(url, options, false);
+            return await this._apiRequestRaw(url, options, false);
         }
         return _fetch;
     }
-    async apiRequestJSON(url, options = {}) {
+    async _apiRequestJSON(url, options = {}) {
         if (!options.headers)
             options.headers = {};
-        options.headers["content-type"] = options.headers["content-type"] ? options.headers["content-type"] : "application/json";
-        let _fetch = await this.apiRequestRaw(url, options);
-        let data = await _fetch.json();
+        options.headers['content-type'] = options.headers['content-type'] ? options.headers['content-type'] : 'application/json';
+        const _fetch = await this._apiRequestRaw(url, options);
+        const data = await _fetch.json();
         // Remove response if it is empty. This makes checking for an empty response easier
         if (data.response && Object.keys(data.response).length === 0)
             delete data.response;
         // console.log(data.messages[0])
-        if (data.messages[0].code !== "0") {
+        if (data.messages[0].code !== '0') {
             throw new FMError(data.messages[0].code, _fetch.status, data);
         }
         data.httpStatus = _fetch.status;
         return data;
     }
+    /**
+     * Retrieves a list of layouts in the current FileMaker database.
+     *
+     * @returns {Promise<Layout[]>} A promise that resolves to an array of Layout objects.
+     * @throws {FMError} If there was an error retrieving the layouts.
+     */
     async listLayouts() {
-        let req = await this.apiRequestJSON(`${this.endpoint}/layouts?page=2`);
+        const req = await this._apiRequestJSON(`${this.endpoint}/layouts?page=2`);
         if (!req.response)
             throw new FMError(req.messages[0].code, req.httpStatus, req.messages[0].message);
         const cycleLayoutNames = (layouts) => {
             let names = [];
-            for (let layout of layouts) {
+            for (const layout of layouts) {
                 if (layout.folderLayoutNames)
                     names = names.concat(cycleLayoutNames(layout.folderLayoutNames));
                 else
@@ -139,47 +171,43 @@ export class Database extends EventEmitter {
             }
             return names;
         };
-        let layoutNames;
         return cycleLayoutNames(req.response.layouts).map(layout => new Layout(this, layout));
     }
-    getLayout(name) {
+    layout(name) {
         return new Layout(this, name);
     }
-    script(name, parameter = "") {
-        return { name, parameter };
-    }
-    _tokenExpired() {
-        this.emit("token_expired");
+    script(name, parameter = '') {
+        return ({ name, parameter });
     }
-    streamURL(url) {
-        return new Promise((resolve, reject) => {
-            if (!url || typeof url !== "string") {
-                throw new Error("URL is empty, or has invalid value");
+    async streamURL(url) {
+        return await new Promise((resolve, reject) => {
+            if (!url || typeof url !== 'string') {
+                throw new Error('URL is empty, or has invalid value');
             }
-            let headers = {};
+            const headers = {};
             if (Object.keys(this.cookies).length !== 0) {
-                headers["Cookie"] = Object.keys(this.cookies)
+                headers.Cookie = Object.keys(this.cookies)
                     .map(key => {
-                    return key + "=" + this.cookies[key];
+                    return key + '=' + this.cookies[key];
                 })
-                    .join("; ");
+                    .join('; ');
             }
-            const check_for_cookies = (res) => {
+            const checkForCookies = (res) => {
                 // Check for the 'set-cookie' header. If it exists, remember it and strip it for better security.
                 if (res.headers['set-cookie']) {
-                    for (let cookie of res.headers['set-cookie']) {
-                        let cookie_split = cookie.split("=");
-                        this.cookies[cookie_split[0]] = cookie_split[1];
+                    for (const cookie of res.headers['set-cookie']) {
+                        const cookieSplit = cookie.split('=');
+                        this.cookies[cookieSplit[0]] = cookieSplit[1];
                     }
                     res.headers['set-cookie'] = undefined;
                 }
             };
             // Automatically switch between the http and https modules, based on which is needed
-            (url.startsWith("https") ? HTTP_REDIRECT.https : HTTP_REDIRECT.http).get(url, {
+            (url.startsWith('https') ? HTTP_REDIRECT.https : HTTP_REDIRECT.http).get(url, {
                 headers,
-                beforeRedirect: (options, res) => check_for_cookies(res)
+                beforeRedirect: (options, res) => { checkForCookies(res); }
             }, (res) => {
-                check_for_cookies(res);
+                checkForCookies(res);
                 resolve(res);
             });
         });

package/src/connection/database.ts

@@ -2,149 +2,169 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
-import {EventEmitter} from "events";
-import {generateAuthorizationHeaders} from "./generateAuthorizationHeaders.js";
-import {FMError} from "../FMError.js";
-import {LayoutInterface} from "../layouts/layoutInterface.js";
-import {Layout} from "../layouts/layout.js";
-import HTTP_REDIRECT from "follow-redirects"
-import {
-    databaseOptionsBase,
-    databaseOptionsWithExternalSources,
-    loginOptionsFileMaker,
-    loginOptionsToken,
-    Script
-} from "../types.js";
-import {HostBase} from "./HostBase.js"
-import {DatabaseBase} from "./databaseBase.js";
-import {ApiLayout, ApiResults} from "../models/apiResults.js";
-import {DatabaseStructure} from "../databaseStructure.js";
-import {IncomingMessage} from "http";
-
-type GetLayoutReturnType<T extends DatabaseStructure, R extends LayoutInterface | string> = R extends string ? T["layouts"][R] : R
-
+import {EventEmitter} from 'events'
+import {generateAuthorizationHeaders} from './generateAuthorizationHeaders.js'
+import {FMError} from '../FMError.js'
+import {type LayoutInterface} from '../layouts/layoutInterface.js'
+import {Layout} from '../layouts/layout.js'
+import HTTP_REDIRECT from 'follow-redirects'
+import {type databaseOptionsBase, type databaseOptionsWithExternalSources, type Script} from '../types.js'
+import {type HostBase} from './HostBase.js'
+import {type DatabaseBase} from './databaseBase.js'
+import {type ApiLayout, type ApiResults} from '../models/apiResults.js'
+import {type DatabaseStructure} from '../databaseStructure.js'
+import {type IncomingMessage} from 'http'
+
+/**
+ * Represents a database connection.
+ * @template T - The structure of the database.
+ */
 export class Database<T extends DatabaseStructure> extends EventEmitter implements DatabaseBase {
-    private _token: any;
-    readonly host: HostBase;
-    private connection_details: databaseOptionsWithExternalSources
-    private cookies: { [key: string]: string } = {}
-    readonly name: string;
+    private _token: string = ''
+    readonly host: HostBase
+    private readonly connection_details: databaseOptionsWithExternalSources
+    private cookies: Record<string, string> = {}
+    readonly name: string
     readonly debug: boolean
 
-    constructor(host: HostBase, conn: databaseOptionsWithExternalSources) {
+    constructor (host: HostBase, conn: databaseOptionsWithExternalSources) {
         super()
         this.host = host
         this.name = conn.database
         this.connection_details = conn
-        this.debug = !!conn.debug
+        this.debug = conn.debug ?? false
     }
 
-    private generateExternalSourceLogin(data: databaseOptionsBase) {
-        if (data.credentials.method === "filemaker") {
-            let _data = <loginOptionsFileMaker>data.credentials
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    private generateExternalSourceLogin (data: databaseOptionsBase) {
+        if (data.credentials.method === 'filemaker') {
+            const _data = data.credentials
             return {
                 database: data.database,
                 username: _data.username,
                 password: _data.password
             }
-        }
-        else {
-            throw "Not yet supported login method"
+        } else {
+            throw new Error('Not yet supported login method')
         }
     }
 
-    async logout(): Promise<void> {
-        if (!this.token) throw new Error("Not logged in")
-
-        let _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
-            method: "DELETE",
+    /**
+     * Logs out the user by deleting the current session token.
+     * Throws an error if the user is not logged in.
+     *
+     * @returns {Promise<void>} A promise that resolves with no value once the logout is successful.
+     * @throws {Error} Throws an error if the user is not logged in.
+     */
+    async logout (): Promise<void> {
+        if (this.token === '') throw new Error('Not logged in')
+
+        const _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
+            method: 'DELETE',
             headers: {
-                "content-type": "application/json"
+                'content-type': 'application/json'
             }
         })
-        let data = await _fetch.json()
+        await _fetch.json()
         // console.log(data)
-        this._token = null
+        this._token = ''
     }
 
-    async login(forceLogin = false) {
+    /**
+     * Logs in to the database. Not required, as this is often done automatically
+     *
+     * @param {boolean} [forceLogin=false] - Whether to force login even if already logged in.
+     * @throws {Error} - Throws an error if already logged in and forceLogin is false.
+     * @throws {FMError} - Throws an FMError if login fails.
+     * @return {Promise<string>} - Returns a promise that resolves to the access token upon successful login.
+     */
+    async login (forceLogin = false) {
+        // console.trace()
         // Reset cookies
         this.cookies = {}
 
         await this.host.getMetadata()
-        if (this.token && !forceLogin) throw new Error("Already logged in. Run logout() first")
+        if (this.token !== '' && !forceLogin) throw new Error('Already logged in. Run logout() first')
 
-        if (this.connection_details.credentials.method === "token") {
-            this._token = (<loginOptionsToken>this.connection_details.credentials).token
+        if (this.connection_details.credentials.method === 'token') {
+            this._token = (this.connection_details.credentials).token
             return this.token
-        }
-        else {
+        } else {
             console.time()
-            let url = new URL(`${this.endpoint}/sessions`)
+            const url = new URL(`${this.endpoint}/sessions`)
             url.hostname = this.host.hostname
-            let res = await fetch(url, {
-                method: "POST",
+            const res = await fetch(url, {
+                method: 'POST',
                 headers: generateAuthorizationHeaders(this.connection_details.credentials) as unknown as HeadersInit,
                 body: JSON.stringify({
                     fmDataSource: this.connection_details.externalSources.map(i => {
-                        let _i = <databaseOptionsBase>i
+                        const _i = i
                         return this.generateExternalSourceLogin(_i)
                     })
                 })
             })
             console.time()
-            let _res = <any>(await res.json())
+            const _res = (await res.json())
             if (res.status === 200) {
-                this._token = res.headers.get('x-fm-data-access-token')
+                this._token = res.headers.get('x-fm-data-access-token') ?? ''
                 return this._token
-            }
-            else {
-                throw new FMError(_res.messages[0].code, _res.status, res)
+            } else {
+                throw new FMError(
+                    _res.messages[0].code as string | number,
+                    _res.status as number,
+                    res
+                )
             }
         }
     }
 
-    get token() {
+    get token () {
         return this._token
     }
 
-    get endpoint(): string {
+    /**
+     * Returns the endpoint URL for the database connection.
+     *
+     * @returns {string} The endpoint URL.
+     */
+    get endpoint (): string {
         return `${this.host.hostname}/fmi/data/v2/databases/${this.name}`
     }
 
-    async apiRequestRaw(url: string | Request, options: any = {}, autoRelogin = true): Promise<Response> {
-        if (this.debug) console.log(`EASYFM DEBUG: ${options.method?.toString().toUpperCase() || "GET"} ${url instanceof Request ? url.url : url}`)
-        if (!this.token) await this.login(true)
+    async _apiRequestRaw (url: string | Request, options: RequestInit & { headers?: Record<string, string> } = {}, autoRelogin = true): Promise<Response> {
+        if (this.debug) console.log(`EASYFM DEBUG: ${JSON.stringify(options)} ${url instanceof Request ? url.url : url}`)
+        if (this.token === '') await this.login(true)
 
         if (!options.headers) options.headers = {}
-        options.headers["authorization"] = "Bearer " + this._token
-        options.rejectUnauthorized = this.host.verify
+        options.headers.authorization = 'Bearer ' + this._token
+        // options.rejectUnauthorized = this.host.verify
 
-        let _fetch = await fetch(url, options)
+        const _fetch = await fetch(url, options)
         if (_fetch.headers.get('set-cookie')) {
-            for (let cookie of _fetch.headers.get('set-cookie') || []) {
-                let cookie_split = cookie.split("=")
-                this.cookies[cookie_split[0]] = cookie_split[1]
+            for (const cookie of _fetch.headers.get('set-cookie') ?? []) {
+                const cookieSplit = cookie.split('=')
+                this.cookies[cookieSplit[0]] = cookieSplit[1]
             }
         }
 
         if (_fetch.status === 401 && autoRelogin) {
             await this.login(true)
-            return await this.apiRequestRaw(url, options, false)
+            return await this._apiRequestRaw(url, options, false)
         }
         return _fetch
     }
-    async apiRequestJSON<T = any>(url: string | Request, options: any = {}): Promise<ApiResults<T>> {
+
+    async _apiRequestJSON<T = any>(url: string | Request, options: RequestInit & { headers?: Record<string, string> } = {}): Promise<ApiResults<T>> {
         if (!options.headers) options.headers = {}
-        options.headers["content-type"] = options.headers["content-type"] ? options.headers["content-type"] : "application/json"
-        let _fetch = await this.apiRequestRaw(url, options)
-        let data = await _fetch.json() as ApiResults<T>
+        options.headers['content-type'] = options.headers['content-type'] ? options.headers['content-type'] : 'application/json'
+        const _fetch = await this._apiRequestRaw(url, options)
+        const data = await _fetch.json() as ApiResults<T>
 
         // Remove response if it is empty. This makes checking for an empty response easier
         if (data.response && Object.keys(data.response).length === 0) delete data.response
 
         // console.log(data.messages[0])
-        if (data.messages[0].code !== "0") {
+        if (data.messages[0].code !== '0') {
             throw new FMError(data.messages[0].code, _fetch.status, data)
         }
 
@@ -152,72 +172,72 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         return data
     }
 
-    async listLayouts() {
-        let req = await this.apiRequestJSON<{layouts: ApiLayout[]}>(`${this.endpoint}/layouts?page=2`)
+    /**
+     * Retrieves a list of layouts in the current FileMaker database.
+     *
+     * @returns {Promise<Layout[]>} A promise that resolves to an array of Layout objects.
+     * @throws {FMError} If there was an error retrieving the layouts.
+     */
+    async listLayouts () {
+        const req = await this._apiRequestJSON<{ layouts: ApiLayout[] }>(`${this.endpoint}/layouts?page=2`)
         if (!req.response) throw new FMError(req.messages[0].code, req.httpStatus, req.messages[0].message)
 
         const cycleLayoutNames = (layouts: ApiLayout[]) => {
-            let names: string[] =  []
-            for (let layout of layouts) {
+            let names: string[] = []
+            for (const layout of layouts) {
                 if (layout.folderLayoutNames) names = names.concat(cycleLayoutNames(layout.folderLayoutNames))
                 else names.push(layout.name)
             }
             return names
         }
-        let layoutNames
-
         return cycleLayoutNames(req.response.layouts).map(layout => new Layout(this, layout))
     }
 
-    getLayout<R extends keyof T["layouts"]>(name: R): Layout<T["layouts"][R]>
-    getLayout<R extends LayoutInterface>(name: string): Layout<R>
-    getLayout(name: string): Layout<any> {
+    layout<R extends keyof T['layouts']>(name: R): Layout<T['layouts'][R]>
+    layout<R extends LayoutInterface>(name: string): Layout<R>
+    layout (name: string): Layout<any> {
         return new Layout<LayoutInterface>(this, name)
     }
 
-    script(name: string, parameter = ""): Script {
-        return ({name, parameter} as Script)
-    }
-
-    _tokenExpired() {
-        this.emit("token_expired")
+    script (name: string, parameter = ''): Script {
+        return ({ name, parameter } satisfies Script)
     }
 
-    streamURL(url: string): Promise<IncomingMessage> {
-        return new Promise((resolve, reject) => {
-            if (!url || typeof url !== "string") {
-                throw new Error("URL is empty, or has invalid value")
+    async streamURL (url: string): Promise<IncomingMessage> {
+        return await new Promise((resolve, reject) => {
+            if (!url || typeof url !== 'string') {
+                throw new Error('URL is empty, or has invalid value')
             }
 
-            let headers: {[key: string]: string} = {}
+            const headers: Record<string, string> = {}
             if (Object.keys(this.cookies).length !== 0) {
-                headers["Cookie"] = Object.keys(this.cookies)
+                headers.Cookie = Object.keys(this.cookies)
                     .map(key => {
-                        return key + "=" + this.cookies[key]
+                        return key + '=' + this.cookies[key]
                     })
-                    .join("; ")
+                    .join('; ')
             }
 
-            const check_for_cookies = (res: HTTP_REDIRECT.ResponseDetails) => {
+            const checkForCookies = (res: HTTP_REDIRECT.ResponseDetails) => {
                 // Check for the 'set-cookie' header. If it exists, remember it and strip it for better security.
                 if (res.headers['set-cookie']) {
-                    for (let cookie of res.headers['set-cookie']) {
-                        let cookie_split = cookie.split("=")
-                        this.cookies[cookie_split[0]] = cookie_split[1]
+                    for (const cookie of res.headers['set-cookie']) {
+                        const cookieSplit = cookie.split('=')
+                        this.cookies[cookieSplit[0]] = cookieSplit[1]
                     }
                     res.headers['set-cookie'] = undefined
                 }
             }
 
             // Automatically switch between the http and https modules, based on which is needed
-            (url.startsWith("https") ? HTTP_REDIRECT.https : HTTP_REDIRECT.http).get(url, {
+            (url.startsWith('https') ? HTTP_REDIRECT.https : HTTP_REDIRECT.http).get(url, {
                 headers,
-                beforeRedirect: (options: any, res: any) => check_for_cookies(res)
+                beforeRedirect: (options: any, res: HTTP_REDIRECT.ResponseDetails) => { checkForCookies(res) }
             }, (res) => {
-                check_for_cookies(res)
+                checkForCookies(res)
 
                 resolve(res)
             })
         })
     }
-}
+}

package/src/connection/databaseBase.d.ts

@@ -1,12 +1,17 @@
 /// <reference types="node" resolution-mode="require"/>
-import { HostBase } from "./HostBase.js";
-import { ApiResults } from "../models/apiResults.js";
-import { IncomingMessage } from "http";
+import { type HostBase } from './HostBase.js';
+import { type ApiResults } from '../models/apiResults.js';
+import { type IncomingMessage } from 'http';
 export interface DatabaseBase {
     host: HostBase;
     readonly name: string;
     endpoint: string;
-    apiRequestJSON<T = unknown>(url: string | Request, options?: RequestInit | undefined, autoRelogin?: boolean): Promise<ApiResults<T>>;
-    apiRequestRaw(url: string | Request, options?: RequestInit | undefined): Promise<Response>;
-    streamURL(url: string): Promise<IncomingMessage>;
+    token: string;
+    _apiRequestJSON: <T = unknown>(url: string | Request, options?: RequestInit & {
+        headers?: Record<string, string>;
+    } | undefined, autoRelogin?: boolean) => Promise<ApiResults<T>>;
+    _apiRequestRaw: (url: string | Request, options?: RequestInit & {
+        headers?: Record<string, string>;
+    } | undefined) => Promise<Response>;
+    streamURL: (url: string) => Promise<IncomingMessage>;
 }