@brokerize/client 1.0.1

package/dist/dependencyDefinitions/xmlHttpRequest.d.ts

@@ -0,0 +1,245 @@
+export type WhatWgXMLHttpRequest = {
+    prototype: XMLHttpRequest;
+    new (): XMLHttpRequest;
+};
+/** Use XMLHttpRequest (XHR) objects to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing. */
+export declare interface XMLHttpRequest extends XMLHttpRequestEventTarget {
+    onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
+    /**
+     * Returns client's state.
+     */
+    readonly readyState: number;
+    /**
+     * Returns the response's body.
+     */
+    readonly response: any;
+    /**
+     * Returns the text response.
+     *
+     * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
+     */
+    readonly responseText: string;
+    /**
+     * Returns the response type.
+     *
+     * Can be set to change the response type. Values are: the empty string (default), "arraybuffer", "blob", "document", "json", and "text".
+     *
+     * When set: setting to "document" is ignored if current global object is not a Window object.
+     *
+     * When set: throws an "InvalidStateError" DOMException if state is loading or done.
+     *
+     * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
+     */
+    responseType: XMLHttpRequestResponseType;
+    readonly responseURL: string;
+    /**
+     * Returns the document response.
+     *
+     * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "document".
+     */
+    readonly status: number;
+    readonly statusText: string;
+    /**
+     * Can be set to a time in milliseconds. When set to a non-zero value will cause fetching to terminate after the given time has passed. When the time has passed, the request has not yet completed, and the synchronous flag is unset, a timeout event will then be dispatched, or a "TimeoutError" DOMException will be thrown otherwise (for the send() method).
+     *
+     * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
+     */
+    timeout: number;
+    /**
+     * True when credentials are to be included in a cross-origin request. False when they are to be excluded in a cross-origin request and when cookies are to be ignored in its response. Initially false.
+     *
+     * When set: throws an "InvalidStateError" DOMException if state is not unsent or opened, or if the send() flag is set.
+     */
+    withCredentials: boolean;
+    /**
+     * Cancels any network activity.
+     */
+    abort(): void;
+    getAllResponseHeaders(): string;
+    getResponseHeader(name: string): string | null;
+    /**
+     * Sets the request method, request URL, and synchronous flag.
+     *
+     * Throws a "SyntaxError" DOMException if either method is not a valid HTTP method or url cannot be parsed.
+     *
+     * Throws a "SecurityError" DOMException if method is a case-insensitive match for `CONNECT`, `TRACE`, or `TRACK`.
+     *
+     * Throws an "InvalidAccessError" DOMException if async is false, current global object is a Window object, and the timeout attribute is not zero or the responseType attribute is not the empty string.
+     */
+    open(method: string, url: string): void;
+    open(method: string, url: string, async: boolean, username?: string | null, password?: string | null): void;
+    /**
+     * Acts as if the `Content-Type` header value for response is mime. (It does not actually change the header though.)
+     *
+     * Throws an "InvalidStateError" DOMException if state is loading or done.
+     */
+    overrideMimeType(mime: string): void;
+    /**
+     * Initiates the request. The body argument provides the request body, if any, and is ignored if the request method is GET or HEAD.
+     *
+     * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
+     */
+    send(body?: BodyInit | null): void;
+    /**
+     * Combines a header in author request headers.
+     *
+     * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
+     *
+     * Throws a "SyntaxError" DOMException if name is not a header name or if value is not a header value.
+     */
+    setRequestHeader(name: string, value: string): void;
+    readonly DONE: number;
+    readonly HEADERS_RECEIVED: number;
+    readonly LOADING: number;
+    readonly OPENED: number;
+    readonly UNSENT: number;
+    addEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+interface XMLHttpRequestEventTargetEventMap {
+    abort: ProgressEvent<XMLHttpRequestEventTarget>;
+    error: ProgressEvent<XMLHttpRequestEventTarget>;
+    load: ProgressEvent<XMLHttpRequestEventTarget>;
+    loadend: ProgressEvent<XMLHttpRequestEventTarget>;
+    loadstart: ProgressEvent<XMLHttpRequestEventTarget>;
+    progress: ProgressEvent<XMLHttpRequestEventTarget>;
+    timeout: ProgressEvent<XMLHttpRequestEventTarget>;
+}
+interface XMLHttpRequestEventTarget extends EventTarget {
+    onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare const XMLHttpRequestEventTarget: {
+    prototype: XMLHttpRequestEventTarget;
+    new (): XMLHttpRequestEventTarget;
+};
+interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
+    readonly lengthComputable: boolean;
+    readonly loaded: number;
+    readonly target: T | null;
+    readonly total: number;
+}
+/** EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. */
+interface EventTarget {
+    /**
+     * Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.
+     *
+     * The options argument sets listener-specific options. For compatibility this can be a boolean, in which case the method behaves exactly as if the value was specified as options's capture.
+     *
+     * When set to true, options's capture prevents callback from being invoked when the event's eventPhase attribute value is BUBBLING_PHASE. When false (or not present), callback will not be invoked when event's eventPhase attribute value is CAPTURING_PHASE. Either way, callback will be invoked if event's eventPhase attribute value is AT_TARGET.
+     *
+     * When set to true, options's passive indicates that the callback will not cancel the event by invoking preventDefault(). This is used to enable performance optimizations described in § 2.8 Observing event listeners.
+     *
+     * When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.
+     *
+     * The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.
+     */
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+    /**
+     * Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.
+     */
+    dispatchEvent(event: Event): boolean;
+    /**
+     * Removes the event listener in target's event listener list with the same type, callback, and options.
+     */
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+}
+/** An event which takes place in the DOM. */
+interface Event {
+    /**
+     * Returns true or false depending on how event was initialized. True if event goes through its target's ancestors in reverse tree order, and false otherwise.
+     */
+    readonly bubbles: boolean;
+    cancelBubble: boolean;
+    /**
+     * Returns true or false depending on how event was initialized. Its return value does not always carry meaning, but true can indicate that part of the operation during which event was dispatched, can be canceled by invoking the preventDefault() method.
+     */
+    readonly cancelable: boolean;
+    /**
+     * Returns true or false depending on how event was initialized. True if event invokes listeners past a ShadowRoot node that is the root of its target, and false otherwise.
+     */
+    readonly composed: boolean;
+    /**
+     * Returns the object whose event listener's callback is currently being invoked.
+     */
+    readonly currentTarget: EventTarget | null;
+    /**
+     * Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise.
+     */
+    readonly defaultPrevented: boolean;
+    /**
+     * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE.
+     */
+    readonly eventPhase: number;
+    /**
+     * Returns true if event was dispatched by the user agent, and false otherwise.
+     */
+    readonly isTrusted: boolean;
+    returnValue: boolean;
+    /** @deprecated */
+    readonly srcElement: EventTarget | null;
+    /**
+     * Returns the object to which event is dispatched (its target).
+     */
+    readonly target: EventTarget | null;
+    /**
+     * Returns the event's timestamp as the number of milliseconds measured relative to the time origin.
+     */
+    readonly timeStamp: number;
+    /**
+     * Returns the type of event, e.g. "click", "hashchange", or "submit".
+     */
+    readonly type: string;
+    /**
+     * Returns the invocation target objects of event's path (objects on which listeners will be invoked), except for any nodes in shadow trees of which the shadow root's mode is "closed" that are not reachable from event's currentTarget.
+     */
+    composedPath(): EventTarget[];
+    initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
+    /**
+     * If invoked when the cancelable attribute value is true, and while executing a listener for the event with passive set to false, signals to the operation that caused event to be dispatched that it needs to be canceled.
+     */
+    preventDefault(): void;
+    /**
+     * Invoking this method prevents event from reaching any registered event listeners after the current one finishes running and, when dispatched in a tree, also prevents event from reaching any other objects.
+     */
+    stopImmediatePropagation(): void;
+    /**
+     * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
+     */
+    stopPropagation(): void;
+    readonly AT_TARGET: number;
+    readonly BUBBLING_PHASE: number;
+    readonly CAPTURING_PHASE: number;
+    readonly NONE: number;
+}
+interface AddEventListenerOptions extends EventListenerOptions {
+    once?: boolean;
+    passive?: boolean;
+}
+interface EventListenerOptions {
+    capture?: boolean;
+}
+declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
+type BodyInit = any;
+interface EventListener {
+    (evt: Event): void;
+}
+interface EventListenerObject {
+    handleEvent(evt: Event): void;
+}
+interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
+    readystatechange: Event;
+}
+type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text";
+export {};

