@decibeltrade/sdk 0.1.4 → 0.1.6

package/dist/read/user-order-history/user-order-history.reader.js

@@ -1,28 +1,95 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserOrderHistoryReader = void 0;
-const base_reader_1 = require("../base-reader");
-const user_order_history_types_1 = require("./user-order-history.types");
-class UserOrderHistoryReader extends base_reader_1.BaseReader {
-    async getByAddr(subAddr) {
-        const response = await this.getRequest({
-            schema: user_order_history_types_1.UserOrdersSchema,
-            url: `${this.deps.config.tradingHttpUrl}/api/v1/order_history`,
-            queryParams: {
-                user: subAddr,
-            },
-        });
-        return response.data;
+var base_reader_1 = require("../base-reader");
+var user_order_history_types_1 = require("./user-order-history.types");
+var UserOrderHistoryReader = /** @class */ (function (_super) {
+    __extends(UserOrderHistoryReader, _super);
+    function UserOrderHistoryReader() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
+    UserOrderHistoryReader.prototype.getByAddr = function (_a) {
+        return __awaiter(this, arguments, void 0, function (_b) {
+            var response;
+            var subAddr = _b.subAddr, fetchOptions = _b.fetchOptions;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.getRequest({
+                            schema: user_order_history_types_1.UserOrdersSchema,
+                            url: "".concat(this.deps.config.tradingHttpUrl, "/api/v1/order_history"),
+                            queryParams: {
+                                user: subAddr,
+                            },
+                            options: fetchOptions,
+                        })];
+                    case 1:
+                        response = _c.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
     /**
      * Subscribe to user order history updates
      * @param subAddr The subaccount address of the user to subscribe to
      * @param onData Callback function for received user order history data
      * @returns A function to unsubscribe from the user order history updates
      */
-    subscribeByAddr(subAddr, onData) {
-        const topic = `user_order_history:${subAddr}`;
+    UserOrderHistoryReader.prototype.subscribeByAddr = function (subAddr, onData) {
+        var topic = "user_order_history:".concat(subAddr);
         return this.deps.ws.subscribe(topic, user_order_history_types_1.UserOrdersWsMessageSchema, onData);
-    }
-}
+    };
+    return UserOrderHistoryReader;
+}(base_reader_1.BaseReader));
 exports.UserOrderHistoryReader = UserOrderHistoryReader;

package/dist/read/user-order-history/user-order-history.types.d.ts

@@ -1,4 +1,8 @@
 import z from "zod/v4";
+import { BaseRequestArgs } from "../base-reader";
+export interface UserOrderHistoryRequestArgs extends BaseRequestArgs {
+    subAddr: string;
+}
 export declare const UserOrderSchema: z.ZodObject<{
     parent: z.ZodString;
     market: z.ZodString;

package/dist/read/user-order-history/user-order-history.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-order-history.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-order-history/user-order-history.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAIvB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;iBAwB1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA2C,CAAC;AAEzE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEpC,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}
+{"version":3,"file":"user-order-history.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-order-history/user-order-history.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,MAAM,WAAW,2BAA4B,SAAQ,eAAe;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;iBAwB1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA2C,CAAC;AAEzE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEpC,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/read/user-order-history/user-order-history.types.js

@@ -1,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserOrdersWsMessageSchema = exports.UserOrdersSchema = exports.UserOrderSchema = void 0;
-const v4_1 = __importDefault(require("zod/v4"));
-const pagination_types_1 = require("../pagination.types");
+var v4_1 = require("zod/v4");
+var pagination_types_1 = require("../pagination.types");
 exports.UserOrderSchema = v4_1.default.object({
     parent: v4_1.default.string(),
     market: v4_1.default.string(),

package/dist/read/user-positions/user-positions.reader.d.ts

@@ -1,5 +1,5 @@
 import { BaseReader } from "../base-reader";
-import { GetUserPositionsArgs, UserPositionsWsMessage } from "./user-positions.types";
+import { UserPositionsRequestArgs, UserPositionsWsMessage } from "./user-positions.types";
 export declare class UserPositionsReader extends BaseReader {
     /**
      * Get the positions for a given user
@@ -7,7 +7,7 @@ export declare class UserPositionsReader extends BaseReader {
      * @param includeDeleted Whether to include deleted positions in the response
      * @returns The positions for the given user
      */
-    getByAddr({ subAddr, marketAddr, includeDeleted, limit, }: GetUserPositionsArgs): Promise<{
+    getByAddr({ subAddr, marketAddr, includeDeleted, limit, fetchOptions, }: UserPositionsRequestArgs): Promise<{
         market: string;
         user: string;
         size: number;

package/dist/read/user-positions/user-positions.reader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-positions.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-positions/user-positions.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EACL,oBAAoB,EAEpB,sBAAsB,EAEvB,MAAM,wBAAwB,CAAC;AAEhC,qBAAa,mBAAoB,SAAQ,UAAU;IACjD;;;;;OAKG;IACG,SAAS,CAAC,EACd,OAAO,EACP,UAAU,EACV,cAAsB,EACtB,KAAU,GACX,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;IAoBvB;;;;;;OAMG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,sBAAsB,KAAK,IAAI;CAKhF"}
+{"version":3,"file":"user-positions.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-positions/user-positions.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EACL,wBAAwB,EAExB,sBAAsB,EAEvB,MAAM,wBAAwB,CAAC;AAEhC,qBAAa,mBAAoB,SAAQ,UAAU;IACjD;;;;;OAKG;IACG,SAAS,CAAC,EACd,OAAO,EACP,UAAU,EACV,cAAsB,EACtB,KAAU,EACV,YAAY,GACb,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;IAqB3B;;;;;;OAMG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,sBAAsB,KAAK,IAAI;CAKhF"}

package/dist/read/user-positions/user-positions.reader.js

@@ -1,31 +1,98 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserPositionsReader = void 0;
-const base_reader_1 = require("../base-reader");
-const user_positions_types_1 = require("./user-positions.types");
-class UserPositionsReader extends base_reader_1.BaseReader {
+var base_reader_1 = require("../base-reader");
+var user_positions_types_1 = require("./user-positions.types");
+var UserPositionsReader = /** @class */ (function (_super) {
+    __extends(UserPositionsReader, _super);
+    function UserPositionsReader() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
     /**
      * Get the positions for a given user
      * @param userAddr The address of the user to get positions for
      * @param includeDeleted Whether to include deleted positions in the response
      * @returns The positions for the given user
      */
-    async getByAddr({ subAddr, marketAddr, includeDeleted = false, limit = 10, }) {
-        const queryParams = new URLSearchParams({
-            user: subAddr,
-            include_deleted: includeDeleted.toString(),
-            limit: limit.toString(),
-        });
-        if (marketAddr) {
-            queryParams.set("market_address", marketAddr);
-        }
-        const response = await this.getRequest({
-            schema: user_positions_types_1.UserPositionsSchema,
-            url: `${this.deps.config.tradingHttpUrl}/api/v1/user_positions`,
-            queryParams,
+    UserPositionsReader.prototype.getByAddr = function (_a) {
+        return __awaiter(this, arguments, void 0, function (_b) {
+            var queryParams, response;
+            var subAddr = _b.subAddr, marketAddr = _b.marketAddr, _c = _b.includeDeleted, includeDeleted = _c === void 0 ? false : _c, _d = _b.limit, limit = _d === void 0 ? 10 : _d, fetchOptions = _b.fetchOptions;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        queryParams = new URLSearchParams({
+                            user: subAddr,
+                            include_deleted: includeDeleted.toString(),
+                            limit: limit.toString(),
+                        });
+                        if (marketAddr) {
+                            queryParams.set("market_address", marketAddr);
+                        }
+                        return [4 /*yield*/, this.getRequest({
+                                schema: user_positions_types_1.UserPositionsSchema,
+                                url: "".concat(this.deps.config.tradingHttpUrl, "/api/v1/user_positions"),
+                                queryParams: queryParams,
+                                options: fetchOptions,
+                            })];
+                    case 1:
+                        response = _e.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
         });
-        return response.data;
-    }
+    };
     /**
      * Subscribe to user positions updates
      * @param subAddr The subaccount address of the user to subscribe to
@@ -33,9 +100,10 @@ class UserPositionsReader extends base_reader_1.BaseReader {
      * @param onData Callback function for received user positions data
      * @returns A function to unsubscribe from the user positions updates
      */
-    subscribeByAddr(subAddr, onData) {
-        const topic = `user_positions:${subAddr}`;
+    UserPositionsReader.prototype.subscribeByAddr = function (subAddr, onData) {
+        var topic = "user_positions:".concat(subAddr);
         return this.deps.ws.subscribe(topic, user_positions_types_1.UserPositionsWsMessageSchema, onData);
-    }
-}
+    };
+    return UserPositionsReader;
+}(base_reader_1.BaseReader));
 exports.UserPositionsReader = UserPositionsReader;

package/dist/read/user-positions/user-positions.types.d.ts

@@ -1,5 +1,6 @@
 import z from "zod/v4";
-export interface GetUserPositionsArgs {
+import { BaseRequestArgs } from "../base-reader";
+export interface UserPositionsRequestArgs extends BaseRequestArgs {
     subAddr: string;
     marketAddr?: string;
     includeDeleted?: boolean;
@@ -61,9 +62,9 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         has_fixed_sized_tpsls: z.ZodBoolean;
     };
     keyof: () => z.ZodEnum<{
-        user: "user";
-        market: "market";
         size: "size";
+        market: "market";
+        user: "user";
         tp_order_id: "tp_order_id";
         tp_trigger_price: "tp_trigger_price";
         tp_limit_price: "tp_limit_price";
@@ -168,7 +169,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         sl_limit_price: z.ZodNullable<z.ZodNumber>;
         has_fixed_sized_tpsls: z.ZodBoolean;
     }, z.core.$strip>;
-    extend: <U extends z.core.$ZodLooseShape & Partial<Record<"user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls", z.core.SomeType>>>(shape: U) => z.ZodObject<(("user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls") & keyof U extends never ? {
+    extend: <U extends z.core.$ZodLooseShape & Partial<Record<"size" | "market" | "user" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls", z.core.SomeType>>>(shape: U) => z.ZodObject<(("size" | "market" | "user" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls") & keyof U extends never ? {
         market: z.ZodString;
         user: z.ZodString;
         size: z.ZodNumber;
@@ -203,7 +204,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         sl_limit_price: z.ZodNullable<z.ZodNumber>;
         has_fixed_sized_tpsls: z.ZodBoolean;
     } extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof U ? never : K]: T_1[K]; } : never) & { [K_1 in keyof U]: U[K_1]; }) extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
-    merge: <U extends z.ZodObject>(other: U) => z.ZodObject<(("user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls") & keyof U["shape"] extends never ? {
+    merge: <U extends z.ZodObject>(other: U) => z.ZodObject<(("size" | "market" | "user" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls") & keyof U["shape"] extends never ? {
         market: z.ZodString;
         user: z.ZodString;
         size: z.ZodNumber;
@@ -238,7 +239,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         sl_limit_price: z.ZodNullable<z.ZodNumber>;
         has_fixed_sized_tpsls: z.ZodBoolean;
     } extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof U["shape"] ? never : K]: T_1[K]; } : never) & (U["shape"] extends infer T_2 extends z.core.util.SomeObject ? { [K_1 in keyof T_2]: T_2[K_1]; } : never)) extends infer T ? { [k in keyof T]: T[k]; } : never, U["_zod"]["config"]>;
-    pick: <M extends z.core.util.Mask<"user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M) => z.ZodObject<Pick<{
+    pick: <M extends z.core.util.Mask<"size" | "market" | "user" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M) => z.ZodObject<Pick<{
         market: z.ZodString;
         user: z.ZodString;
         size: z.ZodNumber;
@@ -255,8 +256,8 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         sl_trigger_price: z.ZodNullable<z.ZodNumber>;
         sl_limit_price: z.ZodNullable<z.ZodNumber>;
         has_fixed_sized_tpsls: z.ZodBoolean;
-    }, Extract<"user", keyof M> | Extract<"market", keyof M> | Extract<"size", keyof M> | Extract<"tp_order_id", keyof M> | Extract<"tp_trigger_price", keyof M> | Extract<"tp_limit_price", keyof M> | Extract<"sl_order_id", keyof M> | Extract<"sl_trigger_price", keyof M> | Extract<"sl_limit_price", keyof M> | Extract<"max_allowed_leverage", keyof M> | Extract<"user_leverage", keyof M> | Extract<"entry_price", keyof M> | Extract<"is_isolated", keyof M> | Extract<"unrealized_funding", keyof M> | Extract<"estimated_liquidation_price", keyof M> | Extract<"has_fixed_sized_tpsls", keyof M>> extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
-    omit: <M extends z.core.util.Mask<"user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M) => z.ZodObject<Omit<{
+    }, Extract<"size", keyof M> | Extract<"market", keyof M> | Extract<"user", keyof M> | Extract<"tp_order_id", keyof M> | Extract<"tp_trigger_price", keyof M> | Extract<"tp_limit_price", keyof M> | Extract<"sl_order_id", keyof M> | Extract<"sl_trigger_price", keyof M> | Extract<"sl_limit_price", keyof M> | Extract<"max_allowed_leverage", keyof M> | Extract<"user_leverage", keyof M> | Extract<"entry_price", keyof M> | Extract<"is_isolated", keyof M> | Extract<"unrealized_funding", keyof M> | Extract<"estimated_liquidation_price", keyof M> | Extract<"has_fixed_sized_tpsls", keyof M>> extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
+    omit: <M extends z.core.util.Mask<"size" | "market" | "user" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M) => z.ZodObject<Omit<{
         market: z.ZodString;
         user: z.ZodString;
         size: z.ZodNumber;
@@ -273,7 +274,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         sl_trigger_price: z.ZodNullable<z.ZodNumber>;
         sl_limit_price: z.ZodNullable<z.ZodNumber>;
         has_fixed_sized_tpsls: z.ZodBoolean;
-    }, Extract<"user", keyof M> | Extract<"market", keyof M> | Extract<"size", keyof M> | Extract<"tp_order_id", keyof M> | Extract<"tp_trigger_price", keyof M> | Extract<"tp_limit_price", keyof M> | Extract<"sl_order_id", keyof M> | Extract<"sl_trigger_price", keyof M> | Extract<"sl_limit_price", keyof M> | Extract<"max_allowed_leverage", keyof M> | Extract<"user_leverage", keyof M> | Extract<"entry_price", keyof M> | Extract<"is_isolated", keyof M> | Extract<"unrealized_funding", keyof M> | Extract<"estimated_liquidation_price", keyof M> | Extract<"has_fixed_sized_tpsls", keyof M>> extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
+    }, Extract<"size", keyof M> | Extract<"market", keyof M> | Extract<"user", keyof M> | Extract<"tp_order_id", keyof M> | Extract<"tp_trigger_price", keyof M> | Extract<"tp_limit_price", keyof M> | Extract<"sl_order_id", keyof M> | Extract<"sl_trigger_price", keyof M> | Extract<"sl_limit_price", keyof M> | Extract<"max_allowed_leverage", keyof M> | Extract<"user_leverage", keyof M> | Extract<"entry_price", keyof M> | Extract<"is_isolated", keyof M> | Extract<"unrealized_funding", keyof M> | Extract<"estimated_liquidation_price", keyof M> | Extract<"has_fixed_sized_tpsls", keyof M>> extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
     partial: {
         (): z.ZodObject<{
             market: z.ZodOptional<z.ZodString>;
@@ -293,7 +294,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
             sl_limit_price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
             has_fixed_sized_tpsls: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>;
-        <M extends z.core.util.Mask<"user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M): z.ZodObject<{
+        <M extends z.core.util.Mask<"size" | "market" | "user" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M): z.ZodObject<{
             market: "market" extends infer T ? T extends "market" ? T extends keyof M ? z.ZodOptional<{
                 market: z.ZodString;
                 user: z.ZodString;
@@ -875,7 +876,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
             sl_limit_price: z.ZodNonOptional<z.ZodNullable<z.ZodNumber>>;
             has_fixed_sized_tpsls: z.ZodNonOptional<z.ZodBoolean>;
         }, z.core.$strip>;
-        <M extends z.core.util.Mask<"user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M): z.ZodObject<{
+        <M extends z.core.util.Mask<"size" | "market" | "user" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "max_allowed_leverage" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M): z.ZodObject<{
             market: "market" extends infer T ? T extends "market" ? T extends keyof M ? z.ZodNonOptional<{
                 market: z.ZodString;
                 user: z.ZodString;

package/dist/read/user-positions/user-positions.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-positions.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-positions/user-positions.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;iBAkB7B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;kBAA8B,CAAC;AAE/D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA+B,CAAC;AAExE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;iBAEvC,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}
+{"version":3,"file":"user-positions.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-positions/user-positions.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,MAAM,WAAW,wBAAyB,SAAQ,eAAe;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;iBAkB7B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;kBAA8B,CAAC;AAE/D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA+B,CAAC;AAExE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;iBAEvC,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/read/user-positions/user-positions.types.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserPositionsWsMessageSchema = exports.UserPositionWsMessageSchema = exports.UserPositionsSchema = exports.UserPositionSchema = void 0;
-const v4_1 = __importDefault(require("zod/v4"));
+var v4_1 = require("zod/v4");
 exports.UserPositionSchema = v4_1.default.object({
     market: v4_1.default.string(),
     user: v4_1.default.string(),

package/dist/read/user-subaccounts/user-subaccounts.reader.d.ts

@@ -1,5 +1,5 @@
 import { BaseReader } from "../base-reader";
-import { GetUserSubaccountsArgs } from "./user-subaccounts.types";
+import { UserSubaccountsRequestArgs } from "./user-subaccounts.types";
 export declare class UserSubaccountsReader extends BaseReader {
     /**
      * Get the subaccounts for a given user
@@ -7,7 +7,7 @@ export declare class UserSubaccountsReader extends BaseReader {
      * @param limit The number of subaccounts to get (default: 10)
      * @returns The subaccounts for the given user
      */
-    getByAddr({ ownerAddr, }: GetUserSubaccountsArgs): Promise<{
+    getByAddr({ ownerAddr, fetchOptions, }: UserSubaccountsRequestArgs): Promise<{
         subaccount_address: string;
         primary_account_address: string;
         is_primary: boolean;

package/dist/read/user-subaccounts/user-subaccounts.reader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-subaccounts.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-subaccounts/user-subaccounts.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,sBAAsB,EAAyB,MAAM,0BAA0B,CAAC;AAEzF,qBAAa,qBAAsB,SAAQ,UAAU;IACnD;;;;;OAKG;IACG,SAAS,CAAC,EACd,SAAS,GAEV,EAAE,sBAAsB;;;;;;;CAc1B"}
+{"version":3,"file":"user-subaccounts.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-subaccounts/user-subaccounts.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,0BAA0B,EAAyB,MAAM,0BAA0B,CAAC;AAE7F,qBAAa,qBAAsB,SAAQ,UAAU;IACnD;;;;;OAKG;IACG,SAAS,CAAC,EACd,SAAS,EAET,YAAY,GACb,EAAE,0BAA0B;;;;;;;CAe9B"}

package/dist/read/user-subaccounts/user-subaccounts.reader.js

@@ -1,28 +1,96 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserSubaccountsReader = void 0;
-const base_reader_1 = require("../base-reader");
-const user_subaccounts_types_1 = require("./user-subaccounts.types");
-class UserSubaccountsReader extends base_reader_1.BaseReader {
+var base_reader_1 = require("../base-reader");
+var user_subaccounts_types_1 = require("./user-subaccounts.types");
+var UserSubaccountsReader = /** @class */ (function (_super) {
+    __extends(UserSubaccountsReader, _super);
+    function UserSubaccountsReader() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
     /**
      * Get the subaccounts for a given user
      * @param ownerAddr The address of the owner to get subaccounts for
      * @param limit The number of subaccounts to get (default: 10)
      * @returns The subaccounts for the given user
      */
-    async getByAddr({ ownerAddr,
-    // limit = 10,
-     }) {
-        const queryParams = new URLSearchParams({
-            owner: ownerAddr,
-            // limit: limit.toString(),
+    UserSubaccountsReader.prototype.getByAddr = function (_a) {
+        return __awaiter(this, arguments, void 0, function (_b) {
+            var queryParams, response;
+            var ownerAddr = _b.ownerAddr, 
+            // limit = 10,
+            fetchOptions = _b.fetchOptions;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        queryParams = new URLSearchParams({
+                            owner: ownerAddr,
+                            // limit: limit.toString(),
+                        });
+                        return [4 /*yield*/, this.getRequest({
+                                schema: user_subaccounts_types_1.UserSubaccountsSchema,
+                                url: "".concat(this.deps.config.tradingHttpUrl, "/api/v1/subaccounts"), // TODO: update to /user_subaccounts?
+                                queryParams: queryParams,
+                                options: fetchOptions,
+                            })];
+                    case 1:
+                        response = _c.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
         });
-        const response = await this.getRequest({
-            schema: user_subaccounts_types_1.UserSubaccountsSchema,
-            url: `${this.deps.config.tradingHttpUrl}/api/v1/subaccounts`, // TODO: update to /user_subaccounts?
-            queryParams,
-        });
-        return response.data;
-    }
-}
+    };
+    return UserSubaccountsReader;
+}(base_reader_1.BaseReader));
 exports.UserSubaccountsReader = UserSubaccountsReader;

package/dist/read/user-subaccounts/user-subaccounts.types.d.ts

@@ -1,5 +1,6 @@
 import z from "zod/v4";
-export interface GetUserSubaccountsArgs {
+import { BaseRequestArgs } from "../base-reader";
+export interface UserSubaccountsRequestArgs extends BaseRequestArgs {
     ownerAddr: string;
 }
 export declare const UserSubaccountSchema: z.ZodObject<{

package/dist/read/user-subaccounts/user-subaccounts.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-subaccounts.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-subaccounts/user-subaccounts.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;CAEnB;AAED,eAAO,MAAM,oBAAoB;;;;;;iBAM/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;kBAAgC,CAAC;AAEnE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,eAAe,GAAG,cAAc,EAAE,CAAC"}
+{"version":3,"file":"user-subaccounts.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-subaccounts/user-subaccounts.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,MAAM,WAAW,0BAA2B,SAAQ,eAAe;IACjE,SAAS,EAAE,MAAM,CAAC;CAEnB;AAED,eAAO,MAAM,oBAAoB;;;;;;iBAM/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;kBAAgC,CAAC;AAEnE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,eAAe,GAAG,cAAc,EAAE,CAAC"}

package/dist/read/user-subaccounts/user-subaccounts.types.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserSubaccountsSchema = exports.UserSubaccountSchema = void 0;
-const v4_1 = __importDefault(require("zod/v4"));
+var v4_1 = require("zod/v4");
 exports.UserSubaccountSchema = v4_1.default.object({
     subaccount_address: v4_1.default.string(),
     primary_account_address: v4_1.default.string(),

package/dist/read/user-trade-history/user-trade-history.reader.d.ts

@@ -1,5 +1,5 @@
 import { BaseReader } from "../base-reader";
-import { UserTradesWsMessage } from "./user-trade-history.types";
+import { UserTradeHistoryRequestArgs, UserTradesWsMessage } from "./user-trade-history.types";
 export declare class UserTradeHistoryReader extends BaseReader {
     /**
      * Get the trade history for a given user
@@ -7,7 +7,7 @@ export declare class UserTradeHistoryReader extends BaseReader {
      * @param limit The number of trades to get (default: 10)
      * @returns The trade history for the given user
      */
-    getByAddr(subAddr: string, limit?: number): Promise<{
+    getByAddr({ subAddr, limit, fetchOptions }: UserTradeHistoryRequestArgs): Promise<{
         account: string;
         market: string;
         action: string;

package/dist/read/user-trade-history/user-trade-history.reader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-trade-history.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-trade-history/user-trade-history.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAEL,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAEpC,qBAAa,sBAAuB,SAAQ,UAAU;IACpD;;;;;OAKG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,SAAK;;;;;;;;;;;;;;;IAU3C;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI;CAK7E"}
+{"version":3,"file":"user-trade-history.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-trade-history/user-trade-history.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EACL,2BAA2B,EAE3B,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAEpC,qBAAa,sBAAuB,SAAQ,UAAU;IACpD;;;;;OAKG;IACG,SAAS,CAAC,EAAE,OAAO,EAAE,KAAU,EAAE,YAAY,EAAE,EAAE,2BAA2B;;;;;;;;;;;;;;;IAWlF;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI;CAK7E"}