mcp-prqx-pricer 1.0.4 → 1.0.6

package/build/index.js

@@ -10,6 +10,8 @@ const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const axios_1 = __importDefault(require("axios"));
 const getProductions_1 = require("./tools/getProductions");
 const getProductionInventory_1 = require("./tools/getProductionInventory");
+const getPricingGroups_1 = require("./tools/getPricingGroups");
+const createPricingGroup_1 = require("./tools/createPricingGroup");
 class PrqxMcpServer {
     server;
     axiosInstance;
@@ -33,6 +35,8 @@ class PrqxMcpServer {
         });
         this.tools.push(new getProductions_1.GetProductionsTool());
         this.tools.push(new getProductionInventory_1.GetProductionInventoryTool());
+        this.tools.push(new getPricingGroups_1.GetPricingGroupsTool());
+        this.tools.push(new createPricingGroup_1.CreatePricingGroupTool());
         this.setupToolHandlers();
         this.server.onerror = (error) => {
             console.error('[Error] MCP server error:', error);

package/build/tools/createPricingGroup.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreatePricingGroupTool = void 0;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+class CreatePricingGroupTool {
+    name = 'CreatePricingGroup';
+    description = 'Create a new pricing group';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            productionId: {
+                type: 'number',
+                description: 'ID of the production that the pricing group will be created for'
+            },
+            name: {
+                type: 'string',
+                description: 'Name of the pricing group'
+            },
+            ceilingPrice: {
+                type: 'number',
+                description: 'Maximum price that the pricing group tickets can have'
+            },
+            floorPrice: {
+                type: 'number',
+                description: 'Minimum price that the pricing group tickets can have'
+            },
+            pricingGroupMode: {
+                type: 'string',
+                description: '(AutoPrice or SimulationOnly) Mode of the pricing group'
+            },
+            amount: {
+                type: 'number',
+                description: 'Amount used to price the anchor ticket of the pricing group based on the first market comparable'
+            },
+            increment: {
+                type: 'string',
+                description: '(increase or decrease) Decides if the amount is applied to increase or decrease the price of the anchor ticket of the pricing group based on the first market comparable'
+            },
+            incrementMethod: {
+                type: 'string',
+                description: '( % or $ ) Decides if the amount is applied as a percentage or a dollar amount'
+            },
+            offsetAmount: {
+                type: 'number',
+                description: 'Offset amount used to price the other tickets in the group based of the previously ranked ticket'
+            },
+            offsetIncrement: {
+                type: 'string',
+                description: '(increase or decrease) Decides if the offset amount is applied to increase or decrease the price of the other tickets in the group based of the previously ranked ticket'
+            },
+            offsetIncrementMethod: {
+                type: 'string',
+                description: '( % or $ ) Decides if the offset amount is applied as a percentage or a dollar amount'
+            },
+            enableShareOptions: {
+                type: 'boolean',
+                description: 'Decides if the pricing group will control the sharing of tickets in a marketplace or not'
+            },
+            shareOptionsType: {
+                type: 'string',
+                description: '(custom or all) Decides if we use custom parameters to share the tickets in the group or if we share them all'
+            },
+            shareAnchor: {
+                type: 'number',
+                description: 'Controls if the anchor ticket of the pricing group will be shared'
+            },
+            customSharingAmount: {
+                type: 'number',
+                description: 'Custom sharing amount use to determine which tickets to share of this pricing group'
+            },
+            customSharingMethod: {
+                type: 'string',
+                description: '( % or $ ) Decides if the custom sharing amount is applied as a percentage or a dollar amount'
+            },
+            applyCeilingOnlyToAnchor: {
+                type: 'boolean',
+                description: 'Decides if the ceiling price will be applied only to the anchor ticket of the pricing group'
+            },
+            applyFloorOnlyToAnchor: {
+                type: 'boolean',
+                description: 'Decides if the floor price will be applied only to the anchor ticket of the pricing group'
+            },
+            floorPricingMethod: {
+                type: 'string',
+                description: '(standard, variable, useFloor or floorRandomize) Decides what method to apply for pricing when the market comparable for the pricing group hits the floor price'
+            },
+            ceilingPricingMethod: {
+                type: 'string',
+                description: '(standard, variable, useCeiling or ceilingRandomize) Decides what method to apply for pricing when the market comparable for the pricing group hits the ceiling price'
+            },
+            noCompPricingMethod: {
+                type: 'string',
+                description: '(standard, variable, ceiling, freezePricing, useFloorForAnchor, useCeilingForAnchor, useCeiling, ceilingRandomize) Decides what method to apply for pricing when there is no market comparables for the pricing group'
+            },
+            pricingGroupRequestRanks: {
+                type: 'array',
+                description: 'Array of objects containing pricing group request ranks starting at 0 (anchor ticket). i.e [{"ticketGroupId": 1, "rank": 0},...]'
+            }
+        },
+        mandatory: ['productionId', 'name', 'ceilingPrice', 'floorPrice', 'pricingGroupMode', 'amount', 'increment', 'incrementMethod', 'pricingGroupRequestRanks']
+    };
+    toolHandler = async (request, httpClient) => {
+        try {
+            if (!request?.params?.arguments) {
+                throw new Error('Missing arguments');
+            }
+            const productionId = request.params.arguments.productionId;
+            const name = request.params.arguments.name;
+            const ceilingPrice = request.params.arguments.ceilingPrice;
+            const floorPrice = request.params.arguments.floorPrice;
+            const pricingGroupRequestType = request.params.arguments.pricingGroupMode;
+            const amount = request.params.arguments.amount;
+            const increment = request.params.arguments.increment;
+            const incrementMethod = request.params.arguments.incrementMethod;
+            const offsetAmount = request.params.arguments.offsetAmount;
+            const offsetIncrement = request.params.arguments.offsetIncrement;
+            const offsetIncrementMethod = request.params.arguments.offsetIncrementMethod;
+            const enableShareOptions = request.params.arguments.enableShareOptions;
+            const shareOptionsType = request.params.arguments.shareOptionsType;
+            const shareAnchor = request.params.arguments.shareAnchor;
+            const customSharingAmount = request.params.arguments.customSharingAmount;
+            const customSharingMethod = request.params.arguments.customSharingMethod;
+            const applyCeilingOnlyToAnchor = request.params.arguments.applyCeilingOnlyToAnchor;
+            const applyFloorOnlyToAnchor = request.params.arguments.applyFloorOnlyToAnchor;
+            const floorPricingMethod = request.params.arguments.floorPricingMethod;
+            const ceilingPricingMethod = request.params.arguments.ceilingPricingMethod;
+            const noCompPricingMethod = request.params.arguments.noCompPricingMethod;
+            const pricingGroupRequestRanks = request.params.arguments.pricingGroupRequestRanks;
+            const args = {
+                productionId: productionId,
+                name: name,
+                ceilingPrice: ceilingPrice,
+                floorPrice: floorPrice,
+                pricingGroupRequestType: pricingGroupRequestType,
+                ruleSet: {
+                    amount: amount,
+                    increment: increment,
+                    incrementMethod: incrementMethod,
+                    offsetAmount: offsetAmount,
+                    offsetIncrement: offsetIncrement,
+                    offsetIncrementMethod: offsetIncrementMethod,
+                    enableShareOptions: enableShareOptions,
+                    shareOptionsType: shareOptionsType,
+                    shareAnchor: shareAnchor,
+                    customSharingAmount: customSharingAmount,
+                    customSharingMethod: customSharingMethod,
+                    applyCeilingOnlyToAnchor: applyCeilingOnlyToAnchor,
+                    applyFloorOnlyToAnchor: applyFloorOnlyToAnchor,
+                    floorPricingMethod: floorPricingMethod,
+                    ceilingPricingMethod: ceilingPricingMethod,
+                    noCompPricingMethod: noCompPricingMethod
+                },
+                marketGroupCriteria: {},
+                pricingGroupRequestRanks: pricingGroupRequestRanks
+            };
+            console.error('[API] Create Pricing Group with arguments:', args);
+            const response = await httpClient.post(`/v2/client/pricing-group`, args);
+            if (response.status !== 200) {
+                throw new Error(`API error: ${response.statusText}`);
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(response.data) }] };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error('Error in Create Pricing Group:', error);
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create pricing group: ${error.message}`);
+            }
+            throw error;
+        }
+    };
+}
+exports.CreatePricingGroupTool = CreatePricingGroupTool;

package/build/tools/getPricingGroups.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPricingGroupsTool = void 0;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+class GetPricingGroupsTool {
+    name = 'GetPricingGroups';
+    description = 'Get the organization pricing groups for a single production';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            productionId: {
+                type: 'number',
+                description: 'ID of the production'
+            }
+        },
+        mandatory: ['productionId']
+    };
+    toolHandler = async (request, httpClient) => {
+        try {
+            const args = request.params.arguments;
+            console.error('[API] Get Pricing Groups with arguments:', args);
+            const response = await httpClient.get(`/v2/client/pricing-group/production/${args.productionId}`);
+            if (response.status !== 200) {
+                throw new Error(`API error: ${response.statusText}`);
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(response.data) }] };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error('Error in Get Pricing Groups:', error);
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to fetch data: ${error.message}`);
+            }
+            throw error;
+        }
+    };
+}
+exports.GetPricingGroupsTool = GetPricingGroupsTool;

