@bosonprotocol/agentic-commerce 1.0.0-alpha.46 → 1.0.0-alpha.48

package/dist/boson/mcp-server/resourceParameterTypes.d.ts

@@ -0,0 +1,498 @@
+import { z } from "zod";
+import { type ActualDisputeResolversFilterParams } from "./filters/disputeResolversFilter.js";
+import { type ActualDisputesFilterParams } from "./filters/disputesFilter.js";
+import { type ActualExchangesFilterParams } from "./filters/exchangesFilter.js";
+import { type ActualFundsFilterParams } from "./filters/fundsFilter.js";
+import { type ActualOffersFilterParams } from "./filters/offersFilter.js";
+import { type ActualProductsFilterParams } from "./filters/productsFilter.js";
+import { type ActualSellersByAddressFilterParams } from "./filters/sellersByAddressFilter.js";
+import { type ActualSellersFilterParams } from "./filters/sellersFilter.js";
+export type FundsResourceParams = {
+    fundsSkip?: number;
+    fundsFirst?: number;
+    fundsOrderBy?: string;
+    fundsOrderDirection?: string;
+} & {
+    [K in ActualFundsFilterParams]?: string;
+};
+export type DisputesResourceParams = {
+    disputesSkip?: number;
+    disputesFirst?: number;
+    disputesOrderBy?: string;
+    disputesOrderDirection?: string;
+} & {
+    [K in ActualDisputesFilterParams]?: string;
+};
+export type ExchangesResourceParams = {
+    exchangesSkip?: number;
+    exchangesFirst?: number;
+    exchangesOrderBy?: string;
+    exchangesOrderDirection?: string;
+} & {
+    [K in ActualExchangesFilterParams]?: string;
+};
+export type OffersResourceParams = {
+    offersSkip?: number;
+    offersFirst?: number;
+    offersOrderBy?: string;
+    offersOrderDirection?: string;
+    exchangesSkip?: number;
+    exchangesFirst?: number;
+    exchangesOrderBy?: string;
+    exchangesOrderDirection?: string;
+    includeExchanges?: boolean;
+} & {
+    [K in ActualOffersFilterParams]?: string;
+};
+export type SellersResourceParams = {
+    sellersSkip?: number;
+    sellersFirst?: number;
+    sellersOrderBy?: string;
+    sellersOrderDirection?: string;
+    includeExchanges?: boolean;
+    includeOffers?: boolean;
+    includeFunds?: boolean;
+    includeLogs?: boolean;
+} & {
+    [K in ActualSellersFilterParams]?: string;
+};
+export type DisputeResolversResourceParams = {
+    disputeResolversSkip?: number;
+    disputeResolversFirst?: number;
+    disputeResolversOrderBy?: string;
+    disputeResolversOrderDirection?: string;
+} & {
+    [K in ActualDisputeResolversFilterParams]?: string;
+};
+export type SellersByAddressResourceParams = {
+    address: string;
+    sellersSkip?: number;
+    sellersFirst?: number;
+    sellersOrderBy?: string;
+    sellersOrderDirection?: string;
+    includeExchanges?: boolean;
+    includeOffers?: boolean;
+    includeFunds?: boolean;
+    includeLogs?: boolean;
+} & {
+    [K in ActualSellersByAddressFilterParams]?: string;
+};
+export type ProductsResourceParams = {
+    productsSkip?: number;
+    productsFirst?: number;
+    productsOrderBy?: string;
+    productsOrderDirection?: string;
+} & {
+    [K in ActualProductsFilterParams]?: string;
+};
+export type SignerAddressResourceParams = Record<string, never>;
+export declare const fundsResourceParamsValidation: z.ZodObject<{
+    fundsSkip: z.ZodOptional<z.ZodNumber>;
+    fundsFirst: z.ZodOptional<z.ZodNumber>;
+    fundsOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    fundsOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    fundsFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    fundsFilter?: Record<string, unknown>;
+    fundsSkip?: number;
+    fundsFirst?: number;
+    fundsOrderBy?: string;
+    fundsOrderDirection?: string;
+}, {
+    fundsFilter?: Record<string, unknown>;
+    fundsSkip?: number;
+    fundsFirst?: number;
+    fundsOrderBy?: string;
+    fundsOrderDirection?: string;
+}>;
+export declare const disputesResourceParamsValidation: z.ZodObject<{
+    disputesSkip: z.ZodOptional<z.ZodNumber>;
+    disputesFirst: z.ZodOptional<z.ZodNumber>;
+    disputesOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    disputesOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    disputesFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    disputesFilter?: Record<string, unknown>;
+    disputesSkip?: number;
+    disputesFirst?: number;
+    disputesOrderBy?: string;
+    disputesOrderDirection?: string;
+}, {
+    disputesFilter?: Record<string, unknown>;
+    disputesSkip?: number;
+    disputesFirst?: number;
+    disputesOrderBy?: string;
+    disputesOrderDirection?: string;
+}>;
+export declare const exchangesResourceParamsValidation: z.ZodObject<{
+    exchangesSkip: z.ZodOptional<z.ZodNumber>;
+    exchangesFirst: z.ZodOptional<z.ZodNumber>;
+    exchangesOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    exchangesOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    exchangesFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    exchangesFilter?: Record<string, unknown>;
+    exchangesSkip?: number;
+    exchangesFirst?: number;
+    exchangesOrderBy?: string;
+    exchangesOrderDirection?: string;
+}, {
+    exchangesFilter?: Record<string, unknown>;
+    exchangesSkip?: number;
+    exchangesFirst?: number;
+    exchangesOrderBy?: string;
+    exchangesOrderDirection?: string;
+}>;
+export declare const sellersResourceParamsValidation: z.ZodObject<{
+    sellersSkip: z.ZodOptional<z.ZodNumber>;
+    sellersFirst: z.ZodOptional<z.ZodNumber>;
+    sellersOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    sellersOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    sellersFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    includeExchanges: z.ZodOptional<z.ZodBoolean>;
+    includeOffers: z.ZodOptional<z.ZodBoolean>;
+    includeFunds: z.ZodOptional<z.ZodBoolean>;
+    includeLogs: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    sellersFilter?: Record<string, unknown>;
+    sellersSkip?: number;
+    sellersFirst?: number;
+    sellersOrderBy?: string;
+    sellersOrderDirection?: string;
+    includeExchanges?: boolean;
+    includeOffers?: boolean;
+    includeFunds?: boolean;
+    includeLogs?: boolean;
+}, {
+    sellersFilter?: Record<string, unknown>;
+    sellersSkip?: number;
+    sellersFirst?: number;
+    sellersOrderBy?: string;
+    sellersOrderDirection?: string;
+    includeExchanges?: boolean;
+    includeOffers?: boolean;
+    includeFunds?: boolean;
+    includeLogs?: boolean;
+}>;
+export declare const offersResourceParamsValidation: z.ZodObject<{
+    offersSkip: z.ZodOptional<z.ZodNumber>;
+    offersFirst: z.ZodOptional<z.ZodNumber>;
+    offersOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    offersOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    offersFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    includeExchanges: z.ZodOptional<z.ZodBoolean>;
+    exchangesSkip: z.ZodOptional<z.ZodNumber>;
+    exchangesFirst: z.ZodOptional<z.ZodNumber>;
+    exchangesOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    exchangesOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    exchangesFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    exchangesFilter?: Record<string, unknown>;
+    offersFilter?: Record<string, unknown>;
+    exchangesSkip?: number;
+    exchangesFirst?: number;
+    exchangesOrderBy?: string;
+    exchangesOrderDirection?: string;
+    includeExchanges?: boolean;
+    offersSkip?: number;
+    offersFirst?: number;
+    offersOrderBy?: string;
+    offersOrderDirection?: string;
+}, {
+    exchangesFilter?: Record<string, unknown>;
+    offersFilter?: Record<string, unknown>;
+    exchangesSkip?: number;
+    exchangesFirst?: number;
+    exchangesOrderBy?: string;
+    exchangesOrderDirection?: string;
+    includeExchanges?: boolean;
+    offersSkip?: number;
+    offersFirst?: number;
+    offersOrderBy?: string;
+    offersOrderDirection?: string;
+}>;
+export declare const disputeResolversResourceParamsValidation: z.ZodObject<{
+    disputeResolversSkip: z.ZodOptional<z.ZodNumber>;
+    disputeResolversFirst: z.ZodOptional<z.ZodNumber>;
+    disputeResolversOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    disputeResolversOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    disputeResolversFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    disputeResolversFilter?: Record<string, unknown>;
+    disputeResolversSkip?: number;
+    disputeResolversFirst?: number;
+    disputeResolversOrderBy?: string;
+    disputeResolversOrderDirection?: string;
+}, {
+    disputeResolversFilter?: Record<string, unknown>;
+    disputeResolversSkip?: number;
+    disputeResolversFirst?: number;
+    disputeResolversOrderBy?: string;
+    disputeResolversOrderDirection?: string;
+}>;
+export declare const sellersByAddressResourceParamsValidation: z.ZodObject<{
+    address: z.ZodString;
+    sellersSkip: z.ZodOptional<z.ZodNumber>;
+    sellersFirst: z.ZodOptional<z.ZodNumber>;
+    sellersOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    sellersOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    sellersFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    includeExchanges: z.ZodOptional<z.ZodBoolean>;
+    includeOffers: z.ZodOptional<z.ZodBoolean>;
+    includeFunds: z.ZodOptional<z.ZodBoolean>;
+    includeLogs: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    address?: string;
+    sellersFilter?: Record<string, unknown>;
+    sellersSkip?: number;
+    sellersFirst?: number;
+    sellersOrderBy?: string;
+    sellersOrderDirection?: string;
+    includeExchanges?: boolean;
+    includeOffers?: boolean;
+    includeFunds?: boolean;
+    includeLogs?: boolean;
+}, {
+    address?: string;
+    sellersFilter?: Record<string, unknown>;
+    sellersSkip?: number;
+    sellersFirst?: number;
+    sellersOrderBy?: string;
+    sellersOrderDirection?: string;
+    includeExchanges?: boolean;
+    includeOffers?: boolean;
+    includeFunds?: boolean;
+    includeLogs?: boolean;
+}>;
+export declare const productsResourceParamsValidation: z.ZodObject<{
+    productsSkip: z.ZodOptional<z.ZodNumber>;
+    productsFirst: z.ZodOptional<z.ZodNumber>;
+    productsOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    productsOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    productsFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    productsFilter?: Record<string, unknown>;
+    productsSkip?: number;
+    productsFirst?: number;
+    productsOrderBy?: string;
+    productsOrderDirection?: string;
+}, {
+    productsFilter?: Record<string, unknown>;
+    productsSkip?: number;
+    productsFirst?: number;
+    productsOrderBy?: string;
+    productsOrderDirection?: string;
+}>;
+export declare const resourceValidationSchemas: {
+    readonly funds: z.ZodObject<{
+        fundsSkip: z.ZodOptional<z.ZodNumber>;
+        fundsFirst: z.ZodOptional<z.ZodNumber>;
+        fundsOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        fundsOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        fundsFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        fundsFilter?: Record<string, unknown>;
+        fundsSkip?: number;
+        fundsFirst?: number;
+        fundsOrderBy?: string;
+        fundsOrderDirection?: string;
+    }, {
+        fundsFilter?: Record<string, unknown>;
+        fundsSkip?: number;
+        fundsFirst?: number;
+        fundsOrderBy?: string;
+        fundsOrderDirection?: string;
+    }>;
+    readonly disputes: z.ZodObject<{
+        disputesSkip: z.ZodOptional<z.ZodNumber>;
+        disputesFirst: z.ZodOptional<z.ZodNumber>;
+        disputesOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        disputesOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        disputesFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        disputesFilter?: Record<string, unknown>;
+        disputesSkip?: number;
+        disputesFirst?: number;
+        disputesOrderBy?: string;
+        disputesOrderDirection?: string;
+    }, {
+        disputesFilter?: Record<string, unknown>;
+        disputesSkip?: number;
+        disputesFirst?: number;
+        disputesOrderBy?: string;
+        disputesOrderDirection?: string;
+    }>;
+    readonly exchanges: z.ZodObject<{
+        exchangesSkip: z.ZodOptional<z.ZodNumber>;
+        exchangesFirst: z.ZodOptional<z.ZodNumber>;
+        exchangesOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        exchangesOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        exchangesFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        exchangesFilter?: Record<string, unknown>;
+        exchangesSkip?: number;
+        exchangesFirst?: number;
+        exchangesOrderBy?: string;
+        exchangesOrderDirection?: string;
+    }, {
+        exchangesFilter?: Record<string, unknown>;
+        exchangesSkip?: number;
+        exchangesFirst?: number;
+        exchangesOrderBy?: string;
+        exchangesOrderDirection?: string;
+    }>;
+    readonly sellers: z.ZodObject<{
+        sellersSkip: z.ZodOptional<z.ZodNumber>;
+        sellersFirst: z.ZodOptional<z.ZodNumber>;
+        sellersOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        sellersOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        sellersFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        includeExchanges: z.ZodOptional<z.ZodBoolean>;
+        includeOffers: z.ZodOptional<z.ZodBoolean>;
+        includeFunds: z.ZodOptional<z.ZodBoolean>;
+        includeLogs: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        sellersFilter?: Record<string, unknown>;
+        sellersSkip?: number;
+        sellersFirst?: number;
+        sellersOrderBy?: string;
+        sellersOrderDirection?: string;
+        includeExchanges?: boolean;
+        includeOffers?: boolean;
+        includeFunds?: boolean;
+        includeLogs?: boolean;
+    }, {
+        sellersFilter?: Record<string, unknown>;
+        sellersSkip?: number;
+        sellersFirst?: number;
+        sellersOrderBy?: string;
+        sellersOrderDirection?: string;
+        includeExchanges?: boolean;
+        includeOffers?: boolean;
+        includeFunds?: boolean;
+        includeLogs?: boolean;
+    }>;
+    readonly offers: z.ZodObject<{
+        offersSkip: z.ZodOptional<z.ZodNumber>;
+        offersFirst: z.ZodOptional<z.ZodNumber>;
+        offersOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        offersOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        offersFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        includeExchanges: z.ZodOptional<z.ZodBoolean>;
+        exchangesSkip: z.ZodOptional<z.ZodNumber>;
+        exchangesFirst: z.ZodOptional<z.ZodNumber>;
+        exchangesOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        exchangesOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        exchangesFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        exchangesFilter?: Record<string, unknown>;
+        offersFilter?: Record<string, unknown>;
+        exchangesSkip?: number;
+        exchangesFirst?: number;
+        exchangesOrderBy?: string;
+        exchangesOrderDirection?: string;
+        includeExchanges?: boolean;
+        offersSkip?: number;
+        offersFirst?: number;
+        offersOrderBy?: string;
+        offersOrderDirection?: string;
+    }, {
+        exchangesFilter?: Record<string, unknown>;
+        offersFilter?: Record<string, unknown>;
+        exchangesSkip?: number;
+        exchangesFirst?: number;
+        exchangesOrderBy?: string;
+        exchangesOrderDirection?: string;
+        includeExchanges?: boolean;
+        offersSkip?: number;
+        offersFirst?: number;
+        offersOrderBy?: string;
+        offersOrderDirection?: string;
+    }>;
+    readonly disputeResolvers: z.ZodObject<{
+        disputeResolversSkip: z.ZodOptional<z.ZodNumber>;
+        disputeResolversFirst: z.ZodOptional<z.ZodNumber>;
+        disputeResolversOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        disputeResolversOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        disputeResolversFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        disputeResolversFilter?: Record<string, unknown>;
+        disputeResolversSkip?: number;
+        disputeResolversFirst?: number;
+        disputeResolversOrderBy?: string;
+        disputeResolversOrderDirection?: string;
+    }, {
+        disputeResolversFilter?: Record<string, unknown>;
+        disputeResolversSkip?: number;
+        disputeResolversFirst?: number;
+        disputeResolversOrderBy?: string;
+        disputeResolversOrderDirection?: string;
+    }>;
+    readonly sellersByAddress: z.ZodObject<{
+        address: z.ZodString;
+        sellersSkip: z.ZodOptional<z.ZodNumber>;
+        sellersFirst: z.ZodOptional<z.ZodNumber>;
+        sellersOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        sellersOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        sellersFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        includeExchanges: z.ZodOptional<z.ZodBoolean>;
+        includeOffers: z.ZodOptional<z.ZodBoolean>;
+        includeFunds: z.ZodOptional<z.ZodBoolean>;
+        includeLogs: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        address?: string;
+        sellersFilter?: Record<string, unknown>;
+        sellersSkip?: number;
+        sellersFirst?: number;
+        sellersOrderBy?: string;
+        sellersOrderDirection?: string;
+        includeExchanges?: boolean;
+        includeOffers?: boolean;
+        includeFunds?: boolean;
+        includeLogs?: boolean;
+    }, {
+        address?: string;
+        sellersFilter?: Record<string, unknown>;
+        sellersSkip?: number;
+        sellersFirst?: number;
+        sellersOrderBy?: string;
+        sellersOrderDirection?: string;
+        includeExchanges?: boolean;
+        includeOffers?: boolean;
+        includeFunds?: boolean;
+        includeLogs?: boolean;
+    }>;
+    readonly products: z.ZodObject<{
+        productsSkip: z.ZodOptional<z.ZodNumber>;
+        productsFirst: z.ZodOptional<z.ZodNumber>;
+        productsOrderBy: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        productsOrderDirection: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+        productsFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        productsFilter?: Record<string, unknown>;
+        productsSkip?: number;
+        productsFirst?: number;
+        productsOrderBy?: string;
+        productsOrderDirection?: string;
+    }, {
+        productsFilter?: Record<string, unknown>;
+        productsSkip?: number;
+        productsFirst?: number;
+        productsOrderBy?: string;
+        productsOrderDirection?: string;
+    }>;
+};
+export declare const SIGNER_ADDRESS_URI = "signer-address://";
+export declare const resourceUriTemplates: {
+    readonly funds: string;
+    readonly disputes: string;
+    readonly exchanges: string;
+    readonly sellers: string;
+    readonly offers: string;
+    readonly disputeResolvers: string;
+    readonly sellersByAddress: string;
+    readonly products: string;
+    readonly signerAddress: "signer-address://";
+};
+export declare function expandUriTemplate(template: string, params: Record<string, unknown>): string;
+//# sourceMappingURL=resourceParameterTypes.d.ts.map