package/dist/dependencyDefinitions/xmlHttpRequest.js

@@ -0,0 +1,2 @@
+// stripped-down version of https://github.com/microsoft/TypeScript/blob/master/lib/lib.dom.d.ts (reduced to the parts we actually use).
+export {};

package/dist/errors.d.ts

@@ -0,0 +1,67 @@
+import { ErrorResponse, ValidationDetail } from "./swagger";
+export declare class TradingError extends Error {
+    code?: string;
+    brokerCode?: string | number;
+    brokerError?: any;
+    httpStatusCode: number;
+    /**
+     * If set, indicates that the `msg` can be attributed to the given broker directly (for example
+     * it is not a networking problem).
+     */
+    msgBrokerName?: string;
+    hint?: Hint;
+    constructor({ msg, code, brokerCode, brokerError, msgBrokerName, httpStatusCode, hint, }: ErrorParams);
+}
+export type ErrorParams = {
+    msg: string;
+    code?: string;
+    brokerCode?: string | number;
+    brokerError?: any;
+    httpStatusCode?: number;
+    msgBrokerName?: string;
+    hint?: Hint;
+};
+export type Hint = {
+    id: string;
+    text: string;
+};
+export declare class BrokerizeError extends Error {
+    /**
+     *
+     * @type {{ [key: string]: FieldErrorsValue; }}
+     * @memberof ErrorResponse
+     */
+    validationDetails?: {
+        [key: string]: ValidationDetail;
+    };
+    /**
+     *
+     * @type {Hint}
+     * @memberof ErrorResponse
+     */
+    hint?: Hint;
+    /**
+     *
+     * @type {string}
+     * @memberof ErrorResponse
+     */
+    msgBrokerName?: string;
+    /**
+     * The human-readable error message. If available, translated to the users's language.
+     * This can always be displayed in frontends (if no specific error code handling is available).
+     * @type {string}
+     * @memberof ErrorResponse
+     */
+    msg: string;
+    /**
+     * The error code.
+     * Currently the following codes are implemented:
+     * 'TRADING_ERROR', 'AUTH', 'RATE_LIMITED', 'VALIDATION_FAILED', 'MUST_ACCEPT_HINT', 'NO_SESSION_AVAILABLE_FOR_PORTFOLIO',
+     *  'SECURITY_NOT_FOUND', 'SECURITY_NOT_TRADABLE_AT_EXCHANGE', 'ORDER_REJECTED', 'INTERNAL_SERVER_ERROR'
+     * @type {string}
+     * @memberof ErrorResponse
+     */
+    code: string;
+    httpStatusCode: number;
+    constructor(statusCode: number, body: ErrorResponse);
+}

