@brokerize/client 1.1.1 → 1.1.3

package/dist/modelExports.d.ts

@@ -152,3 +152,9 @@ export { SecurityQuotes } from "./swagger/models/SecurityQuotes";
 export { SecurityQuote } from "./swagger/models/SecurityQuote";
 export { OrderIntent } from "./swagger/models/OrderIntent";
 export { OrderIntentAvailability } from "./swagger/models/OrderIntentAvailability";
+export { SummarizedTrade } from "./swagger/models/SummarizedTrade";
+export { TradeWarning } from "./swagger/models/TradeWarning";
+export { GetPortfolioTradesResponse } from "./swagger/models/GetPortfolioTradesResponse";
+export { GetPortfolioTradeStatisticsResponse } from "./swagger/models/GetPortfolioTradeStatisticsResponse";
+export { TradeStatisticsItem } from "./swagger/models/TradeStatisticsItem";
+export { TradeStatistics } from "./swagger/models/TradeStatistics";

package/dist/swagger/apis/DefaultApi.d.ts

@@ -9,7 +9,7 @@
  * Do not edit the class manually.
  */
 import * as runtime from "../runtime";
-import { Challenge, CreateGuestUserResponse, CreateTanChallengeParams, DecoupledOperationStatus, EnableSessionTanParams, EnableSessionTanResponse, EndSessionTanResponse, GetAuthInfoResponse, GetOrderResponse, GetPortfolioOrdersResponse, GetPortfolioPositionsResponse, GetPortfolioQuotesResponse, GetUserResponse, ObtainToken200Response, OkResponseBody, PortfoliosResponse, RenamePortfolioRequest, SessionResponse } from "../models";
+import { Challenge, CreateGuestUserResponse, CreateTanChallengeParams, DecoupledOperationStatus, EnableSessionTanParams, EnableSessionTanResponse, EndSessionTanResponse, GetAuthInfoResponse, GetOrderResponse, GetPortfolioOrdersResponse, GetPortfolioPositionsResponse, GetPortfolioQuotesResponse, GetPortfolioTradeStatisticsResponse, GetPortfolioTradesResponse, GetUserResponse, OkResponseBody, PortfoliosResponse, RenamePortfolioRequest, SessionResponse, TokenResponse, TradeWarning } from "../models";
 export interface CancelDecoupledOperationRequest {
     sessionId: string;
     decoupledOperationId: string;
@@ -57,6 +57,18 @@ export interface GetPortfolioPositionsRequest {
 export interface GetPortfolioQuotesRequest {
     portfolioId: string;
 }
+export interface GetPortfolioTradeStatisticsRequest {
+    portfolioId: string;
+    dateRanges: string;
+}
+export interface GetPortfolioTradeWarningsRequest {
+    portfolioId: string;
+}
+export interface GetPortfolioTradesRequest {
+    portfolioId: string;
+    take?: number;
+    skip?: number;
+}
 export interface LogoutSessionRequest {
     sessionId: string;
 }
@@ -163,6 +175,28 @@ export declare class DefaultApi extends runtime.BaseAPI {
     /**
      */
     getPortfolioQuotes(requestParameters: GetPortfolioQuotesRequest, initOverrides?: RequestInit | runtime.InitOverideFunction): Promise<GetPortfolioQuotesResponse>;
+    /**
+     * Load statistics based on the trade list for selected date ranges. The statistics (such as `longestWinningStreak` or `tradeCount`) are computed for each of the requested date ranges.
+     */
+    getPortfolioTradeStatisticsRaw(requestParameters: GetPortfolioTradeStatisticsRequest, initOverrides?: RequestInit | runtime.InitOverideFunction): Promise<runtime.ApiResponse<GetPortfolioTradeStatisticsResponse>>;
+    /**
+     * Load statistics based on the trade list for selected date ranges. The statistics (such as `longestWinningStreak` or `tradeCount`) are computed for each of the requested date ranges.
+     */
+    getPortfolioTradeStatistics(requestParameters: GetPortfolioTradeStatisticsRequest, initOverrides?: RequestInit | runtime.InitOverideFunction): Promise<GetPortfolioTradeStatisticsResponse>;
+    /**
+     */
+    getPortfolioTradeWarningsRaw(requestParameters: GetPortfolioTradeWarningsRequest, initOverrides?: RequestInit | runtime.InitOverideFunction): Promise<runtime.ApiResponse<Array<TradeWarning>>>;
+    /**
+     */
+    getPortfolioTradeWarnings(requestParameters: GetPortfolioTradeWarningsRequest, initOverrides?: RequestInit | runtime.InitOverideFunction): Promise<Array<TradeWarning>>;
+    /**
+     * Load a list of completed trades in a portfolio. A completed trade corresponds to *one* closing of a position. Technically each closing of a position corresponds to one execution of an order with `intent=close` (usually those are sell orders, but in the case of short selling, opening a position is a sell order with intent=open).  The analysis follows the FIFO (First In, First Out) principle to accurately summarize trades. Each time a position is closed (note that partial executions are possible. In this case, each individual execution is regarded as a transaction), the system identifies the earliest corresponding \"open position execution\" that contributed to that closing. The result includes a single entry for each closing transaction, detailing key metrics such as profit/loss and holding period, based on the matched opening transactions.  This could be a real world example: - 2020-01-01: buy 5 stock1 for 100 USD each - 2021-06-01: buy 3 stock1 for 200 USD each - 2021-06-06: sell 6 stock1 for 300 USD each  In this case, the result would be one completed trade (corresponding to the last sell) with a profit of `(300*6)-(100*5+1*200)=1800-700=1100 USD`. There is an open position remaining (2 units of stock1, which correspond to the second buy transaction).  When we add this sell: - 2021-06-07: sell 2 stock1 for 400 USD each  It would add a second complete trade with a profit of `(400*2)-(200*2)=800-400=400 USD`.  For some brokers, the order history may be incomplete (e.g. only reveals the latest 90 days), so that we do not know if there could be older transactions. Thus, our implementation might detect (given the current set of open positions together with the list of order executions) that we cannot figure out the corresponding opening transactions for a closing transaction. Affected trades will be ignored for this analysis and might appear as warning items in the `/warnings` endpoint. Frontends should show those warnings so that users can understand why the analysis is incomplete.
+     */
+    getPortfolioTradesRaw(requestParameters: GetPortfolioTradesRequest, initOverrides?: RequestInit | runtime.InitOverideFunction): Promise<runtime.ApiResponse<GetPortfolioTradesResponse>>;
+    /**
+     * Load a list of completed trades in a portfolio. A completed trade corresponds to *one* closing of a position. Technically each closing of a position corresponds to one execution of an order with `intent=close` (usually those are sell orders, but in the case of short selling, opening a position is a sell order with intent=open).  The analysis follows the FIFO (First In, First Out) principle to accurately summarize trades. Each time a position is closed (note that partial executions are possible. In this case, each individual execution is regarded as a transaction), the system identifies the earliest corresponding \"open position execution\" that contributed to that closing. The result includes a single entry for each closing transaction, detailing key metrics such as profit/loss and holding period, based on the matched opening transactions.  This could be a real world example: - 2020-01-01: buy 5 stock1 for 100 USD each - 2021-06-01: buy 3 stock1 for 200 USD each - 2021-06-06: sell 6 stock1 for 300 USD each  In this case, the result would be one completed trade (corresponding to the last sell) with a profit of `(300*6)-(100*5+1*200)=1800-700=1100 USD`. There is an open position remaining (2 units of stock1, which correspond to the second buy transaction).  When we add this sell: - 2021-06-07: sell 2 stock1 for 400 USD each  It would add a second complete trade with a profit of `(400*2)-(200*2)=800-400=400 USD`.  For some brokers, the order history may be incomplete (e.g. only reveals the latest 90 days), so that we do not know if there could be older transactions. Thus, our implementation might detect (given the current set of open positions together with the list of order executions) that we cannot figure out the corresponding opening transactions for a closing transaction. Affected trades will be ignored for this analysis and might appear as warning items in the `/warnings` endpoint. Frontends should show those warnings so that users can understand why the analysis is incomplete.
+     */
+    getPortfolioTrades(requestParameters: GetPortfolioTradesRequest, initOverrides?: RequestInit | runtime.InitOverideFunction): Promise<GetPortfolioTradesResponse>;
     /**
      */
     getPortfoliosRaw(initOverrides?: RequestInit | runtime.InitOverideFunction): Promise<runtime.ApiResponse<PortfoliosResponse>>;
@@ -196,11 +230,11 @@ export declare class DefaultApi extends runtime.BaseAPI {
     /**
      * Obtain a new access token using a refresh token as specified in https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.4. If `CreateGuestUser` has provided a `refresh_token`, this endpoint may be used to obtain a new `access_token` after the original token has expired.
      */
-    obtainTokenRaw(requestParameters: ObtainTokenRequest, initOverrides?: RequestInit | runtime.InitOverideFunction): Promise<runtime.ApiResponse<ObtainToken200Response>>;
+    obtainTokenRaw(requestParameters: ObtainTokenRequest, initOverrides?: RequestInit | runtime.InitOverideFunction): Promise<runtime.ApiResponse<TokenResponse>>;
     /**
      * Obtain a new access token using a refresh token as specified in https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.4. If `CreateGuestUser` has provided a `refresh_token`, this endpoint may be used to obtain a new `access_token` after the original token has expired.
      */
-    obtainToken(requestParameters: ObtainTokenRequest, initOverrides?: RequestInit | runtime.InitOverideFunction): Promise<ObtainToken200Response>;
+    obtainToken(requestParameters: ObtainTokenRequest, initOverrides?: RequestInit | runtime.InitOverideFunction): Promise<TokenResponse>;
     /**
      * This endpoint can be used to rename the display name of a specified portfolio. To restore the original portfolio name, send a rename request with an empty string as the new name. **Note**: This does not change the original portfolio name at your broker.
      */

package/dist/swagger/apis/DefaultApi.js

@@ -11,7 +11,7 @@
  * Do not edit the class manually.
  */
 import * as runtime from "../runtime";
-import { ChallengeFromJSON, CreateGuestUserResponseFromJSON, CreateTanChallengeParamsToJSON, DecoupledOperationStatusFromJSON, EnableSessionTanParamsToJSON, EnableSessionTanResponseFromJSON, EndSessionTanResponseFromJSON, GetAuthInfoResponseFromJSON, GetOrderResponseFromJSON, GetPortfolioOrdersResponseFromJSON, GetPortfolioPositionsResponseFromJSON, GetPortfolioQuotesResponseFromJSON, GetUserResponseFromJSON, ObtainToken200ResponseFromJSON, OkResponseBodyFromJSON, PortfoliosResponseFromJSON, RenamePortfolioRequestToJSON, SessionResponseFromJSON, } from "../models";
+import { ChallengeFromJSON, CreateGuestUserResponseFromJSON, CreateTanChallengeParamsToJSON, DecoupledOperationStatusFromJSON, EnableSessionTanParamsToJSON, EnableSessionTanResponseFromJSON, EndSessionTanResponseFromJSON, GetAuthInfoResponseFromJSON, GetOrderResponseFromJSON, GetPortfolioOrdersResponseFromJSON, GetPortfolioPositionsResponseFromJSON, GetPortfolioQuotesResponseFromJSON, GetPortfolioTradeStatisticsResponseFromJSON, GetPortfolioTradesResponseFromJSON, GetUserResponseFromJSON, OkResponseBodyFromJSON, PortfoliosResponseFromJSON, RenamePortfolioRequestToJSON, SessionResponseFromJSON, TokenResponseFromJSON, TradeWarningFromJSON, } from "../models";
 /**
  *
  */
@@ -504,6 +504,125 @@ export class DefaultApi extends runtime.BaseAPI {
         const response = await this.getPortfolioQuotesRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Load statistics based on the trade list for selected date ranges. The statistics (such as `longestWinningStreak` or `tradeCount`) are computed for each of the requested date ranges.
+     */
+    async getPortfolioTradeStatisticsRaw(requestParameters, initOverrides) {
+        if (requestParameters.portfolioId === null ||
+            requestParameters.portfolioId === undefined) {
+            throw new runtime.RequiredError("portfolioId", "Required parameter requestParameters.portfolioId was null or undefined when calling getPortfolioTradeStatistics.");
+        }
+        if (requestParameters.dateRanges === null ||
+            requestParameters.dateRanges === undefined) {
+            throw new runtime.RequiredError("dateRanges", "Required parameter requestParameters.dateRanges was null or undefined when calling getPortfolioTradeStatistics.");
+        }
+        const queryParameters = {};
+        if (requestParameters.dateRanges !== undefined) {
+            queryParameters["dateRanges"] = requestParameters.dateRanges;
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-brkrz-client-id"] =
+                this.configuration.apiKey("x-brkrz-client-id"); // clientId authentication
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("idToken", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/portfolios/{portfolioId}/trades/statistics`.replace(`{${"portfolioId"}}`, encodeURIComponent(String(requestParameters.portfolioId))),
+            method: "GET",
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetPortfolioTradeStatisticsResponseFromJSON(jsonValue));
+    }
+    /**
+     * Load statistics based on the trade list for selected date ranges. The statistics (such as `longestWinningStreak` or `tradeCount`) are computed for each of the requested date ranges.
+     */
+    async getPortfolioTradeStatistics(requestParameters, initOverrides) {
+        const response = await this.getPortfolioTradeStatisticsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getPortfolioTradeWarningsRaw(requestParameters, initOverrides) {
+        if (requestParameters.portfolioId === null ||
+            requestParameters.portfolioId === undefined) {
+            throw new runtime.RequiredError("portfolioId", "Required parameter requestParameters.portfolioId was null or undefined when calling getPortfolioTradeWarnings.");
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-brkrz-client-id"] =
+                this.configuration.apiKey("x-brkrz-client-id"); // clientId authentication
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("idToken", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/portfolios/{portfolioId}/trades/warnings`.replace(`{${"portfolioId"}}`, encodeURIComponent(String(requestParameters.portfolioId))),
+            method: "GET",
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TradeWarningFromJSON));
+    }
+    /**
+     */
+    async getPortfolioTradeWarnings(requestParameters, initOverrides) {
+        const response = await this.getPortfolioTradeWarningsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Load a list of completed trades in a portfolio. A completed trade corresponds to *one* closing of a position. Technically each closing of a position corresponds to one execution of an order with `intent=close` (usually those are sell orders, but in the case of short selling, opening a position is a sell order with intent=open).  The analysis follows the FIFO (First In, First Out) principle to accurately summarize trades. Each time a position is closed (note that partial executions are possible. In this case, each individual execution is regarded as a transaction), the system identifies the earliest corresponding \"open position execution\" that contributed to that closing. The result includes a single entry for each closing transaction, detailing key metrics such as profit/loss and holding period, based on the matched opening transactions.  This could be a real world example: - 2020-01-01: buy 5 stock1 for 100 USD each - 2021-06-01: buy 3 stock1 for 200 USD each - 2021-06-06: sell 6 stock1 for 300 USD each  In this case, the result would be one completed trade (corresponding to the last sell) with a profit of `(300*6)-(100*5+1*200)=1800-700=1100 USD`. There is an open position remaining (2 units of stock1, which correspond to the second buy transaction).  When we add this sell: - 2021-06-07: sell 2 stock1 for 400 USD each  It would add a second complete trade with a profit of `(400*2)-(200*2)=800-400=400 USD`.  For some brokers, the order history may be incomplete (e.g. only reveals the latest 90 days), so that we do not know if there could be older transactions. Thus, our implementation might detect (given the current set of open positions together with the list of order executions) that we cannot figure out the corresponding opening transactions for a closing transaction. Affected trades will be ignored for this analysis and might appear as warning items in the `/warnings` endpoint. Frontends should show those warnings so that users can understand why the analysis is incomplete.
+     */
+    async getPortfolioTradesRaw(requestParameters, initOverrides) {
+        if (requestParameters.portfolioId === null ||
+            requestParameters.portfolioId === undefined) {
+            throw new runtime.RequiredError("portfolioId", "Required parameter requestParameters.portfolioId was null or undefined when calling getPortfolioTrades.");
+        }
+        const queryParameters = {};
+        if (requestParameters.take !== undefined) {
+            queryParameters["take"] = requestParameters.take;
+        }
+        if (requestParameters.skip !== undefined) {
+            queryParameters["skip"] = requestParameters.skip;
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-brkrz-client-id"] =
+                this.configuration.apiKey("x-brkrz-client-id"); // clientId authentication
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("idToken", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/portfolios/{portfolioId}/trades`.replace(`{${"portfolioId"}}`, encodeURIComponent(String(requestParameters.portfolioId))),
+            method: "GET",
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetPortfolioTradesResponseFromJSON(jsonValue));
+    }
+    /**
+     * Load a list of completed trades in a portfolio. A completed trade corresponds to *one* closing of a position. Technically each closing of a position corresponds to one execution of an order with `intent=close` (usually those are sell orders, but in the case of short selling, opening a position is a sell order with intent=open).  The analysis follows the FIFO (First In, First Out) principle to accurately summarize trades. Each time a position is closed (note that partial executions are possible. In this case, each individual execution is regarded as a transaction), the system identifies the earliest corresponding \"open position execution\" that contributed to that closing. The result includes a single entry for each closing transaction, detailing key metrics such as profit/loss and holding period, based on the matched opening transactions.  This could be a real world example: - 2020-01-01: buy 5 stock1 for 100 USD each - 2021-06-01: buy 3 stock1 for 200 USD each - 2021-06-06: sell 6 stock1 for 300 USD each  In this case, the result would be one completed trade (corresponding to the last sell) with a profit of `(300*6)-(100*5+1*200)=1800-700=1100 USD`. There is an open position remaining (2 units of stock1, which correspond to the second buy transaction).  When we add this sell: - 2021-06-07: sell 2 stock1 for 400 USD each  It would add a second complete trade with a profit of `(400*2)-(200*2)=800-400=400 USD`.  For some brokers, the order history may be incomplete (e.g. only reveals the latest 90 days), so that we do not know if there could be older transactions. Thus, our implementation might detect (given the current set of open positions together with the list of order executions) that we cannot figure out the corresponding opening transactions for a closing transaction. Affected trades will be ignored for this analysis and might appear as warning items in the `/warnings` endpoint. Frontends should show those warnings so that users can understand why the analysis is incomplete.
+     */
+    async getPortfolioTrades(requestParameters, initOverrides) {
+        const response = await this.getPortfolioTradesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      */
     async getPortfoliosRaw(initOverrides) {
@@ -678,7 +797,7 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
             body: formParams,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => ObtainToken200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => TokenResponseFromJSON(jsonValue));
     }
     /**
      * Obtain a new access token using a refresh token as specified in https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.4. If `CreateGuestUser` has provided a `refresh_token`, this endpoint may be used to obtain a new `access_token` after the original token has expired.

package/dist/swagger/models/ClientConfig.d.ts

@@ -50,6 +50,13 @@ export interface ClientConfig {
      * @memberof ClientConfig
      */
     cognitoClientIds: Array<string>;
+    /**
+     * If this is true, crypto trading is allowed for this client. If this is true, clients must send
+     * some requests to the crypto trading service (for crypto orders) which is controlled by the flag `tradingViaCryptoService`.
+     * @type {boolean}
+     * @memberof ClientConfig
+     */
+    cryptoTradingAllowed?: boolean;
     /**
      *
      * @type {boolean}

package/dist/swagger/models/ClientConfig.js

@@ -30,6 +30,9 @@ export function ClientConfigFromJSONTyped(json, ignoreDiscriminator) {
             : json["allowedOriginsRegularExpressions"],
         brokerEnvFilter: mapValues(json["brokerEnvFilter"], BrokerEnvFilterTypeFromJSON),
         cognitoClientIds: json["cognitoClientIds"],
+        cryptoTradingAllowed: !exists(json, "cryptoTradingAllowed")
+            ? undefined
+            : json["cryptoTradingAllowed"],
         enabled: json["enabled"],
         guestUserInactivityTimeoutSeconds: !exists(json, "guestUserInactivityTimeoutSeconds")
             ? undefined
@@ -63,6 +66,7 @@ export function ClientConfigToJSONRecursive(value, ignoreParent = false) {
         allowedOriginsRegularExpressions: value.allowedOriginsRegularExpressions,
         brokerEnvFilter: mapValues(value.brokerEnvFilter, BrokerEnvFilterTypeToJSON),
         cognitoClientIds: value.cognitoClientIds,
+        cryptoTradingAllowed: value.cryptoTradingAllowed,
         enabled: value.enabled,
         guestUserInactivityTimeoutSeconds: value.guestUserInactivityTimeoutSeconds,
         guestUserLifetime: GuestUserLifetimeToJSON(value.guestUserLifetime),

package/dist/swagger/models/ClientConfigUpdate.d.ts

@@ -65,6 +65,12 @@ export interface ClientConfigUpdate {
      * @memberof ClientConfigUpdate
      */
     cognitoClientIds?: Array<string>;
+    /**
+     * If this is true, crypto trading is allowed for this client.
+     * @type {boolean}
+     * @memberof ClientConfigUpdate
+     */
+    cryptoTradingAllowed?: boolean;
     /**
      *
      * @type {boolean}

package/dist/swagger/models/ClientConfigUpdate.js

@@ -47,6 +47,9 @@ export function ClientConfigUpdateFromJSONTyped(json, ignoreDiscriminator) {
         cognitoClientIds: !exists(json, "cognitoClientIds")
             ? undefined
             : json["cognitoClientIds"],
+        cryptoTradingAllowed: !exists(json, "cryptoTradingAllowed")
+            ? undefined
+            : json["cryptoTradingAllowed"],
         enabled: !exists(json, "enabled") ? undefined : json["enabled"],
         guestUserInactivityTimeoutSeconds: !exists(json, "guestUserInactivityTimeoutSeconds")
             ? undefined
@@ -101,6 +104,7 @@ export function ClientConfigUpdateToJSONRecursive(value, ignoreParent = false) {
             : mapValues(value.brokerEnvFilter, BrokerEnvFilterTypeToJSON),
         clientSecrets: value.clientSecrets,
         cognitoClientIds: value.cognitoClientIds,
+        cryptoTradingAllowed: value.cryptoTradingAllowed,
         enabled: value.enabled,
         guestUserInactivityTimeoutSeconds: value.guestUserInactivityTimeoutSeconds,
         guestUserLifetime: GuestUserLifetimeToJSON(value.guestUserLifetime),

package/dist/swagger/models/GetPortfolioTradeStatisticsResponse.d.ts

@@ -0,0 +1,28 @@
+/**
+ * brokerize
+ * The brokerize API allows clients to implement multi-brokerage with a unified interface. For more information, visit brokerize.com
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { TradeStatisticsItem } from "./TradeStatisticsItem";
+/**
+ *
+ * @export
+ * @interface GetPortfolioTradeStatisticsResponse
+ */
+export interface GetPortfolioTradeStatisticsResponse {
+    /**
+     *
+     * @type {Array<TradeStatisticsItem>}
+     * @memberof GetPortfolioTradeStatisticsResponse
+     */
+    data: Array<TradeStatisticsItem>;
+}
+export declare function GetPortfolioTradeStatisticsResponseFromJSON(json: any): GetPortfolioTradeStatisticsResponse;
+export declare function GetPortfolioTradeStatisticsResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): GetPortfolioTradeStatisticsResponse;
+export declare function GetPortfolioTradeStatisticsResponseToJSONRecursive(value?: GetPortfolioTradeStatisticsResponse | null, ignoreParent?: boolean): any;
+export declare function GetPortfolioTradeStatisticsResponseToJSON(value?: GetPortfolioTradeStatisticsResponse | null): any;

package/dist/swagger/models/GetPortfolioTradeStatisticsResponse.js

@@ -0,0 +1,38 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * brokerize
+ * The brokerize API allows clients to implement multi-brokerage with a unified interface. For more information, visit brokerize.com
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { TradeStatisticsItemFromJSON, TradeStatisticsItemToJSON, } from "./TradeStatisticsItem";
+export function GetPortfolioTradeStatisticsResponseFromJSON(json) {
+    return GetPortfolioTradeStatisticsResponseFromJSONTyped(json, false);
+}
+export function GetPortfolioTradeStatisticsResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json === undefined || json === null) {
+        return json;
+    }
+    return {
+        data: json["data"].map(TradeStatisticsItemFromJSON),
+    };
+}
+export function GetPortfolioTradeStatisticsResponseToJSONRecursive(value, ignoreParent = false) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        data: value.data.map(TradeStatisticsItemToJSON),
+    };
+}
+export function GetPortfolioTradeStatisticsResponseToJSON(value) {
+    return GetPortfolioTradeStatisticsResponseToJSONRecursive(value, false);
+}

package/dist/swagger/models/GetPortfolioTradesResponse.d.ts

@@ -0,0 +1,34 @@
+/**
+ * brokerize
+ * The brokerize API allows clients to implement multi-brokerage with a unified interface. For more information, visit brokerize.com
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { SummarizedTrade } from "./SummarizedTrade";
+/**
+ *
+ * @export
+ * @interface GetPortfolioTradesResponse
+ */
+export interface GetPortfolioTradesResponse {
+    /**
+     *
+     * @type {number}
+     * @memberof GetPortfolioTradesResponse
+     */
+    totalCount: number;
+    /**
+     *
+     * @type {Array<SummarizedTrade>}
+     * @memberof GetPortfolioTradesResponse
+     */
+    trades: Array<SummarizedTrade>;
+}
+export declare function GetPortfolioTradesResponseFromJSON(json: any): GetPortfolioTradesResponse;
+export declare function GetPortfolioTradesResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): GetPortfolioTradesResponse;
+export declare function GetPortfolioTradesResponseToJSONRecursive(value?: GetPortfolioTradesResponse | null, ignoreParent?: boolean): any;
+export declare function GetPortfolioTradesResponseToJSON(value?: GetPortfolioTradesResponse | null): any;

package/dist/swagger/models/GetPortfolioTradesResponse.js

@@ -0,0 +1,40 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * brokerize
+ * The brokerize API allows clients to implement multi-brokerage with a unified interface. For more information, visit brokerize.com
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { SummarizedTradeFromJSON, SummarizedTradeToJSON, } from "./SummarizedTrade";
+export function GetPortfolioTradesResponseFromJSON(json) {
+    return GetPortfolioTradesResponseFromJSONTyped(json, false);
+}
+export function GetPortfolioTradesResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json === undefined || json === null) {
+        return json;
+    }
+    return {
+        totalCount: json["totalCount"],
+        trades: json["trades"].map(SummarizedTradeFromJSON),
+    };
+}
+export function GetPortfolioTradesResponseToJSONRecursive(value, ignoreParent = false) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        totalCount: value.totalCount,
+        trades: value.trades.map(SummarizedTradeToJSON),
+    };
+}
+export function GetPortfolioTradesResponseToJSON(value) {
+    return GetPortfolioTradesResponseToJSONRecursive(value, false);
+}

package/dist/swagger/models/SummarizedTrade.d.ts

@@ -0,0 +1,77 @@
+/**
+ * brokerize
+ * The brokerize API allows clients to implement multi-brokerage with a unified interface. For more information, visit brokerize.com
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { Amount } from "./Amount";
+import { Security } from "./Security";
+/**
+ *
+ * @export
+ * @interface SummarizedTrade
+ */
+export interface SummarizedTrade {
+    /**
+     *
+     * @type {Date}
+     * @memberof SummarizedTrade
+     */
+    closeDateTime: Date;
+    /**
+     *
+     * @type {string}
+     * @memberof SummarizedTrade
+     */
+    details: string;
+    /**
+     *
+     * @type {Amount}
+     * @memberof SummarizedTrade
+     */
+    fees?: Amount;
+    /**
+     *
+     * @type {string}
+     * @memberof SummarizedTrade
+     */
+    id: string;
+    /**
+     *
+     * @type {Date}
+     * @memberof SummarizedTrade
+     */
+    openDateTime: Date;
+    /**
+     *
+     * @type {Amount}
+     * @memberof SummarizedTrade
+     */
+    profitLossAbs: Amount;
+    /**
+     *
+     * @type {number}
+     * @memberof SummarizedTrade
+     */
+    profitLossRel: number;
+    /**
+     *
+     * @type {Security}
+     * @memberof SummarizedTrade
+     */
+    security: Security;
+    /**
+     *
+     * @type {Amount}
+     * @memberof SummarizedTrade
+     */
+    size: Amount;
+}
+export declare function SummarizedTradeFromJSON(json: any): SummarizedTrade;
+export declare function SummarizedTradeFromJSONTyped(json: any, ignoreDiscriminator: boolean): SummarizedTrade;
+export declare function SummarizedTradeToJSONRecursive(value?: SummarizedTrade | null, ignoreParent?: boolean): any;
+export declare function SummarizedTradeToJSON(value?: SummarizedTrade | null): any;

package/dist/swagger/models/SummarizedTrade.js

@@ -0,0 +1,56 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * brokerize
+ * The brokerize API allows clients to implement multi-brokerage with a unified interface. For more information, visit brokerize.com
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { exists } from "../runtime";
+import { AmountFromJSON, AmountToJSON, } from "./Amount";
+import { SecurityFromJSON, SecurityToJSON, } from "./Security";
+export function SummarizedTradeFromJSON(json) {
+    return SummarizedTradeFromJSONTyped(json, false);
+}
+export function SummarizedTradeFromJSONTyped(json, ignoreDiscriminator) {
+    if (json === undefined || json === null) {
+        return json;
+    }
+    return {
+        closeDateTime: new Date(json["closeDateTime"]),
+        details: json["details"],
+        fees: !exists(json, "fees") ? undefined : AmountFromJSON(json["fees"]),
+        id: json["id"],
+        openDateTime: new Date(json["openDateTime"]),
+        profitLossAbs: AmountFromJSON(json["profitLossAbs"]),
+        profitLossRel: json["profitLossRel"],
+        security: SecurityFromJSON(json["security"]),
+        size: AmountFromJSON(json["size"]),
+    };
+}
+export function SummarizedTradeToJSONRecursive(value, ignoreParent = false) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        closeDateTime: value.closeDateTime.toISOString(),
+        details: value.details,
+        fees: AmountToJSON(value.fees),
+        id: value.id,
+        openDateTime: value.openDateTime.toISOString(),
+        profitLossAbs: AmountToJSON(value.profitLossAbs),
+        profitLossRel: value.profitLossRel,
+        security: SecurityToJSON(value.security),
+        size: AmountToJSON(value.size),
+    };
+}
+export function SummarizedTradeToJSON(value) {
+    return SummarizedTradeToJSONRecursive(value, false);
+}

package/dist/swagger/models/TokenResponse.d.ts

@@ -0,0 +1,51 @@
+/**
+ * brokerize
+ * The brokerize API allows clients to implement multi-brokerage with a unified interface. For more information, visit brokerize.com
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface TokenResponse
+ */
+export interface TokenResponse {
+    /**
+     *
+     * @type {string}
+     * @memberof TokenResponse
+     */
+    accessToken: string;
+    /**
+     *
+     * @type {number}
+     * @memberof TokenResponse
+     */
+    expiresIn: number;
+    /**
+     *
+     * @type {string}
+     * @memberof TokenResponse
+     */
+    refreshToken: string;
+    /**
+     *
+     * @type {number}
+     * @memberof TokenResponse
+     */
+    refreshTokenExpiresIn: number;
+    /**
+     * token_type, it should always be "bearer"
+     * @type {string}
+     * @memberof TokenResponse
+     */
+    tokenType: string;
+}
+export declare function TokenResponseFromJSON(json: any): TokenResponse;
+export declare function TokenResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): TokenResponse;
+export declare function TokenResponseToJSONRecursive(value?: TokenResponse | null, ignoreParent?: boolean): any;
+export declare function TokenResponseToJSON(value?: TokenResponse | null): any;