@monaco-protocol/client-v2 0.0.2-dev.0 → 0.0.2-dev.11

package/dist/apis/{MonacoAPIEventSubcategoriesApi.js → HeartbeatManagementApi.js}

@@ -22,93 +22,87 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonacoAPIEventSubcategoriesApi = void 0;
+exports.HeartbeatManagementApi = void 0;
 const runtime = require("../runtime");
 const index_1 = require("../models/index");
 /**
  *
  */
-class MonacoAPIEventSubcategoriesApi extends runtime.BaseAPI {
+class HeartbeatManagementApi extends runtime.BaseAPI {
     /**
-     * Create sub-category
+     * Fetch heartbeat
      */
-    createRaw(requestParameters, initOverrides) {
+    getHeartbeatRaw(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 create().');
-            }
-            if (requestParameters['createSubcategoryRequest'] == null) {
-                throw new runtime.RequiredError('createSubcategoryRequest', 'Required parameter "createSubcategoryRequest" was null or undefined when calling create().');
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling getHeartbeat().');
             }
             const queryParameters = {};
             const headerParameters = {};
-            headerParameters['Content-Type'] = 'application/json';
             if (requestParameters['authorization'] != null) {
                 headerParameters['authorization'] = String(requestParameters['authorization']);
             }
             const response = yield this.request({
-                path: `/subcategories`,
-                method: 'POST',
+                path: `/heartbeat`,
+                method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-                body: (0, index_1.CreateSubcategoryRequestToJSON)(requestParameters['createSubcategoryRequest']),
             }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.SubcategoryFromJSON)(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.HeartbeatResponseFromJSON)(jsonValue));
         });
     }
     /**
-     * Create sub-category
+     * Fetch heartbeat
      */
-    create(requestParameters, initOverrides) {
+    getHeartbeat(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.createRaw(requestParameters, initOverrides);
+            const response = yield this.getHeartbeatRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
-     * Fetch sub-categories by categories
+     * Update heartbeat configuration
      */
-    getAllRaw(requestParameters, initOverrides) {
+    updateHeartbeatRaw(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 getAll().');
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling updateHeartbeat().');
             }
-            const queryParameters = {};
-            if (requestParameters['categoryIds'] != null) {
-                queryParameters['categoryIds'] = requestParameters['categoryIds'];
+            if (requestParameters['updateHeartbeatRequest'] == null) {
+                throw new runtime.RequiredError('updateHeartbeatRequest', 'Required parameter "updateHeartbeatRequest" was null or undefined when calling updateHeartbeat().');
             }
+            const queryParameters = {};
             const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
             if (requestParameters['authorization'] != null) {
                 headerParameters['authorization'] = String(requestParameters['authorization']);
             }
             const response = yield this.request({
-                path: `/subcategories`,
-                method: 'GET',
+                path: `/heartbeat/update`,
+                method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
+                body: (0, index_1.UpdateHeartbeatRequestToJSON)(requestParameters['updateHeartbeatRequest']),
             }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.SubcategoryResponseFromJSON)(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.HeartbeatResponseFromJSON)(jsonValue));
         });
     }
     /**
-     * Fetch sub-categories by categories
+     * Update heartbeat configuration
      */
