pmxt-core 2.9.1 → 2.9.3

package/dist/BaseExchange.d.ts

@@ -1,4 +1,4 @@
-import { UnifiedMarket, UnifiedEvent, PriceCandle, CandleInterval, OrderBook, Trade, Order, Position, Balance, CreateOrderParams } from './types';
+import { UnifiedMarket, UnifiedEvent, PriceCandle, CandleInterval, OrderBook, Trade, UserTrade, Order, Position, Balance, CreateOrderParams, BuiltOrder } from './types';
 import { ExecutionPriceResult } from './utils/math';
 import { AxiosInstance } from 'axios';
 export interface ApiEndpoint {
@@ -37,6 +37,7 @@ export interface EventFetchParams {
     query?: string;
     limit?: number;
     offset?: number;
+    sort?: 'volume' | 'liquidity' | 'newest';
     status?: 'active' | 'inactive' | 'closed' | 'all';
     searchIn?: 'title' | 'description' | 'both';
     eventId?: string;
@@ -59,6 +60,21 @@ export interface TradesParams {
     end?: Date;
     limit?: number;
 }
+export interface MyTradesParams {
+    outcomeId?: string;
+    marketId?: string;
+    since?: Date;
+    until?: Date;
+    limit?: number;
+    cursor?: string;
+}
+export interface OrderHistoryParams {
+    marketId?: string;
+    since?: Date;
+    until?: Date;
+    limit?: number;
+    cursor?: string;
+}
 export type MarketFilterCriteria = {
     text?: string;
     searchIn?: ('title' | 'description' | 'category' | 'tags' | 'outcomes')[];
@@ -126,6 +142,11 @@ export interface ExchangeHas {
     fetchBalance: ExchangeCapability;
     watchOrderBook: ExchangeCapability;
     watchTrades: ExchangeCapability;
+    fetchMyTrades: ExchangeCapability;
+    fetchClosedOrders: ExchangeCapability;
+    fetchAllOrders: ExchangeCapability;
+    buildOrder: ExchangeCapability;
+    submitOrder: ExchangeCapability;
 }
 export interface ExchangeCredentials {
     apiKey?: string;
@@ -135,30 +156,69 @@ export interface ExchangeCredentials {
     signatureType?: number | string;
     funderAddress?: string;
 }
+export interface ExchangeOptions {
+    /**
+     * How long (ms) a market snapshot created by `fetchMarketsPaginated` remains valid
+     * before being discarded and re-fetched from the API on the next call.
+     * Defaults to 0 (no TTL — the snapshot is re-fetched on every initial call).
+     */
+    snapshotTTL?: number;
+}
+/** Shape returned by fetchMarketsPaginated */
+export interface PaginatedMarketsResult {
+    data: UnifiedMarket[];
+    total: number;
+    nextCursor?: string;
+}
 export declare abstract class PredictionMarketExchange {
     [key: string]: any;
     protected credentials?: ExchangeCredentials;
     verbose: boolean;
     http: AxiosInstance;
+    enableRateLimit: boolean;
+    private _rateLimit;
+    private _throttler;
+    private _snapshotTTL;
+    private _snapshot?;
+    get rateLimit(): number;
+    set rateLimit(value: number);
     markets: Record<string, UnifiedMarket>;
     marketsBySlug: Record<string, UnifiedMarket>;
     loadedMarkets: boolean;
     protected apiDescriptor?: ApiDescriptor;
     private apiDescriptors;
     readonly has: ExchangeHas;
-    constructor(credentials?: ExchangeCredentials);
+    constructor(credentials?: ExchangeCredentials, options?: ExchangeOptions);
     abstract get name(): string;
     /**
-     * Load and cache markets from the exchange.
-     * This method populates `this.markets` and `this.marketsBySlug`.
+     * Load and cache all markets from the exchange into `this.markets` and `this.marketsBySlug`.
+     * Subsequent calls return the cached result without hitting the API again.
      *
-     * @param reload - Force a reload of markets from the API even if already loaded
+     * This is the correct way to paginate or iterate over markets without drift.
+     * Because `fetchMarkets()` always hits the API, repeated calls with different `offset`
+     * values may return inconsistent results if the exchange reorders or adds markets between
+     * requests. Use `loadMarkets()` once to get a stable snapshot, then paginate over
+     * `Object.values(exchange.markets)` locally.
+     *
+     * @param reload - Force a fresh fetch from the API even if markets are already loaded
      * @returns Dictionary of markets indexed by marketId
+     *
+     * @example-ts Stable pagination
+     * await exchange.loadMarkets();
+     * const all = Object.values(exchange.markets);
+     * const page1 = all.slice(0, 100);
+     * const page2 = all.slice(100, 200);
+     *
+     * @example-python Stable pagination
+     * exchange.load_markets()
+     * all = list(exchange.markets.values())
+     * page1 = all[:100]
+     * page2 = all[100:200]
      */
     loadMarkets(reload?: boolean): Promise<Record<string, UnifiedMarket>>;
     /**
      * Fetch markets with optional filtering, search, or slug lookup.
-     * This is the primary method for retrieving markets.
+     * Always hits the exchange API — results reflect the live state at the time of the call.
      *
      * @param params - Optional parameters for filtering and search
      * @param params.query - Search keyword to filter markets
@@ -169,6 +229,10 @@ export declare abstract class PredictionMarketExchange {
      * @param params.searchIn - Where to search ('title' | 'description' | 'both')
      * @returns Array of unified markets
      *
+     * @note Calling this repeatedly with different `offset` values does not guarantee stable
+     * ordering — exchanges may reorder or add markets between requests. For stable iteration
+     * across pages, use `loadMarkets()` and paginate over `Object.values(exchange.markets)`.
+     *
      * @note Some exchanges (like Limitless) may only support status 'active' for search results.
      *
      * @example-ts Fetch markets
@@ -186,12 +250,31 @@ export declare abstract class PredictionMarketExchange {
      * markets = exchange.fetch_markets(slug='will-trump-win')
      */
     fetchMarkets(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
+    /**
+     * Fetch markets with cursor-based pagination backed by a stable in-memory snapshot.
+     *
+     * On the first call (or when no cursor is supplied), fetches all markets once and
+     * caches them. Subsequent calls with a cursor returned from a previous call slice
+     * directly from the cached snapshot — no additional API calls are made.
+     *
+     * The snapshot is invalidated after `snapshotTTL` ms (configured via `ExchangeOptions`
+     * in the constructor). A request using a cursor from an expired snapshot throws
+     * `'Cursor has expired'`.
+     *
+     * @param params.limit      - Page size (default: return all markets)
+     * @param params.cursor     - Opaque cursor returned by a previous call
+     * @returns PaginatedMarketsResult with data, total, and optional nextCursor
+     */
+    fetchMarketsPaginated(params?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<PaginatedMarketsResult>;
     /**
      * Fetch events with optional keyword search.
      * Events group related markets together (e.g., "Who will be Fed Chair?" contains multiple candidate markets).
      *
      * @param params - Optional parameters for search and filtering
-     * @param params.query - Search keyword to filter events (required)
+     * @param params.query - Search keyword to filter events. If omitted, returns top events by volume.
      * @param params.limit - Maximum number of results
      * @param params.offset - Pagination offset
      * @param params.searchIn - Where to search ('title' | 'description' | 'both')
@@ -280,7 +363,7 @@ export declare abstract class PredictionMarketExchange {
      * @notes Polymarket: outcomeId is the CLOB Token ID. Kalshi: outcomeId is the Market Ticker.
      * @notes Resolution options: '1m' | '5m' | '15m' | '1h' | '6h' | '1d'
      */
-    fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams): Promise<PriceCandle[]>;
+    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
     /**
      * Fetch the current order book (bids/asks) for a specific outcome.
      * Essential for calculating spread, depth, and execution prices.
@@ -369,6 +452,56 @@ export declare abstract class PredictionMarketExchange {
      * )
      */
     createOrder(params: CreateOrderParams): Promise<Order>;
+    /**
+     * Build an order payload without submitting it to the exchange.
+     * Returns the exchange-native signed order or request body for inspection,
+     * forwarding through a middleware layer, or deferred submission via submitOrder().
+     *
+     * @param params - Order parameters (same as createOrder)
+     * @returns A BuiltOrder containing the exchange-native payload
+     *
+     * @example-ts Build then inspect a Polymarket order
+     * const built = await exchange.buildOrder({
+     *   marketId: market.marketId,
+     *   outcomeId: market.yes.outcomeId,
+     *   side: 'buy',
+     *   type: 'limit',
+     *   amount: 10,
+     *   price: 0.55
+     * });
+     * console.log(built.signedOrder); // EIP-712 signed order struct
+     * const order = await exchange.submitOrder(built);
+     *
+     * @example-python Build then submit a Polymarket order
+     * built = exchange.build_order(
+     *     market_id=market.market_id,
+     *     outcome_id=market.yes.outcome_id,
+     *     side='buy',
+     *     type='limit',
+     *     amount=10,
+     *     price=0.55
+     * )
+     * print(built.signed_order)
+     * order = exchange.submit_order(built)
+     */
+    buildOrder(params: CreateOrderParams): Promise<BuiltOrder>;
+    /**
+     * Submit a pre-built order returned by buildOrder().
+     *
+     * @param built - A BuiltOrder from buildOrder()
+     * @returns The submitted order
+     *
+     * @example-ts Submit a pre-built order
+     * const built = await exchange.buildOrder(params);
+     * const order = await exchange.submitOrder(built);
+     * console.log(`Order ${order.id}: ${order.status}`);
+     *
+     * @example-python Submit a pre-built order
+     * built = exchange.build_order(params)
+     * order = exchange.submit_order(built)
+     * print(f"Order {order.id}: {order.status}")
+     */
+    submitOrder(built: BuiltOrder): Promise<Order>;
     /**
      * Cancel an existing open order.
      *
@@ -423,6 +556,9 @@ export declare abstract class PredictionMarketExchange {
      * orders = exchange.fetch_open_orders('FED-25JAN')
      */
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
+    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
+    fetchClosedOrders(params?: OrderHistoryParams): Promise<Order[]>;
+    fetchAllOrders(params?: OrderHistoryParams): Promise<Order[]>;
     /**
      * Fetch current user positions across all markets.
      *

package/dist/BaseExchange.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PredictionMarketExchange = void 0;
 const math_1 = require("./utils/math");
 const errors_1 = require("./errors");
+const throttler_1 = require("./utils/throttler");
 const axios_1 = __importDefault(require("axios"));
 // ----------------------------------------------------------------------------
 // Base Exchange Class
@@ -14,6 +15,23 @@ class PredictionMarketExchange {
     credentials;
     verbose = false;
     http;
+    enableRateLimit = true;
+    _rateLimit = 1000;
+    _throttler;
+    // Snapshot state for cursor-based pagination
+    _snapshotTTL;
+    _snapshot;
+    get rateLimit() {
+        return this._rateLimit;
+    }
+    set rateLimit(value) {
+        this._rateLimit = value;
+        this._throttler = new throttler_1.Throttler({
+            refillRate: 1 / value,
+            capacity: 1,
+            delay: 1,
+        });
+    }
     // Market Cache
     markets = {};
     marketsBySlug = {};
@@ -35,10 +53,32 @@ class PredictionMarketExchange {
         fetchBalance: false,
         watchOrderBook: false,
         watchTrades: false,
+        fetchMyTrades: false,
+        fetchClosedOrders: false,
+        fetchAllOrders: false,
+        buildOrder: false,
+        submitOrder: false,
     };
-    constructor(credentials) {
+    constructor(credentials, options) {
         this.credentials = credentials;
-        this.http = axios_1.default.create();
+        this._snapshotTTL = options?.snapshotTTL ?? 0;
+        this.http = axios_1.default.create({
+            headers: {
+                'User-Agent': `pmxt (https://github.com/pmxt-dev/pmxt)`
+            }
+        });
+        this._throttler = new throttler_1.Throttler({
+            refillRate: 1 / this._rateLimit,
+            capacity: 1,
+            delay: 1,
+        });
+        // Rate Limit Interceptor
+        this.http.interceptors.request.use(async (config) => {
+            if (this.enableRateLimit) {
+                await this._throttler.throttle();
+            }
+            return config;
+        });
         // Request Interceptor
         this.http.interceptors.request.use((config) => {
             if (this.verbose) {
@@ -71,11 +111,29 @@ class PredictionMarketExchange {
         });
     }
     /**
-     * Load and cache markets from the exchange.
-     * This method populates `this.markets` and `this.marketsBySlug`.
+     * Load and cache all markets from the exchange into `this.markets` and `this.marketsBySlug`.
+     * Subsequent calls return the cached result without hitting the API again.
      *
-     * @param reload - Force a reload of markets from the API even if already loaded
+     * This is the correct way to paginate or iterate over markets without drift.
+     * Because `fetchMarkets()` always hits the API, repeated calls with different `offset`
+     * values may return inconsistent results if the exchange reorders or adds markets between
+     * requests. Use `loadMarkets()` once to get a stable snapshot, then paginate over
+     * `Object.values(exchange.markets)` locally.
+     *
+     * @param reload - Force a fresh fetch from the API even if markets are already loaded
      * @returns Dictionary of markets indexed by marketId
+     *
+     * @example-ts Stable pagination
+     * await exchange.loadMarkets();
+     * const all = Object.values(exchange.markets);
+     * const page1 = all.slice(0, 100);
+     * const page2 = all.slice(100, 200);
+     *
+     * @example-python Stable pagination
+     * exchange.load_markets()
+     * all = list(exchange.markets.values())
+     * page1 = all[:100]
+     * page2 = all[100:200]
      */
     async loadMarkets(reload = false) {
         if (this.loadedMarkets && !reload) {
@@ -98,7 +156,7 @@ class PredictionMarketExchange {
     }
     /**
      * Fetch markets with optional filtering, search, or slug lookup.
-     * This is the primary method for retrieving markets.
+     * Always hits the exchange API — results reflect the live state at the time of the call.
      *
      * @param params - Optional parameters for filtering and search
      * @param params.query - Search keyword to filter markets
@@ -109,6 +167,10 @@ class PredictionMarketExchange {
      * @param params.searchIn - Where to search ('title' | 'description' | 'both')
      * @returns Array of unified markets
      *
+     * @note Calling this repeatedly with different `offset` values does not guarantee stable
+     * ordering — exchanges may reorder or add markets between requests. For stable iteration
+     * across pages, use `loadMarkets()` and paginate over `Object.values(exchange.markets)`.
+     *
      * @note Some exchanges (like Limitless) may only support status 'active' for search results.
      *
      * @example-ts Fetch markets
@@ -128,12 +190,65 @@ class PredictionMarketExchange {
     async fetchMarkets(params) {
         return this.fetchMarketsImpl(params);
     }
+    /**
+     * Fetch markets with cursor-based pagination backed by a stable in-memory snapshot.
+     *
+     * On the first call (or when no cursor is supplied), fetches all markets once and
+     * caches them. Subsequent calls with a cursor returned from a previous call slice
+     * directly from the cached snapshot — no additional API calls are made.
+     *
+     * The snapshot is invalidated after `snapshotTTL` ms (configured via `ExchangeOptions`
+     * in the constructor). A request using a cursor from an expired snapshot throws
+     * `'Cursor has expired'`.
+     *
+     * @param params.limit      - Page size (default: return all markets)
+     * @param params.cursor     - Opaque cursor returned by a previous call
+     * @returns PaginatedMarketsResult with data, total, and optional nextCursor
+     */
+    async fetchMarketsPaginated(params) {
+        const limit = params?.limit;
+        const cursor = params?.cursor;
+        if (cursor) {
+            // Cursor encodes: snapshotId:offset
+            const sep = cursor.indexOf(':');
+            const snapshotId = cursor.substring(0, sep);
+            const offset = parseInt(cursor.substring(sep + 1), 10);
+            if (!this._snapshot ||
+                this._snapshot.id !== snapshotId ||
+                (this._snapshotTTL > 0 && Date.now() - this._snapshot.takenAt > this._snapshotTTL)) {
+                throw new Error('Cursor has expired');
+            }
+            const markets = this._snapshot.markets;
+            const slice = limit !== undefined ? markets.slice(offset, offset + limit) : markets.slice(offset);
+            const nextOffset = offset + slice.length;
+            const nextCursor = nextOffset < markets.length ? `${snapshotId}:${nextOffset}` : undefined;
+            return { data: slice, total: markets.length, nextCursor };
+        }
+        // No cursor — (re)fetch snapshot
+        if (!this._snapshot ||
+            this._snapshotTTL === 0 ||
+            Date.now() - this._snapshot.takenAt > this._snapshotTTL) {
+            const markets = await this.fetchMarketsImpl();
+            this._snapshot = {
+                markets,
+                takenAt: Date.now(),
+                id: Math.random().toString(36).slice(2),
+            };
+        }
+        const markets = this._snapshot.markets;
+        if (!limit) {
+            return { data: markets, total: markets.length, nextCursor: undefined };
+        }
+        const slice = markets.slice(0, limit);
+        const nextCursor = limit < markets.length ? `${this._snapshot.id}:${limit}` : undefined;
+        return { data: slice, total: markets.length, nextCursor };
+    }
     /**
      * Fetch events with optional keyword search.
      * Events group related markets together (e.g., "Who will be Fed Chair?" contains multiple candidate markets).
      *
      * @param params - Optional parameters for search and filtering
-     * @param params.query - Search keyword to filter events (required)
+     * @param params.query - Search keyword to filter events. If omitted, returns top events by volume.
      * @param params.limit - Maximum number of results
      * @param params.offset - Pagination offset
      * @param params.searchIn - Where to search ('title' | 'description' | 'both')
@@ -152,10 +267,7 @@ class PredictionMarketExchange {
      * print(fed_event.title, len(fed_event.markets), 'markets')
      */
     async fetchEvents(params) {
-        if (!params?.query && !params?.eventId && !params?.slug) {
-            throw new Error("fetchEvents() requires a query, eventId, or slug parameter");
-        }
-        return this.fetchEventsImpl(params);
+        return this.fetchEventsImpl(params ?? {});
     }
     /**
      * Fetch a single market by lookup parameters.
@@ -362,6 +474,60 @@ class PredictionMarketExchange {
     async createOrder(params) {
         throw new Error("Method createOrder not implemented.");
     }
+    /**
+     * Build an order payload without submitting it to the exchange.
+     * Returns the exchange-native signed order or request body for inspection,
+     * forwarding through a middleware layer, or deferred submission via submitOrder().
+     *
+     * @param params - Order parameters (same as createOrder)
+     * @returns A BuiltOrder containing the exchange-native payload
+     *
+     * @example-ts Build then inspect a Polymarket order
+     * const built = await exchange.buildOrder({
+     *   marketId: market.marketId,
+     *   outcomeId: market.yes.outcomeId,
+     *   side: 'buy',
+     *   type: 'limit',
+     *   amount: 10,
+     *   price: 0.55
+     * });
+     * console.log(built.signedOrder); // EIP-712 signed order struct
+     * const order = await exchange.submitOrder(built);
+     *
+     * @example-python Build then submit a Polymarket order
+     * built = exchange.build_order(
+     *     market_id=market.market_id,
+     *     outcome_id=market.yes.outcome_id,
+     *     side='buy',
+     *     type='limit',
+     *     amount=10,
+     *     price=0.55
+     * )
+     * print(built.signed_order)
+     * order = exchange.submit_order(built)
+     */
+    async buildOrder(params) {
+        throw new Error("Method buildOrder not implemented.");
+    }
+    /**
+     * Submit a pre-built order returned by buildOrder().
+     *
+     * @param built - A BuiltOrder from buildOrder()
+     * @returns The submitted order
+     *
+     * @example-ts Submit a pre-built order
+     * const built = await exchange.buildOrder(params);
+     * const order = await exchange.submitOrder(built);
+     * console.log(`Order ${order.id}: ${order.status}`);
+     *
+     * @example-python Submit a pre-built order
+     * built = exchange.build_order(params)
+     * order = exchange.submit_order(built)
+     * print(f"Order {order.id}: {order.status}")
+     */
+    async submitOrder(built) {
+        throw new Error("Method submitOrder not implemented.");
+    }
     /**
      * Cancel an existing open order.
      *
@@ -422,6 +588,15 @@ class PredictionMarketExchange {
     async fetchOpenOrders(marketId) {
         throw new Error("Method fetchOpenOrders not implemented.");
     }
+    async fetchMyTrades(params) {
+        throw new Error("Method fetchMyTrades not implemented.");
+    }
+    async fetchClosedOrders(params) {
+        throw new Error("Method fetchClosedOrders not implemented.");
+    }
+    async fetchAllOrders(params) {
+        throw new Error("Method fetchAllOrders not implemented.");
+    }
     /**
      * Fetch current user positions across all markets.
      *

package/dist/exchanges/baozi/fetchEvents.js

@@ -16,17 +16,22 @@ async function fetchEvents(connection, params) {
             status: params.status,
             searchIn: params.searchIn,
         });
-        return markets.map(m => ({
-            id: m.marketId,
-            title: m.title,
-            description: m.description,
-            slug: m.marketId,
-            markets: [m],
-            url: m.url,
-            image: m.image,
-            category: m.category,
-            tags: m.tags,
-        }));
+        return markets.map(m => {
+            const unifiedEvent = {
+                id: m.marketId,
+                title: m.title,
+                description: m.description,
+                slug: m.marketId,
+                markets: [m],
+                volume24h: m.volume24h,
+                volume: m.volume,
+                url: m.url,
+                image: m.image,
+                category: m.category,
+                tags: m.tags,
+            };
+            return unifiedEvent;
+        });
     }
     catch (error) {
         throw errors_1.baoziErrorMapper.mapError(error);

package/dist/exchanges/baozi/index.d.ts

@@ -19,6 +19,11 @@ export declare class BaoziExchange extends PredictionMarketExchange {
         fetchBalance: true;
         watchOrderBook: true;
         watchTrades: false;
+        fetchMyTrades: false;
+        fetchClosedOrders: false;
+        fetchAllOrders: false;
+        buildOrder: false;
+        submitOrder: false;
     };
     private auth?;
     private connection;

package/dist/exchanges/baozi/index.js

@@ -28,6 +28,11 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchBalance: true,
         watchOrderBook: true,
         watchTrades: false,
+        fetchMyTrades: false,
+        fetchClosedOrders: false,
+        fetchAllOrders: false,
+        buildOrder: false,
+        submitOrder: false,
     };
     auth;
     connection;
@@ -43,6 +48,7 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
             credentials = options;
         }
         super(credentials);
+        this.rateLimit = 500;
         rpcUrl = rpcUrl
             || process.env.BAOZI_RPC_URL
             || process.env.HELIUS_RPC_URL

package/dist/exchanges/kalshi/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-02-18T16:13:58.523Z
+ * Generated at: 2026-03-04T17:45:20.579Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const kalshiApiSpec: {
@@ -11,6 +11,12 @@ export declare const kalshiApiSpec: {
     };
     servers: {
         url: string;
+        variables: {
+            env: {
+                default: string;
+                enum: string[];
+            };
+        };
     }[];
     paths: {
         "/historical/cutoff": {

package/dist/exchanges/kalshi/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.kalshiApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-02-18T16:13:58.523Z
+ * Generated at: 2026-03-04T17:45:20.579Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.kalshiApiSpec = {
@@ -14,7 +14,16 @@ exports.kalshiApiSpec = {
     },
     "servers": [
         {
-            "url": "https://api.elections.kalshi.com/trade-api/v2"
+            "url": "https://{env}.elections.kalshi.com/trade-api/v2",
+            "variables": {
+                "env": {
+                    "default": "api",
+                    "enum": [
+                        "api",
+                        "demo-api"
+                    ]
+                }
+            }
         }
     ],
     "paths": {