package/dist/errors.js

@@ -0,0 +1,25 @@
+export class TradingError extends Error {
+    constructor({ msg, code, brokerCode, brokerError, msgBrokerName, httpStatusCode, hint, }) {
+        super(msg);
+        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain (https://stackoverflow.com/questions/41102060/typescript-extending-error-class)
+        this.name = "TradingError";
+        this.code = code;
+        this.brokerCode = brokerCode;
+        this.httpStatusCode = httpStatusCode || 500;
+        this.brokerError = brokerError;
+        this.msgBrokerName = msgBrokerName;
+        this.hint = hint;
+    }
+}
+export class BrokerizeError extends Error {
+    constructor(statusCode, body) {
+        super(body.msg);
+        this.httpStatusCode = statusCode;
+        this.name = "BrokerizeError";
+        this.msg = body.msg;
+        this.code = body.code;
+        this.validationDetails = body.validationDetails;
+        this.hint = body.hint;
+        this.msgBrokerName = body.msgBrokerName;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import { AuthContextConfiguration, BrokerizeConfig, CognitoConfig, CognitoFacade, CognitoPoolConfig, Auth, RegisteredUserAuthContextConfiguration, TokenSet } from "./apiCtx";
+import { AuthorizedApiContext } from "./authorizedApiContext";
+import { BrokerizeError } from "./errors";
+import * as Models from "./modelExports";
+import { BrokerizeWebSocketClient, Callback, Subscription } from "./websocketClient";
+import * as WebSocketTypes from "./websocketTypes";
+import * as Utils from "./utils";
+export { BrokerizeConfig, AuthContextConfiguration, AuthorizedApiContext, BrokerizeWebSocketClient, Models, WebSocketTypes, Subscription, Callback, Utils, BrokerizeError, Auth, TokenSet, };
+export { CognitoPoolConfig, RegisteredUserAuthContextConfiguration };
+export { CognitoConfig, CognitoFacade };
+export declare class Brokerize {
+    private _cfg;
+    private _defaultApi;
+    constructor(cfg: BrokerizeConfig);
+    createGuestUser(): Promise<AuthContextConfiguration>;
+    /**
+     * Create a context for making authorized API calls. This context will automatically take care of refreshing the access token
+     * tokens if required. The `AuthorizedApiContext` then is used to make API calls on behalf of the active user.
+     *
+     * @param authCtxCfg the auth context data, e.g. a token set for a guest user
+     * @param tokenRefreshCallback when a token refresh occurs, this callback is called and can store the stored tokens
+     * @returns
+     */
+    createAuthorizedContext(authCtxCfg: AuthContextConfiguration, tokenRefreshCallback?: TokenRefreshCallback): AuthorizedApiContext;
+    getCognitoConfig(): CognitoPoolConfig | undefined;
+    /**
+     * Create an "Auth" object which can be used to retrive access tokens.
+     * Can be used by applications to manually make requests to the API without
+     * using the provided `AuthorizedApiContext` methods.
+     *
+     * @param authCtxCfg the auth context configuration
+     * @param tokenRefreshCallback when a token refresh occurs, this callback is called and can store the stored tokens
+     * @returns
+     */
+    createAuth(authCtxCfg: AuthContextConfiguration, tokenRefreshCallback?: TokenRefreshCallback): Auth;
+}
+/**
+ * When a token update occurs (e.g. due to a refreshToken call), this callback is called.
+ * Clients can save the new tokens to their persistent token storage.
+ */
+export type TokenRefreshCallback = (cfg: AuthContextConfiguration) => void;

package/dist/index.js

@@ -0,0 +1,101 @@
+/* Import/Export the DOM parts we rely on. Those are partial copies from the official TypeScript DOM library definitions (https://github.com/microsoft/TypeScript/blob/master/lib/lib.dom.d.ts),
+   but reduced to the parts actually used by bg-trading. */
+import { createAuth, createConfiguration, } from "./apiCtx";
+import { AuthorizedApiContext } from "./authorizedApiContext";
+import { BrokerizeError } from "./errors";
+import * as openApiClient from "./swagger";
+import * as Models from "./modelExports";
+import * as WebSocketTypes from "./websocketTypes";
+import * as Utils from "./utils";
+export { AuthorizedApiContext, Models, WebSocketTypes, Utils, BrokerizeError, };
+export class Brokerize {
+    constructor(cfg) {
+        if (!cfg.fetch) {
+            const global = getGlobalObject();
+            if (!global.fetch) {
+                throw new Error("fetch is not provided and no global fetch function is available");
+            }
+            cfg.fetch = global.fetch.bind(global);
+        }
+        if (!cfg.createAbortController) {
+            const global = getGlobalObject();
+            if (!global.AbortController) {
+                throw new Error("createAbortController not provided and no global AbortController is available");
+            }
+            cfg.createAbortController = () => {
+                return new global.AbortController();
+            };
+        }
+        if (!cfg.createWebSocket) {
+            const global = getGlobalObject();
+            if (!global.WebSocket) {
+                throw new Error("WebSocket implementation not available. Please provide one in BrokerizeConfig.");
+            }
+            cfg.createWebSocket = (url, protocol) => new global.WebSocket(url, protocol);
+        }
+        this._cfg = cfg;
+        this._defaultApi = new openApiClient.DefaultApi(createConfiguration(cfg));
+    }
+    async createGuestUser() {
+        const updatedAt = Date.now();
+        const user = await this._defaultApi.createGuestUser({
+            headers: {
+                "x-brkrz-client-id": this._cfg.clientId,
+                "Content-Type": "application/json",
+            },
+        });
+        return {
+            type: "guest",
+            idToken: user.idToken,
+            tokens: {
+                updatedAt,
+                response: user,
+            },
+        };
+    }
+    /**
+     * Create a context for making authorized API calls. This context will automatically take care of refreshing the access token
+     * tokens if required. The `AuthorizedApiContext` then is used to make API calls on behalf of the active user.
+     *
+     * @param authCtxCfg the auth context data, e.g. a token set for a guest user
+     * @param tokenRefreshCallback when a token refresh occurs, this callback is called and can store the stored tokens
+     * @returns
+     */
+    createAuthorizedContext(authCtxCfg, tokenRefreshCallback) {
+        return new AuthorizedApiContext(this._cfg, this.createAuth(authCtxCfg, tokenRefreshCallback));
+    }
+    getCognitoConfig() {
+        var _a;
+        return (_a = this._cfg.cognito) === null || _a === void 0 ? void 0 : _a.poolConfig;
+    }
+    /**
+     * Create an "Auth" object which can be used to retrive access tokens.
+     * Can be used by applications to manually make requests to the API without
+     * using the provided `AuthorizedApiContext` methods.
+     *
+     * @param authCtxCfg the auth context configuration
+     * @param tokenRefreshCallback when a token refresh occurs, this callback is called and can store the stored tokens
+     * @returns
+     */
+    createAuth(authCtxCfg, tokenRefreshCallback) {
+        var _a;
+        return createAuth({
+            authCfg: authCtxCfg,
+            cfg: this._cfg,
+            tokenRefreshCallback,
+            options: {
+                cognitoFacade: (_a = this._cfg.cognito) === null || _a === void 0 ? void 0 : _a.cognitoFacade,
+            },
+        });
+    }
+}
+function getGlobalObject() {
+    let global;
+    try {
+        global = Function("return this")();
+    }
+    catch (e) {
+        global = window;
+    }
+    return global;
+}

package/dist/modelExports.d.ts

@@ -0,0 +1,154 @@
+export { AddOAuthReturnToUrlRequest } from "./swagger/models/AddOAuthReturnToUrlRequest";
+export { AddOriginRequest } from "./swagger/models/AddOriginRequest";
+export { AddSessionCompleteChallengeParams } from "./swagger/models/AddSessionCompleteChallengeParams";
+export { AddSessionParams } from "./swagger/models/AddSessionParams";
+export { Amount } from "./swagger/models/Amount";
+export { AuthInfo } from "./swagger/models/AuthInfo";
+export { AuthMethod } from "./swagger/models/AuthMethod";
+export { AuthMethodChallengeResponse } from "./swagger/models/AuthMethodChallengeResponse";
+export { AuthMethodDecoupled } from "./swagger/models/AuthMethodDecoupled";
+export { AuthMethodFlow } from "./swagger/models/AuthMethodFlow";
+export { AuthMethodTan } from "./swagger/models/AuthMethodTan";
+export { BrokerEnvFilterType } from "./swagger/models/BrokerEnvFilterType";
+export { BrokerEnvironment } from "./swagger/models/BrokerEnvironment";
+export { BrokerLoginForm } from "./swagger/models/BrokerLoginForm";
+export { BrokerLoginFormField } from "./swagger/models/BrokerLoginFormField";
+export { BrokerMeta } from "./swagger/models/BrokerMeta";
+export { BrokerMetaFeatures } from "./swagger/models/BrokerMetaFeatures";
+export { BrokerMetaImages } from "./swagger/models/BrokerMetaImages";
+export { CancelOrderChallengeParams } from "./swagger/models/CancelOrderChallengeParams";
+export { CancelOrderChallengeResponse } from "./swagger/models/CancelOrderChallengeResponse";
+export { CancelOrderParams } from "./swagger/models/CancelOrderParams";
+export { CancelOrderParamsMode } from "./swagger/models/CancelOrderParamsMode";
+export { CashAccount } from "./swagger/models/CashAccount";
+export { CashAccountQuotes } from "./swagger/models/CashAccountQuotes";
+export { CashQuotation } from "./swagger/models/CashQuotation";
+export { Challenge } from "./swagger/models/Challenge";
+export { ChangeOrderChallengeParams } from "./swagger/models/ChangeOrderChallengeParams";
+export { ChangeOrderParams } from "./swagger/models/ChangeOrderParams";
+export { ClientConfig } from "./swagger/models/ClientConfig";
+export { PageConfig } from "./swagger/models/PageConfig";
+export { PagesConfigurationResponse } from "./swagger/models/PagesConfigurationResponse";
+export { ClientsResponseInner } from "./swagger/models/ClientsResponseInner";
+export { ClientConfigMaintenanceStatus } from "./swagger/models/ClientConfigMaintenanceStatus";
+export { ConfirmOAuthParams } from "./swagger/models/ConfirmOAuthParams";
+export { ConfirmOAuthResponse } from "./swagger/models/ConfirmOAuthResponse";
+export { CostDetailsLink } from "./swagger/models/CostDetailsLink";
+export { CreateClient200Response } from "./swagger/models/CreateClient200Response";
+export { GetAcessTokenAvailablePermissions200Response } from "./swagger/models/GetAcessTokenAvailablePermissions200Response";
+export { AvailablePermissionsNode } from "./swagger/models/AvailablePermissionsNode";
+export { CreateGuestUserResponse } from "./swagger/models/CreateGuestUserResponse";
+export { CreateAccessTokenParams } from "./swagger/models/CreateAccessTokenParams";
+export { GetAccessTokensResponse } from "./swagger/models/GetAccessTokensResponse";
+export { CreateModeSessionTan } from "./swagger/models/CreateModeSessionTan";
+export { CreateOrderChallengeParams } from "./swagger/models/CreateOrderChallengeParams";
+export { CreateOrderParams } from "./swagger/models/CreateOrderParams";
+export { CreateTanChallengeParams } from "./swagger/models/CreateTanChallengeParams";
+export { CreateTradeResponse } from "./swagger/models/CreateTradeResponse";
+export { CreatedResponseBody } from "./swagger/models/CreatedResponseBody";
+export { DecoupledOperationState } from "./swagger/models/DecoupledOperationState";
+export { DecoupledOperationStatus } from "./swagger/models/DecoupledOperationStatus";
+export { DefaultOrderValidityByOrderModel } from "./swagger/models/DefaultOrderValidityByOrderModel";
+export { DemoAccount } from "./swagger/models/DemoAccount";
+export { DemoAccountSettings } from "./swagger/models/DemoAccountSettings";
+export { DemoAccountsResponse } from "./swagger/models/DemoAccountsResponse";
+export { Direction } from "./swagger/models/Direction";
+export { EnableSessionTanParams } from "./swagger/models/EnableSessionTanParams";
+export { EnableSessionTanParamsChallengeResponse } from "./swagger/models/EnableSessionTanParamsChallengeResponse";
+export { EnableSessionTanParamsDecoupled } from "./swagger/models/EnableSessionTanParamsDecoupled";
+export { EnableSessionTanParamsKind } from "./swagger/models/EnableSessionTanParamsKind";
+export { EnableSessionTanParamsTan } from "./swagger/models/EnableSessionTanParamsTan";
+export { EnableSessionTanResponse } from "./swagger/models/EnableSessionTanResponse";
+export { EndSessionTanResponse } from "./swagger/models/EndSessionTanResponse";
+export { ErrorResponse } from "./swagger/models/ErrorResponse";
+export { EstimateChangeOrderCostsParams } from "./swagger/models/EstimateChangeOrderCostsParams";
+export { Exchange } from "./swagger/models/Exchange";
+export { ExchangeMeta } from "./swagger/models/ExchangeMeta";
+export { ExchangesResponse } from "./swagger/models/ExchangesResponse";
+export { GenericTable } from "./swagger/models/GenericTable";
+export { GenericTableRow } from "./swagger/models/GenericTableRow";
+export { GenericTableRowEntry } from "./swagger/models/GenericTableRowEntry";
+export { GenericTableRowSubheading } from "./swagger/models/GenericTableRowSubheading";
+export { GenericTableRowText } from "./swagger/models/GenericTableRowText";
+export { GenericTableRowType } from "./swagger/models/GenericTableRowType";
+export { GenericTableRowValue } from "./swagger/models/GenericTableRowValue";
+export { GenericTableRowValueAmount } from "./swagger/models/GenericTableRowValueAmount";
+export { GenericTableRowValueDatetime } from "./swagger/models/GenericTableRowValueDatetime";
+export { GenericTableRowValueLink } from "./swagger/models/GenericTableRowValueLink";
+export { GenericTableRowValueLinkPortfolio } from "./swagger/models/GenericTableRowValueLinkPortfolio";
+export { GenericTableRowValueLinkUrl } from "./swagger/models/GenericTableRowValueLinkUrl";
+export { GenericTableRowValueLinkValue } from "./swagger/models/GenericTableRowValueLinkValue";
+export { GenericTableRowValueLinkValueType } from "./swagger/models/GenericTableRowValueLinkValueType";
+export { GenericTableRowValueText } from "./swagger/models/GenericTableRowValueText";
+export { GenericTableRowValueType } from "./swagger/models/GenericTableRowValueType";
+export { GetAuthInfoResponse } from "./swagger/models/GetAuthInfoResponse";
+export { GetBrokersResponse } from "./swagger/models/GetBrokersResponse";
+export { GetCostEstimationParams } from "./swagger/models/GetCostEstimationParams";
+export { GetOrderResponse } from "./swagger/models/GetOrderResponse";
+export { GetPortfolioOrdersResponse } from "./swagger/models/GetPortfolioOrdersResponse";
+export { GetPortfolioPositionsResponse } from "./swagger/models/GetPortfolioPositionsResponse";
+export { GetPortfolioQuotesResponse } from "./swagger/models/GetPortfolioQuotesResponse";
+export { GetQuoteParams } from "./swagger/models/GetQuoteParams";
+export { GetQuoteResponse } from "./swagger/models/GetQuoteResponse";
+export { GetUserResponse } from "./swagger/models/GetUserResponse";
+export { Hint } from "./swagger/models/Hint";
+export { LegalTermsResponse } from "./swagger/models/LegalTermsResponse";
+export { LegalTermConfirmItem } from "./swagger/models/LegalTermConfirmItem";
+export { LoginResponse } from "./swagger/models/LoginResponse";
+export { LoginResponseChallenge } from "./swagger/models/LoginResponseChallenge";
+export { LoginResponseReady } from "./swagger/models/LoginResponseReady";
+export { LoginResponseState } from "./swagger/models/LoginResponseState";
+export { MaintenanceStatus } from "./swagger/models/MaintenanceStatus";
+export { OkResponseBody } from "./swagger/models/OkResponseBody";
+export { Order } from "./swagger/models/Order";
+export { OrderChanges } from "./swagger/models/OrderChanges";
+export { OrderCostEstimation } from "./swagger/models/OrderCostEstimation";
+export { OrderCreate } from "./swagger/models/OrderCreate";
+export { OrderExecution } from "./swagger/models/OrderExecution";
+export { OrderExtension } from "./swagger/models/OrderExtension";
+export { OrderModel } from "./swagger/models/OrderModel";
+export { OrderStatus } from "./swagger/models/OrderStatus";
+export { OrderValidity } from "./swagger/models/OrderValidity";
+export { OrderValidityType } from "./swagger/models/OrderValidityType";
+export { OrderValidityTypeByOrderModel } from "./swagger/models/OrderValidityTypeByOrderModel";
+export { Portfolio } from "./swagger/models/Portfolio";
+export { PortfolioQuotes } from "./swagger/models/PortfolioQuotes";
+export { PortfolioSyncInfo } from "./swagger/models/PortfolioSyncInfo";
+export { PortfolioSyncInfoComplete } from "./swagger/models/PortfolioSyncInfoComplete";
+export { PortfolioSyncInfoError } from "./swagger/models/PortfolioSyncInfoError";
+export { PortfolioSyncInfoIncomplete } from "./swagger/models/PortfolioSyncInfoIncomplete";
+export { PortfolioSyncInfoPending } from "./swagger/models/PortfolioSyncInfoPending";
+export { PortfolioSyncInfoStatus } from "./swagger/models/PortfolioSyncInfoStatus";
+export { PortfoliosResponse } from "./swagger/models/PortfoliosResponse";
+export { Position } from "./swagger/models/Position";
+export { PositionValuation } from "./swagger/models/PositionValuation";
+export { PrepareOAuthRedirectParams } from "./swagger/models/PrepareOAuthRedirectParams";
+export { PrepareOAuthRedirectResponse } from "./swagger/models/PrepareOAuthRedirectResponse";
+export { PrepareTradeResponse } from "./swagger/models/PrepareTradeResponse";
+export { PreparedTrade } from "./swagger/models/PreparedTrade";
+export { TakeProfitStopLossCapabilites } from "./swagger/models/TakeProfitStopLossCapabilites";
+export { TakeProfitStopLossDetail } from "./swagger/models/TakeProfitStopLossDetail";
+export { QuoteExpiration } from "./swagger/models/QuoteExpiration";
+export { RenderGenericTableParams } from "./swagger/models/RenderGenericTableParams";
+export { RiskClassInfo } from "./swagger/models/RiskClassInfo";
+export { Security } from "./swagger/models/Security";
+export { SecuritySelector } from "./swagger/models/SecuritySelector";
+export { SecurityDetailedInfo } from "./swagger/models/SecurityDetailedInfo";
+export { SellPosition } from "./swagger/models/SellPosition";
+export { Session } from "./swagger/models/Session";
+export { SessionResponse } from "./swagger/models/SessionResponse";
+export { SessionSyncInfo } from "./swagger/models/SessionSyncInfo";
+export { SessionSyncInfoError } from "./swagger/models/SessionSyncInfoError";
+export { SessionSyncInfoPending } from "./swagger/models/SessionSyncInfoPending";
+export { SessionSyncInfoStatus } from "./swagger/models/SessionSyncInfoStatus";
+export { SessionSyncInfoSynced } from "./swagger/models/SessionSyncInfoSynced";
+export { SetClientConfigRequest } from "./swagger/models/SetClientConfigRequest";
+export { StringMapByOrderModel } from "./swagger/models/StringMapByOrderModel";
+export { SyncError } from "./swagger/models/SyncError";
+export { TrailingDistance, TrailingDistanceModeEnum, } from "./swagger/models/TrailingDistance";
+export { ValidationDetail } from "./swagger/models/ValidationDetail";
+export { SecurityQuotesResponse } from "./swagger/models/SecurityQuotesResponse";
+export { SecurityQuotes } from "./swagger/models/SecurityQuotes";
+export { SecurityQuote } from "./swagger/models/SecurityQuote";
+export { OrderIntent } from "./swagger/models/OrderIntent";
+export { OrderIntentAvailability } from "./swagger/models/OrderIntentAvailability";