pmxt-core 2.22.2 → 2.24.0

package/dist/exchanges/smarkets/normalizer.d.ts

@@ -0,0 +1,18 @@
+import { UnifiedMarket, UnifiedEvent, OrderBook, Trade, UserTrade, Position, Balance, Order } from '../../types';
+import { IExchangeNormalizer } from '../interfaces';
+import { SmarketsRawEventWithMarkets, SmarketsRawEvent, SmarketsRawMarket, SmarketsRawContract, SmarketsRawQuote, SmarketsRawActivityRow, SmarketsRawOrder, SmarketsRawVolume, SmarketsRawBalance } from './fetcher';
+export declare class SmarketsNormalizer implements IExchangeNormalizer<SmarketsRawEventWithMarkets, SmarketsRawEventWithMarkets> {
+    normalizeMarket(raw: SmarketsRawEventWithMarkets): UnifiedMarket | null;
+    normalizeMarketsFromEvent(raw: SmarketsRawEventWithMarkets): UnifiedMarket[];
+    normalizeRawMarket(event: SmarketsRawEvent, market: SmarketsRawMarket, contracts: SmarketsRawContract[], volumes: SmarketsRawVolume[]): UnifiedMarket | null;
+    normalizeEvent(raw: SmarketsRawEventWithMarkets): UnifiedEvent | null;
+    normalizeOrderBook(raw: Record<string, SmarketsRawQuote>, _id: string): OrderBook;
+    normalizeActivityTrade(raw: SmarketsRawActivityRow, index: number): Trade;
+    normalizeActivityUserTrade(raw: SmarketsRawActivityRow, index: number): UserTrade;
+    normalizeOrder(raw: SmarketsRawOrder): Order;
+    normalizeCreateOrderResponse(raw: Record<string, any>): Order;
+    normalizePosition(raw: SmarketsRawOrder): Position;
+    normalizeBalance(raw: SmarketsRawBalance): Balance[];
+    private mapOrderStatus;
+    private mapOrderType;
+}