package/build/types/pricingGroup.js

@@ -0,0 +1,53 @@
+"use strict";
+// TypeScript interfaces for /v2/client/pricing-group/production/{ProductionId} response
+// Generated based on OpenAPI pricer.json
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoCompPricingMethod = exports.CeilingPricingMethod = exports.FloorPricingMethod = exports.ShareOptionsType = exports.CustomSharingMethod = exports.PricingGroupRequestType = exports.LowerOutlierMethod = void 0;
+var LowerOutlierMethod;
+(function (LowerOutlierMethod) {
+    LowerOutlierMethod[LowerOutlierMethod["Quantity"] = 0] = "Quantity";
+    LowerOutlierMethod[LowerOutlierMethod["Currency"] = 1] = "Currency";
+    LowerOutlierMethod[LowerOutlierMethod["Percentage"] = 2] = "Percentage";
+    LowerOutlierMethod[LowerOutlierMethod["PercentThresholdOfPosition"] = 3] = "PercentThresholdOfPosition";
+    LowerOutlierMethod[LowerOutlierMethod["CurrencyThresholdOfPosition"] = 4] = "CurrencyThresholdOfPosition";
+})(LowerOutlierMethod || (exports.LowerOutlierMethod = LowerOutlierMethod = {}));
+var PricingGroupRequestType;
+(function (PricingGroupRequestType) {
+    PricingGroupRequestType[PricingGroupRequestType["AutoPrice"] = 0] = "AutoPrice";
+    PricingGroupRequestType[PricingGroupRequestType["SimulationOnly"] = 1] = "SimulationOnly";
+})(PricingGroupRequestType || (exports.PricingGroupRequestType = PricingGroupRequestType = {}));
+var CustomSharingMethod;
+(function (CustomSharingMethod) {
+    CustomSharingMethod["Percentage"] = "%";
+    CustomSharingMethod["Currency"] = "$";
+})(CustomSharingMethod || (exports.CustomSharingMethod = CustomSharingMethod = {}));
+var ShareOptionsType;
+(function (ShareOptionsType) {
+    ShareOptionsType[ShareOptionsType["Custom"] = 0] = "Custom";
+    ShareOptionsType[ShareOptionsType["All"] = 1] = "All";
+})(ShareOptionsType || (exports.ShareOptionsType = ShareOptionsType = {}));
+var FloorPricingMethod;
+(function (FloorPricingMethod) {
+    FloorPricingMethod[FloorPricingMethod["Standard"] = 0] = "Standard";
+    FloorPricingMethod[FloorPricingMethod["Variable"] = 1] = "Variable";
+    FloorPricingMethod[FloorPricingMethod["UseFloor"] = 2] = "UseFloor";
+    FloorPricingMethod[FloorPricingMethod["FloorRandomize"] = 3] = "FloorRandomize";
+})(FloorPricingMethod || (exports.FloorPricingMethod = FloorPricingMethod = {}));
+var CeilingPricingMethod;
+(function (CeilingPricingMethod) {
+    CeilingPricingMethod[CeilingPricingMethod["Standard"] = 0] = "Standard";
+    CeilingPricingMethod[CeilingPricingMethod["Variable"] = 1] = "Variable";
+    CeilingPricingMethod[CeilingPricingMethod["UseCeiling"] = 2] = "UseCeiling";
+    CeilingPricingMethod[CeilingPricingMethod["CeilingRandomize"] = 3] = "CeilingRandomize";
+})(CeilingPricingMethod || (exports.CeilingPricingMethod = CeilingPricingMethod = {}));
+var NoCompPricingMethod;
+(function (NoCompPricingMethod) {
+    NoCompPricingMethod[NoCompPricingMethod["Standard"] = 0] = "Standard";
+    NoCompPricingMethod[NoCompPricingMethod["Variable"] = 1] = "Variable";
+    NoCompPricingMethod[NoCompPricingMethod["Ceiling"] = 2] = "Ceiling";
+    NoCompPricingMethod[NoCompPricingMethod["FreezePricing"] = 3] = "FreezePricing";
+    NoCompPricingMethod[NoCompPricingMethod["UseFloorForAnchor"] = 4] = "UseFloorForAnchor";
+    NoCompPricingMethod[NoCompPricingMethod["UseCeilingForAnchor"] = 5] = "UseCeilingForAnchor";
+    NoCompPricingMethod[NoCompPricingMethod["UseCeiling"] = 6] = "UseCeiling";
+    NoCompPricingMethod[NoCompPricingMethod["CeilingRandomize"] = 7] = "CeilingRandomize";
+})(NoCompPricingMethod || (exports.NoCompPricingMethod = NoCompPricingMethod = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-prqx-pricer",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "",
   "main": "index.js",
   "bin": {

package/src/index.ts

@@ -12,6 +12,8 @@ import {
 import { McpTool } from "./types/tool";
 import { GetProductionsTool } from "./tools/getProductions";
 import { GetProductionInventoryTool } from "./tools/getProductionInventory";
+import { GetPricingGroupsTool } from "./tools/getPricingGroups";
+import { CreatePricingGroupTool } from "./tools/createPricingGroup";
 
   class PrqxMcpServer{
     private server: Server;
@@ -40,6 +42,8 @@ import { GetProductionInventoryTool } from "./tools/getProductionInventory";
 
       this.tools.push(new GetProductionsTool());
       this.tools.push(new GetProductionInventoryTool());
+      this.tools.push(new GetPricingGroupsTool());
+      this.tools.push(new CreatePricingGroupTool());
       this.setupToolHandlers();
 
       this.server.onerror = (error) => {

package/src/tools/createPricingGroup.ts

@@ -0,0 +1,174 @@
+import { McpTool } from "../types/tool";
+import { CallToolRequest, ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import axios from "axios";
+import { CeilingPricingMethod, CustomSharingMethod, FloorPricingMethod, NoCompPricingMethod, PricingGroupRequest, PricingGroupRequestType, PricingGroupResponse, ShareOptionsType, TicketGroupRequestRank } from "../types/pricingGroup";
+
+export class CreatePricingGroupTool implements McpTool {
+    name = 'CreatePricingGroup';
+    description = 'Create a new pricing group';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            productionId: {
+                type: 'number',
+                description: 'ID of the production that the pricing group will be created for'
+            },
+            name: {
+                type: 'string',
+                description: 'Name of the pricing group'
+            },
+            ceilingPrice: {
+                type: 'number',
+                description: 'Maximum price that the pricing group tickets can have'
+            },
+            floorPrice: {
+                type: 'number',
+                description: 'Minimum price that the pricing group tickets can have'
+            },
+            pricingGroupMode: {
+                type: 'string',
+                description: '(AutoPrice or SimulationOnly) Mode of the pricing group'
+            },
+            amount: {
+                type: 'number',
+                description: 'Amount used to price the anchor ticket of the pricing group based on the first market comparable'
+            },
+            increment:{
+                type: 'string',
+                description: '(increase or decrease) Decides if the amount is applied to increase or decrease the price of the anchor ticket of the pricing group based on the first market comparable'
+            },
+            incrementMethod: {
+                type: 'string',
+                description: '( % or $ ) Decides if the amount is applied as a percentage or a dollar amount'
+            },
+            offsetAmount: {
+                type: 'number',
+                description: 'Offset amount used to price the other tickets in the group based of the previously ranked ticket'
+            },
+            offsetIncrement: {
+                type: 'string',
+                description: '(increase or decrease) Decides if the offset amount is applied to increase or decrease the price of the other tickets in the group based of the previously ranked ticket'
+            },
+            offsetIncrementMethod: {
+                type: 'string',
+                description: '( % or $ ) Decides if the offset amount is applied as a percentage or a dollar amount'
+            },
+            enableShareOptions: {
+                type: 'boolean',
+                description: 'Decides if the pricing group will control the sharing of tickets in a marketplace or not'
+            },
+            shareOptionsType: {
+                type: 'string',
+                description: '(custom or all) Decides if we use custom parameters to share the tickets in the group or if we share them all'
+            },
+            shareAnchor: {
+                type: 'number',
+                description: 'Controls if the anchor ticket of the pricing group will be shared'
+            },
+            customSharingAmount: {
+                type: 'number',
+                description: 'Custom sharing amount use to determine which tickets to share of this pricing group'
+            },
+            customSharingMethod: {
+                type: 'string',
+                description: '( % or $ ) Decides if the custom sharing amount is applied as a percentage or a dollar amount'
+            },
+            applyCeilingOnlyToAnchor: {
+                type: 'boolean',
+                description: 'Decides if the ceiling price will be applied only to the anchor ticket of the pricing group'
+            },
+            applyFloorOnlyToAnchor: {
+                type: 'boolean',
+                description: 'Decides if the floor price will be applied only to the anchor ticket of the pricing group'
+            },
+            floorPricingMethod: {
+                type: 'string',
+                description: '(standard, variable, useFloor or floorRandomize) Decides what method to apply for pricing when the market comparable for the pricing group hits the floor price'
+            },
+            ceilingPricingMethod: {
+                type: 'string',
+                description: '(standard, variable, useCeiling or ceilingRandomize) Decides what method to apply for pricing when the market comparable for the pricing group hits the ceiling price'
+            },
+            noCompPricingMethod: {
+                type: 'string',
+                description: '(standard, variable, ceiling, freezePricing, useFloorForAnchor, useCeilingForAnchor, useCeiling, ceilingRandomize) Decides what method to apply for pricing when there is no market comparables for the pricing group'
+            },
+            pricingGroupRequestRanks: {
+                type: 'array',
+                description: 'Array of objects containing pricing group request ranks starting at 0 (anchor ticket). i.e [{"ticketGroupId": 1, "rank": 0},...]'
+            }
+        },
+        mandatory: ['productionId', 'name', 'ceilingPrice', 'floorPrice', 'pricingGroupMode', 'amount', 'increment', 'incrementMethod', 'pricingGroupRequestRanks']
+    };
+    toolHandler = async (request: CallToolRequest, httpClient: axios.AxiosInstance) => {
+        try{
+            if (!request?.params?.arguments) {
+                throw new Error('Missing arguments');
+            }
+
+            const productionId = request.params.arguments.productionId as number;
+            const name = request.params.arguments.name as string;
+            const ceilingPrice = request.params.arguments.ceilingPrice as number;
+            const floorPrice = request.params.arguments.floorPrice as number;
+            const pricingGroupRequestType = request.params.arguments.pricingGroupMode as PricingGroupRequestType;
+            const amount = request.params.arguments.amount as number;
+            const increment = request.params.arguments.increment as string;
+            const incrementMethod = request.params.arguments.incrementMethod as string;
+            const offsetAmount = request.params.arguments.offsetAmount as number | undefined;
+            const offsetIncrement = request.params.arguments.offsetIncrement as string | undefined;
+            const offsetIncrementMethod = request.params.arguments.offsetIncrementMethod as string | undefined;
+            const enableShareOptions = request.params.arguments.enableShareOptions as boolean | undefined;
+            const shareOptionsType = request.params.arguments.shareOptionsType as ShareOptionsType | undefined;
+            const shareAnchor = request.params.arguments.shareAnchor as number | undefined;
+            const customSharingAmount = request.params.arguments.customSharingAmount as number | undefined;
+            const customSharingMethod = request.params.arguments.customSharingMethod as CustomSharingMethod | undefined;
+            const applyCeilingOnlyToAnchor = request.params.arguments.applyCeilingOnlyToAnchor as boolean | undefined;
+            const applyFloorOnlyToAnchor = request.params.arguments.applyFloorOnlyToAnchor as boolean | undefined;
+            const floorPricingMethod = request.params.arguments.floorPricingMethod as FloorPricingMethod | undefined;
+            const ceilingPricingMethod = request.params.arguments.ceilingPricingMethod as CeilingPricingMethod | undefined;
+            const noCompPricingMethod = request.params.arguments.noCompPricingMethod as NoCompPricingMethod | undefined;
+            const pricingGroupRequestRanks = request.params.arguments.pricingGroupRequestRanks as TicketGroupRequestRank[];
+
+            const args : PricingGroupRequest = {
+                productionId: productionId,
+                name: name,
+                ceilingPrice: ceilingPrice,
+                floorPrice: floorPrice,
+                pricingGroupRequestType: pricingGroupRequestType,
+                ruleSet: {
+                    amount: amount,
+                    increment: increment,
+                    incrementMethod: incrementMethod,
+                    offsetAmount: offsetAmount,
+                    offsetIncrement: offsetIncrement,
+                    offsetIncrementMethod: offsetIncrementMethod,
+                    enableShareOptions: enableShareOptions,
+                    shareOptionsType: shareOptionsType,
+                    shareAnchor: shareAnchor,
+                    customSharingAmount: customSharingAmount,
+                    customSharingMethod: customSharingMethod,
+                    applyCeilingOnlyToAnchor: applyCeilingOnlyToAnchor,
+                    applyFloorOnlyToAnchor: applyFloorOnlyToAnchor,
+                    floorPricingMethod: floorPricingMethod,
+                    ceilingPricingMethod: ceilingPricingMethod,
+                    noCompPricingMethod: noCompPricingMethod
+                },
+                marketGroupCriteria: {},
+                pricingGroupRequestRanks: pricingGroupRequestRanks
+            };
+            console.error('[API] Create Pricing Group with arguments:', args);
+            const response = await httpClient.post<PricingGroupResponse>(`/v2/client/pricing-group`, args);
+            if (response.status !== 200) {
+                throw new Error(`API error: ${response.statusText}`);
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(response.data) }] };
+        } catch (error) {
+            if (error instanceof Error) {
+                console.error('Error in Create Pricing Group:', error);
+                throw new McpError(ErrorCode.InternalError, `Failed to create pricing group: ${error.message}`);
+            }
+            throw error;
+        }
+    };
+}
+

package/src/tools/getPricingGroups.ts

@@ -0,0 +1,37 @@
+import { CallToolRequest } from "@modelcontextprotocol/sdk/types.js";
+import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { AxiosInstance } from "axios";
+import { McpTool } from "../types/tool";
+import { GetPricingGroupByProductionIdResponse } from "../types/pricingGroup";
+
+export class GetPricingGroupsTool implements McpTool {
+    name = 'GetPricingGroups';
+    description = 'Get the organization pricing groups for a single production';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            productionId: {
+                type: 'number',
+                description: 'ID of the production'
+            }
+        },
+        mandatory: ['productionId']
+    };
+    toolHandler = async (request: CallToolRequest, httpClient: AxiosInstance) => {
+        try {
+            const args = request.params.arguments as { productionId: number };
+            console.error('[API] Get Pricing Groups with arguments:', args);
+            const response = await httpClient.get<GetPricingGroupByProductionIdResponse>(`/v2/client/pricing-group/production/${args.productionId}`);
+            if (response.status !== 200) {
+                throw new Error(`API error: ${response.statusText}`);
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(response.data) }] };
+        } catch (error) {
+            if (error instanceof Error) {
+                console.error('Error in Get Pricing Groups:', error);
+                throw new McpError(ErrorCode.InternalError, `Failed to fetch data: ${error.message}`);
+            }
+            throw error;
+        }
+    };
+}    