package/dist/boson/mcp-server/resourceParameterTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourceParameterTypes.d.ts","sourceRoot":"","sources":["../../../src/boson/mcp-server/resourceParameterTypes.ts"],"names":[],"mappings":"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"}

package/dist/boson/mcp-server/resourceParameterTypes.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceUriTemplates = exports.SIGNER_ADDRESS_URI = exports.resourceValidationSchemas = exports.productsResourceParamsValidation = exports.sellersByAddressResourceParamsValidation = exports.disputeResolversResourceParamsValidation = exports.offersResourceParamsValidation = exports.sellersResourceParamsValidation = exports.exchangesResourceParamsValidation = exports.disputesResourceParamsValidation = exports.fundsResourceParamsValidation = void 0;
+exports.expandUriTemplate = expandUriTemplate;
+const core_sdk_1 = require("@bosonprotocol/core-sdk");
+const core_sdk_2 = require("@fermionprotocol/core-sdk");
+const zod_1 = require("zod");
+const disputeResolversFilter_js_1 = require("./filters/disputeResolversFilter.js");
+const disputesFilter_js_1 = require("./filters/disputesFilter.js");
+const exchangesFilter_js_1 = require("./filters/exchangesFilter.js");
+const fundsFilter_js_1 = require("./filters/fundsFilter.js");
+const offersFilter_js_1 = require("./filters/offersFilter.js");
+const productsFilter_js_1 = require("./filters/productsFilter.js");
+const sellersByAddressFilter_js_1 = require("./filters/sellersByAddressFilter.js");
+const sellersFilter_js_1 = require("./filters/sellersFilter.js");
+// Create Zod validation schemas from the resource parameter types
+exports.fundsResourceParamsValidation = zod_1.z.object({
+    fundsSkip: zod_1.z.number().optional(),
+    fundsFirst: zod_1.z.number().optional(),
+    fundsOrderBy: zod_1.z
+        .enum(Object.values(core_sdk_2.Subgraph.FundsEntity_OrderBy))
+        .optional(),
+    fundsOrderDirection: zod_1.z
+        .enum(Object.values(core_sdk_2.Subgraph.OrderDirection))
+        .optional(),
+    fundsFilter: zod_1.z.record(zod_1.z.unknown()).optional(),
+});
+exports.disputesResourceParamsValidation = zod_1.z.object({
+    disputesSkip: zod_1.z.number().optional(),
+    disputesFirst: zod_1.z.number().optional(),
+    disputesOrderBy: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.Dispute_OrderBy))
+        .optional(),
+    disputesOrderDirection: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.OrderDirection))
+        .optional(),
+    disputesFilter: zod_1.z.record(zod_1.z.unknown()).optional(),
+});
+exports.exchangesResourceParamsValidation = zod_1.z.object({
+    exchangesSkip: zod_1.z.number().optional(),
+    exchangesFirst: zod_1.z.number().optional(),
+    exchangesOrderBy: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.Exchange_OrderBy))
+        .optional(),
+    exchangesOrderDirection: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.OrderDirection))
+        .optional(),
+    exchangesFilter: zod_1.z.record(zod_1.z.unknown()).optional(),
+});
+exports.sellersResourceParamsValidation = zod_1.z.object({
+    sellersSkip: zod_1.z.number().optional(),
+    sellersFirst: zod_1.z.number().optional(),
+    sellersOrderBy: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.Seller_OrderBy))
+        .optional(),
+    sellersOrderDirection: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.OrderDirection))
+        .optional(),
+    sellersFilter: zod_1.z.record(zod_1.z.unknown()).optional(),
+    includeExchanges: zod_1.z.boolean().optional(),
+    includeOffers: zod_1.z.boolean().optional(),
+    includeFunds: zod_1.z.boolean().optional(),
+    includeLogs: zod_1.z.boolean().optional(),
+});
+exports.offersResourceParamsValidation = zod_1.z.object({
+    offersSkip: zod_1.z.number().optional(),
+    offersFirst: zod_1.z.number().optional(),
+    offersOrderBy: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.Offer_OrderBy))
+        .optional(),
+    offersOrderDirection: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.OrderDirection))
+        .optional(),
+    offersFilter: zod_1.z.record(zod_1.z.unknown()).optional(),
+    includeExchanges: zod_1.z.boolean().optional(),
+    exchangesSkip: zod_1.z.number().optional(),
+    exchangesFirst: zod_1.z.number().optional(),
+    exchangesOrderBy: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.Exchange_OrderBy))
+        .optional(),
+    exchangesOrderDirection: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.OrderDirection))
+        .optional(),
+    exchangesFilter: zod_1.z.record(zod_1.z.unknown()).optional(),
+});
+exports.disputeResolversResourceParamsValidation = zod_1.z.object({
+    disputeResolversSkip: zod_1.z.number().optional(),
+    disputeResolversFirst: zod_1.z.number().optional(),
+    disputeResolversOrderBy: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.DisputeResolver_OrderBy))
+        .optional(),
+    disputeResolversOrderDirection: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.OrderDirection))
+        .optional(),
+    disputeResolversFilter: zod_1.z.record(zod_1.z.unknown()).optional(),
+});
+exports.sellersByAddressResourceParamsValidation = zod_1.z.object({
+    address: zod_1.z.string(),
+    sellersSkip: zod_1.z.number().optional(),
+    sellersFirst: zod_1.z.number().optional(),
+    sellersOrderBy: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.Seller_OrderBy))
+        .optional(),
+    sellersOrderDirection: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.OrderDirection))
+        .optional(),
+    sellersFilter: zod_1.z.record(zod_1.z.unknown()).optional(),
+    includeExchanges: zod_1.z.boolean().optional(),
+    includeOffers: zod_1.z.boolean().optional(),
+    includeFunds: zod_1.z.boolean().optional(),
+    includeLogs: zod_1.z.boolean().optional(),
+});
+exports.productsResourceParamsValidation = zod_1.z.object({
+    productsSkip: zod_1.z.number().optional(),
+    productsFirst: zod_1.z.number().optional(),
+    productsOrderBy: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.ProductV1Product_OrderBy))
+        .optional(),
+    productsOrderDirection: zod_1.z
+        .enum(Object.values(core_sdk_1.subgraph.OrderDirection))
+        .optional(),
+    productsFilter: zod_1.z.record(zod_1.z.unknown()).optional(),
+});
+// Type-safe validation schemas that can be used by validation.ts
+exports.resourceValidationSchemas = {
+    funds: exports.fundsResourceParamsValidation,
+    disputes: exports.disputesResourceParamsValidation,
+    exchanges: exports.exchangesResourceParamsValidation,
+    sellers: exports.sellersResourceParamsValidation,
+    offers: exports.offersResourceParamsValidation,
+    disputeResolvers: exports.disputeResolversResourceParamsValidation,
+    sellersByAddress: exports.sellersByAddressResourceParamsValidation,
+    products: exports.productsResourceParamsValidation,
+};
+// Static URI constants for resources without parameters
+exports.SIGNER_ADDRESS_URI = "signer-address://";
+// Export URI templates from filter definitions
+exports.resourceUriTemplates = {
+    funds: fundsFilter_js_1.fundsUriTemplate,
+    disputes: disputesFilter_js_1.disputesUriTemplate,
+    exchanges: exchangesFilter_js_1.exchangesUriTemplate,
+    sellers: sellersFilter_js_1.sellersUriTemplate,
+    offers: offersFilter_js_1.offersUriTemplate,
+    disputeResolvers: disputeResolversFilter_js_1.disputeResolversUriTemplate,
+    sellersByAddress: sellersByAddressFilter_js_1.sellersByAddressUriTemplate,
+    products: productsFilter_js_1.productsUriTemplate,
+    signerAddress: exports.SIGNER_ADDRESS_URI,
+};
+// Helper function to expand URI templates with parameters
+// This is a simplified RFC 6570 URI template processor
+function expandUriTemplate(template, params) {
+    // Extract the base URI and query template
+    const [baseUri, queryTemplate] = template.split("{?");
+    if (!queryTemplate) {
+        return baseUri;
+    }
+    // Remove the closing } and split by comma
+    const paramNames = queryTemplate.replace("}", "").split(",");
+    // Build query string from params that exist in the template
+    const queryParams = paramNames
+        .map((name) => {
+        const value = params[name];
+        if (value !== undefined && value !== null) {
+            return `${encodeURIComponent(name)}=${encodeURIComponent(
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            typeof value === "object" ? JSON.stringify(value) : String(value))}`;
+        }
+        return null;
+    })
+        .filter(Boolean)
+        .join("&");
+    return queryParams ? `${baseUri}?${queryParams}` : baseUri;
+}
+//# sourceMappingURL=resourceParameterTypes.js.map