package/dist/exchanges/smarkets/normalizer.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmarketsNormalizer = void 0;
+const market_utils_1 = require("../../utils/market-utils");
+const price_1 = require("./price");
+// ----------------------------------------------------------------------------
+// Helpers
+// ----------------------------------------------------------------------------
+function extractEventCategory(event) {
+    const eventType = event.type;
+    if (typeof eventType === 'object' && eventType !== null) {
+        return eventType.domain;
+    }
+    if (typeof eventType === 'string') {
+        // e.g. "football_match" -> "football"
+        const parts = eventType.split('_');
+        if (parts.length >= 2) {
+            return parts.slice(0, -1).join('_');
+        }
+        return eventType;
+    }
+    return undefined;
+}
+function buildEventUrl(event) {
+    if (event.full_slug) {
+        return `https://smarkets.com${event.full_slug}`;
+    }
+    return `https://smarkets.com/event/${event.id}/${event.slug}`;
+}
+function buildContractOutcome(contract, marketId) {
+    return {
+        outcomeId: contract.id,
+        marketId,
+        label: contract.name,
+        price: 0,
+    };
+}
+// ----------------------------------------------------------------------------
+// Normalizer
+// ----------------------------------------------------------------------------
+class SmarketsNormalizer {
+    normalizeMarket(raw) {
+        if (!raw || !raw.markets || raw.markets.length === 0)
+            return null;
+        return this.normalizeRawMarket(raw.event, raw.markets[0], raw.contracts, raw.volumes);
+    }
+    normalizeMarketsFromEvent(raw) {
+        const results = [];
+        for (const market of raw.markets) {
+            const marketContracts = raw.contracts.filter(c => c.market_id === market.id);
+            const marketVolumes = raw.volumes.filter(v => v.market_id === market.id);
+            const um = this.normalizeRawMarket(raw.event, market, marketContracts, marketVolumes);
+            if (um)
+                results.push(um);
+        }
+        return results;
+    }
+    normalizeRawMarket(event, market, contracts, volumes) {
+        if (!market)
+            return null;
+        const marketContracts = contracts.filter(c => c.market_id === market.id);
+        const volume = volumes.find(v => v.market_id === market.id);
+        const outcomes = marketContracts.map(contract => buildContractOutcome(contract, market.id));
+        const category = extractEventCategory(event);
+        const tags = [];
+        if (category)
+            tags.push(category);
+        if (market.category && !tags.includes(market.category)) {
+            tags.push(market.category);
+        }
+        if (market.categories) {
+            for (const cat of market.categories) {
+                if (!tags.includes(cat))
+                    tags.push(cat);
+            }
+        }
+        // Derive resolution date from event end_date or start_datetime
+        const resolutionDate = event.end_date
+            ? new Date(event.end_date)
+            : event.start_datetime
+                ? new Date(event.start_datetime)
+                : new Date();
+        const um = {
+            marketId: market.id,
+            eventId: event.id,
+            title: event.name,
+            description: market.description || market.name || '',
+            slug: market.slug,
+            outcomes,
+            resolutionDate,
+            volume24h: 0, // Smarkets does not provide 24h volume separately
+            volume: volume ? (0, price_1.fromQuantityUnits)(volume.volume) : undefined,
+            liquidity: 0,
+            url: buildEventUrl(event),
+            category,
+            tags,
+        };
+        (0, market_utils_1.addBinaryOutcomes)(um);
+        return um;
+    }
+    normalizeEvent(raw) {
+        if (!raw || !raw.event)
+            return null;
+        const markets = this.normalizeMarketsFromEvent(raw);
+        const category = extractEventCategory(raw.event);
+        return {
+            id: raw.event.id,
+            title: raw.event.name,
+            description: raw.event.description || '',
+            slug: raw.event.slug,
+            markets,
+            volume24h: markets.reduce((sum, m) => sum + m.volume24h, 0),
+            volume: markets.some(m => m.volume !== undefined)
+                ? markets.reduce((sum, m) => sum + (m.volume ?? 0), 0)
+                : undefined,
+            url: buildEventUrl(raw.event),
+            category,
+            tags: category ? [category] : [],
+        };
+    }
+    normalizeOrderBook(raw, _id) {
+        const allBids = [];
+        const allAsks = [];
+        for (const contractId of Object.keys(raw)) {
+            const quote = raw[contractId];
+            if (!quote)
+                continue;
+            for (const bid of (quote.bids || [])) {
+                allBids.push({
+                    price: (0, price_1.fromBasisPoints)(bid.price),
+                    size: (0, price_1.fromQuantityUnits)(bid.quantity),
+                });
+            }
+            for (const offer of (quote.offers || [])) {
+                allAsks.push({
+                    price: (0, price_1.fromBasisPoints)(offer.price),
+                    size: (0, price_1.fromQuantityUnits)(offer.quantity),
+                });
+            }
+        }
+        const sortedBids = [...allBids].sort((a, b) => b.price - a.price);
+        const sortedAsks = [...allAsks].sort((a, b) => a.price - b.price);
+        return {
+            bids: sortedBids,
+            asks: sortedAsks,
+            timestamp: Date.now(),
+        };
+    }
+    normalizeActivityTrade(raw, index) {
+        const price = raw.price !== null ? (0, price_1.fromBasisPoints)(raw.price) : 0;
+        const amount = raw.quantity !== null ? (0, price_1.fromQuantityUnits)(raw.quantity) : 0;
+        let side = 'unknown';
+        if (raw.side === 'buy')
+            side = 'buy';
+        else if (raw.side === 'sell')
+            side = 'sell';
+        return {
+            id: `${raw.seq}-${raw.subseq}`,
+            timestamp: new Date(raw.timestamp).getTime(),
+            price,
+            amount,
+            side,
+            outcomeId: raw.contract_id || undefined,
+        };
+    }
+    normalizeActivityUserTrade(raw, index) {
+        const trade = this.normalizeActivityTrade(raw, index);
+        return {
+            ...trade,
+            orderId: raw.order_id || undefined,
+        };
+    }
+    normalizeOrder(raw) {
+        return {
+            id: raw.id,
+            marketId: raw.market_id,
+            outcomeId: raw.contract_id,
+            side: raw.side === 'buy' ? 'buy' : 'sell',
+            type: this.mapOrderType(raw.type),
+            price: (0, price_1.fromBasisPoints)(raw.price),
+            amount: (0, price_1.fromQuantityUnits)(raw.quantity),
+            status: this.mapOrderStatus(raw.state),
+            filled: (0, price_1.fromQuantityUnits)(raw.quantity_filled),
+            remaining: (0, price_1.fromQuantityUnits)(raw.quantity_unfilled),
+            timestamp: new Date(raw.created_datetime).getTime(),
+        };
+    }
+    normalizeCreateOrderResponse(raw) {
+        const totalExecuted = raw.total_executed_quantity || 0;
+        const availableQty = raw.available_quantity || 0;
+        const quantity = raw.quantity || (totalExecuted + availableQty);
+        let status = 'open';
+        if (totalExecuted > 0 && availableQty === 0) {
+            status = 'filled';
+        }
+        else if (totalExecuted > 0) {
+            status = 'open';
+        }
+        else {
+            status = 'pending';
+        }
+        return {
+            id: raw.order_id,
+            marketId: raw.market_id,
+            outcomeId: raw.contract_id,
+            side: raw.side === 'buy' ? 'buy' : 'sell',
+            type: 'limit',
+            price: (0, price_1.fromBasisPoints)(raw.price),
+            amount: (0, price_1.fromQuantityUnits)(quantity),
+            status,
+            filled: (0, price_1.fromQuantityUnits)(totalExecuted),
+            remaining: (0, price_1.fromQuantityUnits)(availableQty),
+            timestamp: Date.now(),
+        };
+    }
+    normalizePosition(raw) {
+        const size = (0, price_1.fromQuantityUnits)(raw.quantity_filled);
+        const entryPrice = raw.average_price_matched
+            ? (0, price_1.fromBasisPoints)(raw.average_price_matched)
+            : (0, price_1.fromBasisPoints)(raw.price);
+        return {
+            marketId: raw.market_id,
+            outcomeId: raw.contract_id,
+            outcomeLabel: raw.contract_id,
+            size: raw.side === 'buy' ? size : -size,
+            entryPrice,
+            currentPrice: entryPrice,
+            unrealizedPnL: 0,
+        };
+    }
+    normalizeBalance(raw) {
+        const balance = parseFloat(raw.balance || '0');
+        const available = parseFloat(raw.available_balance || '0');
+        return [{
+                currency: raw.currency || 'GBP',
+                total: balance,
+                available,
+                locked: balance - available,
+            }];
+    }
+    // -- Private helpers ------------------------------------------------------
+    mapOrderStatus(state) {
+        switch (state) {
+            case 'created':
+                return 'pending';
+            case 'partial':
+                return 'open';
+            case 'filled':
+            case 'settled':
+                return 'filled';
+            default:
+                return 'open';
+        }
+    }
+    mapOrderType(type) {
+        switch (type) {
+            case 'immediate_or_cancel':
+                return 'market';
+            case 'good_til_cancelled':
+            case 'good_til_halted':
+            case 'keep_in_play':
+            default:
+                return 'limit';
+        }
+    }
+}
+exports.SmarketsNormalizer = SmarketsNormalizer;

