@monaco-protocol/client-v2 0.0.91-dev → 0.0.96-develop

package/dist/apis/OrdersApi.d.ts

@@ -10,7 +10,7 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { BatchCancelOrdersRequest, BatchCreateOrderRequest, BatchOrderResponse, ChunkOrderResponse, CreateOrderRequest, IDResponse, OrderResponse, PagedOrderResponse, TradeResponse } from '../models/index';
+import type { BatchCancelOrdersRequest, BatchCreateOrderRequest, BatchIDResponse, BatchOrderResponse, ChunkOrderResponse, CreateOrderRequest, IDResponse, OrderResponse, PagedOrderResponse, TradeResponse } from '../models/index';
 export interface OrdersApiCancelOrderRequest {
     authorization: string;
     id: string;
@@ -35,6 +35,14 @@ export interface OrdersApiCreateOrderOperationRequest {
     authorization: string;
     createOrderRequest: CreateOrderRequest;
 }
+export interface OrdersApiCreateOrderRequestRequest {
+    authorization: string;
+    createOrderRequest: CreateOrderRequest;
+}
+export interface OrdersApiCreateOrderRequestsRequest {
+    authorization: string;
+    batchCreateOrderRequest: BatchCreateOrderRequest;
+}
 export interface OrdersApiCreateOrdersRequest {
     authorization: string;
     batchCreateOrderRequest: BatchCreateOrderRequest;
@@ -129,6 +137,22 @@ export declare class OrdersApi extends runtime.BaseAPI {
      * Create order
      */
     createOrder(requestParameters: OrdersApiCreateOrderOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OrderResponse>;
+    /**
+     * (Coming soon) Submit a request to create an order and get back an acknowledgement response containing the order\'s ID immediately. An order with a status of Pending will be created immediately in order to generate an ID; Any in-play/BIR delay, as well as initial matching will be performed asynchronously. Updates about orders created via this method maybe found as OrderUpdate messages through the StreamAPI and/or by calling GET /orders/{id} with the returned ID
+     */
+    createOrderRequestRaw(requestParameters: OrdersApiCreateOrderRequestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<IDResponse>>;
+    /**
+     * (Coming soon) Submit a request to create an order and get back an acknowledgement response containing the order\'s ID immediately. An order with a status of Pending will be created immediately in order to generate an ID; Any in-play/BIR delay, as well as initial matching will be performed asynchronously. Updates about orders created via this method maybe found as OrderUpdate messages through the StreamAPI and/or by calling GET /orders/{id} with the returned ID
+     */
+    createOrderRequest(requestParameters: OrdersApiCreateOrderRequestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<IDResponse>;
+    /**
+     * (Coming soon) Submit a request to create multiple orders and get back an acknowledgement response containing the orders\' ID\'s immediately. Orders with status of Pending will be created immediately in order to generate IDs; Any in-play/BIR delay, as well as initial matching will be performed asynchronously. The order IDs, and/or any errors, will be ordered in the response in the same order as in the request. Updates about orders created via this method maybe found as OrderUpdate messages through the StreamAPI and/or by calling GET /orders/{id} with the returned IDs
+     */
+    createOrderRequestsRaw(requestParameters: OrdersApiCreateOrderRequestsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BatchIDResponse>>;
+    /**
+     * (Coming soon) Submit a request to create multiple orders and get back an acknowledgement response containing the orders\' ID\'s immediately. Orders with status of Pending will be created immediately in order to generate IDs; Any in-play/BIR delay, as well as initial matching will be performed asynchronously. The order IDs, and/or any errors, will be ordered in the response in the same order as in the request. Updates about orders created via this method maybe found as OrderUpdate messages through the StreamAPI and/or by calling GET /orders/{id} with the returned IDs
+     */
+    createOrderRequests(requestParameters: OrdersApiCreateOrderRequestsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BatchIDResponse>;
     /**
      * Create multiple orders
      */
@@ -162,11 +186,11 @@ export declare class OrdersApi extends runtime.BaseAPI {
      */
     getOrders(requestParameters: OrdersApiGetOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PagedOrderResponse>;
     /**
-     * Fetch orders settled in date range, filtered by wallet (settled orders are those of status \'Won\', \'Lost\', or \'Voided\'). Page size limit 500.
+     * Fetch orders settled in date range, filtered by wallet (settled orders are those of status \'Won\', \'Lost\', or \'Voided\'). Page size limit 500, max date range is 10 days.
      */
     getOrdersSettledBetweenRaw(requestParameters: OrdersApiGetOrdersSettledBetweenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PagedOrderResponse>>;
     /**
-     * Fetch orders settled in date range, filtered by wallet (settled orders are those of status \'Won\', \'Lost\', or \'Voided\'). Page size limit 500.
+     * Fetch orders settled in date range, filtered by wallet (settled orders are those of status \'Won\', \'Lost\', or \'Voided\'). Page size limit 500, max date range is 10 days.
      */
     getOrdersSettledBetween(requestParameters: OrdersApiGetOrdersSettledBetweenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PagedOrderResponse>;
     /**
@@ -183,8 +207,10 @@ export declare class OrdersApi extends runtime.BaseAPI {
  */
 export declare const GetOrdersStatusesEnum: {
     readonly Cancelled: "Cancelled";
+    readonly Failed: "Failed";
     readonly Matched: "Matched";
     readonly PartiallyMatched: "PartiallyMatched";
+    readonly Pending: "Pending";
     readonly Unmatched: "Unmatched";
     readonly Won: "Won";
     readonly Lost: "Lost";

package/dist/apis/OrdersApi.js

@@ -218,6 +218,78 @@ class OrdersApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * (Coming soon) Submit a request to create an order and get back an acknowledgement response containing the order\'s ID immediately. An order with a status of Pending will be created immediately in order to generate an ID; Any in-play/BIR delay, as well as initial matching will be performed asynchronously. Updates about orders created via this method maybe found as OrderUpdate messages through the StreamAPI and/or by calling GET /orders/{id} with the returned ID
+     */
+    createOrderRequestRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['authorization'] == null) {
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling createOrderRequest().');
+            }
+            if (requestParameters['createOrderRequest'] == null) {
+                throw new runtime.RequiredError('createOrderRequest', 'Required parameter "createOrderRequest" was null or undefined when calling createOrderRequest().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['authorization'] != null) {
+                headerParameters['authorization'] = String(requestParameters['authorization']);
+            }
+            const response = yield this.request({
+                path: `/order-requests`,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, index_1.CreateOrderRequestToJSON)(requestParameters['createOrderRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.IDResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * (Coming soon) Submit a request to create an order and get back an acknowledgement response containing the order\'s ID immediately. An order with a status of Pending will be created immediately in order to generate an ID; Any in-play/BIR delay, as well as initial matching will be performed asynchronously. Updates about orders created via this method maybe found as OrderUpdate messages through the StreamAPI and/or by calling GET /orders/{id} with the returned ID
+     */
+    createOrderRequest(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createOrderRequestRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * (Coming soon) Submit a request to create multiple orders and get back an acknowledgement response containing the orders\' ID\'s immediately. Orders with status of Pending will be created immediately in order to generate IDs; Any in-play/BIR delay, as well as initial matching will be performed asynchronously. The order IDs, and/or any errors, will be ordered in the response in the same order as in the request. Updates about orders created via this method maybe found as OrderUpdate messages through the StreamAPI and/or by calling GET /orders/{id} with the returned IDs
+     */
+    createOrderRequestsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['authorization'] == null) {
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling createOrderRequests().');
+            }
+            if (requestParameters['batchCreateOrderRequest'] == null) {
+                throw new runtime.RequiredError('batchCreateOrderRequest', 'Required parameter "batchCreateOrderRequest" was null or undefined when calling createOrderRequests().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['authorization'] != null) {
+                headerParameters['authorization'] = String(requestParameters['authorization']);
+            }
+            const response = yield this.request({
+                path: `/order-requests/batch`,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, index_1.BatchCreateOrderRequestToJSON)(requestParameters['batchCreateOrderRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.BatchIDResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * (Coming soon) Submit a request to create multiple orders and get back an acknowledgement response containing the orders\' ID\'s immediately. Orders with status of Pending will be created immediately in order to generate IDs; Any in-play/BIR delay, as well as initial matching will be performed asynchronously. The order IDs, and/or any errors, will be ordered in the response in the same order as in the request. Updates about orders created via this method maybe found as OrderUpdate messages through the StreamAPI and/or by calling GET /orders/{id} with the returned IDs
+     */
+    createOrderRequests(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createOrderRequestsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Create multiple orders
      */
@@ -399,7 +471,7 @@ class OrdersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Fetch orders settled in date range, filtered by wallet (settled orders are those of status \'Won\', \'Lost\', or \'Voided\'). Page size limit 500.
+     * Fetch orders settled in date range, filtered by wallet (settled orders are those of status \'Won\', \'Lost\', or \'Voided\'). Page size limit 500, max date range is 10 days.
      */
     getOrdersSettledBetweenRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -445,7 +517,7 @@ class OrdersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Fetch orders settled in date range, filtered by wallet (settled orders are those of status \'Won\', \'Lost\', or \'Voided\'). Page size limit 500.
+     * Fetch orders settled in date range, filtered by wallet (settled orders are those of status \'Won\', \'Lost\', or \'Voided\'). Page size limit 500, max date range is 10 days.
      */
     getOrdersSettledBetween(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -503,8 +575,10 @@ exports.OrdersApi = OrdersApi;
  */
 exports.GetOrdersStatusesEnum = {
     Cancelled: 'Cancelled',
+    Failed: 'Failed',
     Matched: 'Matched',
     PartiallyMatched: 'PartiallyMatched',
+    Pending: 'Pending',
     Unmatched: 'Unmatched',
     Won: 'Won',
     Lost: 'Lost',

package/dist/apis/PricesApi.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Monaco API
+ * A RESTful API that allows you to interact with the Monaco Exchange. Provides endpoints for managing Events, Markets, Sessions, Wallets and Orders. To interact with the API, a client must have an App Id and an API Key to authenticate and create a session.
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import type { PagedMarketWithPricesResponse } from '../models/index';
+export interface GetPricesRequest {
+    authorization: string;
+    eventStarting?: GetPricesEventStartingEnum;
+    fromDateTime?: Date;
+    toDateTime?: Date;
+    marketStatuses?: Set<GetPricesMarketStatusesEnum>;
+    marketIds?: Set<string>;
+    page?: number;
+    size?: number;
+    sort?: Array<string>;
+}
+/**
+ *
+ */
+export declare class PricesApi extends runtime.BaseAPI {
+    /**
+     * Fetch market prices, filtered by either provided market ids, or event start time - with optional filtering on market status. Paginated by number of markets.
+     */
+    getPricesRaw(requestParameters: GetPricesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PagedMarketWithPricesResponse>>;
+    /**
+     * Fetch market prices, filtered by either provided market ids, or event start time - with optional filtering on market status. Paginated by number of markets.
+     */
+    getPrices(requestParameters: GetPricesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PagedMarketWithPricesResponse>;
+}
+/**
+ * @export
+ */
+export declare const GetPricesEventStartingEnum: {
+    readonly Live: "Live";
+    readonly Today: "Today";
+    readonly Later: "Later";
+    readonly Range: "Range";
+};
+export type GetPricesEventStartingEnum = typeof GetPricesEventStartingEnum[keyof typeof GetPricesEventStartingEnum];
+/**
+ * @export
+ */
+export declare const GetPricesMarketStatusesEnum: {
+    readonly Initializing: "Initializing";
+    readonly Open: "Open";
+    readonly Locked: "Locked";
+    readonly Settling: "Settling";
+    readonly Settled: "Settled";
+    readonly Voiding: "Voiding";
+    readonly Voided: "Voided";
+    readonly Closed: "Closed";
+};
+export type GetPricesMarketStatusesEnum = typeof GetPricesMarketStatusesEnum[keyof typeof GetPricesMarketStatusesEnum];

package/dist/apis/PricesApi.js

@@ -0,0 +1,110 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Monaco API
+ * A RESTful API that allows you to interact with the Monaco Exchange. Provides endpoints for managing Events, Markets, Sessions, Wallets and Orders. To interact with the API, a client must have an App Id and an API Key to authenticate and create a session.
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPricesMarketStatusesEnum = exports.GetPricesEventStartingEnum = exports.PricesApi = void 0;
+const runtime = require("../runtime");
+const index_1 = require("../models/index");
+/**
+ *
+ */
+class PricesApi extends runtime.BaseAPI {
+    /**
+     * Fetch market prices, filtered by either provided market ids, or event start time - with optional filtering on market status. Paginated by number of markets.
+     */
+    getPricesRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['authorization'] == null) {
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling getPrices().');
+            }
+            const queryParameters = {};
+            if (requestParameters['eventStarting'] != null) {
+                queryParameters['eventStarting'] = requestParameters['eventStarting'];
+            }
+            if (requestParameters['fromDateTime'] != null) {
+                queryParameters['fromDateTime'] = requestParameters['fromDateTime'].toISOString();
+            }
+            if (requestParameters['toDateTime'] != null) {
+                queryParameters['toDateTime'] = requestParameters['toDateTime'].toISOString();
+            }
+            if (requestParameters['marketStatuses'] != null) {
+                queryParameters['marketStatuses'] = requestParameters['marketStatuses'];
+            }
+            if (requestParameters['marketIds'] != null) {
+                queryParameters['marketIds'] = requestParameters['marketIds'];
+            }
+            if (requestParameters['page'] != null) {
+                queryParameters['page'] = requestParameters['page'];
+            }
+            if (requestParameters['size'] != null) {
+                queryParameters['size'] = requestParameters['size'];
+            }
+            if (requestParameters['sort'] != null) {
+                queryParameters['sort'] = requestParameters['sort'];
+            }
+            const headerParameters = {};
+            if (requestParameters['authorization'] != null) {
+                headerParameters['authorization'] = String(requestParameters['authorization']);
+            }
+            const response = yield this.request({
+                path: `/prices`,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.PagedMarketWithPricesResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Fetch market prices, filtered by either provided market ids, or event start time - with optional filtering on market status. Paginated by number of markets.
+     */
+    getPrices(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPricesRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+}
+exports.PricesApi = PricesApi;
+/**
+ * @export
+ */
+exports.GetPricesEventStartingEnum = {
+    Live: 'Live',
+    Today: 'Today',
+    Later: 'Later',
+    Range: 'Range'
+};
+/**
+ * @export
+ */
+exports.GetPricesMarketStatusesEnum = {
+    Initializing: 'Initializing',
+    Open: 'Open',
+    Locked: 'Locked',
+    Settling: 'Settling',
+    Settled: 'Settled',
+    Voiding: 'Voiding',
+    Voided: 'Voided',
+    Closed: 'Closed'
+};

package/dist/apis/WalletsApi.d.ts

@@ -10,7 +10,12 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { CreateWalletRequest, DepositAddressResponse, DepositRequestResponse, PagedMarketPositionResponse, PagedTransactionResponse, PagedWalletResponse, TransferResponse, UpdateWalletOverdraftRequest, WalletMetricsResponse, WalletResponse, WithdrawalRequestRequest, WithdrawalRequestResponse } from '../models/index';
+import type { BalanceUpdateRequest, CreateWalletRequest, DepositAddressResponse, DepositRequestResponse, PagedMarketPositionResponse, PagedTransactionResponse, PagedWalletResponse, TransferResponse, UpdateWalletOverdraftRequest, WalletMetricsResponse, WalletResponse, WithdrawalRequestRequest, WithdrawalRequestResponse } from '../models/index';
+export interface WalletsApiBalanceUpdateOperationRequest {
+    authorization: string;
+    id: string;
+    balanceUpdateRequest: BalanceUpdateRequest;
+}
 export interface WalletsApiCreateWalletOperationRequest {
     authorization: string;
     createWalletRequest: CreateWalletRequest;
@@ -77,6 +82,16 @@ export interface WalletsApiUpdateWalletOverdraftOperationRequest {
  *
  */
 export declare class WalletsApi extends runtime.BaseAPI {
+    /**
+     * Manually credit or debit wallet balance
+     * Adjust wallet balance
+     */
+    balanceUpdateRaw(requestParameters: WalletsApiBalanceUpdateOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WalletResponse>>;
+    /**
+     * Manually credit or debit wallet balance
+     * Adjust wallet balance
+     */
+    balanceUpdate(requestParameters: WalletsApiBalanceUpdateOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WalletResponse>;
     /**
      * Creates a wallet that can be used to create orders and receive winnings
      * Create a wallet

package/dist/apis/WalletsApi.js

@@ -29,6 +29,47 @@ const index_1 = require("../models/index");
  *
  */
 class WalletsApi extends runtime.BaseAPI {
+    /**
+     * Manually credit or debit wallet balance
+     * Adjust wallet balance
+     */
+    balanceUpdateRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['authorization'] == null) {
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling balanceUpdate().');
+            }
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling balanceUpdate().');
+            }
+            if (requestParameters['balanceUpdateRequest'] == null) {
+                throw new runtime.RequiredError('balanceUpdateRequest', 'Required parameter "balanceUpdateRequest" was null or undefined when calling balanceUpdate().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['authorization'] != null) {
+                headerParameters['authorization'] = String(requestParameters['authorization']);
+            }
+            const response = yield this.request({
+                path: `/wallets/{id}/balance-update`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, index_1.BalanceUpdateRequestToJSON)(requestParameters['balanceUpdateRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.WalletResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Manually credit or debit wallet balance
+     * Adjust wallet balance
+     */
+    balanceUpdate(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.balanceUpdateRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates a wallet that can be used to create orders and receive winnings
      * Create a wallet

package/dist/models/AppPermissionRequest.d.ts

@@ -38,6 +38,8 @@ export declare const AppPermissionRequestPermissionEnum: {
     readonly OrderCanViewAll: "OrderCanViewAll";
     readonly TradeCanViewAll: "TradeCanViewAll";
     readonly WalletCanUpdateOverdraft: "WalletCanUpdateOverdraft";
+    readonly WalletCanViewAll: "WalletCanViewAll";
+    readonly WalletCanAdjustBalance: "WalletCanAdjustBalance";
 };
 export type AppPermissionRequestPermissionEnum = typeof AppPermissionRequestPermissionEnum[keyof typeof AppPermissionRequestPermissionEnum];
 /**

package/dist/models/AppPermissionRequest.js

@@ -34,7 +34,9 @@ exports.AppPermissionRequestPermissionEnum = {
     MarketCanAdmin: 'MarketCanAdmin',
     OrderCanViewAll: 'OrderCanViewAll',
     TradeCanViewAll: 'TradeCanViewAll',
-    WalletCanUpdateOverdraft: 'WalletCanUpdateOverdraft'
+    WalletCanUpdateOverdraft: 'WalletCanUpdateOverdraft',
+    WalletCanViewAll: 'WalletCanViewAll',
+    WalletCanAdjustBalance: 'WalletCanAdjustBalance'
 };
 /**
  * Check if a given object implements the AppPermissionRequest interface.

package/dist/models/BalanceUpdateRequest.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Monaco API
+ * A RESTful API that allows you to interact with the Monaco Exchange. Provides endpoints for managing Events, Markets, Sessions, Wallets and Orders. To interact with the API, a client must have an App Id and an API Key to authenticate and create a session.
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * 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 BalanceUpdateRequest
+ */
+export interface BalanceUpdateRequest {
+    /**
+     *
+     * @type {string}
+     * @memberof BalanceUpdateRequest
+     */
+    currencyId: string;
+    /**
+     *
+     * @type {string}
+     * @memberof BalanceUpdateRequest
+     */
+    type: BalanceUpdateRequestTypeEnum;
+    /**
+     *
+     * @type {number}
+     * @memberof BalanceUpdateRequest
+     */
+    amount?: number;
+    /**
+     * Required: a unique identifier for this transaction, such as a Solana transaction id
+     * @type {string}
+     * @memberof BalanceUpdateRequest
+     */
+    transactionUniqueIdentifier: string;
+    /**
+     * Required: a description for this transaction, such as the reason for the update
+     * @type {string}
+     * @memberof BalanceUpdateRequest
+     */
+    transactionDescription: string;
+}
+/**
+ * @export
+ */
+export declare const BalanceUpdateRequestTypeEnum: {
+    readonly Credit: "Credit";
+    readonly Debit: "Debit";
+};
+export type BalanceUpdateRequestTypeEnum = typeof BalanceUpdateRequestTypeEnum[keyof typeof BalanceUpdateRequestTypeEnum];
+/**
+ * Check if a given object implements the BalanceUpdateRequest interface.
+ */
+export declare function instanceOfBalanceUpdateRequest(value: object): value is BalanceUpdateRequest;
+export declare function BalanceUpdateRequestFromJSON(json: any): BalanceUpdateRequest;
+export declare function BalanceUpdateRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean): BalanceUpdateRequest;
+export declare function BalanceUpdateRequestToJSON(json: any): BalanceUpdateRequest;
+export declare function BalanceUpdateRequestToJSONTyped(value?: BalanceUpdateRequest | null, ignoreDiscriminator?: boolean): any;

package/dist/models/BalanceUpdateRequest.js

@@ -0,0 +1,72 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Monaco API
+ * A RESTful API that allows you to interact with the Monaco Exchange. Provides endpoints for managing Events, Markets, Sessions, Wallets and Orders. To interact with the API, a client must have an App Id and an API Key to authenticate and create a session.
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BalanceUpdateRequestTypeEnum = void 0;
+exports.instanceOfBalanceUpdateRequest = instanceOfBalanceUpdateRequest;
+exports.BalanceUpdateRequestFromJSON = BalanceUpdateRequestFromJSON;
+exports.BalanceUpdateRequestFromJSONTyped = BalanceUpdateRequestFromJSONTyped;
+exports.BalanceUpdateRequestToJSON = BalanceUpdateRequestToJSON;
+exports.BalanceUpdateRequestToJSONTyped = BalanceUpdateRequestToJSONTyped;
+/**
+ * @export
+ */
+exports.BalanceUpdateRequestTypeEnum = {
+    Credit: 'Credit',
+    Debit: 'Debit'
+};
+/**
+ * Check if a given object implements the BalanceUpdateRequest interface.
+ */
+function instanceOfBalanceUpdateRequest(value) {
+    if (!('currencyId' in value) || value['currencyId'] === undefined)
+        return false;
+    if (!('type' in value) || value['type'] === undefined)
+        return false;
+    if (!('transactionUniqueIdentifier' in value) || value['transactionUniqueIdentifier'] === undefined)
+        return false;
+    if (!('transactionDescription' in value) || value['transactionDescription'] === undefined)
+        return false;
+    return true;
+}
+function BalanceUpdateRequestFromJSON(json) {
+    return BalanceUpdateRequestFromJSONTyped(json, false);
+}
+function BalanceUpdateRequestFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'currencyId': json['currencyId'],
+        'type': json['type'],
+        'amount': json['amount'] == null ? undefined : json['amount'],
+        'transactionUniqueIdentifier': json['transactionUniqueIdentifier'],
+        'transactionDescription': json['transactionDescription'],
+    };
+}
+function BalanceUpdateRequestToJSON(json) {
+    return BalanceUpdateRequestToJSONTyped(json, false);
+}
+function BalanceUpdateRequestToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'currencyId': value['currencyId'],
+        'type': value['type'],
+        'amount': value['amount'],
+        'transactionUniqueIdentifier': value['transactionUniqueIdentifier'],
+        'transactionDescription': value['transactionDescription'],
+    };
+}

package/dist/models/BatchIDResponse.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Monaco API
+ * A RESTful API that allows you to interact with the Monaco Exchange. Provides endpoints for managing Events, Markets, Sessions, Wallets and Orders. To interact with the API, a client must have an App Id and an API Key to authenticate and create a session.
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { Meta } from './Meta';
+import type { BatchIDResponseIdsInner } from './BatchIDResponseIdsInner';
+/**
+ *
+ * @export
+ * @interface BatchIDResponse
+ */
+export interface BatchIDResponse {
+    /**
+     *
+     * @type {Meta}
+     * @memberof BatchIDResponse
+     */
+    meta?: Meta;
+    /**
+     *
+     * @type {Array<BatchIDResponseIdsInner>}
+     * @memberof BatchIDResponse
+     */
+    ids?: Array<BatchIDResponseIdsInner>;
+}
+/**
+ * Check if a given object implements the BatchIDResponse interface.
+ */
+export declare function instanceOfBatchIDResponse(value: object): value is BatchIDResponse;
+export declare function BatchIDResponseFromJSON(json: any): BatchIDResponse;
+export declare function BatchIDResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): BatchIDResponse;
+export declare function BatchIDResponseToJSON(json: any): BatchIDResponse;
+export declare function BatchIDResponseToJSONTyped(value?: BatchIDResponse | null, ignoreDiscriminator?: boolean): any;

package/dist/models/BatchIDResponse.js

@@ -0,0 +1,52 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Monaco API
+ * A RESTful API that allows you to interact with the Monaco Exchange. Provides endpoints for managing Events, Markets, Sessions, Wallets and Orders. To interact with the API, a client must have an App Id and an API Key to authenticate and create a session.
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfBatchIDResponse = instanceOfBatchIDResponse;
+exports.BatchIDResponseFromJSON = BatchIDResponseFromJSON;
+exports.BatchIDResponseFromJSONTyped = BatchIDResponseFromJSONTyped;
+exports.BatchIDResponseToJSON = BatchIDResponseToJSON;
+exports.BatchIDResponseToJSONTyped = BatchIDResponseToJSONTyped;
+const Meta_1 = require("./Meta");
+const BatchIDResponseIdsInner_1 = require("./BatchIDResponseIdsInner");
+/**
+ * Check if a given object implements the BatchIDResponse interface.
+ */
+function instanceOfBatchIDResponse(value) {
+    return true;
+}
+function BatchIDResponseFromJSON(json) {
+    return BatchIDResponseFromJSONTyped(json, false);
+}
+function BatchIDResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'meta': json['_meta'] == null ? undefined : (0, Meta_1.MetaFromJSON)(json['_meta']),
+        'ids': json['ids'] == null ? undefined : (json['ids'].map(BatchIDResponseIdsInner_1.BatchIDResponseIdsInnerFromJSON)),
+    };
+}
+function BatchIDResponseToJSON(json) {
+    return BatchIDResponseToJSONTyped(json, false);
+}
+function BatchIDResponseToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        '_meta': (0, Meta_1.MetaToJSON)(value['meta']),
+        'ids': value['ids'] == null ? undefined : (value['ids'].map(BatchIDResponseIdsInner_1.BatchIDResponseIdsInnerToJSON)),
+    };
+}

package/dist/models/BatchIDResponseIdsInner.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Monaco API
+ * A RESTful API that allows you to interact with the Monaco Exchange. Provides endpoints for managing Events, Markets, Sessions, Wallets and Orders. To interact with the API, a client must have an App Id and an API Key to authenticate and create a session.
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { OrderFailure } from './OrderFailure';
+import type { OrderID } from './OrderID';
+/**
+ * @type BatchIDResponseIdsInner
+ *
+ * @export
+ */
+export type BatchIDResponseIdsInner = OrderFailure | OrderID;
+export declare function BatchIDResponseIdsInnerFromJSON(json: any): BatchIDResponseIdsInner;
+export declare function BatchIDResponseIdsInnerFromJSONTyped(json: any, ignoreDiscriminator: boolean): BatchIDResponseIdsInner;
+export declare function BatchIDResponseIdsInnerToJSON(json: any): any;
+export declare function BatchIDResponseIdsInnerToJSONTyped(value?: BatchIDResponseIdsInner | null, ignoreDiscriminator?: boolean): any;

package/dist/models/BatchIDResponseIdsInner.js

@@ -0,0 +1,51 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Monaco API
+ * A RESTful API that allows you to interact with the Monaco Exchange. Provides endpoints for managing Events, Markets, Sessions, Wallets and Orders. To interact with the API, a client must have an App Id and an API Key to authenticate and create a session.
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchIDResponseIdsInnerFromJSON = BatchIDResponseIdsInnerFromJSON;
+exports.BatchIDResponseIdsInnerFromJSONTyped = BatchIDResponseIdsInnerFromJSONTyped;
+exports.BatchIDResponseIdsInnerToJSON = BatchIDResponseIdsInnerToJSON;
+exports.BatchIDResponseIdsInnerToJSONTyped = BatchIDResponseIdsInnerToJSONTyped;
+const OrderFailure_1 = require("./OrderFailure");
+const OrderID_1 = require("./OrderID");
+function BatchIDResponseIdsInnerFromJSON(json) {
+    return BatchIDResponseIdsInnerFromJSONTyped(json, false);
+}
+function BatchIDResponseIdsInnerFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    if ((0, OrderFailure_1.instanceOfOrderFailure)(json)) {
+        return (0, OrderFailure_1.OrderFailureFromJSONTyped)(json, true);
+    }
+    if ((0, OrderID_1.instanceOfOrderID)(json)) {
+        return (0, OrderID_1.OrderIDFromJSONTyped)(json, true);
+    }
+    return {};
+}
+function BatchIDResponseIdsInnerToJSON(json) {
+    return BatchIDResponseIdsInnerToJSONTyped(json, false);
+}
+function BatchIDResponseIdsInnerToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    if ((0, OrderFailure_1.instanceOfOrderFailure)(value)) {
+        return (0, OrderFailure_1.OrderFailureToJSON)(value);
+    }
+    if ((0, OrderID_1.instanceOfOrderID)(value)) {
+        return (0, OrderID_1.OrderIDToJSON)(value);
+    }
+    return {};
+}

package/dist/models/Order.d.ts

@@ -116,8 +116,10 @@ export interface Order {
      * The status of an order can be one of the following
      * <ul>
      *     <li> Cancelled - The order was not matched and has been cancelled either on request or automatically</li>
+     *     <li> Failed - A pending order was persisted but then failed to be fully created</li>
      *     <li> Matched - The order has been matched, either fully, or partially where the remaining unmatched stake has been cancelled, either on request or automatically</li>
      *     <li> PartiallyMatched - The order has been partially matched, and the remaining unmatched portion might still be matched</li>
+     *     <li> Pending - An order has been persisted but has not yet been processed</li>
      *     <li> Unmatched - The order has not yet been matched, and the remaining unmatched portion might still be matched</li>
      *     <li> Won - The market has been settled and this previously Matched order has been deemed to have Won</li>
      *     <li> Lost - The market has been settled and this previously Matched order has been deemed to have Lost</li>
@@ -153,8 +155,10 @@ export type OrderSideEnum = typeof OrderSideEnum[keyof typeof OrderSideEnum];
  */
 export declare const OrderStatusEnum: {
     readonly Cancelled: "Cancelled";
+    readonly Failed: "Failed";
     readonly Matched: "Matched";
     readonly PartiallyMatched: "PartiallyMatched";
+    readonly Pending: "Pending";
     readonly Unmatched: "Unmatched";
     readonly Won: "Won";
     readonly Lost: "Lost";

package/dist/models/Order.js

@@ -32,8 +32,10 @@ exports.OrderSideEnum = {
  */
 exports.OrderStatusEnum = {
     Cancelled: 'Cancelled',
+    Failed: 'Failed',
     Matched: 'Matched',
     PartiallyMatched: 'PartiallyMatched',
+    Pending: 'Pending',
     Unmatched: 'Unmatched',
     Won: 'Won',
     Lost: 'Lost',

package/dist/models/OrderID.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Monaco API
+ * A RESTful API that allows you to interact with the Monaco Exchange. Provides endpoints for managing Events, Markets, Sessions, Wallets and Orders. To interact with the API, a client must have an App Id and an API Key to authenticate and create a session.
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * 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 OrderID
+ */
+export interface OrderID {
+    /**
+     *
+     * @type {string}
+     * @memberof OrderID
+     */
+    id?: string;
+}
+/**
+ * Check if a given object implements the OrderID interface.
+ */
+export declare function instanceOfOrderID(value: object): value is OrderID;
+export declare function OrderIDFromJSON(json: any): OrderID;
+export declare function OrderIDFromJSONTyped(json: any, ignoreDiscriminator: boolean): OrderID;
+export declare function OrderIDToJSON(json: any): OrderID;
+export declare function OrderIDToJSONTyped(value?: OrderID | null, ignoreDiscriminator?: boolean): any;

package/dist/models/OrderID.js

@@ -0,0 +1,48 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Monaco API
+ * A RESTful API that allows you to interact with the Monaco Exchange. Provides endpoints for managing Events, Markets, Sessions, Wallets and Orders. To interact with the API, a client must have an App Id and an API Key to authenticate and create a session.
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfOrderID = instanceOfOrderID;
+exports.OrderIDFromJSON = OrderIDFromJSON;
+exports.OrderIDFromJSONTyped = OrderIDFromJSONTyped;
+exports.OrderIDToJSON = OrderIDToJSON;
+exports.OrderIDToJSONTyped = OrderIDToJSONTyped;
+/**
+ * Check if a given object implements the OrderID interface.
+ */
+function instanceOfOrderID(value) {
+    return true;
+}
+function OrderIDFromJSON(json) {
+    return OrderIDFromJSONTyped(json, false);
+}
+function OrderIDFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'id': json['id'] == null ? undefined : json['id'],
+    };
+}
+function OrderIDToJSON(json) {
+    return OrderIDToJSONTyped(json, false);
+}
+function OrderIDToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'id': value['id'],
+    };
+}

package/dist/models/OrderSummary.d.ts

@@ -74,8 +74,10 @@ export interface OrderSummary {
      * The status of an order can be one of the following
      * <ul>
      *     <li> Cancelled - The order was not matched and has been cancelled either on request or automatically</li>
+     *     <li> Failed - A pending order was persisted but then failed to be fully created</li>
      *     <li> Matched - The order has been matched, either fully, or partially where the remaining unmatched stake has been cancelled, either on request or automatically</li>
      *     <li> PartiallyMatched - The order has been partially matched, and the remaining unmatched portion might still be matched</li>
+     *     <li> Pending - An order has been persisted but has not yet been processed</li>
      *     <li> Unmatched - The order has not yet been matched, and the remaining unmatched portion might still be matched</li>
      *     <li> Won - The market has been settled and this previously Matched order has been deemed to have Won</li>
      *     <li> Lost - The market has been settled and this previously Matched order has been deemed to have Lost</li>
@@ -106,8 +108,10 @@ export type OrderSummarySideEnum = typeof OrderSummarySideEnum[keyof typeof Orde
  */
 export declare const OrderSummaryStatusEnum: {
     readonly Cancelled: "Cancelled";
+    readonly Failed: "Failed";
     readonly Matched: "Matched";
     readonly PartiallyMatched: "PartiallyMatched";
+    readonly Pending: "Pending";
     readonly Unmatched: "Unmatched";
     readonly Won: "Won";
     readonly Lost: "Lost";

package/dist/models/OrderSummary.js

@@ -32,8 +32,10 @@ exports.OrderSummarySideEnum = {
  */
 exports.OrderSummaryStatusEnum = {
     Cancelled: 'Cancelled',
+    Failed: 'Failed',
     Matched: 'Matched',
     PartiallyMatched: 'PartiallyMatched',
+    Pending: 'Pending',
     Unmatched: 'Unmatched',
     Won: 'Won',
     Lost: 'Lost',

package/dist/models/PagedMarketWithPricesResponse.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Monaco API
+ * A RESTful API that allows you to interact with the Monaco Exchange. Provides endpoints for managing Events, Markets, Sessions, Wallets and Orders. To interact with the API, a client must have an App Id and an API Key to authenticate and create a session.
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { MarketOutcomeSummary } from './MarketOutcomeSummary';
+import type { Meta } from './Meta';
+import type { CategorySummary } from './CategorySummary';
+import type { EventSummary } from './EventSummary';
+import type { SubcategorySummary } from './SubcategorySummary';
+import type { Market } from './Market';
+import type { MarketLiquidities } from './MarketLiquidities';
+import type { MarketTypeSummary } from './MarketTypeSummary';
+import type { EventGroupSummary } from './EventGroupSummary';
+import type { EventParticipant } from './EventParticipant';
+/**
+ *
+ * @export
+ * @interface PagedMarketWithPricesResponse
+ */
+export interface PagedMarketWithPricesResponse {
+    /**
+     *
+     * @type {Meta}
+     * @memberof PagedMarketWithPricesResponse
+     */
+    meta?: Meta;
+    /**
+     *
+     * @type {Array<Market>}
+     * @memberof PagedMarketWithPricesResponse
+     */
+    markets?: Array<Market>;
+    /**
+     *
+     * @type {Array<MarketTypeSummary>}
+     * @memberof PagedMarketWithPricesResponse
+     */
+    marketTypes?: Array<MarketTypeSummary>;
+    /**
+     *
+     * @type {Array<MarketOutcomeSummary>}
+     * @memberof PagedMarketWithPricesResponse
+     */
+    marketOutcomes?: Array<MarketOutcomeSummary>;
+    /**
+     *
+     * @type {Array<EventSummary>}
+     * @memberof PagedMarketWithPricesResponse
+     */
+    events?: Array<EventSummary>;
+    /**
+     *
+     * @type {Array<EventGroupSummary>}
+     * @memberof PagedMarketWithPricesResponse
+     */
+    eventGroups?: Array<EventGroupSummary>;
+    /**
+     *
+     * @type {Array<SubcategorySummary>}
+     * @memberof PagedMarketWithPricesResponse
+     */
+    subcategories?: Array<SubcategorySummary>;
+    /**
+     *
+     * @type {Array<CategorySummary>}
+     * @memberof PagedMarketWithPricesResponse
+     */
+    categories?: Array<CategorySummary>;
+    /**
+     *
+     * @type {Array<MarketLiquidities>}
+     * @memberof PagedMarketWithPricesResponse
+     */
+    prices?: Array<MarketLiquidities>;
+    /**
+     *
+     * @type {Array<EventParticipant>}
+     * @memberof PagedMarketWithPricesResponse
+     */
+    participants?: Array<EventParticipant>;
+}
+/**
+ * Check if a given object implements the PagedMarketWithPricesResponse interface.
+ */
+export declare function instanceOfPagedMarketWithPricesResponse(value: object): value is PagedMarketWithPricesResponse;
+export declare function PagedMarketWithPricesResponseFromJSON(json: any): PagedMarketWithPricesResponse;
+export declare function PagedMarketWithPricesResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): PagedMarketWithPricesResponse;
+export declare function PagedMarketWithPricesResponseToJSON(json: any): PagedMarketWithPricesResponse;
+export declare function PagedMarketWithPricesResponseToJSONTyped(value?: PagedMarketWithPricesResponse | null, ignoreDiscriminator?: boolean): any;

package/dist/models/PagedMarketWithPricesResponse.js

@@ -0,0 +1,76 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Monaco API
+ * A RESTful API that allows you to interact with the Monaco Exchange. Provides endpoints for managing Events, Markets, Sessions, Wallets and Orders. To interact with the API, a client must have an App Id and an API Key to authenticate and create a session.
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfPagedMarketWithPricesResponse = instanceOfPagedMarketWithPricesResponse;
+exports.PagedMarketWithPricesResponseFromJSON = PagedMarketWithPricesResponseFromJSON;
+exports.PagedMarketWithPricesResponseFromJSONTyped = PagedMarketWithPricesResponseFromJSONTyped;
+exports.PagedMarketWithPricesResponseToJSON = PagedMarketWithPricesResponseToJSON;
+exports.PagedMarketWithPricesResponseToJSONTyped = PagedMarketWithPricesResponseToJSONTyped;
+const MarketOutcomeSummary_1 = require("./MarketOutcomeSummary");
+const Meta_1 = require("./Meta");
+const CategorySummary_1 = require("./CategorySummary");
+const EventSummary_1 = require("./EventSummary");
+const SubcategorySummary_1 = require("./SubcategorySummary");
+const Market_1 = require("./Market");
+const MarketLiquidities_1 = require("./MarketLiquidities");
+const MarketTypeSummary_1 = require("./MarketTypeSummary");
+const EventGroupSummary_1 = require("./EventGroupSummary");
+const EventParticipant_1 = require("./EventParticipant");
+/**
+ * Check if a given object implements the PagedMarketWithPricesResponse interface.
+ */
+function instanceOfPagedMarketWithPricesResponse(value) {
+    return true;
+}
+function PagedMarketWithPricesResponseFromJSON(json) {
+    return PagedMarketWithPricesResponseFromJSONTyped(json, false);
+}
+function PagedMarketWithPricesResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'meta': json['_meta'] == null ? undefined : (0, Meta_1.MetaFromJSON)(json['_meta']),
+        'markets': json['markets'] == null ? undefined : (json['markets'].map(Market_1.MarketFromJSON)),
+        'marketTypes': json['marketTypes'] == null ? undefined : (json['marketTypes'].map(MarketTypeSummary_1.MarketTypeSummaryFromJSON)),
+        'marketOutcomes': json['marketOutcomes'] == null ? undefined : (json['marketOutcomes'].map(MarketOutcomeSummary_1.MarketOutcomeSummaryFromJSON)),
+        'events': json['events'] == null ? undefined : (json['events'].map(EventSummary_1.EventSummaryFromJSON)),
+        'eventGroups': json['eventGroups'] == null ? undefined : (json['eventGroups'].map(EventGroupSummary_1.EventGroupSummaryFromJSON)),
+        'subcategories': json['subcategories'] == null ? undefined : (json['subcategories'].map(SubcategorySummary_1.SubcategorySummaryFromJSON)),
+        'categories': json['categories'] == null ? undefined : (json['categories'].map(CategorySummary_1.CategorySummaryFromJSON)),
+        'prices': json['prices'] == null ? undefined : (json['prices'].map(MarketLiquidities_1.MarketLiquiditiesFromJSON)),
+        'participants': json['participants'] == null ? undefined : (json['participants'].map(EventParticipant_1.EventParticipantFromJSON)),
+    };
+}
+function PagedMarketWithPricesResponseToJSON(json) {
+    return PagedMarketWithPricesResponseToJSONTyped(json, false);
+}
+function PagedMarketWithPricesResponseToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        '_meta': (0, Meta_1.MetaToJSON)(value['meta']),
+        'markets': value['markets'] == null ? undefined : (value['markets'].map(Market_1.MarketToJSON)),
+        'marketTypes': value['marketTypes'] == null ? undefined : (value['marketTypes'].map(MarketTypeSummary_1.MarketTypeSummaryToJSON)),
+        'marketOutcomes': value['marketOutcomes'] == null ? undefined : (value['marketOutcomes'].map(MarketOutcomeSummary_1.MarketOutcomeSummaryToJSON)),
+        'events': value['events'] == null ? undefined : (value['events'].map(EventSummary_1.EventSummaryToJSON)),
+        'eventGroups': value['eventGroups'] == null ? undefined : (value['eventGroups'].map(EventGroupSummary_1.EventGroupSummaryToJSON)),
+        'subcategories': value['subcategories'] == null ? undefined : (value['subcategories'].map(SubcategorySummary_1.SubcategorySummaryToJSON)),
+        'categories': value['categories'] == null ? undefined : (value['categories'].map(CategorySummary_1.CategorySummaryToJSON)),
+        'prices': value['prices'] == null ? undefined : (value['prices'].map(MarketLiquidities_1.MarketLiquiditiesToJSON)),
+        'participants': value['participants'] == null ? undefined : (value['participants'].map(EventParticipant_1.EventParticipantToJSON)),
+    };
+}

package/dist/models/Transaction.d.ts

@@ -70,6 +70,8 @@ export declare const TransactionCodeEnum: {
     readonly WalletToWallet: "WalletToWallet";
     readonly Commission: "Commission";
     readonly MarketPositionVoid: "MarketPositionVoid";
+    readonly ManualDebit: "ManualDebit";
+    readonly ManualCredit: "ManualCredit";
 };
 export type TransactionCodeEnum = typeof TransactionCodeEnum[keyof typeof TransactionCodeEnum];
 /**

package/dist/models/Transaction.js

@@ -30,7 +30,9 @@ exports.TransactionCodeEnum = {
     TradeWin: 'TradeWin',
     WalletToWallet: 'WalletToWallet',
     Commission: 'Commission',
-    MarketPositionVoid: 'MarketPositionVoid'
+    MarketPositionVoid: 'MarketPositionVoid',
+    ManualDebit: 'ManualDebit',
+    ManualCredit: 'ManualCredit'
 };
 /**
  * Check if a given object implements the Transaction interface.

package/dist/models/index.d.ts

@@ -10,8 +10,11 @@ export * from './AppPermissionResponse';
 export * from './AppResponse';
 export * from './AppStatus';
 export * from './AppStatusResponse';
+export * from './BalanceUpdateRequest';
 export * from './BatchCancelOrdersRequest';
 export * from './BatchCreateOrderRequest';
+export * from './BatchIDResponse';
+export * from './BatchIDResponseIdsInner';
 export * from './BatchOrderResponse';
 export * from './BatchOrderResponseOrdersInner';
 export * from './Category';
@@ -77,6 +80,7 @@ export * from './Meta';
 export * from './ModifyParticipantsRequest';
 export * from './Order';
 export * from './OrderFailure';
+export * from './OrderID';
 export * from './OrderResponse';
 export * from './OrderSummary';
 export * from './PageMeta';

package/dist/models/index.js

@@ -28,8 +28,11 @@ __exportStar(require("./AppPermissionResponse"), exports);
 __exportStar(require("./AppResponse"), exports);
 __exportStar(require("./AppStatus"), exports);
 __exportStar(require("./AppStatusResponse"), exports);
+__exportStar(require("./BalanceUpdateRequest"), exports);
 __exportStar(require("./BatchCancelOrdersRequest"), exports);
 __exportStar(require("./BatchCreateOrderRequest"), exports);
+__exportStar(require("./BatchIDResponse"), exports);
+__exportStar(require("./BatchIDResponseIdsInner"), exports);
 __exportStar(require("./BatchOrderResponse"), exports);
 __exportStar(require("./BatchOrderResponseOrdersInner"), exports);
 __exportStar(require("./Category"), exports);
@@ -95,6 +98,7 @@ __exportStar(require("./Meta"), exports);
 __exportStar(require("./ModifyParticipantsRequest"), exports);
 __exportStar(require("./Order"), exports);
 __exportStar(require("./OrderFailure"), exports);
+__exportStar(require("./OrderID"), exports);
 __exportStar(require("./OrderResponse"), exports);
 __exportStar(require("./OrderSummary"), exports);
 __exportStar(require("./PageMeta"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monaco-protocol/client-v2",
-  "version": "0.0.91-dev",
+  "version": "0.0.96-develop",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [