@schibsted/account-sdk-browser 6.0.0-alpha.1 → 6.0.0-alpha.3

package/src/types/session.ts

@@ -0,0 +1,147 @@
+/* Copyright 2026 Schibsted Products & Technology AS. Licensed under the terms of the MIT license.
+ * See LICENSE.md in the project root.
+ */
+
+/**
+ * User identifier returned by Session Service responses.
+ *
+ * Session Service historically returned numeric ids, while some integrations and tests use
+ * string ids. SDK convenience methods normalize this where they promise a string.
+ */
+export type SessionUserId = number | string;
+
+// Session Service object payloads.
+
+/**
+ * Successful response returned from {@link Identity#hasSession}.
+ *
+ * `result` means the has-session call itself succeeded. `result: true` means the user is
+ * connected to the merchant; `result: false` means a session may exist, but the user is not
+ * connected to this client.
+ */
+export type SessionSuccessResponse = {
+    /** Response status code. Example: 200. */
+    code: number;
+    /** Response type. Example: 'OK'. */
+    type: string;
+    /** Human-readable response description. Example: 'OK'. */
+    description: string;
+    /**
+     * Is the user connected to the merchant? This means the merchant id is in the list of
+     * merchants connected to this user.
+     */
+    result: boolean;
+    /** Connection status string. Deprecated; use `Identity.isConnected()`. Example: 'connected'. */
+    userStatus?: string;
+    /** Cookie base domain used as the `SP_ID` cookie domain fallback. Example: 'spid.no'. */
+    baseDomain?: string;
+    /** Legacy session id. Obsolete. Example: '58eca10fdbb9f6df72c3368f'. */
+    id?: string;
+    /** A numeric user id which is unique per realm (country). Example: 37162 */
+    userId?: SessionUserId;
+    /** Globally unique user id. Example: 'b3b23aa7-34f2-5d02-a10e-5a3455c6ab2c' */
+    uuid?: string;
+    /** Session token used for the `SP_ID` cookie. Example: 'eyJjbGllbnRfaWQ...'. */
+    sp_id?: string;
+    /** Session response TTL in seconds. Example: 300. */
+    expiresIn?: number;
+    /** Server time as a Unix timestamp in seconds. Example: 1506285759. */
+    serverTime?: number;
+    /**
+     * Example: 'NCdzXaz4ZRb7...' The sig parameter is a concatenation of an HMAC SHA-256
+     * signature string, a dot (.) and a base64url encoded JSON object (session).
+     * {@link http://techdocs.spid.no/sdks/js/response-signature-and-validation/}
+     */
+    sig?: string;
+    /** User display name. Example: 'batman'. */
+    displayName?: string;
+    /** User given name. Example: 'Bruce'. */
+    givenName?: string;
+    /** User family name. Example: 'Wayne'. */
+    familyName?: string;
+    /** User gender value. Example: 'male', 'female', 'undisclosed'. */
+    gender?: string;
+    /** User profile photo URL. Example: 'http://www.srv.com/some/picture.jpg' . */
+    photo?: string;
+    /** Whether tracking is enabled for this session. Example: true. */
+    tracking?: boolean;
+    /** Whether the client agreement is accepted. Example: true. */
+    clientAgreementAccepted?: boolean;
+    /** Whether the default agreement is accepted. Example: true. */
+    defaultAgreementAccepted?: boolean;
+    /** Pairwise user id for this client. Example: 'b2a23caa...'. */
+    pairId?: string;
+    /** User SDRN. Example: 'sdrn:spid.no:user:12345'. */
+    sdrn?: string;
+};
+
+/**
+ * Successful has-session response for a user connected to the merchant.
+ */
+export type ConnectedSessionResponse = SessionSuccessResponse & {
+    result: true;
+};
+
+/**
+ * Connected session response that also carries a usable user id.
+ */
+export type ConnectedSessionWithUserIdResponse = ConnectedSessionResponse & {
+    userId: SessionUserId;
+};
+
+/**
+ * Failure payload returned by Session Service.
+ *
+ * API and network failures usually reject with {@link SDKError}; this shape represents a failure
+ * payload when one is returned by Session Service and reaches the has-session flow.
+ */
+export type SessionFailureResponse = {
+    /** Failure payload returned by Session Service. Usually an object, but tests also pass strings. */
+    error: string | number | boolean | object;
+    response?: {
+        /** Response status code. Example: 404. */
+        code: number;
+        /** Response type. Example: 'NOT_FOUND'. */
+        type: string;
+        /** Human-readable response description. Example: 'No session found'. */
+        description: string;
+        /** Cookie base domain used as the `SP_ID` cookie domain fallback. Example: 'spid.no'. */
+        baseDomain?: string;
+        /** Time span in milliseconds. Example: 30 * 60 * 1000 (for 30 minutes) */
+        expiresIn?: number;
+        result?: boolean;
+        /** Server time in seconds since the Unix Epoch. Example: 1506287788 */
+        serverTime?: number;
+        [key: string]: string | number | boolean | object | null | undefined;
+    };
+};
+
+/**
+ * Object response that does not match one of the SDK-known has-session shapes.
+ *
+ * This intentionally includes `{}`. Historically `hasSession()` could resolve an empty object or
+ * other object payloads that callers inspected themselves, so the SDK preserves those responses.
+ */
+export type UnrecognizedSessionResponse = object;
+
+export type RedirectSessionResponse = string;
+
+export type SessionObjectResponse =
+    | SessionSuccessResponse
+    | SessionFailureResponse
+    | UnrecognizedSessionResponse;
+
+export type RedirectSessionPayload = {
+    redirectURL: string;
+};
+
+export type NormalizedSessionPayload = SessionObjectResponse | RedirectSessionPayload;
+
+/**
+ * Public response union returned from {@link Identity#hasSession}.
+ */
+export type SessionResponse =
+    | SessionSuccessResponse
+    | SessionFailureResponse
+    | UnrecognizedSessionResponse
+    | RedirectSessionResponse;