package/dist/exchanges/smarkets/price.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Smarkets price and quantity conversion utilities.
+ *
+ * Smarkets uses percentage basis points (0-10000) for prices
+ * and 1/10000 GBP units for quantities.
+ */
+/**
+ * Convert Smarkets basis points (0-10000) to probability (0.0-1.0).
+ */
+export declare function fromBasisPoints(basisPoints: number): number;
+/**
+ * Convert probability (0.0-1.0) to Smarkets basis points (0-10000).
+ */
+export declare function toBasisPoints(probability: number): number;
+/**
+ * Convert Smarkets quantity units (1/10000 GBP) to GBP.
+ */
+export declare function fromQuantityUnits(units: number): number;
+/**
+ * Convert GBP to Smarkets quantity units (1/10000 GBP).
+ */
+export declare function toQuantityUnits(gbp: number): number;
+/**
+ * Get the complement probability (for binary markets: No = 1 - Yes).
+ */
+export declare function invertProbability(price: number): number;

package/dist/exchanges/smarkets/price.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Smarkets price and quantity conversion utilities.
+ *
+ * Smarkets uses percentage basis points (0-10000) for prices
+ * and 1/10000 GBP units for quantities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBasisPoints = fromBasisPoints;
+exports.toBasisPoints = toBasisPoints;
+exports.fromQuantityUnits = fromQuantityUnits;
+exports.toQuantityUnits = toQuantityUnits;
+exports.invertProbability = invertProbability;
+const BASIS_POINTS_SCALE = 10000;
+/**
+ * Convert Smarkets basis points (0-10000) to probability (0.0-1.0).
+ */
+function fromBasisPoints(basisPoints) {
+    return basisPoints / BASIS_POINTS_SCALE;
+}
+/**
+ * Convert probability (0.0-1.0) to Smarkets basis points (0-10000).
+ */
+function toBasisPoints(probability) {
+    return Math.round(probability * BASIS_POINTS_SCALE);
+}
+/**
+ * Convert Smarkets quantity units (1/10000 GBP) to GBP.
+ */
+function fromQuantityUnits(units) {
+    return units / BASIS_POINTS_SCALE;
+}
+/**
+ * Convert GBP to Smarkets quantity units (1/10000 GBP).
+ */
+function toQuantityUnits(gbp) {
+    return Math.round(gbp * BASIS_POINTS_SCALE);
+}
+/**
+ * Get the complement probability (for binary markets: No = 1 - Yes).
+ */
+function invertProbability(price) {
+    return 1 - price;
+}