package/src/types/pricingGroup.ts

@@ -0,0 +1,148 @@
+// TypeScript interfaces for /v2/client/pricing-group/production/{ProductionId} response
+// Generated based on OpenAPI pricer.json
+
+export interface PricingGroupResponse {
+  id: number;
+  name?: string | null;
+  ceilingPrice?: number | null;
+  floorPrice: number;
+  retailCeilingPrice?: number | null;
+  retailFloorPrice?: number | null;
+  ruleSet: RuleDto;
+  marketGroupCriteria: MarketCriteriaDto;
+  dynamicMarketGroupCriteria: DynamicMarketGroupCriteriaDto;
+  pricingGroupTickets?: PricingGroupTicketsResult[] | null;
+  isAutoPricingEnabled: boolean;
+}
+
+export enum LowerOutlierMethod{
+  Quantity,
+  Currency,
+  Percentage,
+  PercentThresholdOfPosition,
+  CurrencyThresholdOfPosition
+}
+
+export interface RowRange {
+  startRow: number;
+  endRow: number;
+}
+
+export interface MarketCriteriaDto {
+  sections?: SectionDto[];
+  validSplitsIncludeV2?: number[];
+  validSplitsIncludeMax?: boolean;
+  deliveryMethodInclude?: string[];
+  attributesExclude?: string[];
+  lowerOutlierMethod?: LowerOutlierMethod;
+  lowerOutlierAmount?: number;
+  lowerOutlierThreshold?: number;
+  includeSpeculativeTickets?: boolean;
+  isSplitsDynamic?: boolean;
+  rowRanges?: RowRange[];
+}
+
+export interface SectionDto {
+  sectionName?: string;
+  sectionKey?: string;
+  rowRanges?: RowRange[];
+}
+
+export interface DynamicMarketGroupCriteriaDto {
+  validSplitsV2: ValidSplits;
+}
+
+export interface ValidSplits {
+  splits?: number[] | null;
+  includeMax: boolean;
+}
+
+export interface PricingGroupTicketsResult {
+  ticketGroupId: number;
+  rank?: number | null;
+  listPrice?: number | null;
+  retailPrice?: number | null;
+  isShared?: boolean | null;
+  isFloorHit: boolean;
+  isCeilingHit: boolean;
+  isNoActiveCompHit: boolean;
+}
+
+export enum PricingGroupRequestType{
+  AutoPrice,
+  SimulationOnly
+}
+
+export interface RuleDto{
+  increment?: string;
+  incrementMethod?: string;
+  amount: number;
+  offsetIncrement?: string;
+  offsetIncrementMethod?: string;
+  offsetAmount?: number;
+  enableShareOptions?: boolean;
+  shareOptionsType?: ShareOptionsType;
+  shareAnchor?: number;
+  floorPricingMethod?: FloorPricingMethod;
+  ceilingPricingMethod?: CeilingPricingMethod;
+  noCompPricingMethod?: NoCompPricingMethod;
+  customSharingAmount?: number;
+  customSharingMethod?: CustomSharingMethod;
+  applyCeilingOnlyToAnchor?: boolean;
+  applyFloorOnlyToAnchor?: boolean;
+}
+
+export enum CustomSharingMethod{
+  Percentage = "%",
+  Currency = "$"
+}
+
+export enum ShareOptionsType{
+  Custom,
+  All
+}
+
+export enum FloorPricingMethod{
+  Standard,
+  Variable,
+  UseFloor,
+  FloorRandomize
+}
+
+export enum CeilingPricingMethod{
+  Standard,
+  Variable,
+  UseCeiling,
+  CeilingRandomize
+}
+
+export enum NoCompPricingMethod{
+  Standard,
+  Variable,
+  Ceiling,
+  FreezePricing,
+  UseFloorForAnchor,
+  UseCeilingForAnchor,
+  UseCeiling,
+  CeilingRandomize
+}
+
+export interface PricingGroupRequest{
+  name?: string;
+  ceilingPrice?: number;
+  floorPrice?: number;
+  pricingGroupRequestType?: PricingGroupRequestType;
+  pricingGroupRequestRanks: TicketGroupRequestRank[];
+  ruleSet: RuleDto;
+  marketGroupCriteria: MarketCriteriaDto;
+  productionId: number;
+  pricingTemplateId?: number;
+}
+
+export interface TicketGroupRequestRank{
+  ticketGroupId: number;
+  rank: number;
+}
+
+// The response for the endpoint is an array of PricingGroupResponse
+export type GetPricingGroupByProductionIdResponse = PricingGroupResponse[];