-    getAll(requestParameters, initOverrides) {
+    updateHeartbeat(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.getAllRaw(requestParameters, initOverrides);
+            const response = yield this.updateHeartbeatRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
-     * Fetch sub-category by id
+     * Update heartbeat last received timestamp
      */
-    getByIdRaw(requestParameters, initOverrides) {
+    updateHeartbeatLastReceivedRaw(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 getById().');
-            }
-            if (requestParameters['id'] == null) {
-                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getById().');
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling updateHeartbeatLastReceived().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -116,22 +110,22 @@ class MonacoAPIEventSubcategoriesApi extends runtime.BaseAPI {
                 headerParameters['authorization'] = String(requestParameters['authorization']);
             }
             const response = yield this.request({
-                path: `/subcategories/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-                method: 'GET',
+                path: `/heartbeat`,
+                method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
             }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.SubcategoryResponseFromJSON)(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.HeartbeatResponseFromJSON)(jsonValue));
         });
     }
     /**
-     * Fetch sub-category by id
+     * Update heartbeat last received timestamp
      */
-    getById(requestParameters, initOverrides) {
+    updateHeartbeatLastReceived(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.getByIdRaw(requestParameters, initOverrides);
+            const response = yield this.updateHeartbeatLastReceivedRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
 }
-exports.MonacoAPIEventSubcategoriesApi = MonacoAPIEventSubcategoriesApi;
+exports.HeartbeatManagementApi = HeartbeatManagementApi;

package/dist/apis/MarketPricesApi.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { MarketLiquiditiesResponse, MarketPriceLadderResponse } from '../models/index';
+export interface GetMarketPriceLadderRequest {
+    authorization: string;
+}
+export interface GetMarketsPricesRequest {
+    authorization: string;
+    marketIds: Array<string>;
+}
+/**
+ *
+ */
+export declare class MarketPricesApi extends runtime.BaseAPI {
+    /**
+     * Fetch market price ladder
+     */
+    getMarketPriceLadderRaw(requestParameters: GetMarketPriceLadderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MarketPriceLadderResponse>>;
+    /**
+     * Fetch market price ladder
+     */
+    getMarketPriceLadder(requestParameters: GetMarketPriceLadderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MarketPriceLadderResponse>;
+    /**
+     * Fetch market prices
+     */
+    getMarketsPricesRaw(requestParameters: GetMarketsPricesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MarketLiquiditiesResponse>>;
+    /**
+     * Fetch market prices
+     */
+    getMarketsPrices(requestParameters: GetMarketsPricesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MarketLiquiditiesResponse>;
+}

package/dist/apis/MarketPricesApi.js

@@ -0,0 +1,101 @@
+"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.MarketPricesApi = void 0;
+const runtime = require("../runtime");
+const index_1 = require("../models/index");
+/**
+ *
+ */
+class MarketPricesApi extends runtime.BaseAPI {
+    /**
+     * Fetch market price ladder
+     */
+    getMarketPriceLadderRaw(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 getMarketPriceLadder().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (requestParameters['authorization'] != null) {
+                headerParameters['authorization'] = String(requestParameters['authorization']);
+            }
+            const response = yield this.request({
+                path: `/market-prices/ladder`,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MarketPriceLadderResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Fetch market price ladder
+     */
+    getMarketPriceLadder(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getMarketPriceLadderRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Fetch market prices
+     */
+    getMarketsPricesRaw(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 getMarketsPrices().');
+            }
+            if (requestParameters['marketIds'] == null) {
+                throw new runtime.RequiredError('marketIds', 'Required parameter "marketIds" was null or undefined when calling getMarketsPrices().');
+            }
+            const queryParameters = {};
+            if (requestParameters['marketIds'] != null) {
+                queryParameters['marketIds'] = requestParameters['marketIds'];
+            }
+            const headerParameters = {};
+            if (requestParameters['authorization'] != null) {
+                headerParameters['authorization'] = String(requestParameters['authorization']);
+            }
+            const response = yield this.request({
+                path: `/market-prices`,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MarketLiquiditiesResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Fetch market prices
+     */
+    getMarketsPrices(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getMarketsPricesRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+}
+exports.MarketPricesApi = MarketPricesApi;

package/dist/apis/{MonacoAPIMarketTypesApi.d.ts → MarketTypesApi.d.ts}

@@ -25,7 +25,7 @@ export interface GetMarketTypesRequest {
 /**
  *
  */
-export declare class MonacoAPIMarketTypesApi extends runtime.BaseAPI {
+export declare class MarketTypesApi extends runtime.BaseAPI {
     /**
      * Create market type
      */

package/dist/apis/{MonacoAPIMarketTypesApi.js → MarketTypesApi.js}

@@ -22,13 +22,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonacoAPIMarketTypesApi = void 0;
+exports.MarketTypesApi = void 0;
 const runtime = require("../runtime");
 const index_1 = require("../models/index");
 /**
  *
  */
-class MonacoAPIMarketTypesApi extends runtime.BaseAPI {
+class MarketTypesApi extends runtime.BaseAPI {
     /**
      * Create market type
      */
@@ -131,4 +131,4 @@ class MonacoAPIMarketTypesApi extends runtime.BaseAPI {
         });
     }
 }
-exports.MonacoAPIMarketTypesApi = MonacoAPIMarketTypesApi;
+exports.MarketTypesApi = MarketTypesApi;

package/dist/apis/{MonacoAPIMarketsApi.d.ts → MarketsApi.d.ts}

@@ -10,10 +10,10 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { AddMarketOutcomeRequest, CreateMarketRequest, MarketLiquidityResponse, MarketResponse, MarketResultRequest, PageRequest, PagedMarketPositionResponse, PagedOrderResponse, ToggleActionRequest } from '../models/index';
+import type { AddMarketOutcomeRequest, CreateMarketRequest, MarketLiquidityResponse, MarketResponse, MarketResultRequest, MarketUpdateResponse, PagedMarketPositionResponse, PagedOrderResponse, ToggleActionRequest, UpdateDateRequest, UpdateNameRequest } from '../models/index';
 export interface AddMarketOutcomeOperationRequest {
     authorization: string;
-    id: number;
+    id: string;
     addMarketOutcomeRequest: AddMarketOutcomeRequest;
 }
 export interface CreateMarketOperationRequest {
@@ -22,75 +22,96 @@ export interface CreateMarketOperationRequest {
 }
 export interface GetMarketRequest {
     authorization: string;
-    id: number;
+    id: string;
 }
 export interface GetMarketOrdersRequest {
     authorization: string;
-    id: number;
+    id: string;
     walletIds?: Array<string>;
-    pageRequest?: PageRequest;
+    page?: number;
+    size?: number;
+    sort?: Array<string>;
 }
-export interface GetMarketPositionsRequest {
+export interface GetMarketPositions1Request {
     authorization: string;
-    id: number;
+    id: string;
     walletIds?: Array<string>;
-    page?: PageRequest;
+    page?: number;
+    size?: number;
+    sort?: Array<string>;
 }
 export interface GetMarketPricesRequest {
     authorization: string;
-    id: number;
+    id: string;
 }
 export interface GetMarketsRequest {
     authorization: string;
-    ids?: Set<number>;
-    eventIds?: Set<number>;
-    v?: Set<string>;
+    ids?: Set<string>;
+    ownerAppIds?: Set<string>;
+    eventIds?: Set<string>;
+    marketTypeIds?: Set<string>;
     statuses?: Set<GetMarketsStatusesEnum>;
-    inPlay?: boolean;
+    inPlayStatuses?: Set<GetMarketsInPlayStatusesEnum>;
     fromDateTime?: Date;
     toDateTime?: Date;
+    published?: boolean;
 }
 export interface LockMarketRequest {
     authorization: string;
-    id: number;
+    id: string;
 }
 export interface OpenMarketRequest {
     authorization: string;
-    id: number;
+    id: string;
 }
 export interface PublishMarketRequest {
     authorization: string;
-    id: number;
+    id: string;
+    toggleActionRequest: ToggleActionRequest;
+}
+export interface SetCrossMatchingRequest {
+    authorization: string;
+    id: string;
     toggleActionRequest: ToggleActionRequest;
 }
 export interface SetResultsForMarketRequest {
     authorization: string;
-    id: number;
+    id: string;
     marketResultRequest: MarketResultRequest;
 }
 export interface SettleMarketRequest {
     authorization: string;
-    id: number;
+    id: string;
 }
 export interface SuspendMarketRequest {
     authorization: string;
-    id: number;
+    id: string;
     toggleActionRequest: ToggleActionRequest;
 }
+export interface UpdateMarketLockAtRequest {
+    authorization: string;
+    id: string;
+    updateDateRequest: UpdateDateRequest;
+}
+export interface UpdateMarketNameRequest {
+    authorization: string;
+    id: string;
+    updateNameRequest: UpdateNameRequest;
+}
 export interface VoidMarketRequest {
     authorization: string;
-    id: number;
+    id: string;
 }
 /**
  *
  */
-export declare class MonacoAPIMarketsApi extends runtime.BaseAPI {
+export declare class MarketsApi extends runtime.BaseAPI {
     /**
-     * Create market outcome
+     * Add a new market outcome to a market
      */
     addMarketOutcomeRaw(requestParameters: AddMarketOutcomeOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
     /**
-     * Create market outcome
+     * Add a new market outcome to a market
      */
     addMarketOutcome(requestParameters: AddMarketOutcomeOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
     /**
@@ -120,11 +141,11 @@ export declare class MonacoAPIMarketsApi extends runtime.BaseAPI {
     /**
      * Fetch market positions by wallets
      */
-    getMarketPositionsRaw(requestParameters: GetMarketPositionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PagedMarketPositionResponse>>;
+    getMarketPositions1Raw(requestParameters: GetMarketPositions1Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PagedMarketPositionResponse>>;
     /**
      * Fetch market positions by wallets
      */
-    getMarketPositions(requestParameters: GetMarketPositionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PagedMarketPositionResponse>;
+    getMarketPositions1(requestParameters: GetMarketPositions1Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PagedMarketPositionResponse>;
     /**
      * Fetch market prices
      */
@@ -165,6 +186,14 @@ export declare class MonacoAPIMarketsApi extends runtime.BaseAPI {
      * Publish market
      */
     publishMarket(requestParameters: PublishMarketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Set market results
+     */
+    setCrossMatchingRaw(requestParameters: SetCrossMatchingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Set market results
+     */
+    setCrossMatching(requestParameters: SetCrossMatchingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
     /**
      * Set market results
      */
@@ -189,6 +218,22 @@ export declare class MonacoAPIMarketsApi extends runtime.BaseAPI {
      * Suspend market
      */
     suspendMarket(requestParameters: SuspendMarketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Update the lock at date/time of a market
+     */
+    updateMarketLockAtRaw(requestParameters: UpdateMarketLockAtRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MarketUpdateResponse>>;
+    /**
+     * Update the lock at date/time of a market
+     */
+    updateMarketLockAt(requestParameters: UpdateMarketLockAtRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MarketUpdateResponse>;
+    /**
+     * Update the name of a market
+     */
+    updateMarketNameRaw(requestParameters: UpdateMarketNameRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MarketUpdateResponse>>;
+    /**
+     * Update the name of a market
+     */
+    updateMarketName(requestParameters: UpdateMarketNameRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MarketUpdateResponse>;
     /**
      * Void market
      */
@@ -212,3 +257,12 @@ export declare const GetMarketsStatusesEnum: {
     readonly Closed: "Closed";
 };
 export type GetMarketsStatusesEnum = typeof GetMarketsStatusesEnum[keyof typeof GetMarketsStatusesEnum];
+/**
+ * @export
+ */
+export declare const GetMarketsInPlayStatusesEnum: {
+    readonly NotApplicable: "NotApplicable";
+    readonly PrePlay: "PrePlay";
+    readonly InPlay: "InPlay";
+};
+export type GetMarketsInPlayStatusesEnum = typeof GetMarketsInPlayStatusesEnum[keyof typeof GetMarketsInPlayStatusesEnum];