package/src/{url.js → url.ts}

@@ -2,20 +2,16 @@
  * See LICENSE.md in the project root.
  */
 
-'use strict'
-
-import { assert, isNonEmptyString, isUrl, isNonEmptyObj } from './validate.js';
+import { assert, isNonEmptyObj, isNonEmptyString, isUrl } from './validate.js';
 
 /**
  * A simple utility function that allows looking up URLs from a dictionary
- * @memberof core
- * @param {string} url - A url like http://example.com, or a key used for lookup
- * @param {object<string,string>} urlMap - A map of URLs like
- * `{ DEV: 'http://dev.example.com' }`
- * @throws {SDKError} - If the url is not an string or is an empty string
- * @return {string} The url that points to the server
+ * @param url - A url like http://example.com, or a key used for lookup
+ * @param urlMap - A map of URLs like `{ DEV: 'http://dev.example.com' }`
+ * @returns The resolved URL: the mapped value when `url` is a known key, otherwise `url` itself
+ * @throws {SDKError} - If the url is not a string or is an empty string
  */
-export function urlMapper(url, urlMap) {
+export function urlMapper(url: string, urlMap: Record<string, string>): string {
     assert(isNonEmptyString(url), `"url" param must be a non empty string: ${typeof url}`);
     if (isNonEmptyObj(urlMap) && isUrl(urlMap[url])) {
         return urlMap[url];

package/src/{validate.js → validate.ts}

@@ -2,9 +2,7 @@
  * See LICENSE.md in the project root.
  */
 
-'use strict';
-
-import SDKError from './SDKError.js';
+import SDKError from './sdk-error.js';
 
 /*
  * This module defines a set of validation functions which are used in the rest of the SDK.
@@ -16,13 +14,13 @@ import SDKError from './SDKError.js';
 /**
  * A utility function that throws an SDKError if an assertion fails. It's mostly useful for
  * validating function inputs.
- * @memberof core
- * @param {boolean} condition - The condition that we're asserting
- * @param {string} [message = Assertion failed] - The error message
+ *
+ * Narrows `condition` for the rest of the enclosing scope (TypeScript assertion signature).
+ * @param condition - The condition that we're asserting
+ * @param message - The error message
  * @throws {SDKError} - If the condition is falsy it throws the appropriate error
- * @return {void}
  */
-export function assert(condition, message = 'Assertion failed') {
+export function assert(condition: boolean, message = 'Assertion failed'): asserts condition {
     if (!condition) {
         throw new SDKError(message);
     }
@@ -30,82 +28,68 @@ export function assert(condition, message = 'Assertion failed') {
 
 /**
  * Checks if a value is a string or not
- * @memberof core
- * @param {*} value - The value to check
- * @return {boolean}
+ * @param value - The value to check
  */
-export function isStr(value) {
+export function isStr(value: unknown): value is string {
     return typeof value === 'string';
 }
 
 /**
  * Checks if a value is a non-empty string
- * @memberof core
- * @param {*} value - The value to check
- * @return {boolean}
+ * @param value - The value to check
  */
-export function isNonEmptyString(value) {
+export function isNonEmptyString(value: unknown): value is string {
     return typeof value === 'string' && value.length > 0;
 }
 
 /**
  * checks if a given value is an object (but not null)
- * @memberof core
- * @param {*} value - The value to check
- * @return {boolean}
+ * @param value - The value to check
  */
-export function isObject(value) {
+export function isObject(value: unknown): value is Record<string, unknown> {
     return typeof value === 'object' && value !== null;
 }
 
 /**
  * Checks if a given value is an object with at least one own key
- * @memberof core
- * @param {*} value - The value to check
- * @return {boolean}
+ * @param value - The value to check
  */
-export function isNonEmptyObj(value) {
+export function isNonEmptyObj(value: unknown): value is Record<string, unknown> {
     return isObject(value) && Object.keys(value).length > 0;
 }
 
 /**
  * Checks if a given string is a valid URL
- * @memberof core
- * @param {string} value - The string to be tested
- * @param {...string} mandatoryFields - A list of mandatory fields that should exist in the parsed
- * URL object
- * @return {boolean}
+ * @param value - The string to be tested
+ * @param mandatoryFields - A list of mandatory fields that should exist in the parsed
+ * `URL` object
  */
-export function isUrl(value, ...mandatoryFields) {
+export function isUrl(value: string, ...mandatoryFields: (keyof URL)[]): boolean {
     try {
         const parsedUrl = new URL(value);
-        return mandatoryFields.every(f => parsedUrl[f]);
-    } catch (urlParsingError) {
+        return mandatoryFields.every((f) => parsedUrl[f]);
+    } catch {
         return false;
     }
 }
 
 /**
  * Checks if a given value is a function
- * @memberof core
- * @param {*} value - The value to check
- * @return {boolean}
+ * @param value - The value to check
  */
-export function isFunction(value) {
+export function isFunction(value: unknown): value is (...args: unknown[]) => unknown {
     return typeof value === 'function';
 }
 
 /**
  * Checks if a string matches any of the strings in a set of possibilities
- * @memberof core
- * @param {string} value
- * @param {string[]} possibilities - An array of strings that'll be used to check the string
+ * @param value
+ * @param possibilities - An array of strings that'll be used to check the string
  * inclusion. Note that for performance reasons, we don't validate this parameter.
- * @param {boolean} [caseSensitive=false] - Should the check be case sensitive
- * @return {boolean}
+ * @param caseSensitive - Should the check be case sensitive
  */
-export function isStrIn(value, possibilities, caseSensitive = false) {
-    const _isSameStrCaseInsensitive = str =>
+export function isStrIn(value: string, possibilities: string[], caseSensitive = false): boolean {
+    const _isSameStrCaseInsensitive = (str: string) =>
         isStr(str) && value.toUpperCase() === str.toUpperCase();
     if (!(isStr(value) && Array.isArray(possibilities))) {
         return false;

package/src/{version.js → version.ts}

@@ -1,5 +1,4 @@
 // Version is bumped automatically by release-please. See release-please-config.json.
 
-'use strict'
-const version = '6.0.0-alpha.1'; // x-release-please-version
+const version = '6.0.0-alpha.3'; // x-release-please-version
 export default version;

package/identity.d.ts

@@ -1 +0,0 @@
-export * from "./src/identity.js";

package/identity.js

@@ -1,5 +0,0 @@
-/* Copyright 2026 Schibsted Products & Technology AS. Licensed under the terms of the MIT license.
- * See LICENSE.md in the project root.
- */
-
-export { default, Identity } from './src/identity.js';

package/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./identity.js";
-export * from "./monetization.js";
-export * from "./payment.js";
-export { default as SDKError } from "./src/SDKError.js";

package/index.js

@@ -1,9 +0,0 @@
-/* Copyright 2026 Schibsted Products & Technology AS. Licensed under the terms of the MIT license.
- * See LICENSE.md in the project root.
- */
-
-'use strict';
-
-export * from './identity.js';
-export * from './monetization.js';
-export * from './payment.js';

package/monetization.d.ts

@@ -1 +0,0 @@
-export * from "./src/monetization.js";

package/monetization.js

@@ -1,5 +0,0 @@
-/* Copyright 2026 Schibsted Products & Technology AS. Licensed under the terms of the MIT license.
- * See LICENSE.md in the project root.
- */
-
-export { default, Monetization } from './src/monetization.js';

package/payment.d.ts

@@ -1 +0,0 @@
-export * from "./src/payment.js";

package/payment.js

@@ -1,5 +0,0 @@
-/* Copyright 2026 Schibsted Products & Technology AS. Licensed under the terms of the MIT license.
- * See LICENSE.md in the project root.
- */
-
-export { default, Payment } from './src/payment.js';

package/src/RESTClient.d.ts

@@ -1,89 +0,0 @@
-/**
- * This class can be used for creating a wrapper around a server and all its endpoints.
- * Its functionality is extended by {@link JSONPClient}
- * Creates a client to a REST server. While useful stand-alone, it's also used for some other
- * types of client that change some functionalities.
- * @throws {SDKError} if any of options are invalid
- * @summary the simplest way to communicate to a REST endpoint without any
- *          special authentication
- * @memberof core
- * @private
- */
-export class RESTClient {
-    /**
-     * Construct query string for WHATWG urls
-     * @private
-     * @param {object} query - Object to generate query string from
-     * @param {boolean} useDefaultParams - Use defaultParams or not
-     * @param {object} defaultParams - Default params
-     * @returns {string} Query string
-     */
-    private static search;
-    /**
-     * @param {object} options
-     * @param {string} [options.serverUrl=PRE] - The URL to the server eg.
-     * https://login.schibsted.com or a URL key like 'DEV' in combination with {@link envDic}.
-     * @param {object} [options.envDic] - A dictionary that will be used for looking up
-     * {@link serverUrl} keys. If serverUrl is always a URL, you don't need this.
-     * @param {function} [options.fetch=window.fetch] - The fetch function to use. It can be native
-     * or a polyfill
-     * @param {function} [options.log] - A function that will be called with log messages about
-     * request and response
-     * @param {object} [options.defaultParams={}] - a set of parameters to add to every call custom.
-     *        As long as it supports the standard fetch API we're good.
-     */
-    constructor({ serverUrl, envDic, fetch, log, defaultParams }: {
-        serverUrl?: string;
-        envDic?: any;
-        fetch?: Function;
-        log?: Function;
-        defaultParams?: any;
-    });
-    url: URL;
-    defaultParams: any;
-    log: Function;
-    fetch: Function;
-    /**
-     * Makes the actual call to the server and deals with headers, data objects and the edge cases.
-     * Please note that this method expects the response to be in JSON format. However, it'll not
-     * parse the response if its code is not in the 200 range.
-     * @param {object} options - an obligatory options object
-     * @param {string} options.method - can be 'GET', 'POST', 'DELETE', etc. case sensitive.  To be
-     *        more specific, this can be one of the values that are passed to the `methods`
-     *        property of the constructor's `options` parameter.
-     * @param {string} options.pathname - the path to the endpoint like 'api/2/endpoint-name'
-     * @param {Object} [options.data={}] - data payload (depending on GET/DELETE or POST it may be a query
-     *        string or form body)
-     * @param {array} [options.headers] - fetch options headers
-     * @param {boolean} [options.useDefaultParams] - should we add the defaultParams to the query?
-     * @param {object} [options.fetchOptions] - fetch options
-     * @throws {SDKError} - if the call can't be made for whatever reason.
-     * @return {Promise<object>} - A promise that will resolve to the call's response or reject if there
-     *         is an error before making the call or if the server returns a non-2xx error or
-     *         something that's not parsable as JSON.
-     */
-    go({ method, headers, pathname, data, useDefaultParams, fetchOptions }: {
-        method: string;
-        pathname: string;
-        data?: any;
-        headers?: any[];
-        useDefaultParams?: boolean;
-        fetchOptions?: any;
-    }): Promise<any>;
-    /**
-     * Creates a url that points to an endpoint in the server
-     * @param {string} [pathname=] - WHATWG pathname ie. 'api/2/endpoint-name'
-     * @param {object} [query={}] - WHATWG query. It's the data payload.
-     * @param {boolean} [useDefaultParams=true] - should we add the defaultParams to the query?
-     * @return {string} - the resulting url string ready to pass to fetch
-     */
-    makeUrl(pathname?: string, query?: any, useDefaultParams?: boolean): string;
-    /**
-     * Make a GET request
-     * @param {string} pathname - WHATWG pathname ie. 'api/2/endpoint-name'
-     * @param {object} [data={}] - the data payload.
-     * @return {Promise}
-     */
-    get(pathname: string, data?: any): Promise<any>;
-}
-export default RESTClient;

package/src/RESTClient.js

@@ -1,193 +0,0 @@
-/* Copyright 2024 Schibsted Products & Technology AS. Licensed under the terms of the MIT license.
- * See LICENSE.md in the project root.
- */
-
-'use strict';
-
-import SDKError from './SDKError.js';
-import { cloneDefined } from './object.js';
-import { urlMapper } from './url.js';
-import { assert, isObject, isFunction, isStr, isNonEmptyString } from './validate.js';
-
-/**
- * Converts a series of parameters of various types to a string that's suitable for logging.
- * @private
- * @param {Array.<*>} msg - a number of parameters from any type (including objects)
- * @return {string}
- */
-const logString = (msg) => msg.map(m => isObject(m) ? JSON.stringify(m, null, 2) : m).join(' ');
-
-/**
- * Calls a log function passing a string
- * @private
- * @param {function} fn - the log function
- * @param {...*} msg - a series of message objects
- * @return {*} - The result of calling fn
- */
-const logFn = (fn, ...msg) => (typeof fn === 'function') && fn(logString(msg));
-
-/**
- * Encode a string like URLSearchParams would do
- * @private
- * @param {string} str - The input
- * @returns {string} The encoded string
- */
-function encode(str) {
-    const replace = {
-        '!': '%21',
-        "'": '%27',
-        '(': '%28',
-        ')': '%29',
-        '~': '%7E',
-        '%20': '+',
-        '%00': '\x00'
-    };
-    return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, match => replace[match]);
-}
-
-const globalFetch = () => window.fetch && window.fetch.bind(window);
-
-/**
- * This class can be used for creating a wrapper around a server and all its endpoints.
- * Its functionality is extended by {@link JSONPClient}
- * Creates a client to a REST server. While useful stand-alone, it's also used for some other
- * types of client that change some functionalities.
- * @throws {SDKError} if any of options are invalid
- * @summary the simplest way to communicate to a REST endpoint without any
- *          special authentication
- * @memberof core
- * @private
- */
-export class RESTClient {
-
-    /**
-     * @param {object} options
-     * @param {string} [options.serverUrl=PRE] - The URL to the server eg.
-     * https://login.schibsted.com or a URL key like 'DEV' in combination with {@link envDic}.
-     * @param {object} [options.envDic] - A dictionary that will be used for looking up
-     * {@link serverUrl} keys. If serverUrl is always a URL, you don't need this.
-     * @param {function} [options.fetch=window.fetch] - The fetch function to use. It can be native
-     * or a polyfill
-     * @param {function} [options.log] - A function that will be called with log messages about
-     * request and response
-     * @param {object} [options.defaultParams={}] - a set of parameters to add to every call custom.
-     *        As long as it supports the standard fetch API we're good.
-     */
-    constructor({ serverUrl = 'PRE', envDic, fetch = globalFetch(), log, defaultParams = {}}) {
-        assert(isObject(defaultParams), `defaultParams should be a non-null object`);
-
-        const mappedUrl = urlMapper(serverUrl, envDic);
-        const handledServerUrl = mappedUrl.endsWith('/') ? mappedUrl : `${mappedUrl}/`;
-        this.url = new URL(handledServerUrl);
-
-        this.defaultParams = defaultParams;
-
-        if (log) {
-            assert(isFunction(log), `log must be a function but it is ${log}`);
-            this.log = log;
-        }
-
-        if (fetch) {
-            assert(isFunction(fetch), 'Fetch should be a function');
-            this.fetch = fetch;
-        }
-    }
-
-    /**
-     * Makes the actual call to the server and deals with headers, data objects and the edge cases.
-     * Please note that this method expects the response to be in JSON format. However, it'll not
-     * parse the response if its code is not in the 200 range.
-     * @param {object} options - an obligatory options object
-     * @param {string} options.method - can be 'GET', 'POST', 'DELETE', etc. case sensitive.  To be
-     *        more specific, this can be one of the values that are passed to the `methods`
-     *        property of the constructor's `options` parameter.
-     * @param {string} options.pathname - the path to the endpoint like 'api/2/endpoint-name'
-     * @param {Object} [options.data={}] - data payload (depending on GET/DELETE or POST it may be a query
-     *        string or form body)
-     * @param {array} [options.headers] - fetch options headers
-     * @param {boolean} [options.useDefaultParams] - should we add the defaultParams to the query?
-     * @param {object} [options.fetchOptions] - fetch options
-     * @throws {SDKError} - if the call can't be made for whatever reason.
-     * @return {Promise<object>} - A promise that will resolve to the call's response or reject if there
-     *         is an error before making the call or if the server returns a non-2xx error or
-     *         something that's not parsable as JSON.
-     */
-    async go({
-        method,
-        headers,
-        pathname,
-        data = {},
-        useDefaultParams = true,
-        fetchOptions = { method, credentials: 'include' }
-    }) {
-        assert(isFunction(this.fetch),
-            `Can't make a call. The reference to fetch is missing or not a function.`);
-        assert(isNonEmptyString(method), `Method must be a non empty string but it is "${method}"`);
-        assert(isNonEmptyString(pathname), `Pathname must be string but it is "${pathname}"`);
-        assert(isObject(data), `data must be a non-null object`);
-
-        fetchOptions.headers = isObject(headers) ? cloneDefined(headers) : {};
-        const fullUrl = this.makeUrl(pathname, data, useDefaultParams);
-
-        logFn(this.log, 'Request:', fetchOptions.method.toUpperCase(), fullUrl);
-        logFn(this.log, 'Request Headers:', fetchOptions.headers);
-        logFn(this.log, 'Request Body:', fetchOptions.body);
-        try {
-            const response = await this.fetch(fullUrl, fetchOptions);
-            logFn(this.log, 'Response Code:', response.status, response.statusText);
-            if (!response.ok) {
-                // status code not in range 200-299
-                throw new SDKError(response.statusText, { code: response.status });
-            }
-            const responseObject = await response.json();
-            logFn(this.log, 'Response Parsed:', responseObject);
-            return responseObject;
-        } catch (err) {
-            let msg = isStr(err) ? err : 'Unknown RESTClient error';
-            if (isObject(err) && isStr(err.message)) {
-                msg = err.message;
-            }
-            throw new SDKError(`Failed to '${method}' '${fullUrl}': '${msg}'`, err);
-        }
-    }
-
-    /**
-     * Creates a url that points to an endpoint in the server
-     * @param {string} [pathname=] - WHATWG pathname ie. 'api/2/endpoint-name'
-     * @param {object} [query={}] - WHATWG query. It's the data payload.
-     * @param {boolean} [useDefaultParams=true] - should we add the defaultParams to the query?
-     * @return {string} - the resulting url string ready to pass to fetch
-     */
-    makeUrl(pathname = '', query = {}, useDefaultParams = true) {
-        const handledPathname = pathname.startsWith('/') ? pathname.slice(1) : pathname;
-
-        const url = new URL(handledPathname, this.url);
-        url.search = RESTClient.search(query, useDefaultParams, this.defaultParams);
-        return url.href;
-    }
-
-    /**
-     * Make a GET request
-     * @param {string} pathname - WHATWG pathname ie. 'api/2/endpoint-name'
-     * @param {object} [data={}] - the data payload.
-     * @return {Promise}
-     */
-    get(pathname, data) {
-        return this.go({ method: 'get', pathname, data });
-    }
-
-    /**
-     * Construct query string for WHATWG urls
-     * @private
-     * @param {object} query - Object to generate query string from
-     * @param {boolean} useDefaultParams - Use defaultParams or not
-     * @param {object} defaultParams - Default params
-     * @returns {string} Query string
-     */
-    static search(query, useDefaultParams, defaultParams) {
-        const params = useDefaultParams ? cloneDefined(defaultParams, query) : cloneDefined(query);
-        return Object.keys(params).filter(p => params[p]!=='').map(p => `${encode(p)}=${encode(params[p])}`).join('&');
-    }
-}
-
-export default RESTClient;

package/src/SDKError.d.ts

@@ -1,16 +0,0 @@
-/**
- * Represents a SDK error. This is returned from all rejected promises that are returned from an API
- * call. Constructs an SDK error ready to throw
- * @summary When the SDK throws an error, it's supposed to be an instance of this class
- * @private
- */
-export default class SDKError extends Error {
-    /**
-     * @property {number} code - The HTTP error code
-     * @extends {Error}
-     * @param {string} message - The error message
-     * @param {object} [errorObject] - The error object that was returned from the server. Any
-     * property of errorObject object will be copied into this instance SDKError
-     */
-    constructor(message: string, errorObject?: any);
-}