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

package/README.md

@@ -1,46 +1,52 @@
-## @monaco-protocol/client-v2@0.1
+## @monaco-protocol/client-v2
 
-This generator creates TypeScript/JavaScript client that utilizes [Fetch API](https://fetch.spec.whatwg.org/). The generated Node module can be used in the following environments:
+Typescript client for Monaco Protocol API v2
 
-Environment
-* Node.js
-* Webpack
-* Browserify
+### Generating OpenAPI Client
 
-Language level
-* ES5 - you must have a Promises/A+ library installed
-* ES6
+To generate the OpenAPI client, run the following commands:
 
-Module system
-* CommonJS
-* ES6 module system
+```
+export $OPENAPI_URL # first export the OpenAPI URL
+yarn generate
+```
 
-It can be used in both TypeScript and JavaScript. In TypeScript, the definition will be automatically resolved via `package.json`. ([Reference](https://www.typescriptlang.org/docs/handbook/declaration-files/consumption.html))
+alternatively
+```
+OPENAPI_URL=https://docs.api.monacoprotocol.xyz/v1/exchange-openapi.json yarn generate
+```
 
-### Building
+### Releasing
 
-To build and compile the typescript sources to javascript use:
+Build, version and publish a new version using the `release` commands:
 ```
-npm install
-npm run build
+yarn release:dev    # yarn version:dev && yarn publish:dev
+yarn release:prod   # yarn version:prod && yarn publish:prod
 ```
 
-### Publishing
-
-First build the package then run `npm publish`
+Alternatively, use individual commands below
 
-### Consuming
+### Building
 
-navigate to the folder of your consuming project and run one of the following commands.
+Build and generate dist:
+```
+yarn build
+```
 
-_published:_
+### Versioning
 
+Bump the version using these commands, this creates a new commit in the repository:
 ```
-npm install @monaco-protocol/client-v2@0.1 --save
+yarn version:dev 
+yarn version:prod
 ```
 
-_unPublished (not recommended):_
+### Publishing
+
+Publish the package using:
 
 ```
-npm install PATH_TO_GENERATED_PACKAGE --save
+yarn publish:dev
+yarn publish:prod
 ```
+

package/dist/apis/{MonacoAPIAPIKeyManagementApi.d.ts → APIKeyManagementApi.d.ts}

@@ -11,7 +11,7 @@
  */
 import * as runtime from '../runtime';
 import type { APIKeyResponse, CreateAPIKeyRequest, DeactivateAPIKeyRequest, RenameAPIKeyRequest } from '../models/index';
-export interface Create5Request {
+export interface CreateApiKeyRequest {
     authorization: string;
     createAPIKeyRequest: CreateAPIKeyRequest;
 }
@@ -26,15 +26,15 @@ export interface RenameRequest {
 /**
  *
  */
-export declare class MonacoAPIAPIKeyManagementApi extends runtime.BaseAPI {
+export declare class APIKeyManagementApi extends runtime.BaseAPI {
     /**
      * Create api key
      */
-    create5Raw(requestParameters: Create5Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<APIKeyResponse>>;
+    createApiKeyRaw(requestParameters: CreateApiKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<APIKeyResponse>>;
     /**
      * Create api key
      */
-    create5(requestParameters: Create5Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<APIKeyResponse>;
+    createApiKey(requestParameters: CreateApiKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<APIKeyResponse>;
     /**
      * Deactivate api key
      */

package/dist/apis/{MonacoAPIAPIKeyManagementApi.js → APIKeyManagementApi.js}

@@ -22,23 +22,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonacoAPIAPIKeyManagementApi = void 0;
+exports.APIKeyManagementApi = void 0;
 const runtime = require("../runtime");
 const index_1 = require("../models/index");
 /**
  *
  */
-class MonacoAPIAPIKeyManagementApi extends runtime.BaseAPI {
+class APIKeyManagementApi extends runtime.BaseAPI {
     /**
      * Create api key
      */
-    create5Raw(requestParameters, initOverrides) {
+    createApiKeyRaw(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 create5().');
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling createApiKey().');
             }
             if (requestParameters['createAPIKeyRequest'] == null) {
-                throw new runtime.RequiredError('createAPIKeyRequest', 'Required parameter "createAPIKeyRequest" was null or undefined when calling create5().');
+                throw new runtime.RequiredError('createAPIKeyRequest', 'Required parameter "createAPIKeyRequest" was null or undefined when calling createApiKey().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -59,9 +59,9 @@ class MonacoAPIAPIKeyManagementApi extends runtime.BaseAPI {
     /**
      * Create api key
      */
-    create5(requestParameters, initOverrides) {
+    createApiKey(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.create5Raw(requestParameters, initOverrides);
+            const response = yield this.createApiKeyRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
@@ -138,4 +138,4 @@ class MonacoAPIAPIKeyManagementApi extends runtime.BaseAPI {
         });
     }
 }
-exports.MonacoAPIAPIKeyManagementApi = MonacoAPIAPIKeyManagementApi;
+exports.APIKeyManagementApi = APIKeyManagementApi;

package/dist/apis/{MonacoAPIAppManagementApi.d.ts → AppManagementApi.d.ts}

@@ -11,10 +11,10 @@
  */
 import * as runtime from '../runtime';
 import type { AppResponse, CommissionRateResponse, CreateAppRequest, UpdateAppCommissionRateRequest } from '../models/index';
-export interface Create4Request {
+export interface CreateAppOperationRequest {
     createAppRequest: CreateAppRequest;
 }
-export interface GetById4Request {
+export interface GetAppByIdRequest {
     authorization: string;
     id: string;
 }
@@ -30,23 +30,23 @@ export interface UpdateCommissionRateRequest {
 /**
  *
  */
-export declare class MonacoAPIAppManagementApi extends runtime.BaseAPI {
+export declare class AppManagementApi extends runtime.BaseAPI {
     /**
      * Create app
      */
-    create4Raw(requestParameters: Create4Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AppResponse>>;
+    createAppRaw(requestParameters: CreateAppOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AppResponse>>;
     /**
      * Create app
      */
-    create4(requestParameters: Create4Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AppResponse>;
+    createApp(requestParameters: CreateAppOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AppResponse>;
     /**
      * Fetch app by id
      */
-    getById4Raw(requestParameters: GetById4Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AppResponse>>;
+    getAppByIdRaw(requestParameters: GetAppByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AppResponse>>;
     /**
      * Fetch app by id
      */
-    getById4(requestParameters: GetById4Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AppResponse>;
+    getAppById(requestParameters: GetAppByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AppResponse>;
     /**
      * Fetch commission rates
      */

package/dist/apis/{MonacoAPIAppManagementApi.js → AppManagementApi.js}

@@ -22,20 +22,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonacoAPIAppManagementApi = void 0;
+exports.AppManagementApi = void 0;
 const runtime = require("../runtime");
 const index_1 = require("../models/index");
 /**
  *
  */
-class MonacoAPIAppManagementApi extends runtime.BaseAPI {
+class AppManagementApi extends runtime.BaseAPI {
     /**
      * Create app
      */
-    create4Raw(requestParameters, initOverrides) {
+    createAppRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['createAppRequest'] == null) {
-                throw new runtime.RequiredError('createAppRequest', 'Required parameter "createAppRequest" was null or undefined when calling create4().');
+                throw new runtime.RequiredError('createAppRequest', 'Required parameter "createAppRequest" was null or undefined when calling createApp().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -53,22 +53,22 @@ class MonacoAPIAppManagementApi extends runtime.BaseAPI {
     /**
      * Create app
      */
-    create4(requestParameters, initOverrides) {
+    createApp(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.create4Raw(requestParameters, initOverrides);
+            const response = yield this.createAppRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
      * Fetch app by id
      */
-    getById4Raw(requestParameters, initOverrides) {
+    getAppByIdRaw(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 getById4().');
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling getAppById().');
             }
             if (requestParameters['id'] == null) {
-                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getById4().');
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getAppById().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -87,9 +87,9 @@ class MonacoAPIAppManagementApi extends runtime.BaseAPI {
     /**
      * Fetch app by id
      */
-    getById4(requestParameters, initOverrides) {
+    getAppById(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.getById4Raw(requestParameters, initOverrides);
+            const response = yield this.getAppByIdRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
@@ -167,4 +167,4 @@ class MonacoAPIAppManagementApi extends runtime.BaseAPI {
         });
     }
 }
-exports.MonacoAPIAppManagementApi = MonacoAPIAppManagementApi;
+exports.AppManagementApi = AppManagementApi;

package/dist/apis/{MonacoAPICurrenciesApi.d.ts → CurrenciesApi.d.ts}

@@ -14,14 +14,14 @@ import type { CurrencyResponse } from '../models/index';
 export interface CurrenciesRequest {
     authorization: string;
 }
-export interface GetById2Request {
+export interface GetCurrencyByIdRequest {
     authorization: string;
-    id: number;
+    id: string;
 }
 /**
  *
  */
-export declare class MonacoAPICurrenciesApi extends runtime.BaseAPI {
+export declare class CurrenciesApi extends runtime.BaseAPI {
     /**
      * Returns the list of currencies supported by the exchange
      * Fetch a list of supported currencies
@@ -36,10 +36,10 @@ export declare class MonacoAPICurrenciesApi extends runtime.BaseAPI {
      * Returns the currency or 404
      * Fetch currency by its ID
      */
-    getById2Raw(requestParameters: GetById2Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CurrencyResponse>>;
+    getCurrencyByIdRaw(requestParameters: GetCurrencyByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CurrencyResponse>>;
     /**
      * Returns the currency or 404
      * Fetch currency by its ID
      */
-    getById2(requestParameters: GetById2Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CurrencyResponse>;
+    getCurrencyById(requestParameters: GetCurrencyByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CurrencyResponse>;
 }

package/dist/apis/{MonacoAPICurrenciesApi.js → CurrenciesApi.js}

@@ -22,13 +22,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonacoAPICurrenciesApi = void 0;
+exports.CurrenciesApi = void 0;
 const runtime = require("../runtime");
 const index_1 = require("../models/index");
 /**
  *
  */
-class MonacoAPICurrenciesApi extends runtime.BaseAPI {
+class CurrenciesApi extends runtime.BaseAPI {
     /**
      * Returns the list of currencies supported by the exchange
      * Fetch a list of supported currencies
@@ -66,13 +66,13 @@ class MonacoAPICurrenciesApi extends runtime.BaseAPI {
      * Returns the currency or 404
      * Fetch currency by its ID
      */
-    getById2Raw(requestParameters, initOverrides) {
+    getCurrencyByIdRaw(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 getById2().');
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling getCurrencyById().');
             }
             if (requestParameters['id'] == null) {
-                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getById2().');
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getCurrencyById().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -92,11 +92,11 @@ class MonacoAPICurrenciesApi extends runtime.BaseAPI {
      * Returns the currency or 404
      * Fetch currency by its ID
      */
-    getById2(requestParameters, initOverrides) {
+    getCurrencyById(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.getById2Raw(requestParameters, initOverrides);
+            const response = yield this.getCurrencyByIdRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
 }
-exports.MonacoAPICurrenciesApi = MonacoAPICurrenciesApi;
+exports.CurrenciesApi = CurrenciesApi;

package/dist/apis/EventCategoriesApi.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 { Category, CategoryResponse, CreateCategoryRequest } from '../models/index';
+export interface CreateCategoryOperationRequest {
+    authorization: string;
+    createCategoryRequest: CreateCategoryRequest;
+}
+export interface GetAllCategoriesRequest {
+    authorization: string;
+}
+export interface GetCategoryByIdRequest {
+    authorization: string;
+    id: string;
+}
+/**
+ *
+ */
+export declare class EventCategoriesApi extends runtime.BaseAPI {
+    /**
+     * Create event category
+     */
+    createCategoryRaw(requestParameters: CreateCategoryOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Category>>;
+    /**
+     * Create event category
+     */
+    createCategory(requestParameters: CreateCategoryOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Category>;
+    /**
+     * Fetch all event categories
+     */
+    getAllCategoriesRaw(requestParameters: GetAllCategoriesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CategoryResponse>>;
+    /**
+     * Fetch all event categories
+     */
+    getAllCategories(requestParameters: GetAllCategoriesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CategoryResponse>;
+    /**
+     * Fetch event category by id
+     */
+    getCategoryByIdRaw(requestParameters: GetCategoryByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CategoryResponse>>;
+    /**
+     * Fetch event category by id
+     */
+    getCategoryById(requestParameters: GetCategoryByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CategoryResponse>;
+}

package/dist/apis/{MonacoAPIEventCategoriesApi.js → EventCategoriesApi.js}

@@ -22,23 +22,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonacoAPIEventCategoriesApi = void 0;
+exports.EventCategoriesApi = void 0;
 const runtime = require("../runtime");
 const index_1 = require("../models/index");
 /**
  *
  */
-class MonacoAPIEventCategoriesApi extends runtime.BaseAPI {
+class EventCategoriesApi extends runtime.BaseAPI {
     /**
      * Create event category
      */
-    create3Raw(requestParameters, initOverrides) {
+    createCategoryRaw(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 create3().');
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling createCategory().');
             }
             if (requestParameters['createCategoryRequest'] == null) {
-                throw new runtime.RequiredError('createCategoryRequest', 'Required parameter "createCategoryRequest" was null or undefined when calling create3().');
+                throw new runtime.RequiredError('createCategoryRequest', 'Required parameter "createCategoryRequest" was null or undefined when calling createCategory().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -59,19 +59,19 @@ class MonacoAPIEventCategoriesApi extends runtime.BaseAPI {
     /**
      * Create event category
      */
-    create3(requestParameters, initOverrides) {
+    createCategory(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.create3Raw(requestParameters, initOverrides);
+            const response = yield this.createCategoryRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
      * Fetch all event categories
      */
-    getAll2Raw(requestParameters, initOverrides) {
+    getAllCategoriesRaw(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 getAll2().');
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling getAllCategories().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -90,22 +90,22 @@ class MonacoAPIEventCategoriesApi extends runtime.BaseAPI {
     /**
      * Fetch all event categories
      */
-    getAll2(requestParameters, initOverrides) {
+    getAllCategories(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.getAll2Raw(requestParameters, initOverrides);
+            const response = yield this.getAllCategoriesRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
      * Fetch event category by id
      */
-    getById3Raw(requestParameters, initOverrides) {
+    getCategoryByIdRaw(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 getById3().');
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling getCategoryById().');
             }
             if (requestParameters['id'] == null) {
-                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getById3().');
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getCategoryById().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -124,11 +124,11 @@ class MonacoAPIEventCategoriesApi extends runtime.BaseAPI {
     /**
      * Fetch event category by id
      */
-    getById3(requestParameters, initOverrides) {
+    getCategoryById(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.getById3Raw(requestParameters, initOverrides);
+            const response = yield this.getCategoryByIdRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
 }
-exports.MonacoAPIEventCategoriesApi = MonacoAPIEventCategoriesApi;
+exports.EventCategoriesApi = EventCategoriesApi;

package/dist/apis/EventGroupsApi.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 { CreateEventGroupRequest, EventGroupResponse } from '../models/index';
+export interface CreateEventGroupOperationRequest {
+    authorization: string;
+    createEventGroupRequest: CreateEventGroupRequest;
+}
+export interface GetAllEventGroupsRequest {
+    authorization: string;
+    subcategoryIds?: Set<string>;
+}
+export interface GetEventGroupByIdRequest {
+    authorization: string;
+    id: string;
+}
+/**
+ *
+ */
+export declare class EventGroupsApi extends runtime.BaseAPI {
+    /**
+     * Create event group
+     */
+    createEventGroupRaw(requestParameters: CreateEventGroupOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EventGroupResponse>>;
+    /**
+     * Create event group
+     */
+    createEventGroup(requestParameters: CreateEventGroupOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EventGroupResponse>;
+    /**
+     * Fetch all event groups
+     */
+    getAllEventGroupsRaw(requestParameters: GetAllEventGroupsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EventGroupResponse>>;
+    /**
+     * Fetch all event groups
+     */
+    getAllEventGroups(requestParameters: GetAllEventGroupsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EventGroupResponse>;
+    /**
+     * Fetch event group by id
+     */
+    getEventGroupByIdRaw(requestParameters: GetEventGroupByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EventGroupResponse>>;
+    /**
+     * Fetch event group by id
+     */
+    getEventGroupById(requestParameters: GetEventGroupByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EventGroupResponse>;
+}

package/dist/apis/{MonacoAPIEventGroupsApi.js → EventGroupsApi.js}

@@ -22,23 +22,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonacoAPIEventGroupsApi = void 0;
+exports.EventGroupsApi = void 0;
 const runtime = require("../runtime");
 const index_1 = require("../models/index");
 /**
  *
  */
-class MonacoAPIEventGroupsApi extends runtime.BaseAPI {
+class EventGroupsApi extends runtime.BaseAPI {
     /**
      * Create event group
      */
-    create2Raw(requestParameters, initOverrides) {
+    createEventGroupRaw(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 create2().');
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling createEventGroup().');
             }
             if (requestParameters['createEventGroupRequest'] == null) {
-                throw new runtime.RequiredError('createEventGroupRequest', 'Required parameter "createEventGroupRequest" was null or undefined when calling create2().');
+                throw new runtime.RequiredError('createEventGroupRequest', 'Required parameter "createEventGroupRequest" was null or undefined when calling createEventGroup().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -59,19 +59,19 @@ class MonacoAPIEventGroupsApi extends runtime.BaseAPI {
     /**
      * Create event group
      */
-    create2(requestParameters, initOverrides) {
+    createEventGroup(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.create2Raw(requestParameters, initOverrides);
+            const response = yield this.createEventGroupRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
-     * Fethc all event groups
+     * Fetch all event groups
      */
-    getAll1Raw(requestParameters, initOverrides) {
+    getAllEventGroupsRaw(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 getAll1().');
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling getAllEventGroups().');
             }
             const queryParameters = {};
             if (requestParameters['subcategoryIds'] != null) {
@@ -91,24 +91,24 @@ class MonacoAPIEventGroupsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Fethc all event groups
+     * Fetch all event groups
      */
-    getAll1(requestParameters, initOverrides) {
+    getAllEventGroups(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.getAll1Raw(requestParameters, initOverrides);
+            const response = yield this.getAllEventGroupsRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
      * Fetch event group by id
      */
-    getById1Raw(requestParameters, initOverrides) {
+    getEventGroupByIdRaw(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 getById1().');
+                throw new runtime.RequiredError('authorization', 'Required parameter "authorization" was null or undefined when calling getEventGroupById().');
             }
             if (requestParameters['id'] == null) {
-                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getById1().');
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getEventGroupById().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -127,11 +127,11 @@ class MonacoAPIEventGroupsApi extends runtime.BaseAPI {
     /**
      * Fetch event group by id
      */
-    getById1(requestParameters, initOverrides) {
+    getEventGroupById(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.getById1Raw(requestParameters, initOverrides);
+            const response = yield this.getEventGroupByIdRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
 }
-exports.MonacoAPIEventGroupsApi = MonacoAPIEventGroupsApi;
+exports.EventGroupsApi = EventGroupsApi;