zklighter-perps 1.0.28 → 1.0.30

package/apis/OrderApi.ts

@@ -40,49 +40,49 @@ import {
     TradesToJSON,
 } from '../models/index';
 
-export interface GetAccountActiveOrdersRequest {
+export interface AccountActiveOrdersRequest {
     account_index: number;
     market_id: number;
 }
 
-export interface GetAccountInactiveOrdersRequest {
+export interface AccountInactiveOrdersRequest {
     account_index: number;
-    filter: GetAccountInactiveOrdersFilterEnum;
+    filter: AccountInactiveOrdersFilterEnum;
     limit: number;
     market_id?: number;
     cursor?: string;
 }
 
-export interface GetAccountOrdersRequest {
+export interface AccountOrdersRequest {
     account_index: number;
     market_id: number;
     limit: number;
     cursor?: string;
 }
 
-export interface GetOrderBookDetailsRequest {
-    filter: GetOrderBookDetailsFilterEnum;
+export interface OrderBookDetailsRequest {
+    filter: OrderBookDetailsFilterEnum;
     market_id?: number;
 }
 
-export interface GetOrderBookOrdersRequest {
+export interface OrderBookOrdersRequest {
     market_id: number;
     limit: number;
 }
 
-export interface GetOrderBooksRequest {
-    filter: GetOrderBooksFilterEnum;
+export interface OrderBooksRequest {
+    filter: OrderBooksFilterEnum;
     market_id?: number;
 }
 
-export interface GetRecentTradesRequest {
+export interface RecentTradesRequest {
     market_id: number;
     limit: number;
 }
 
-export interface GetTradesRequest {
+export interface TradesRequest {
     market_id: number;
-    by: GetTradesByEnum;
+    by: TradesByEnum;
     from: number;
     limit: number;
     order_index?: number;
@@ -95,20 +95,20 @@ export class OrderApi extends runtime.BaseAPI {
 
     /**
      * Get account active orders
-     * GetAccountActiveOrders
+     * accountActiveOrders
      */
-    async getAccountActiveOrdersRaw(requestParameters: GetAccountActiveOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Orders>> {
+    async accountActiveOrdersRaw(requestParameters: AccountActiveOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Orders>> {
         if (requestParameters['account_index'] == null) {
             throw new runtime.RequiredError(
                 'account_index',
-                'Required parameter "account_index" was null or undefined when calling getAccountActiveOrders().'
+                'Required parameter "account_index" was null or undefined when calling accountActiveOrders().'
             );
         }
 
         if (requestParameters['market_id'] == null) {
             throw new runtime.RequiredError(
                 'market_id',
-                'Required parameter "market_id" was null or undefined when calling getAccountActiveOrders().'
+                'Required parameter "market_id" was null or undefined when calling accountActiveOrders().'
             );
         }
 
@@ -136,36 +136,36 @@ export class OrderApi extends runtime.BaseAPI {
 
     /**
      * Get account active orders
-     * GetAccountActiveOrders
+     * accountActiveOrders
      */
-    async getAccountActiveOrders(requestParameters: GetAccountActiveOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Orders> {
-        const response = await this.getAccountActiveOrdersRaw(requestParameters, initOverrides);
+    async accountActiveOrders(requestParameters: AccountActiveOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Orders> {
+        const response = await this.accountActiveOrdersRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get account active orders
-     * GetAccountInactiveOrders
+     * accountInactiveOrders
      */
-    async getAccountInactiveOrdersRaw(requestParameters: GetAccountInactiveOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Orders>> {
+    async accountInactiveOrdersRaw(requestParameters: AccountInactiveOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Orders>> {
         if (requestParameters['account_index'] == null) {
             throw new runtime.RequiredError(
                 'account_index',
-                'Required parameter "account_index" was null or undefined when calling getAccountInactiveOrders().'
+                'Required parameter "account_index" was null or undefined when calling accountInactiveOrders().'
             );
         }
 
         if (requestParameters['filter'] == null) {
             throw new runtime.RequiredError(
                 'filter',
-                'Required parameter "filter" was null or undefined when calling getAccountInactiveOrders().'
+                'Required parameter "filter" was null or undefined when calling accountInactiveOrders().'
             );
         }
 
         if (requestParameters['limit'] == null) {
             throw new runtime.RequiredError(
                 'limit',
-                'Required parameter "limit" was null or undefined when calling getAccountInactiveOrders().'
+                'Required parameter "limit" was null or undefined when calling accountInactiveOrders().'
             );
         }
 
@@ -205,36 +205,36 @@ export class OrderApi extends runtime.BaseAPI {
 
     /**
      * Get account active orders
-     * GetAccountInactiveOrders
+     * accountInactiveOrders
      */
-    async getAccountInactiveOrders(requestParameters: GetAccountInactiveOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Orders> {
-        const response = await this.getAccountInactiveOrdersRaw(requestParameters, initOverrides);
+    async accountInactiveOrders(requestParameters: AccountInactiveOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Orders> {
+        const response = await this.accountInactiveOrdersRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get account orders
-     * GetAccountOrders
+     * accountOrders
      */
-    async getAccountOrdersRaw(requestParameters: GetAccountOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Orders>> {
+    async accountOrdersRaw(requestParameters: AccountOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Orders>> {
         if (requestParameters['account_index'] == null) {
             throw new runtime.RequiredError(
                 'account_index',
-                'Required parameter "account_index" was null or undefined when calling getAccountOrders().'
+                'Required parameter "account_index" was null or undefined when calling accountOrders().'
             );
         }
 
         if (requestParameters['market_id'] == null) {
             throw new runtime.RequiredError(
                 'market_id',
-                'Required parameter "market_id" was null or undefined when calling getAccountOrders().'
+                'Required parameter "market_id" was null or undefined when calling accountOrders().'
             );
         }
 
         if (requestParameters['limit'] == null) {
             throw new runtime.RequiredError(
                 'limit',
-                'Required parameter "limit" was null or undefined when calling getAccountOrders().'
+                'Required parameter "limit" was null or undefined when calling accountOrders().'
             );
         }
 
@@ -270,18 +270,18 @@ export class OrderApi extends runtime.BaseAPI {
 
     /**
      * Get account orders
-     * GetAccountOrders
+     * accountOrders
      */
-    async getAccountOrders(requestParameters: GetAccountOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Orders> {
-        const response = await this.getAccountOrdersRaw(requestParameters, initOverrides);
+    async accountOrders(requestParameters: AccountOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Orders> {
+        const response = await this.accountOrdersRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get exchange stats
-     * GetExchangeStats
+     * exchangeStats
      */
-    async getExchangeStatsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ExchangeStats>> {
+    async exchangeStatsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ExchangeStats>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -298,22 +298,22 @@ export class OrderApi extends runtime.BaseAPI {
 
     /**
      * Get exchange stats
-     * GetExchangeStats
+     * exchangeStats
      */
-    async getExchangeStats(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ExchangeStats> {
-        const response = await this.getExchangeStatsRaw(initOverrides);
+    async exchangeStats(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ExchangeStats> {
+        const response = await this.exchangeStatsRaw(initOverrides);
         return await response.value();
     }
 
     /**
      * Get order books metadata
-     * GetOrderBookDetails
+     * orderBookDetails
      */
-    async getOrderBookDetailsRaw(requestParameters: GetOrderBookDetailsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OrderBookDetails>> {
+    async orderBookDetailsRaw(requestParameters: OrderBookDetailsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OrderBookDetails>> {
         if (requestParameters['filter'] == null) {
             throw new runtime.RequiredError(
                 'filter',
-                'Required parameter "filter" was null or undefined when calling getOrderBookDetails().'
+                'Required parameter "filter" was null or undefined when calling orderBookDetails().'
             );
         }
 
@@ -341,29 +341,29 @@ export class OrderApi extends runtime.BaseAPI {
 
     /**
      * Get order books metadata
-     * GetOrderBookDetails
+     * orderBookDetails
      */
-    async getOrderBookDetails(requestParameters: GetOrderBookDetailsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OrderBookDetails> {
-        const response = await this.getOrderBookDetailsRaw(requestParameters, initOverrides);
+    async orderBookDetails(requestParameters: OrderBookDetailsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OrderBookDetails> {
+        const response = await this.orderBookDetailsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get order book orders
-     * GetOrderBookOrders
+     * orderBookOrders
      */
-    async getOrderBookOrdersRaw(requestParameters: GetOrderBookOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OrderBookOrders>> {
+    async orderBookOrdersRaw(requestParameters: OrderBookOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OrderBookOrders>> {
         if (requestParameters['market_id'] == null) {
             throw new runtime.RequiredError(
                 'market_id',
-                'Required parameter "market_id" was null or undefined when calling getOrderBookOrders().'
+                'Required parameter "market_id" was null or undefined when calling orderBookOrders().'
             );
         }
 
         if (requestParameters['limit'] == null) {
             throw new runtime.RequiredError(
                 'limit',
-                'Required parameter "limit" was null or undefined when calling getOrderBookOrders().'
+                'Required parameter "limit" was null or undefined when calling orderBookOrders().'
             );
         }
 
@@ -391,22 +391,22 @@ export class OrderApi extends runtime.BaseAPI {
 
     /**
      * Get order book orders
-     * GetOrderBookOrders
+     * orderBookOrders
      */
-    async getOrderBookOrders(requestParameters: GetOrderBookOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OrderBookOrders> {
-        const response = await this.getOrderBookOrdersRaw(requestParameters, initOverrides);
+    async orderBookOrders(requestParameters: OrderBookOrdersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OrderBookOrders> {
+        const response = await this.orderBookOrdersRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get order books metadata
-     * GetOrderBooks
+     * Get order books metadata.<hr>**Response Description:**<br><br>1) **Taker and maker fees** are in percentage.<br>2) **Min base amount:** The amount of base token that can be traded in a single order.<br>3) **Min quote amount:** The amount of quote token that can be traded in a single order.<br>4) **Supported size decimals:** The number of decimal places that can be used for the size of the order.<br>5) **Supported price decimals:** The number of decimal places that can be used for the price of the order.<br>6) **Supported quote decimals:** Size Decimals + Quote Decimals.
+     * orderBooks
      */
-    async getOrderBooksRaw(requestParameters: GetOrderBooksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OrderBooks>> {
+    async orderBooksRaw(requestParameters: OrderBooksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OrderBooks>> {
         if (requestParameters['filter'] == null) {
             throw new runtime.RequiredError(
                 'filter',
-                'Required parameter "filter" was null or undefined when calling getOrderBooks().'
+                'Required parameter "filter" was null or undefined when calling orderBooks().'
             );
         }
 
@@ -433,30 +433,30 @@ export class OrderApi extends runtime.BaseAPI {
     }
 
     /**
-     * Get order books metadata
-     * GetOrderBooks
+     * Get order books metadata.<hr>**Response Description:**<br><br>1) **Taker and maker fees** are in percentage.<br>2) **Min base amount:** The amount of base token that can be traded in a single order.<br>3) **Min quote amount:** The amount of quote token that can be traded in a single order.<br>4) **Supported size decimals:** The number of decimal places that can be used for the size of the order.<br>5) **Supported price decimals:** The number of decimal places that can be used for the price of the order.<br>6) **Supported quote decimals:** Size Decimals + Quote Decimals.
+     * orderBooks
      */
-    async getOrderBooks(requestParameters: GetOrderBooksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OrderBooks> {
-        const response = await this.getOrderBooksRaw(requestParameters, initOverrides);
+    async orderBooks(requestParameters: OrderBooksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OrderBooks> {
+        const response = await this.orderBooksRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get recent trades
-     * GetRecentTrades
+     * recentTrades
      */
-    async getRecentTradesRaw(requestParameters: GetRecentTradesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Trades>> {
+    async recentTradesRaw(requestParameters: RecentTradesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Trades>> {
         if (requestParameters['market_id'] == null) {
             throw new runtime.RequiredError(
                 'market_id',
-                'Required parameter "market_id" was null or undefined when calling getRecentTrades().'
+                'Required parameter "market_id" was null or undefined when calling recentTrades().'
             );
         }
 
         if (requestParameters['limit'] == null) {
             throw new runtime.RequiredError(
                 'limit',
-                'Required parameter "limit" was null or undefined when calling getRecentTrades().'
+                'Required parameter "limit" was null or undefined when calling recentTrades().'
             );
         }
 
@@ -484,43 +484,43 @@ export class OrderApi extends runtime.BaseAPI {
 
     /**
      * Get recent trades
-     * GetRecentTrades
+     * recentTrades
      */
-    async getRecentTrades(requestParameters: GetRecentTradesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Trades> {
-        const response = await this.getRecentTradesRaw(requestParameters, initOverrides);
+    async recentTrades(requestParameters: RecentTradesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Trades> {
+        const response = await this.recentTradesRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get trades
-     * GetTrades
+     * trades
      */
-    async getTradesRaw(requestParameters: GetTradesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Trades>> {
+    async tradesRaw(requestParameters: TradesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Trades>> {
         if (requestParameters['market_id'] == null) {
             throw new runtime.RequiredError(
                 'market_id',
-                'Required parameter "market_id" was null or undefined when calling getTrades().'
+                'Required parameter "market_id" was null or undefined when calling trades().'
             );
         }
 
         if (requestParameters['by'] == null) {
             throw new runtime.RequiredError(
                 'by',
-                'Required parameter "by" was null or undefined when calling getTrades().'
+                'Required parameter "by" was null or undefined when calling trades().'
             );
         }
 
         if (requestParameters['from'] == null) {
             throw new runtime.RequiredError(
                 'from',
-                'Required parameter "from" was null or undefined when calling getTrades().'
+                'Required parameter "from" was null or undefined when calling trades().'
             );
         }
 
         if (requestParameters['limit'] == null) {
             throw new runtime.RequiredError(
                 'limit',
-                'Required parameter "limit" was null or undefined when calling getTrades().'
+                'Required parameter "limit" was null or undefined when calling trades().'
             );
         }
 
@@ -560,10 +560,10 @@ export class OrderApi extends runtime.BaseAPI {
 
     /**
      * Get trades
-     * GetTrades
+     * trades
      */
-    async getTrades(requestParameters: GetTradesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Trades> {
-        const response = await this.getTradesRaw(requestParameters, initOverrides);
+    async trades(requestParameters: TradesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Trades> {
+        const response = await this.tradesRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -572,33 +572,33 @@ export class OrderApi extends runtime.BaseAPI {
 /**
  * @export
  */
-export const GetAccountInactiveOrdersFilterEnum = {
+export const AccountInactiveOrdersFilterEnum = {
     MarketId: 'market_id',
     All: 'all'
 } as const;
-export type GetAccountInactiveOrdersFilterEnum = typeof GetAccountInactiveOrdersFilterEnum[keyof typeof GetAccountInactiveOrdersFilterEnum];
+export type AccountInactiveOrdersFilterEnum = typeof AccountInactiveOrdersFilterEnum[keyof typeof AccountInactiveOrdersFilterEnum];
 /**
  * @export
  */
-export const GetOrderBookDetailsFilterEnum = {
+export const OrderBookDetailsFilterEnum = {
     MarketId: 'market_id',
     All: 'all'
 } as const;
-export type GetOrderBookDetailsFilterEnum = typeof GetOrderBookDetailsFilterEnum[keyof typeof GetOrderBookDetailsFilterEnum];
+export type OrderBookDetailsFilterEnum = typeof OrderBookDetailsFilterEnum[keyof typeof OrderBookDetailsFilterEnum];
 /**
  * @export
  */
-export const GetOrderBooksFilterEnum = {
+export const OrderBooksFilterEnum = {
     MarketId: 'market_id',
     All: 'all'
 } as const;
-export type GetOrderBooksFilterEnum = typeof GetOrderBooksFilterEnum[keyof typeof GetOrderBooksFilterEnum];
+export type OrderBooksFilterEnum = typeof OrderBooksFilterEnum[keyof typeof OrderBooksFilterEnum];
 /**
  * @export
  */
-export const GetTradesByEnum = {
+export const TradesByEnum = {
     BlockHeight: 'block_height',
     Timestamp: 'timestamp',
     TradeId: 'trade_id'
 } as const;
-export type GetTradesByEnum = typeof GetTradesByEnum[keyof typeof GetTradesByEnum];
+export type TradesByEnum = typeof TradesByEnum[keyof typeof TradesByEnum];

package/apis/RootApi.ts

@@ -32,9 +32,9 @@ export class RootApi extends runtime.BaseAPI {
 
     /**
      * Get status of zklighter
-     * GetStatus
+     * status
      */
-    async getStatusRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Status>> {
+    async statusRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Status>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -51,10 +51,10 @@ export class RootApi extends runtime.BaseAPI {
 
     /**
      * Get status of zklighter
-     * GetStatus
+     * status
      */
-    async getStatus(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Status> {
-        const response = await this.getStatusRaw(initOverrides);
+    async status(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Status> {
+        const response = await this.statusRaw(initOverrides);
         return await response.value();
     }