package/dist/exchanges/smarkets/price.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/exchanges/smarkets/price.test.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const price_1 = require("./price");
+describe('Smarkets price conversions', () => {
+    describe('fromBasisPoints', () => {
+        test('converts basis points to a probability', () => {
+            expect((0, price_1.fromBasisPoints)(0)).toBe(0);
+            expect((0, price_1.fromBasisPoints)(5500)).toBe(0.55);
+            expect((0, price_1.fromBasisPoints)(10000)).toBe(1);
+        });
+    });
+    describe('toBasisPoints', () => {
+        test('converts a probability to basis points', () => {
+            expect((0, price_1.toBasisPoints)(0)).toBe(0);
+            expect((0, price_1.toBasisPoints)(0.55)).toBe(5500);
+            expect((0, price_1.toBasisPoints)(1)).toBe(10000);
+        });
+        test('rounds non-integer results', () => {
+            expect((0, price_1.toBasisPoints)(0.12345)).toBe(1235);
+        });
+        test('round-trips with fromBasisPoints', () => {
+            const bp = (0, price_1.toBasisPoints)(0.42);
+            expect((0, price_1.fromBasisPoints)(bp)).toBeCloseTo(0.42);
+        });
+    });
+    describe('fromQuantityUnits', () => {
+        test('converts quantity units to GBP', () => {
+            expect((0, price_1.fromQuantityUnits)(0)).toBe(0);
+            expect((0, price_1.fromQuantityUnits)(10000)).toBe(1);
+            expect((0, price_1.fromQuantityUnits)(25000)).toBe(2.5);
+        });
+    });
+    describe('toQuantityUnits', () => {
+        test('converts GBP to quantity units', () => {
+            expect((0, price_1.toQuantityUnits)(0)).toBe(0);
+            expect((0, price_1.toQuantityUnits)(1)).toBe(10000);
+            expect((0, price_1.toQuantityUnits)(2.5)).toBe(25000);
+        });
+        test('rounds fractional units', () => {
+            expect((0, price_1.toQuantityUnits)(0.123456)).toBe(1235);
+        });
+    });
+    describe('invertProbability', () => {
+        test('returns the complement of a probability', () => {
+            expect((0, price_1.invertProbability)(0)).toBe(1);
+            expect((0, price_1.invertProbability)(1)).toBe(0);
+            expect((0, price_1.invertProbability)(0.3)).toBeCloseTo(0.7);
+        });
+    });
+});

