@pear-protocol/types 0.0.20 → 0.1.0

package/dist/admin/client-ids/entities.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const ClientIdEntity: z.ZodObject<{
+    id: z.ZodUUID;
+    code: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodBoolean;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type ClientIdEntity = z.output<typeof ClientIdEntity>;

package/dist/admin/client-ids/entities.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+const ClientIdEntity = z.object({
+  id: z.uuid(),
+  code: z.string(),
+  label: z.string(),
+  description: z.string().optional(),
+  isActive: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+}).describe("Client ID registry entry");
+
+export { ClientIdEntity };

package/dist/admin/client-ids/index.d.ts

@@ -0,0 +1,4 @@
+export * from './entities';
+export * from './payloads';
+export * from './queries';
+export * from './responses';

package/dist/admin/client-ids/index.js

@@ -0,0 +1,4 @@
+export * from './entities';
+export * from './payloads';
+export * from './queries';
+export * from './responses';

package/dist/admin/client-ids/payloads.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const CreateClientIdPayload: z.ZodObject<{
+    code: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreateClientIdPayloadInput = z.input<typeof CreateClientIdPayload>;
+export type CreateClientIdPayload = z.output<typeof CreateClientIdPayload>;
+export declare const UpdateClientIdPayload: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UpdateClientIdPayloadInput = z.input<typeof UpdateClientIdPayload>;
+export type UpdateClientIdPayload = z.output<typeof UpdateClientIdPayload>;

package/dist/admin/client-ids/payloads.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+const CreateClientIdPayload = z.object({
+  code: z.string().min(1).max(64).describe("Stable, immutable attribution key"),
+  label: z.string().min(1).max(128),
+  description: z.string().max(256).optional()
+}).describe("Payload to create a client ID");
+const UpdateClientIdPayload = z.object({
+  label: z.string().min(1).max(128).optional(),
+  description: z.string().max(256).optional()
+}).describe("Payload to update a client ID label/description");
+
+export { CreateClientIdPayload, UpdateClientIdPayload };

package/dist/admin/client-ids/queries.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const ListClientIdsParams: z.ZodObject<{
+    scope: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        all: "all";
+    }>>;
+}, z.core.$strip>;
+export type ListClientIdsParamsInput = z.input<typeof ListClientIdsParams>;
+export type ListClientIdsParams = z.output<typeof ListClientIdsParams>;

package/dist/admin/client-ids/queries.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+const ListClientIdsParams = z.object({
+  scope: z.enum(["active", "inactive", "all"]).default("all")
+});
+
+export { ListClientIdsParams };

package/dist/admin/client-ids/responses.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const ListClientIdsResponse: z.ZodArray<z.ZodObject<{
+    id: z.ZodUUID;
+    code: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodBoolean;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>>;
+export type ListClientIdsResponse = z.output<typeof ListClientIdsResponse>;

package/dist/admin/client-ids/responses.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { ClientIdEntity } from './entities';
+
+const ListClientIdsResponse = z.array(ClientIdEntity);
+
+export { ListClientIdsResponse };

package/dist/auth/entities.d.ts

@@ -8,6 +8,7 @@ export declare const AuthenticatedUser: z.ZodObject<{
     role: z.ZodEnum<{
         basic: "basic";
         pro: "pro";
+        admin: "admin";
     }>;
     providerId: z.ZodNullable<z.ZodString>;
     loginMethod: z.ZodEnum<{

package/dist/auth/entities.js

@@ -3,7 +3,7 @@ import { z } from 'zod';
 const LoginMethod = z.enum(["email", "evm_wallet"]).describe("Authentication provider used for the current session");
 const AuthenticatedUser = z.object({
   id: z.uuid().describe("User UUID"),
-  role: z.enum(["basic", "pro"]).describe("User role"),
+  role: z.enum(["basic", "pro", "admin"]).describe("User role"),
   providerId: z.string().nullable().describe("Provider identifier (wallet address or email)"),
   loginMethod: LoginMethod.describe("Authentication provider used for the current session")
 }).describe("Current authenticated user info");

package/dist/auth/payloads.d.ts

@@ -19,11 +19,13 @@ export declare const WalletLoginRequest: z.ZodObject<{
     address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     signature: z.ZodString;
     accessCode: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodString;
 }, z.core.$strip>;
 export declare const EmailLoginRequest: z.ZodObject<{
     method: z.ZodLiteral<"email">;
     email: z.ZodPipe<z.ZodEmail, z.ZodTransform<string, string>>;
     password: z.ZodString;
+    clientId: z.ZodString;
 }, z.core.$strip>;
 export declare const VerifyEmailRequest: z.ZodObject<{
     token: z.ZodString;
@@ -45,10 +47,12 @@ export declare const LoginRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     signature: z.ZodString;
     accessCode: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     method: z.ZodLiteral<"email">;
     email: z.ZodPipe<z.ZodEmail, z.ZodTransform<string, string>>;
     password: z.ZodString;
+    clientId: z.ZodString;
 }, z.core.$strip>], "method">;
 export declare const RefreshTokenRequest: z.ZodObject<{
     refreshToken: z.ZodString;

package/dist/auth/payloads.js

@@ -3,6 +3,7 @@ import { z } from 'zod';
 const EthereumAddress = z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address").transform((val) => val.toLowerCase()).describe("Ethereum wallet address (0x-prefixed, 40 hex chars, lowercase)");
 const Email = z.email("Invalid email address").transform((val) => val.toLowerCase()).describe("Email address (lowercase)");
 const Password = z.string().min(8, "Password must be at least 8 characters").max(128, "Password must be at most 128 characters").describe("Password for authentication");
+const ClientIdCode = z.string().min(1, "clientId is required").max(64, "clientId is too long").describe("Attribution route code (client_ids.code)");
 const AccessCode = z.string().trim().max(64).optional().describe("Optional beta access code");
 const RequestNonceRequest = z.object({
   address: EthereumAddress
@@ -23,12 +24,14 @@ const WalletLoginRequest = z.object({
   method: z.literal("wallet").describe('Must be "wallet" for wallet authentication'),
   address: EthereumAddress,
   signature: z.string().min(1, "Signature is required").describe("Signature of the nonce message"),
-  accessCode: AccessCode
+  accessCode: AccessCode,
+  clientId: ClientIdCode
 }).describe("Wallet-based authentication using nonce signature");
 const EmailLoginRequest = z.object({
   method: z.literal("email").describe('Must be "email" for email authentication'),
   email: Email,
-  password: Password
+  password: Password,
+  clientId: ClientIdCode
 }).describe("Email-based authentication using email and password");
 const VerifyEmailRequest = z.object({
   token: z.string().min(1, "Token is required").describe("Verification token"),

package/dist/auth/response.d.ts

@@ -7,6 +7,7 @@ export declare const LoginResponse: z.ZodObject<{
         role: z.ZodEnum<{
             basic: "basic";
             pro: "pro";
+            admin: "admin";
         }>;
         providerId: z.ZodNullable<z.ZodString>;
         loginMethod: z.ZodEnum<{
@@ -41,6 +42,7 @@ export declare const MeResponse: z.ZodObject<{
     role: z.ZodEnum<{
         basic: "basic";
         pro: "pro";
+        admin: "admin";
     }>;
     providerId: z.ZodNullable<z.ZodString>;
     loginMethod: z.ZodEnum<{

package/dist/bundle.d.ts

@@ -1,3 +1,4 @@
+export * from './admin/client-ids';
 export * from './auth';
 export * from './common/trade-legs';
 export * from './connector';
@@ -7,14 +8,17 @@ export * from './funding';
 export * from './instrument';
 export * from './instrument-precision';
 export * from './leverage';
+export * from './market';
 export * from './misc';
 export * from './order';
+export * from './portfolio';
 export * from './position';
 export * from './price';
 export * from './rebalance';
 export * from './schedule';
 export * from './statistics';
 export * from './sync';
+export * from './tca';
 export * from './trade';
 export * from './trade-accounts';
 export * from './trigger';

package/dist/bundle.js

@@ -1,3 +1,4 @@
+export * from './admin/client-ids';
 export * from './auth';
 export * from './common/trade-legs';
 export * from './connector';
@@ -7,14 +8,17 @@ export * from './funding';
 export * from './instrument';
 export * from './instrument-precision';
 export * from './leverage';
+export * from './market';
 export * from './misc';
 export * from './order';
+export * from './portfolio';
 export * from './position';
 export * from './price';
 export * from './rebalance';
 export * from './schedule';
 export * from './statistics';
 export * from './sync';
+export * from './tca';
 export * from './trade';
 export * from './trade-accounts';
 export * from './trigger';

package/dist/instrument/entities.d.ts

@@ -7,6 +7,23 @@ export declare const InstrumentType: z.ZodEnum<{
     hip3: "hip3";
 }>;
 export type InstrumentType = z.infer<typeof InstrumentType>;
+export declare const InstrumentTradeabilityStatus: z.ZodEnum<{
+    tradable: "tradable";
+    reduce_only: "reduce_only";
+    not_tradable: "not_tradable";
+}>;
+export type InstrumentTradeabilityStatus = z.infer<typeof InstrumentTradeabilityStatus>;
+export declare const InstrumentTradeabilityReason: z.ZodNullable<z.ZodString>;
+export type InstrumentTradeabilityReason = z.infer<typeof InstrumentTradeabilityReason>;
+export declare const InstrumentTradeability: z.ZodObject<{
+    status: z.ZodEnum<{
+        tradable: "tradable";
+        reduce_only: "reduce_only";
+        not_tradable: "not_tradable";
+    }>;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type InstrumentTradeability = z.output<typeof InstrumentTradeability>;
 export declare const Instrument: z.ZodObject<{
     id: z.ZodString;
     base: z.ZodString;
@@ -40,5 +57,13 @@ export declare const Instrument: z.ZodObject<{
             max: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
+    tradeability: z.ZodObject<{
+        status: z.ZodEnum<{
+            tradable: "tradable";
+            reduce_only: "reduce_only";
+            not_tradable: "not_tradable";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
 }, z.core.$strip>;
 export type Instrument = z.output<typeof Instrument>;

package/dist/instrument/entities.js

@@ -4,6 +4,12 @@ import { InstrumentPrecision } from '../instrument-precision';
 
 const InstrumentId = z.string().trim().min(1, "Instrument ID is required").max(64, "Instrument ID must be at most 64 characters").regex(/^[^\s][^\s]*$/, "Instrument ID contains invalid characters");
 const InstrumentType = z.enum(["spot", "perp", "hip3"]);
+const InstrumentTradeabilityStatus = z.enum(["tradable", "reduce_only", "not_tradable"]);
+const InstrumentTradeabilityReason = z.string().nullable();
+const InstrumentTradeability = z.object({
+  status: InstrumentTradeabilityStatus,
+  reason: InstrumentTradeabilityReason
+});
 const Instrument = z.object({
   /**
    * Exchange specific instrument identifier
@@ -42,7 +48,11 @@ const Instrument = z.object({
   /**
    * The precision of the instrument.
    */
-  precision: InstrumentPrecision
+  precision: InstrumentPrecision,
+  /**
+   * Whether this instrument can be traded normally.
+   */
+  tradeability: InstrumentTradeability
 });
 
-export { Instrument, InstrumentId, InstrumentType };
+export { Instrument, InstrumentId, InstrumentTradeability, InstrumentTradeabilityReason, InstrumentTradeabilityStatus, InstrumentType };

package/dist/instrument/queries.d.ts

@@ -1,4 +1,11 @@
 import { z } from 'zod';
+export declare const InstrumentScope: z.ZodEnum<{
+    all: "all";
+    tradable: "tradable";
+    reduce_only: "reduce_only";
+    not_tradable: "not_tradable";
+}>;
+export type InstrumentScope = z.infer<typeof InstrumentScope>;
 export declare const InstrumentListParams: z.ZodObject<{
     connector: z.ZodEnum<{
         hyperliquid: "hyperliquid";
@@ -7,5 +14,12 @@ export declare const InstrumentListParams: z.ZodObject<{
         okx: "okx";
         lighter: "lighter";
     }>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        tradable: "tradable";
+        reduce_only: "reduce_only";
+        not_tradable: "not_tradable";
+    }>>;
 }, z.core.$strip>;
+export type InstrumentListParamsInput = z.input<typeof InstrumentListParams>;
 export type InstrumentListParams = z.output<typeof InstrumentListParams>;

package/dist/instrument/queries.js

@@ -1,8 +1,10 @@
 import { z } from 'zod';
 import { Connector } from '../connector';
 
+const InstrumentScope = z.enum(["tradable", "reduce_only", "not_tradable", "all"]);
 const InstrumentListParams = z.object({
-  connector: Connector
+  connector: Connector,
+  scope: InstrumentScope.default("all")
 });
 
-export { InstrumentListParams };
+export { InstrumentListParams, InstrumentScope };

package/dist/instrument/responses.d.ts

@@ -33,6 +33,14 @@ export declare const InstrumentListResponse: z.ZodObject<{
                 max: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>>;
             }, z.core.$strip>>;
         }, z.core.$strip>;
+        tradeability: z.ZodObject<{
+            status: z.ZodEnum<{
+                tradable: "tradable";
+                reduce_only: "reduce_only";
+                not_tradable: "not_tradable";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type InstrumentListResponse = z.output<typeof InstrumentListResponse>;

package/dist/market/entities.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+export declare const Market: z.ZodObject<{
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+    }>;
+    instrumentId: z.ZodString;
+    displaySymbol: z.ZodString;
+    base: z.ZodString;
+    quote: z.ZodString;
+    price: z.ZodString;
+    volume24h: z.ZodString;
+    change24h: z.ZodString;
+    openInterest: z.ZodString;
+    fundingRate: z.ZodString;
+    tradeability: z.ZodObject<{
+        status: z.ZodEnum<{
+            tradable: "tradable";
+            reduce_only: "reduce_only";
+            not_tradable: "not_tradable";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type Market = z.output<typeof Market>;
+export declare const BasketMarket: z.ZodObject<{
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+    }>;
+    basketKey: z.ZodString;
+    displaySymbol: z.ZodString;
+    longInstrumentIds: z.ZodArray<z.ZodString>;
+    shortInstrumentIds: z.ZodArray<z.ZodString>;
+    price: z.ZodString;
+    priceChange24h: z.ZodString;
+    weightRatio: z.ZodString;
+    weightRatioChange24h: z.ZodString;
+    netFunding: z.ZodString;
+    volume24h: z.ZodString;
+    openInterest: z.ZodString;
+    tradeability: z.ZodObject<{
+        status: z.ZodEnum<{
+            tradable: "tradable";
+            reduce_only: "reduce_only";
+            not_tradable: "not_tradable";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    updatedAt: z.ZodNumber;
+    hasMaterializedStats: z.ZodBoolean;
+}, z.core.$strip>;
+export type BasketMarket = z.output<typeof BasketMarket>;
+export declare const MarketTotals: z.ZodObject<{
+    markets: z.ZodNumber;
+    volume24h: z.ZodString;
+    openInterest: z.ZodString;
+}, z.core.$strip>;
+export type MarketTotals = z.output<typeof MarketTotals>;

package/dist/market/entities.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { Connector } from '../connector';
+import { InstrumentTradeability, InstrumentId } from '../instrument';
+
+const Market = z.object({
+  connector: Connector,
+  instrumentId: InstrumentId,
+  displaySymbol: z.string(),
+  base: z.string(),
+  quote: z.string(),
+  price: z.string(),
+  volume24h: z.string(),
+  change24h: z.string(),
+  openInterest: z.string(),
+  fundingRate: z.string(),
+  tradeability: InstrumentTradeability,
+  updatedAt: z.number()
+});
+const BasketMarket = z.object({
+  connector: Connector,
+  basketKey: z.string(),
+  displaySymbol: z.string(),
+  longInstrumentIds: z.array(InstrumentId),
+  shortInstrumentIds: z.array(InstrumentId),
+  price: z.string(),
+  priceChange24h: z.string(),
+  weightRatio: z.string(),
+  weightRatioChange24h: z.string(),
+  netFunding: z.string(),
+  volume24h: z.string(),
+  openInterest: z.string(),
+  tradeability: InstrumentTradeability,
+  updatedAt: z.number(),
+  hasMaterializedStats: z.boolean()
+});
+const MarketTotals = z.object({
+  markets: z.number(),
+  volume24h: z.string(),
+  openInterest: z.string()
+});
+
+export { BasketMarket, Market, MarketTotals };

package/dist/market/index.d.ts

@@ -0,0 +1,3 @@
+export * from './entities';
+export * from './queries';
+export * from './responses';

package/dist/market/index.js

@@ -0,0 +1,3 @@
+export * from './entities';
+export * from './queries';
+export * from './responses';

package/dist/market/queries.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const MarketsQueryParams: z.ZodObject<{
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+    }>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        tradable: "tradable";
+        reduce_only: "reduce_only";
+        not_tradable: "not_tradable";
+    }>>;
+}, z.core.$strip>;
+export type MarketsQueryParamsInput = z.input<typeof MarketsQueryParams>;
+export type MarketsQueryParams = z.output<typeof MarketsQueryParams>;
+export declare const MarketBasketsQueryParams: z.ZodObject<{
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+    }>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        tradable: "tradable";
+        reduce_only: "reduce_only";
+        not_tradable: "not_tradable";
+    }>>;
+    search: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type MarketBasketsQueryParamsInput = z.input<typeof MarketBasketsQueryParams>;
+export type MarketBasketsQueryParams = z.output<typeof MarketBasketsQueryParams>;

package/dist/market/queries.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { Connector } from '../connector';
+import { InstrumentScope } from '../instrument';
+
+const MarketsQueryParams = z.object({
+  connector: Connector,
+  // Markets are connector-scoped so the API can return one exchange's live view
+  // without mixing instruments that have different ids, liquidity, or stats feeds.
+  scope: InstrumentScope.default("tradable")
+});
+const MarketBasketsQueryParams = z.object({
+  connector: Connector,
+  scope: InstrumentScope.default("tradable"),
+  search: z.string().trim().max(128).optional(),
+  limit: z.coerce.number().int().min(1).max(1e3).default(500),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+
+export { MarketBasketsQueryParams, MarketsQueryParams };

package/dist/market/responses.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+export declare const MarketsResponse: z.ZodObject<{
+    markets: z.ZodArray<z.ZodObject<{
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+        instrumentId: z.ZodString;
+        displaySymbol: z.ZodString;
+        base: z.ZodString;
+        quote: z.ZodString;
+        price: z.ZodString;
+        volume24h: z.ZodString;
+        change24h: z.ZodString;
+        openInterest: z.ZodString;
+        fundingRate: z.ZodString;
+        tradeability: z.ZodObject<{
+            status: z.ZodEnum<{
+                tradable: "tradable";
+                reduce_only: "reduce_only";
+                not_tradable: "not_tradable";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        updatedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    totals: z.ZodObject<{
+        markets: z.ZodNumber;
+        volume24h: z.ZodString;
+        openInterest: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type MarketsResponse = z.output<typeof MarketsResponse>;
+export declare const MarketBasketsResponse: z.ZodObject<{
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+    count: z.ZodNumber;
+    markets: z.ZodArray<z.ZodObject<{
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+        basketKey: z.ZodString;
+        displaySymbol: z.ZodString;
+        longInstrumentIds: z.ZodArray<z.ZodString>;
+        shortInstrumentIds: z.ZodArray<z.ZodString>;
+        price: z.ZodString;
+        priceChange24h: z.ZodString;
+        weightRatio: z.ZodString;
+        weightRatioChange24h: z.ZodString;
+        netFunding: z.ZodString;
+        volume24h: z.ZodString;
+        openInterest: z.ZodString;
+        tradeability: z.ZodObject<{
+            status: z.ZodEnum<{
+                tradable: "tradable";
+                reduce_only: "reduce_only";
+                not_tradable: "not_tradable";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        updatedAt: z.ZodNumber;
+        hasMaterializedStats: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MarketBasketsResponse = z.output<typeof MarketBasketsResponse>;

package/dist/market/responses.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { MarketTotals, Market, BasketMarket } from './entities';
+
+const MarketsResponse = z.object({
+  markets: z.array(Market),
+  totals: MarketTotals
+});
+const MarketBasketsResponse = z.object({
+  limit: z.number(),
+  offset: z.number(),
+  count: z.number(),
+  markets: z.array(BasketMarket)
+});
+
+export { MarketBasketsResponse, MarketsResponse };