package/dist/index.d.ts

@@ -11,6 +11,8 @@ export * from './exchanges/probable';
 export * from './exchanges/baozi';
 export * from './exchanges/myriad';
 export * from './exchanges/opinion';
+export * from './exchanges/metaculus';
+export * from './exchanges/smarkets';
 export * from './server/app';
 export * from './server/utils/port-manager';
 export * from './server/utils/lock-file';
@@ -22,6 +24,8 @@ import { ProbableExchange } from './exchanges/probable';
 import { BaoziExchange } from './exchanges/baozi';
 import { MyriadExchange } from './exchanges/myriad';
 import { OpinionExchange } from './exchanges/opinion';
+import { MetaculusExchange } from './exchanges/metaculus';
+import { SmarketsExchange } from './exchanges/smarkets';
 declare const pmxt: {
     Polymarket: typeof PolymarketExchange;
     Limitless: typeof LimitlessExchange;
@@ -31,6 +35,8 @@ declare const pmxt: {
     Baozi: typeof BaoziExchange;
     Myriad: typeof MyriadExchange;
     Opinion: typeof OpinionExchange;
+    Metaculus: typeof MetaculusExchange;
+    Smarkets: typeof SmarketsExchange;
 };
 export declare const Polymarket: typeof PolymarketExchange;
 export declare const Limitless: typeof LimitlessExchange;
@@ -40,4 +46,6 @@ export declare const Probable: typeof ProbableExchange;
 export declare const Baozi: typeof BaoziExchange;
 export declare const Myriad: typeof MyriadExchange;
 export declare const Opinion: typeof OpinionExchange;
+export declare const Metaculus: typeof MetaculusExchange;
+export declare const Smarkets: typeof SmarketsExchange;
 export default pmxt;

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Opinion = exports.Myriad = exports.Baozi = exports.Probable = exports.KalshiDemo = exports.Kalshi = exports.Limitless = exports.Polymarket = exports.parseOpenApiSpec = void 0;
+exports.Smarkets = exports.Metaculus = exports.Opinion = exports.Myriad = exports.Baozi = exports.Probable = exports.KalshiDemo = exports.Kalshi = exports.Limitless = exports.Polymarket = exports.parseOpenApiSpec = void 0;
 __exportStar(require("./BaseExchange"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils/math"), exports);
@@ -29,6 +29,8 @@ __exportStar(require("./exchanges/probable"), exports);
 __exportStar(require("./exchanges/baozi"), exports);
 __exportStar(require("./exchanges/myriad"), exports);
 __exportStar(require("./exchanges/opinion"), exports);
+__exportStar(require("./exchanges/metaculus"), exports);
+__exportStar(require("./exchanges/smarkets"), exports);
 __exportStar(require("./server/app"), exports);
 __exportStar(require("./server/utils/port-manager"), exports);
 __exportStar(require("./server/utils/lock-file"), exports);
@@ -40,6 +42,8 @@ const probable_1 = require("./exchanges/probable");
 const baozi_1 = require("./exchanges/baozi");
 const myriad_1 = require("./exchanges/myriad");
 const opinion_1 = require("./exchanges/opinion");
+const metaculus_1 = require("./exchanges/metaculus");
+const smarkets_1 = require("./exchanges/smarkets");
 const pmxt = {
     Polymarket: polymarket_1.PolymarketExchange,
     Limitless: limitless_1.LimitlessExchange,
@@ -49,6 +53,8 @@ const pmxt = {
     Baozi: baozi_1.BaoziExchange,
     Myriad: myriad_1.MyriadExchange,
     Opinion: opinion_1.OpinionExchange,
+    Metaculus: metaculus_1.MetaculusExchange,
+    Smarkets: smarkets_1.SmarketsExchange,
 };
 exports.Polymarket = polymarket_1.PolymarketExchange;
 exports.Limitless = limitless_1.LimitlessExchange;
@@ -58,4 +64,6 @@ exports.Probable = probable_1.ProbableExchange;
 exports.Baozi = baozi_1.BaoziExchange;
 exports.Myriad = myriad_1.MyriadExchange;
 exports.Opinion = opinion_1.OpinionExchange;
+exports.Metaculus = metaculus_1.MetaculusExchange;
+exports.Smarkets = smarkets_1.SmarketsExchange;
 exports.default = pmxt;

package/dist/server/app.js

@@ -14,6 +14,8 @@ const probable_1 = require("../exchanges/probable");
 const baozi_1 = require("../exchanges/baozi");
 const myriad_1 = require("../exchanges/myriad");
 const opinion_1 = require("../exchanges/opinion");
+const metaculus_1 = require("../exchanges/metaculus");
+const smarkets_1 = require("../exchanges/smarkets");
 const errors_1 = require("../errors");
 // Singleton instances for local usage (when no credentials provided)
 const defaultExchanges = {
@@ -25,6 +27,8 @@ const defaultExchanges = {
     baozi: null,
     myriad: null,
     opinion: null,
+    metaculus: null,
+    smarkets: null,
 };
 async function startServer(port, accessToken) {
     const app = (0, express_1.default)();
@@ -58,7 +62,10 @@ async function startServer(port, accessToken) {
             // If credentials are provided, create a new instance for this request
             // Otherwise, use the singleton instance
             let exchange;
-            if (credentials && (credentials.privateKey || credentials.apiKey)) {
+            if (credentials &&
+                (credentials.privateKey ||
+                    credentials.apiKey ||
+                    credentials.apiToken)) {
                 exchange = createExchange(exchangeName, credentials);
             }
             else {
@@ -143,8 +150,11 @@ function createExchange(name, credentials) {
                 apiKey: credentials?.apiKey || process.env.POLYMARKET_API_KEY,
                 apiSecret: credentials?.apiSecret || process.env.POLYMARKET_API_SECRET,
                 passphrase: credentials?.passphrase || process.env.POLYMARKET_PASSPHRASE,
-                funderAddress: credentials?.funderAddress,
-                signatureType: credentials?.signatureType,
+                funderAddress: credentials?.funderAddress ||
+                    process.env.POLYMARKET_FUNDER_ADDRESS ||
+                    process.env.POLYMARKET_PROXY_ADDRESS,
+                signatureType: credentials?.signatureType ||
+                    process.env.POLYMARKET_SIGNATURE_TYPE,
             });
         case "limitless":
             return new limitless_1.LimitlessExchange({
@@ -193,6 +203,15 @@ function createExchange(name, credentials) {
                 privateKey: credentials?.privateKey || process.env.OPINION_PRIVATE_KEY,
                 funderAddress: credentials?.funderAddress,
             });
+        case "metaculus":
+            return new metaculus_1.MetaculusExchange({
+                apiToken: credentials?.apiToken || process.env.METACULUS_API_TOKEN,
+            });
+        case "smarkets":
+            return new smarkets_1.SmarketsExchange({
+                apiKey: credentials?.apiKey || process.env.SMARKETS_EMAIL,
+                privateKey: credentials?.privateKey || process.env.SMARKETS_PASSWORD,
+            });
         default:
             throw new Error(`Unknown exchange: ${name}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxt-core",
-  "version": "2.22.2",
+  "version": "2.24.0",
   "description": "pmxt is a unified prediction market data API. The ccxt for prediction markets.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,8 +29,8 @@
     "test": "jest -c jest.config.js",
     "server": "tsx watch src/server/index.ts",
     "server:prod": "node dist/server/index.js",
-    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=2.22.2,library=urllib3",
-    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=2.22.2,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
+    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=2.24.0,library=urllib3",
+    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=2.24.0,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
     "fetch:openapi": "node scripts/fetch-openapi-specs.js",
     "extract:jsdoc": "node ../scripts/extract-jsdoc.js",
     "generate:docs": "npm run extract:jsdoc && node ../scripts/generate-api-docs.js",