npm - @adcp/sdk - Versions diffs - 14.0.0-beta.11 → 14.0.0-beta.13 - Mend

@adcp/sdk 14.0.0-beta.11 → 14.0.0-beta.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (235) hide show

package/dist/lib/schemas/index.d.ts CHANGED Viewed

@@ -39,11 +39,395 @@
  * });
  * ```
  */
-import type { z } from 'zod';
+import { z } from 'zod';
 import * as schemas from '../types/schemas.generated';
+import type { CanonicalGetProductsRequest } from '../v2/projection/creative-delivery';
 import type { KnownToolRequestSchemas } from '../utils/tool-request-schemas';
 import { type ResolvedToolSchemaDocument, type ResponseVariant } from '../validation/schema-loader';
 export * from '../types/schemas.generated';
+type LooseObjectSchemaFor<T extends object> = z.ZodObject<{
+    [K in keyof T]-?: undefined extends T[K] ? z.ZodOptional<z.ZodType<Exclude<T[K], undefined>, Exclude<T[K], undefined>>> : z.ZodType<T[K], T[K]>;
+}, z.core.$loose> & z.ZodType<T & Record<string, unknown>, T & Record<string, unknown>>;
+/** Wire-compatible request schema, including the legacy `format_ids` selector. */
+export declare const LegacyGetProductsRequestSchema: z.ZodObject<{
+    adcp_version: z.ZodOptional<z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
+    adcp_major_version: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+    idempotency_key: z.ZodOptional<z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
+    buying_mode: z.ZodType<"brief" | "wholesale" | "refine", "brief" | "wholesale" | "refine", z.core.$ZodTypeInternals<"brief" | "wholesale" | "refine", "brief" | "wholesale" | "refine">>;
+    brief: z.ZodOptional<z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
+    refine: z.ZodOptional<z.ZodType<({
+        scope: "request";
+        ask: string;
+    } | {
+        scope: "product";
+        product_id: string;
+        action?: "include" | "omit" | "more_like_this";
+        ask?: string;
+    } | {
+        scope: "proposal";
+        proposal_id: string;
+        action?: "include" | "omit" | "finalize";
+        ask?: string;
+    })[], ({
+        scope: "request";
+        ask: string;
+    } | {
+        scope: "product";
+        product_id: string;
+        action?: "include" | "omit" | "more_like_this";
+        ask?: string;
+    } | {
+        scope: "proposal";
+        proposal_id: string;
+        action?: "include" | "omit" | "finalize";
+        ask?: string;
+    })[], z.core.$ZodTypeInternals<({
+        scope: "request";
+        ask: string;
+    } | {
+        scope: "product";
+        product_id: string;
+        action?: "include" | "omit" | "more_like_this";
+        ask?: string;
+    } | {
+        scope: "proposal";
+        proposal_id: string;
+        action?: "include" | "omit" | "finalize";
+        ask?: string;
+    })[], ({
+        scope: "request";
+        ask: string;
+    } | {
+        scope: "product";
+        product_id: string;
+        action?: "include" | "omit" | "more_like_this";
+        ask?: string;
+    } | {
+        scope: "proposal";
+        proposal_id: string;
+        action?: "include" | "omit" | "finalize";
+        ask?: string;
+    })[]>>>;
+    brand: z.ZodOptional<z.ZodType<import("..").BrandReference, import("..").BrandReference, z.core.$ZodTypeInternals<import("..").BrandReference, import("..").BrandReference>>>;
+    catalog: z.ZodOptional<z.ZodType<import("..").Catalog, import("..").Catalog, z.core.$ZodTypeInternals<import("..").Catalog, import("..").Catalog>>>;
+    account: z.ZodOptional<z.ZodType<import("..").AccountReference, import("..").AccountReference, z.core.$ZodTypeInternals<import("..").AccountReference, import("..").AccountReference>>>;
+    preferred_delivery_types: z.ZodOptional<z.ZodType<import("../types/core.generated").DeliveryType[], import("../types/core.generated").DeliveryType[], z.core.$ZodTypeInternals<import("../types/core.generated").DeliveryType[], import("../types/core.generated").DeliveryType[]>>>;
+    filters: z.ZodOptional<z.ZodType<import("../types/tools.generated").ProductFilters, import("../types/tools.generated").ProductFilters, z.core.$ZodTypeInternals<import("../types/tools.generated").ProductFilters, import("../types/tools.generated").ProductFilters>>>;
+    targeting_overlay: z.ZodOptional<z.ZodType<{
+        geo_countries?: [string, ...string[]];
+        geo_countries_exclude?: [string, ...string[]];
+        geo_regions?: [string, ...string[]];
+        geo_regions_exclude?: [string, ...string[]];
+        geo_metros?: [{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }, ...{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }[]];
+        geo_metros_exclude?: [{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }, ...{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }[]];
+        geo_postal_areas?: [import("../types/tools.generated").PostalArea, ...import("../types/tools.generated").PostalArea[]];
+        geo_postal_areas_exclude?: [import("../types/tools.generated").PostalArea, ...import("../types/tools.generated").PostalArea[]];
+        geo_places?: [import("../types/tools.generated").GeographicPlaceArea, ...import("../types/tools.generated").GeographicPlaceArea[]];
+        geo_places_exclude?: [import("../types/tools.generated").GeographicPlaceArea, ...import("../types/tools.generated").GeographicPlaceArea[]];
+        daypart_targets?: [import("../types/tools.generated").DaypartTarget, ...import("../types/tools.generated").DaypartTarget[]];
+        axe_include_segment?: string;
+        axe_exclude_segment?: string;
+        audience_include?: [string, ...string[]];
+        audience_exclude?: [string, ...string[]];
+        signal_targeting_groups?: import("../types/tools.generated").PackageSignalTargetingGroups;
+        signal_targeting?: [import("..").SignalTargeting, ...import("..").SignalTargeting[]];
+        demographics?: import("../types/tools.generated").DemographicTargetingIntent;
+        frequency_cap?: import("..").FrequencyCap;
+        property_list?: import("../types/tools.generated").PropertyListReference;
+        property_list_exclude?: import("../types/tools.generated").PropertyListReference;
+        collection_list?: import("../types/tools.generated").CollectionListReference;
+        collection_list_exclude?: import("../types/tools.generated").CollectionListReference;
+        placement_selection?: import("../types/tools.generated").PlacementSelection;
+        age_restriction?: {
+            min: number;
+            verification_required?: boolean;
+            accepted_methods?: [import("../types/core.generated").AgeVerificationMethod, ...import("../types/core.generated").AgeVerificationMethod[]];
+        };
+        device_platform?: [import("../types/core.generated").DevicePlatform, ...import("../types/core.generated").DevicePlatform[]];
+        device_platform_exclude?: [import("../types/core.generated").DevicePlatform, ...import("../types/core.generated").DevicePlatform[]];
+        device_type?: [import("..").DeviceType, ...import("..").DeviceType[]];
+        device_type_exclude?: [import("..").DeviceType, ...import("..").DeviceType[]];
+        browser?: [import("../types/core.generated").BrowserFamily, ...import("../types/core.generated").BrowserFamily[]];
+        browser_exclude?: [import("../types/core.generated").BrowserFamily, ...import("../types/core.generated").BrowserFamily[]];
+        store_catchments?: [{
+            catalog_id: string;
+            store_ids?: [string, ...string[]];
+            catchment_ids?: [string, ...string[]];
+        }, ...{
+            catalog_id: string;
+            store_ids?: [string, ...string[]];
+            catchment_ids?: [string, ...string[]];
+        }[]];
+        geo_proximity?: [({} | {} | {}), ...({} | {} | {})[]];
+        language?: [import("../types/tools.generated").LanguageTag, ...import("../types/tools.generated").LanguageTag[]];
+        keyword_targets?: [{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+            bid_price?: number;
+        }, ...{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+            bid_price?: number;
+        }[]];
+        negative_keywords?: [{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+        }, ...{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+        }[]];
+    }, {
+        geo_countries?: [string, ...string[]];
+        geo_countries_exclude?: [string, ...string[]];
+        geo_regions?: [string, ...string[]];
+        geo_regions_exclude?: [string, ...string[]];
+        geo_metros?: [{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }, ...{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }[]];
+        geo_metros_exclude?: [{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }, ...{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }[]];
+        geo_postal_areas?: [import("../types/tools.generated").PostalArea, ...import("../types/tools.generated").PostalArea[]];
+        geo_postal_areas_exclude?: [import("../types/tools.generated").PostalArea, ...import("../types/tools.generated").PostalArea[]];
+        geo_places?: [import("../types/tools.generated").GeographicPlaceArea, ...import("../types/tools.generated").GeographicPlaceArea[]];
+        geo_places_exclude?: [import("../types/tools.generated").GeographicPlaceArea, ...import("../types/tools.generated").GeographicPlaceArea[]];
+        daypart_targets?: [import("../types/tools.generated").DaypartTarget, ...import("../types/tools.generated").DaypartTarget[]];
+        axe_include_segment?: string;
+        axe_exclude_segment?: string;
+        audience_include?: [string, ...string[]];
+        audience_exclude?: [string, ...string[]];
+        signal_targeting_groups?: import("../types/tools.generated").PackageSignalTargetingGroups;
+        signal_targeting?: [import("..").SignalTargeting, ...import("..").SignalTargeting[]];
+        demographics?: import("../types/tools.generated").DemographicTargetingIntent;
+        frequency_cap?: import("..").FrequencyCap;
+        property_list?: import("../types/tools.generated").PropertyListReference;
+        property_list_exclude?: import("../types/tools.generated").PropertyListReference;
+        collection_list?: import("../types/tools.generated").CollectionListReference;
+        collection_list_exclude?: import("../types/tools.generated").CollectionListReference;
+        placement_selection?: import("../types/tools.generated").PlacementSelection;
+        age_restriction?: {
+            min: number;
+            verification_required?: boolean;
+            accepted_methods?: [import("../types/core.generated").AgeVerificationMethod, ...import("../types/core.generated").AgeVerificationMethod[]];
+        };
+        device_platform?: [import("../types/core.generated").DevicePlatform, ...import("../types/core.generated").DevicePlatform[]];
+        device_platform_exclude?: [import("../types/core.generated").DevicePlatform, ...import("../types/core.generated").DevicePlatform[]];
+        device_type?: [import("..").DeviceType, ...import("..").DeviceType[]];
+        device_type_exclude?: [import("..").DeviceType, ...import("..").DeviceType[]];
+        browser?: [import("../types/core.generated").BrowserFamily, ...import("../types/core.generated").BrowserFamily[]];
+        browser_exclude?: [import("../types/core.generated").BrowserFamily, ...import("../types/core.generated").BrowserFamily[]];
+        store_catchments?: [{
+            catalog_id: string;
+            store_ids?: [string, ...string[]];
+            catchment_ids?: [string, ...string[]];
+        }, ...{
+            catalog_id: string;
+            store_ids?: [string, ...string[]];
+            catchment_ids?: [string, ...string[]];
+        }[]];
+        geo_proximity?: [({} | {} | {}), ...({} | {} | {})[]];
+        language?: [import("../types/tools.generated").LanguageTag, ...import("../types/tools.generated").LanguageTag[]];
+        keyword_targets?: [{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+            bid_price?: number;
+        }, ...{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+            bid_price?: number;
+        }[]];
+        negative_keywords?: [{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+        }, ...{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+        }[]];
+    }, z.core.$ZodTypeInternals<{
+        geo_countries?: [string, ...string[]];
+        geo_countries_exclude?: [string, ...string[]];
+        geo_regions?: [string, ...string[]];
+        geo_regions_exclude?: [string, ...string[]];
+        geo_metros?: [{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }, ...{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }[]];
+        geo_metros_exclude?: [{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }, ...{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }[]];
+        geo_postal_areas?: [import("../types/tools.generated").PostalArea, ...import("../types/tools.generated").PostalArea[]];
+        geo_postal_areas_exclude?: [import("../types/tools.generated").PostalArea, ...import("../types/tools.generated").PostalArea[]];
+        geo_places?: [import("../types/tools.generated").GeographicPlaceArea, ...import("../types/tools.generated").GeographicPlaceArea[]];
+        geo_places_exclude?: [import("../types/tools.generated").GeographicPlaceArea, ...import("../types/tools.generated").GeographicPlaceArea[]];
+        daypart_targets?: [import("../types/tools.generated").DaypartTarget, ...import("../types/tools.generated").DaypartTarget[]];
+        axe_include_segment?: string;
+        axe_exclude_segment?: string;
+        audience_include?: [string, ...string[]];
+        audience_exclude?: [string, ...string[]];
+        signal_targeting_groups?: import("../types/tools.generated").PackageSignalTargetingGroups;
+        signal_targeting?: [import("..").SignalTargeting, ...import("..").SignalTargeting[]];
+        demographics?: import("../types/tools.generated").DemographicTargetingIntent;
+        frequency_cap?: import("..").FrequencyCap;
+        property_list?: import("../types/tools.generated").PropertyListReference;
+        property_list_exclude?: import("../types/tools.generated").PropertyListReference;
+        collection_list?: import("../types/tools.generated").CollectionListReference;
+        collection_list_exclude?: import("../types/tools.generated").CollectionListReference;
+        placement_selection?: import("../types/tools.generated").PlacementSelection;
+        age_restriction?: {
+            min: number;
+            verification_required?: boolean;
+            accepted_methods?: [import("../types/core.generated").AgeVerificationMethod, ...import("../types/core.generated").AgeVerificationMethod[]];
+        };
+        device_platform?: [import("../types/core.generated").DevicePlatform, ...import("../types/core.generated").DevicePlatform[]];
+        device_platform_exclude?: [import("../types/core.generated").DevicePlatform, ...import("../types/core.generated").DevicePlatform[]];
+        device_type?: [import("..").DeviceType, ...import("..").DeviceType[]];
+        device_type_exclude?: [import("..").DeviceType, ...import("..").DeviceType[]];
+        browser?: [import("../types/core.generated").BrowserFamily, ...import("../types/core.generated").BrowserFamily[]];
+        browser_exclude?: [import("../types/core.generated").BrowserFamily, ...import("../types/core.generated").BrowserFamily[]];
+        store_catchments?: [{
+            catalog_id: string;
+            store_ids?: [string, ...string[]];
+            catchment_ids?: [string, ...string[]];
+        }, ...{
+            catalog_id: string;
+            store_ids?: [string, ...string[]];
+            catchment_ids?: [string, ...string[]];
+        }[]];
+        geo_proximity?: [({} | {} | {}), ...({} | {} | {})[]];
+        language?: [import("../types/tools.generated").LanguageTag, ...import("../types/tools.generated").LanguageTag[]];
+        keyword_targets?: [{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+            bid_price?: number;
+        }, ...{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+            bid_price?: number;
+        }[]];
+        negative_keywords?: [{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+        }, ...{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+        }[]];
+    }, {
+        geo_countries?: [string, ...string[]];
+        geo_countries_exclude?: [string, ...string[]];
+        geo_regions?: [string, ...string[]];
+        geo_regions_exclude?: [string, ...string[]];
+        geo_metros?: [{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }, ...{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }[]];
+        geo_metros_exclude?: [{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }, ...{
+            system: import("../types/core.generated").MetroAreaSystem;
+            values: [string, ...string[]];
+        }[]];
+        geo_postal_areas?: [import("../types/tools.generated").PostalArea, ...import("../types/tools.generated").PostalArea[]];
+        geo_postal_areas_exclude?: [import("../types/tools.generated").PostalArea, ...import("../types/tools.generated").PostalArea[]];
+        geo_places?: [import("../types/tools.generated").GeographicPlaceArea, ...import("../types/tools.generated").GeographicPlaceArea[]];
+        geo_places_exclude?: [import("../types/tools.generated").GeographicPlaceArea, ...import("../types/tools.generated").GeographicPlaceArea[]];
+        daypart_targets?: [import("../types/tools.generated").DaypartTarget, ...import("../types/tools.generated").DaypartTarget[]];
+        axe_include_segment?: string;
+        axe_exclude_segment?: string;
+        audience_include?: [string, ...string[]];
+        audience_exclude?: [string, ...string[]];
+        signal_targeting_groups?: import("../types/tools.generated").PackageSignalTargetingGroups;
+        signal_targeting?: [import("..").SignalTargeting, ...import("..").SignalTargeting[]];
+        demographics?: import("../types/tools.generated").DemographicTargetingIntent;
+        frequency_cap?: import("..").FrequencyCap;
+        property_list?: import("../types/tools.generated").PropertyListReference;
+        property_list_exclude?: import("../types/tools.generated").PropertyListReference;
+        collection_list?: import("../types/tools.generated").CollectionListReference;
+        collection_list_exclude?: import("../types/tools.generated").CollectionListReference;
+        placement_selection?: import("../types/tools.generated").PlacementSelection;
+        age_restriction?: {
+            min: number;
+            verification_required?: boolean;
+            accepted_methods?: [import("../types/core.generated").AgeVerificationMethod, ...import("../types/core.generated").AgeVerificationMethod[]];
+        };
+        device_platform?: [import("../types/core.generated").DevicePlatform, ...import("../types/core.generated").DevicePlatform[]];
+        device_platform_exclude?: [import("../types/core.generated").DevicePlatform, ...import("../types/core.generated").DevicePlatform[]];
+        device_type?: [import("..").DeviceType, ...import("..").DeviceType[]];
+        device_type_exclude?: [import("..").DeviceType, ...import("..").DeviceType[]];
+        browser?: [import("../types/core.generated").BrowserFamily, ...import("../types/core.generated").BrowserFamily[]];
+        browser_exclude?: [import("../types/core.generated").BrowserFamily, ...import("../types/core.generated").BrowserFamily[]];
+        store_catchments?: [{
+            catalog_id: string;
+            store_ids?: [string, ...string[]];
+            catchment_ids?: [string, ...string[]];
+        }, ...{
+            catalog_id: string;
+            store_ids?: [string, ...string[]];
+            catchment_ids?: [string, ...string[]];
+        }[]];
+        geo_proximity?: [({} | {} | {}), ...({} | {} | {})[]];
+        language?: [import("../types/tools.generated").LanguageTag, ...import("../types/tools.generated").LanguageTag[]];
+        keyword_targets?: [{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+            bid_price?: number;
+        }, ...{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+            bid_price?: number;
+        }[]];
+        negative_keywords?: [{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+        }, ...{
+            keyword: string;
+            match_type: import("../types/core.generated").MatchType;
+        }[]];
+    }>>>;
+    required_overlay_support: z.ZodOptional<z.ZodType<import("../types/core.generated").TargetingOverlayRequirements, import("../types/core.generated").TargetingOverlayRequirements, z.core.$ZodTypeInternals<import("../types/core.generated").TargetingOverlayRequirements, import("../types/core.generated").TargetingOverlayRequirements>>>;
+    property_list: z.ZodOptional<z.ZodType<import("../types/tools.generated").PropertyListReference, import("../types/tools.generated").PropertyListReference, z.core.$ZodTypeInternals<import("../types/tools.generated").PropertyListReference, import("../types/tools.generated").PropertyListReference>>>;
+    fields: z.ZodOptional<z.ZodType<("name" | "forecast" | "description" | "publisher_properties" | "audience_evidence" | "product_id" | "channels" | "video_placement_types" | "audio_distribution_types" | "sponsored_placement_types" | "social_placement_surfaces" | "format_options" | "placements" | "delivery_type" | "exclusivity" | "pricing_options" | "reporting_capabilities" | "catalog_types" | "signal_targeting_allowed" | "signal_targeting_rules" | "demographic_targeting" | "audience_evidence_selections" | "max_optimization_goals" | "catalog_match" | "brief_relevance" | "expires_at" | "product_card" | "format_ids" | "outcome_measurement" | "delivery_measurement" | "creative_policy" | "metric_optimization" | "conversion_tracking" | "data_provider_signals" | "included_signals" | "signal_targeting_options" | "overlay_support" | "targeting_resolution" | "collections" | "collection_targeting_allowed" | "installments" | "is_custom" | "product_card_detailed" | "enforced_policies" | "trusted_match")[], ("name" | "forecast" | "description" | "publisher_properties" | "audience_evidence" | "product_id" | "channels" | "video_placement_types" | "audio_distribution_types" | "sponsored_placement_types" | "social_placement_surfaces" | "format_options" | "placements" | "delivery_type" | "exclusivity" | "pricing_options" | "reporting_capabilities" | "catalog_types" | "signal_targeting_allowed" | "signal_targeting_rules" | "demographic_targeting" | "audience_evidence_selections" | "max_optimization_goals" | "catalog_match" | "brief_relevance" | "expires_at" | "product_card" | "format_ids" | "outcome_measurement" | "delivery_measurement" | "creative_policy" | "metric_optimization" | "conversion_tracking" | "data_provider_signals" | "included_signals" | "signal_targeting_options" | "overlay_support" | "targeting_resolution" | "collections" | "collection_targeting_allowed" | "installments" | "is_custom" | "product_card_detailed" | "enforced_policies" | "trusted_match")[], z.core.$ZodTypeInternals<("name" | "forecast" | "description" | "publisher_properties" | "audience_evidence" | "product_id" | "channels" | "video_placement_types" | "audio_distribution_types" | "sponsored_placement_types" | "social_placement_surfaces" | "format_options" | "placements" | "delivery_type" | "exclusivity" | "pricing_options" | "reporting_capabilities" | "catalog_types" | "signal_targeting_allowed" | "signal_targeting_rules" | "demographic_targeting" | "audience_evidence_selections" | "max_optimization_goals" | "catalog_match" | "brief_relevance" | "expires_at" | "product_card" | "format_ids" | "outcome_measurement" | "delivery_measurement" | "creative_policy" | "metric_optimization" | "conversion_tracking" | "data_provider_signals" | "included_signals" | "signal_targeting_options" | "overlay_support" | "targeting_resolution" | "collections" | "collection_targeting_allowed" | "installments" | "is_custom" | "product_card_detailed" | "enforced_policies" | "trusted_match")[], ("name" | "forecast" | "description" | "publisher_properties" | "audience_evidence" | "product_id" | "channels" | "video_placement_types" | "audio_distribution_types" | "sponsored_placement_types" | "social_placement_surfaces" | "format_options" | "placements" | "delivery_type" | "exclusivity" | "pricing_options" | "reporting_capabilities" | "catalog_types" | "signal_targeting_allowed" | "signal_targeting_rules" | "demographic_targeting" | "audience_evidence_selections" | "max_optimization_goals" | "catalog_match" | "brief_relevance" | "expires_at" | "product_card" | "format_ids" | "outcome_measurement" | "delivery_measurement" | "creative_policy" | "metric_optimization" | "conversion_tracking" | "data_provider_signals" | "included_signals" | "signal_targeting_options" | "overlay_support" | "targeting_resolution" | "collections" | "collection_targeting_allowed" | "installments" | "is_custom" | "product_card_detailed" | "enforced_policies" | "trusted_match")[]>>>;
+    time_budget: z.ZodOptional<z.ZodType<import("..").Duration, import("..").Duration, z.core.$ZodTypeInternals<import("..").Duration, import("..").Duration>>>;
+    push_notification_config: z.ZodOptional<z.ZodType<import("../types/tools.generated").PushNotificationConfig, import("../types/tools.generated").PushNotificationConfig, z.core.$ZodTypeInternals<import("../types/tools.generated").PushNotificationConfig, import("../types/tools.generated").PushNotificationConfig>>>;
+    pagination: z.ZodOptional<z.ZodType<import("..").PaginationRequest, import("..").PaginationRequest, z.core.$ZodTypeInternals<import("..").PaginationRequest, import("..").PaginationRequest>>>;
+    if_wholesale_feed_version: z.ZodOptional<z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
+    if_pricing_version: z.ZodOptional<z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
+    context: z.ZodOptional<z.ZodType<import("../types/tools.generated").ContextObject, import("../types/tools.generated").ContextObject, z.core.$ZodTypeInternals<import("../types/tools.generated").ContextObject, import("../types/tools.generated").ContextObject>>>;
+    required_policies: z.ZodOptional<z.ZodType<string[], string[], z.core.$ZodTypeInternals<string[], string[]>>>;
+    ext: z.ZodOptional<z.ZodType<import("..").ExtensionObject, import("..").ExtensionObject, z.core.$ZodTypeInternals<import("..").ExtensionObject, import("..").ExtensionObject>>>;
+}, z.core.$loose> & z.ZodType<import("..").LegacyGetProductsRequest & Record<string, unknown>, import("..").LegacyGetProductsRequest & Record<string, unknown>, z.core.$ZodTypeInternals<import("..").LegacyGetProductsRequest & Record<string, unknown>, import("..").LegacyGetProductsRequest & Record<string, unknown>>>;
+/** Primary request schema; legacy `format_ids` selection is rejected. */
+export declare const GetProductsRequestSchema: LooseObjectSchemaFor<CanonicalGetProductsRequest>;
 export { BiddingPolicySchema } from '../validation/bidding-policy';
 export { CanonicalBudgetAllocationSchema } from '../validation/budget-allocation';
 export { TOOL_REQUEST_SCHEMAS } from '../utils/tool-request-schemas';

package/dist/lib/schemas/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/schemas/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,~~KAAK,~~EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;~~AAC7B~~,OAAO,KAAK,OAAO,MAAM,4BAA4B,CAAC;AAEtD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAC7E,OAAO,EAEL,KAAK,0BAA0B,EAC/B,KAAK,eAAe,EACrB,MAAM,6BAA6B,CAAC;AAGrC,cAAc,4BAA4B,CAAC;~~AAC3C~~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"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/schemas/index.ts"],"names":[],"mappings":"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"}

package/dist/lib/schemas/index.js CHANGED Viewed

@@ -31,6 +31,8 @@ var schemas_exports = {};
 __export(schemas_exports, {
   BiddingPolicySchema: () => import_bidding_policy.BiddingPolicySchema,
   CanonicalBudgetAllocationSchema: () => import_budget_allocation.CanonicalBudgetAllocationSchema,
+  GetProductsRequestSchema: () => GetProductsRequestSchema,
+  LegacyGetProductsRequestSchema: () => LegacyGetProductsRequestSchema,
   SyncCreativesActionSchema: () => import_sync_creatives.SyncCreativesActionSchema,
   SyncCreativesItemSchema: () => import_sync_creatives.SyncCreativesItemSchema,
   SyncCreativesResponseStrictSchema: () => import_sync_creatives.SyncCreativesResponseStrictSchema,
@@ -45,7 +47,9 @@ __export(schemas_exports, {
   getToolResponseSchema: () => getToolResponseSchema
 });
 module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
 var schemas = __toESM(require('../types/schemas.generated.js'));
+var import_inline_enums = require('../types/inline-enums.generated.js');
 var import_tool_request_schemas = require('../utils/tool-request-schemas.js');
 var import_schema_loader = require('../validation/schema-loader.js');
 var import_adcp_version_config = require('../utils/adcp-version-config.js');
@@ -55,6 +59,13 @@ var import_budget_allocation = require('../validation/budget-allocation.js');
 var import_tool_request_schemas2 = require('../utils/tool-request-schemas.js');
 var import_response_schemas = require('../utils/response-schemas.js');
 var import_sync_creatives = require('../validation/sync-creatives.js');
+const LegacyGetProductsRequestSchema = schemas.GetProductsRequestSchema;
+const canonicalGetProductsFields = import_inline_enums.GetProductsRequest_FieldsValues.filter(
+  (field) => field !== "format_ids"
+);
+const GetProductsRequestSchema = schemas.GetProductsRequestSchema.safeExtend({
+  fields: import_zod.z.array(import_zod.z.enum(canonicalGetProductsFields)).optional()
+});
 function getToolInputSchema(toolName, options = {}) {
   return (0, import_schema_loader.getToolSchemaDocument)(toolName, "request", (0, import_adcp_version_config.resolveAdcpVersion)(options.adcpVersion));
 }
@@ -100,6 +111,8 @@ function customToolForSchema(name, description, inputSchema, handler) {
 0 && (module.exports = {
   BiddingPolicySchema,
   CanonicalBudgetAllocationSchema,
+  GetProductsRequestSchema,
+  LegacyGetProductsRequestSchema,
   SyncCreativesActionSchema,
   SyncCreativesItemSchema,
   SyncCreativesResponseStrictSchema,

package/dist/lib/schemas/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../../../src/lib/schemas/index.ts"],"sourcesContent":["/*\n Consolidated schema exports for MCP tool registration.\n \n The generated Zod schemas in `../types/schemas.generated` cover every\n * AdCP tool — the framework-registered {@link AdcpToolMap} tools AND\n * tools like `creative_approval`, `search_brands`, and brand verification\n * tasks that ship as `customTools` extensions because the spec models them\n * outside the SDK's framework-registered surface.\n \n This module re-exports the generated schemas plus two convenience\n * helpers for the `customTools` registration path:\n \n - {@link TOOL_INPUT_SHAPES}: `toolName → raw Zod shape` map, ready to\n * pass as `inputSchema` to MCP SDK's `server.registerTool()` when the\n * request schema is a ZodObject.\n * - {@link TOOL_INPUT_SCHEMAS}: `toolName → full Zod schema` map for\n * custom tools whose request schema is a union/intersection and cannot\n * be represented as a raw shape without weakening validation.\n * - {@link TOOL_RESPONSE_SCHEMAS}: `toolName → full Zod response schema`\n * map for response validation and compliance tooling.\n * - {@link customToolFor}: sugar for registering a single custom tool\n * with type-safe `handler` params derived from the schema's shape.\n * - {@link customToolForSchema}: same sugar for full Zod schemas.\n \n ```ts\n * import { createAdcpServer } from '@adcp/sdk/server/legacy/v5';\n * import { TOOL_INPUT_SHAPES, customToolFor } from '@adcp/sdk/schemas';\n \n createAdcpServer({\n * customTools: {\n * creative_approval: customToolFor(\n * 'creative_approval',\n * 'Accept a buyer creative for approval.',\n * TOOL_INPUT_SHAPES.creative_approval,\n * async (args, extra) => { ... },\n * ),\n * },\n * ...,\n * });\n * ```\n /\n\nimport type { z } from 'zod';\nimport as schemas from '../types/schemas.generated';\nimport { TOOL_REQUEST_SCHEMAS } from '../utils/tool-request-schemas';\nimport type { KnownToolRequestSchemas } from '../utils/tool-request-schemas';\nimport {\n getToolSchemaDocument,\n type ResolvedToolSchemaDocument,\n type ResponseVariant,\n} from '../validation/schema-loader';\nimport { resolveAdcpVersion } from '../utils/adcp-version-config';\n\nexport * from '../types/schemas.generated';\nexport { BiddingPolicySchema } from '../validation/bidding-policy';\nexport { CanonicalBudgetAllocationSchema } from '../validation/budget-allocation';\nexport { TOOL_REQUEST_SCHEMAS } from '../utils/tool-request-schemas';\nexport { TOOL_RESPONSE_SCHEMAS } from '../utils/response-schemas';\nexport {\n SyncCreativesItemSchema,\n SyncCreativesSuccessStrictSchema,\n SyncCreativesResponseStrictSchema,\n SyncCreativesActionSchema,\n} from '../validation/sync-creatives';\nexport type { SyncCreativesItem, SyncCreativesSuccessStrict } from '../validation/sync-creatives';\n\nexport interface ToolSchemaLookupOptions {\n /** AdCP release/minor/legacy alias resolved through the bundled schema loader. /\n adcpVersion?: string;\n}\n\nexport interface ToolResponseSchemaLookupOptions extends ToolSchemaLookupOptions {\n /* Response arm to retrieve. Defaults to the synchronous response schema. /\n variant?: ResponseVariant;\n}\n\nexport type VersionedToolSchema = ResolvedToolSchemaDocument;\n\n/* Retrieve the protocol-authored request JSON Schema for a specific AdCP release. /\nexport function getToolInputSchema(\n toolName: string,\n options: ToolSchemaLookupOptions = {}\n): VersionedToolSchema \| undefined {\n return getToolSchemaDocument(toolName, 'request', resolveAdcpVersion(options.adcpVersion));\n}\n\n/* Retrieve a protocol-authored response JSON Schema for a specific AdCP release. /\nexport function getToolResponseSchema(\n toolName: string,\n options: ToolResponseSchemaLookupOptions = {}\n): VersionedToolSchema \| undefined {\n return getToolSchemaDocument(toolName, options.variant ?? 'sync', resolveAdcpVersion(options.adcpVersion));\n}\n\ntype InputShape = Record<string, z.ZodType>;\ntype InputSchema = z.ZodType;\ntype ShapeOf<T> = T extends { shape: infer TShape extends InputShape } ? TShape : never;\ntype ToolInputShapes = {\n [K in keyof KnownToolRequestSchemas]: ShapeOf<KnownToolRequestSchemas[K]>;\n} & {\n creative_approval: typeof schemas.CreativeApprovalRequestSchema.shape;\n search_brands: typeof schemas.SearchBrandsRequestSchema.shape;\n verify_brand_claims: typeof schemas.VerifyBrandClaimsRequestBulkSchema.shape;\n} & {\n readonly [toolName: string]: Readonly<InputShape> \| undefined;\n};\n\ntype ToolInputSchemas = {\n [K in keyof KnownToolRequestSchemas]: KnownToolRequestSchemas[K];\n} & {\n creative_approval: typeof schemas.CreativeApprovalRequestSchema;\n search_brands: typeof schemas.SearchBrandsRequestSchema;\n verify_brand_claim: typeof schemas.VerifyBrandClaimRequestSchema;\n verify_brand_claims: typeof schemas.VerifyBrandClaimsRequestBulkSchema;\n} & {\n readonly [toolName: string]: InputSchema \| undefined;\n};\n\nfunction shapeOf<T extends { shape?: InputShape }>(s: T \| undefined): T['shape'] \| undefined {\n const candidate = s?.shape;\n return candidate && typeof candidate === 'object' ? candidate : undefined;\n}\n\n/\n Map of every known AdCP tool name to its Zod input shape — i.e., the\n * `.shape` of its request schema, ready to pass as `inputSchema` to MCP\n * SDK's `server.registerTool()`.\n \n Superset of {@link TOOL_REQUEST_SCHEMAS}: covers every tool already\n * registered with the framework (get_products, create_media_buy,\n * sync_catalogs, check_governance, comply_test_controller, all five\n * _collection_list tools, validate_property_delivery, acquire_rights,\n et al.) PLUS shape-compatible custom surfaces such as `creative_approval`,\n * `search_brands`, and `verify_brand_claims` so sellers don't have to\n * hand-author shapes for those either.\n \n `verify_brand_claim` is intentionally not present here: its request schema\n * is an envelope intersected with a claim-variant union, so use\n * {@link TOOL_INPUT_SCHEMAS} with {@link customToolForSchema} to preserve the\n * discriminated union at validation time.\n \n Known tool names retain exact `.shape` field types for IDE completion and\n * handler inference. Arbitrary string lookups return `undefined` until callers\n * narrow the tool name to a known key.\n \n If a future AdCP release adds a new tool with a generated request\n * schema, add its entry here (or to `TOOL_REQUEST_SCHEMAS` if it's\n * framework-registrable) — CI's `ci:schema-check` catches missing\n * map entries by diffing against the generated schemas.\n /\nexport const TOOL_INPUT_SHAPES = Object.freeze({\n ...Object.fromEntries(\n Object.entries(TOOL_REQUEST_SCHEMAS).map(([k, s]) => {\n const shape = shapeOf(s);\n if (!shape) {\n throw new Error(\n `TOOL_REQUEST_SCHEMAS[\"${k}\"] has no .shape — schema must be a ZodObject (use merge() not and())`\n );\n }\n return [k, shape] as const;\n })\n ),\n creative_approval: schemas.CreativeApprovalRequestSchema.shape,\n search_brands: schemas.SearchBrandsRequestSchema.shape,\n verify_brand_claims: schemas.VerifyBrandClaimsRequestBulkSchema.shape,\n}) as Readonly<ToolInputShapes>;\n\n/\n Map of known AdCP tool names to their full generated Zod request schemas.\n \n Prefer {@link TOOL_INPUT_SHAPES} when registering a shape-compatible tool\n * with `registerTool()`. Use this map for union/intersection request schemas,\n * notably `verify_brand_claim`, where a raw shape would lose the correlation\n * between `claim_type` and the corresponding `claim` payload.\n /\nexport const TOOL_INPUT_SCHEMAS = Object.freeze({\n ...TOOL_REQUEST_SCHEMAS,\n creative_approval: schemas.CreativeApprovalRequestSchema,\n search_brands: schemas.SearchBrandsRequestSchema,\n verify_brand_claim: schemas.VerifyBrandClaimRequestSchema,\n verify_brand_claims: schemas.VerifyBrandClaimsRequestBulkSchema,\n}) as Readonly<ToolInputSchemas>;\n\n/\n Register a custom tool with MCP-compatible `inputSchema` + handler\n * wiring. Returns an object shaped for\n * `AdcpServerConfig.customTools[name]` — pass it straight through.\n \n Why it exists: sellers adding tools outside `AdcpToolMap` have to\n * publish an `inputSchema` via `tools/list` (MCP spec requirement). Doing\n * that by hand means authoring a Zod shape that matches the generated\n * AdCP spec schema — easy to drift silently. Using this helper guarantees\n * the advertised shape is the same shape the SDK validates the request\n * against.\n /\nexport function customToolFor<TShape extends InputShape>(\n name: string,\n description: string,\n inputSchema: TShape,\n handler: (args: z.input<z.ZodObject<TShape>>, extra?: unknown) => unknown \| Promise<unknown>\n): {\n description: string;\n inputSchema: TShape;\n handler: (args: z.input<z.ZodObject<TShape>>, extra?: unknown) => unknown \| Promise<unknown>;\n} {\n // `name` participates in the return contract's narrowing only indirectly\n // (via the caller's key when spread into `customTools`). Callers retain\n // it as a parameter so future stricter registration (logging, metrics,\n // schema-registry lookups) can be added without an API break.\n void name;\n return { description, inputSchema, handler };\n}\n\n/\n Register a custom tool whose MCP `inputSchema` is a full Zod schema rather\n * than a raw shape. Use this for request schemas with top-level unions or\n * intersections, where `.shape` would either be unavailable or would weaken\n * runtime validation.\n */\nexport function customToolForSchema<TSchema extends InputSchema>(\n name: string,\n description: string,\n inputSchema: TSchema,\n handler: (args: z.input<TSchema>, extra?: unknown) => unknown \| Promise<unknown>\n): {\n description: string;\n inputSchema: TSchema;\n handler: (args: z.input<TSchema>, extra?: unknown) => unknown \| Promise<unknown>;\n} {\n void name;\n return { description, inputSchema, handler };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2CA,cAAyB;AACzB,kCAAqC;AAErC,2BAIO;AACP,iCAAmC;AAEnC,4BAAc,uCArDd;AAsDA,4BAAoC;AACpC,+BAAgD;AAChD,IAAAA,+BAAqC;AACrC,8BAAsC;AACtC,4BAKO;AAgBA,SAAS,mBACd,UACA,UAAmC,CAAC,GACH;AACjC,aAAO,4CAAsB,UAAU,eAAW,+CAAmB,QAAQ,WAAW,CAAC;AAC3F;AAGO,SAAS,sBACd,UACA,UAA2C,CAAC,GACX;AACjC,aAAO,4CAAsB,UAAU,QAAQ,WAAW,YAAQ,+CAAmB,QAAQ,WAAW,CAAC;AAC3G;AA0BA,SAAS,QAA0C,GAA0C;AAC3F,QAAM,YAAY,GAAG;AACrB,SAAO,aAAa,OAAO,cAAc,WAAW,YAAY;AAClE;AA6BO,MAAM,oBAAoB,OAAO,OAAO;AAAA,EAC7C,GAAG,OAAO;AAAA,IACR,OAAO,QAAQ,gDAAoB,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM;AACnD,YAAM,QAAQ,QAAQ,CAAC;AACvB,UAAI,CAAC,OAAO;AACV,cAAM,IAAI;AAAA,UACR,yBAAyB,CAAC;AAAA,QAC5B;AAAA,MACF;AACA,aAAO,CAAC,GAAG,KAAK;AAAA,IAClB,CAAC;AAAA,EACH;AAAA,EACA,mBAAmB,QAAQ,8BAA8B;AAAA,EACzD,eAAe,QAAQ,0BAA0B;AAAA,EACjD,qBAAqB,QAAQ,mCAAmC;AAClE,CAAC;AAUM,MAAM,qBAAqB,OAAO,OAAO;AAAA,EAC9C,GAAG;AAAA,EACH,mBAAmB,QAAQ;AAAA,EAC3B,eAAe,QAAQ;AAAA,EACvB,oBAAoB,QAAQ;AAAA,EAC5B,qBAAqB,QAAQ;AAC/B,CAAC;AAcM,SAAS,cACd,MACA,aACA,aACA,SAKA;AAKA,OAAK;AACL,SAAO,EAAE,aAAa,aAAa,QAAQ;AAC7C;AAQO,SAAS,oBACd,MACA,aACA,aACA,SAKA;AACA,OAAK;AACL,SAAO,EAAE,aAAa,aAAa,QAAQ;AAC7C;","names":["import_tool_request_schemas"]}
1	+ {"version":3,"sources":["../../../src/lib/schemas/index.ts"],"sourcesContent":["/*\n Consolidated schema exports for MCP tool registration.\n \n The generated Zod schemas in `../types/schemas.generated` cover every\n * AdCP tool — the framework-registered {@link AdcpToolMap} tools AND\n * tools like `creative_approval`, `search_brands`, and brand verification\n * tasks that ship as `customTools` extensions because the spec models them\n * outside the SDK's framework-registered surface.\n \n This module re-exports the generated schemas plus two convenience\n * helpers for the `customTools` registration path:\n \n - {@link TOOL_INPUT_SHAPES}: `toolName → raw Zod shape` map, ready to\n * pass as `inputSchema` to MCP SDK's `server.registerTool()` when the\n * request schema is a ZodObject.\n * - {@link TOOL_INPUT_SCHEMAS}: `toolName → full Zod schema` map for\n * custom tools whose request schema is a union/intersection and cannot\n * be represented as a raw shape without weakening validation.\n * - {@link TOOL_RESPONSE_SCHEMAS}: `toolName → full Zod response schema`\n * map for response validation and compliance tooling.\n * - {@link customToolFor}: sugar for registering a single custom tool\n * with type-safe `handler` params derived from the schema's shape.\n * - {@link customToolForSchema}: same sugar for full Zod schemas.\n \n ```ts\n * import { createAdcpServer } from '@adcp/sdk/server/legacy/v5';\n * import { TOOL_INPUT_SHAPES, customToolFor } from '@adcp/sdk/schemas';\n \n createAdcpServer({\n * customTools: {\n * creative_approval: customToolFor(\n * 'creative_approval',\n * 'Accept a buyer creative for approval.',\n * TOOL_INPUT_SHAPES.creative_approval,\n * async (args, extra) => { ... },\n * ),\n * },\n * ...,\n * });\n * ```\n /\n\nimport { z } from 'zod';\nimport as schemas from '../types/schemas.generated';\nimport { GetProductsRequest_FieldsValues } from '../types/inline-enums.generated';\nimport type { CanonicalGetProductsRequest } from '../v2/projection/creative-delivery';\nimport { TOOL_REQUEST_SCHEMAS } from '../utils/tool-request-schemas';\nimport type { KnownToolRequestSchemas } from '../utils/tool-request-schemas';\nimport {\n getToolSchemaDocument,\n type ResolvedToolSchemaDocument,\n type ResponseVariant,\n} from '../validation/schema-loader';\nimport { resolveAdcpVersion } from '../utils/adcp-version-config';\n\nexport * from '../types/schemas.generated';\n\ntype LooseObjectSchemaFor<T extends object> = z.ZodObject<\n {\n [K in keyof T]-?: undefined extends T[K]\n ? z.ZodOptional<z.ZodType<Exclude<T[K], undefined>, Exclude<T[K], undefined>>>\n : z.ZodType<T[K], T[K]>;\n },\n z.core.$loose\n> &\n z.ZodType<T & Record<string, unknown>, T & Record<string, unknown>>;\n\n/** Wire-compatible request schema, including the legacy `format_ids` selector. /\nexport const LegacyGetProductsRequestSchema = schemas.GetProductsRequestSchema;\n\ntype CanonicalGetProductsField = NonNullable<CanonicalGetProductsRequest['fields']>[number];\nconst canonicalGetProductsFields = GetProductsRequest_FieldsValues.filter(\n (field): field is CanonicalGetProductsField => field !== 'format_ids'\n) as [CanonicalGetProductsField, ...CanonicalGetProductsField[]];\n\n/* Primary request schema; legacy `format_ids` selection is rejected. /\nexport const GetProductsRequestSchema = schemas.GetProductsRequestSchema.safeExtend({\n fields: z.array(z.enum(canonicalGetProductsFields)).optional(),\n}) as unknown as LooseObjectSchemaFor<CanonicalGetProductsRequest>;\n\nexport { BiddingPolicySchema } from '../validation/bidding-policy';\nexport { CanonicalBudgetAllocationSchema } from '../validation/budget-allocation';\nexport { TOOL_REQUEST_SCHEMAS } from '../utils/tool-request-schemas';\nexport { TOOL_RESPONSE_SCHEMAS } from '../utils/response-schemas';\nexport {\n SyncCreativesItemSchema,\n SyncCreativesSuccessStrictSchema,\n SyncCreativesResponseStrictSchema,\n SyncCreativesActionSchema,\n} from '../validation/sync-creatives';\nexport type { SyncCreativesItem, SyncCreativesSuccessStrict } from '../validation/sync-creatives';\n\nexport interface ToolSchemaLookupOptions {\n /* AdCP release/minor/legacy alias resolved through the bundled schema loader. /\n adcpVersion?: string;\n}\n\nexport interface ToolResponseSchemaLookupOptions extends ToolSchemaLookupOptions {\n /* Response arm to retrieve. Defaults to the synchronous response schema. /\n variant?: ResponseVariant;\n}\n\nexport type VersionedToolSchema = ResolvedToolSchemaDocument;\n\n/* Retrieve the protocol-authored request JSON Schema for a specific AdCP release. /\nexport function getToolInputSchema(\n toolName: string,\n options: ToolSchemaLookupOptions = {}\n): VersionedToolSchema \| undefined {\n return getToolSchemaDocument(toolName, 'request', resolveAdcpVersion(options.adcpVersion));\n}\n\n/* Retrieve a protocol-authored response JSON Schema for a specific AdCP release. /\nexport function getToolResponseSchema(\n toolName: string,\n options: ToolResponseSchemaLookupOptions = {}\n): VersionedToolSchema \| undefined {\n return getToolSchemaDocument(toolName, options.variant ?? 'sync', resolveAdcpVersion(options.adcpVersion));\n}\n\ntype InputShape = Record<string, z.ZodType>;\ntype InputSchema = z.ZodType;\ntype ShapeOf<T> = T extends { shape: infer TShape extends InputShape } ? TShape : never;\ntype ToolInputShapes = {\n [K in keyof KnownToolRequestSchemas]: ShapeOf<KnownToolRequestSchemas[K]>;\n} & {\n creative_approval: typeof schemas.CreativeApprovalRequestSchema.shape;\n search_brands: typeof schemas.SearchBrandsRequestSchema.shape;\n verify_brand_claims: typeof schemas.VerifyBrandClaimsRequestBulkSchema.shape;\n} & {\n readonly [toolName: string]: Readonly<InputShape> \| undefined;\n};\n\ntype ToolInputSchemas = {\n [K in keyof KnownToolRequestSchemas]: KnownToolRequestSchemas[K];\n} & {\n creative_approval: typeof schemas.CreativeApprovalRequestSchema;\n search_brands: typeof schemas.SearchBrandsRequestSchema;\n verify_brand_claim: typeof schemas.VerifyBrandClaimRequestSchema;\n verify_brand_claims: typeof schemas.VerifyBrandClaimsRequestBulkSchema;\n} & {\n readonly [toolName: string]: InputSchema \| undefined;\n};\n\nfunction shapeOf<T extends { shape?: InputShape }>(s: T \| undefined): T['shape'] \| undefined {\n const candidate = s?.shape;\n return candidate && typeof candidate === 'object' ? candidate : undefined;\n}\n\n/\n Map of every known AdCP tool name to its Zod input shape — i.e., the\n * `.shape` of its request schema, ready to pass as `inputSchema` to MCP\n * SDK's `server.registerTool()`.\n \n Superset of {@link TOOL_REQUEST_SCHEMAS}: covers every tool already\n * registered with the framework (get_products, create_media_buy,\n * sync_catalogs, check_governance, comply_test_controller, all five\n * _collection_list tools, validate_property_delivery, acquire_rights,\n et al.) PLUS shape-compatible custom surfaces such as `creative_approval`,\n * `search_brands`, and `verify_brand_claims` so sellers don't have to\n * hand-author shapes for those either.\n \n `verify_brand_claim` is intentionally not present here: its request schema\n * is an envelope intersected with a claim-variant union, so use\n * {@link TOOL_INPUT_SCHEMAS} with {@link customToolForSchema} to preserve the\n * discriminated union at validation time.\n \n Known tool names retain exact `.shape` field types for IDE completion and\n * handler inference. Arbitrary string lookups return `undefined` until callers\n * narrow the tool name to a known key.\n \n If a future AdCP release adds a new tool with a generated request\n * schema, add its entry here (or to `TOOL_REQUEST_SCHEMAS` if it's\n * framework-registrable) — CI's `ci:schema-check` catches missing\n * map entries by diffing against the generated schemas.\n /\nexport const TOOL_INPUT_SHAPES = Object.freeze({\n ...Object.fromEntries(\n Object.entries(TOOL_REQUEST_SCHEMAS).map(([k, s]) => {\n const shape = shapeOf(s);\n if (!shape) {\n throw new Error(\n `TOOL_REQUEST_SCHEMAS[\"${k}\"] has no .shape — schema must be a ZodObject (use merge() not and())`\n );\n }\n return [k, shape] as const;\n })\n ),\n creative_approval: schemas.CreativeApprovalRequestSchema.shape,\n search_brands: schemas.SearchBrandsRequestSchema.shape,\n verify_brand_claims: schemas.VerifyBrandClaimsRequestBulkSchema.shape,\n}) as Readonly<ToolInputShapes>;\n\n/\n Map of known AdCP tool names to their full generated Zod request schemas.\n \n Prefer {@link TOOL_INPUT_SHAPES} when registering a shape-compatible tool\n * with `registerTool()`. Use this map for union/intersection request schemas,\n * notably `verify_brand_claim`, where a raw shape would lose the correlation\n * between `claim_type` and the corresponding `claim` payload.\n /\nexport const TOOL_INPUT_SCHEMAS = Object.freeze({\n ...TOOL_REQUEST_SCHEMAS,\n creative_approval: schemas.CreativeApprovalRequestSchema,\n search_brands: schemas.SearchBrandsRequestSchema,\n verify_brand_claim: schemas.VerifyBrandClaimRequestSchema,\n verify_brand_claims: schemas.VerifyBrandClaimsRequestBulkSchema,\n}) as Readonly<ToolInputSchemas>;\n\n/\n Register a custom tool with MCP-compatible `inputSchema` + handler\n * wiring. Returns an object shaped for\n * `AdcpServerConfig.customTools[name]` — pass it straight through.\n \n Why it exists: sellers adding tools outside `AdcpToolMap` have to\n * publish an `inputSchema` via `tools/list` (MCP spec requirement). Doing\n * that by hand means authoring a Zod shape that matches the generated\n * AdCP spec schema — easy to drift silently. Using this helper guarantees\n * the advertised shape is the same shape the SDK validates the request\n * against.\n /\nexport function customToolFor<TShape extends InputShape>(\n name: string,\n description: string,\n inputSchema: TShape,\n handler: (args: z.input<z.ZodObject<TShape>>, extra?: unknown) => unknown \| Promise<unknown>\n): {\n description: string;\n inputSchema: TShape;\n handler: (args: z.input<z.ZodObject<TShape>>, extra?: unknown) => unknown \| Promise<unknown>;\n} {\n // `name` participates in the return contract's narrowing only indirectly\n // (via the caller's key when spread into `customTools`). Callers retain\n // it as a parameter so future stricter registration (logging, metrics,\n // schema-registry lookups) can be added without an API break.\n void name;\n return { description, inputSchema, handler };\n}\n\n/\n Register a custom tool whose MCP `inputSchema` is a full Zod schema rather\n * than a raw shape. Use this for request schemas with top-level unions or\n * intersections, where `.shape` would either be unavailable or would weaken\n * runtime validation.\n */\nexport function customToolForSchema<TSchema extends InputSchema>(\n name: string,\n description: string,\n inputSchema: TSchema,\n handler: (args: z.input<TSchema>, extra?: unknown) => unknown \| Promise<unknown>\n): {\n description: string;\n inputSchema: TSchema;\n handler: (args: z.input<TSchema>, extra?: unknown) => unknown \| Promise<unknown>;\n} {\n void name;\n return { description, inputSchema, handler };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0CA,iBAAkB;AAClB,cAAyB;AACzB,0BAAgD;AAEhD,kCAAqC;AAErC,2BAIO;AACP,iCAAmC;AAEnC,4BAAc,uCAvDd;AAgFA,4BAAoC;AACpC,+BAAgD;AAChD,IAAAA,+BAAqC;AACrC,8BAAsC;AACtC,4BAKO;AArBA,MAAM,iCAAiC,QAAQ;AAGtD,MAAM,6BAA6B,oDAAgC;AAAA,EACjE,CAAC,UAA8C,UAAU;AAC3D;AAGO,MAAM,2BAA2B,QAAQ,yBAAyB,WAAW;AAAA,EAClF,QAAQ,aAAE,MAAM,aAAE,KAAK,0BAA0B,CAAC,EAAE,SAAS;AAC/D,CAAC;AA2BM,SAAS,mBACd,UACA,UAAmC,CAAC,GACH;AACjC,aAAO,4CAAsB,UAAU,eAAW,+CAAmB,QAAQ,WAAW,CAAC;AAC3F;AAGO,SAAS,sBACd,UACA,UAA2C,CAAC,GACX;AACjC,aAAO,4CAAsB,UAAU,QAAQ,WAAW,YAAQ,+CAAmB,QAAQ,WAAW,CAAC;AAC3G;AA0BA,SAAS,QAA0C,GAA0C;AAC3F,QAAM,YAAY,GAAG;AACrB,SAAO,aAAa,OAAO,cAAc,WAAW,YAAY;AAClE;AA6BO,MAAM,oBAAoB,OAAO,OAAO;AAAA,EAC7C,GAAG,OAAO;AAAA,IACR,OAAO,QAAQ,gDAAoB,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM;AACnD,YAAM,QAAQ,QAAQ,CAAC;AACvB,UAAI,CAAC,OAAO;AACV,cAAM,IAAI;AAAA,UACR,yBAAyB,CAAC;AAAA,QAC5B;AAAA,MACF;AACA,aAAO,CAAC,GAAG,KAAK;AAAA,IAClB,CAAC;AAAA,EACH;AAAA,EACA,mBAAmB,QAAQ,8BAA8B;AAAA,EACzD,eAAe,QAAQ,0BAA0B;AAAA,EACjD,qBAAqB,QAAQ,mCAAmC;AAClE,CAAC;AAUM,MAAM,qBAAqB,OAAO,OAAO;AAAA,EAC9C,GAAG;AAAA,EACH,mBAAmB,QAAQ;AAAA,EAC3B,eAAe,QAAQ;AAAA,EACvB,oBAAoB,QAAQ;AAAA,EAC5B,qBAAqB,QAAQ;AAC/B,CAAC;AAcM,SAAS,cACd,MACA,aACA,aACA,SAKA;AAKA,OAAK;AACL,SAAO,EAAE,aAAa,aAAa,QAAQ;AAC7C;AAQO,SAAS,oBACd,MACA,aACA,aACA,SAKA;AACA,OAAK;AACL,SAAO,EAAE,aAAa,aAAa,QAAQ;AAC7C;","names":["import_tool_request_schemas"]}

package/dist/lib/schemas/index.mjs CHANGED Viewed

@@ -1,10 +1,19 @@
+import { z } from "zod";
 import * as schemas from "../types/schemas.generated.mjs";
+import { GetProductsRequest_FieldsValues } from "../types/inline-enums.generated.mjs";
 import { TOOL_REQUEST_SCHEMAS } from "../utils/tool-request-schemas.mjs";
 import {
   getToolSchemaDocument
 } from "../validation/schema-loader.mjs";
 import { resolveAdcpVersion } from "../utils/adcp-version-config.mjs";
 export * from "../types/schemas.generated.mjs";
+const LegacyGetProductsRequestSchema = schemas.GetProductsRequestSchema;
+const canonicalGetProductsFields = GetProductsRequest_FieldsValues.filter(
+  (field) => field !== "format_ids"
+);
+const GetProductsRequestSchema = schemas.GetProductsRequestSchema.safeExtend({
+  fields: z.array(z.enum(canonicalGetProductsFields)).optional()
+});
 import { BiddingPolicySchema } from "../validation/bidding-policy.mjs";
 import { CanonicalBudgetAllocationSchema } from "../validation/budget-allocation.mjs";
 import { TOOL_REQUEST_SCHEMAS as TOOL_REQUEST_SCHEMAS2 } from "../utils/tool-request-schemas.mjs";
@@ -59,6 +68,8 @@ function customToolForSchema(name, description, inputSchema, handler) {
 export {
   BiddingPolicySchema,
   CanonicalBudgetAllocationSchema,
+  GetProductsRequestSchema,
+  LegacyGetProductsRequestSchema,
   SyncCreativesActionSchema,
   SyncCreativesItemSchema,
   SyncCreativesResponseStrictSchema,

package/dist/lib/schemas/index.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../../../src/lib/schemas/index.ts"],"sourcesContent":["/*\n Consolidated schema exports for MCP tool registration.\n \n The generated Zod schemas in `../types/schemas.generated` cover every\n * AdCP tool — the framework-registered {@link AdcpToolMap} tools AND\n * tools like `creative_approval`, `search_brands`, and brand verification\n * tasks that ship as `customTools` extensions because the spec models them\n * outside the SDK's framework-registered surface.\n \n This module re-exports the generated schemas plus two convenience\n * helpers for the `customTools` registration path:\n \n - {@link TOOL_INPUT_SHAPES}: `toolName → raw Zod shape` map, ready to\n * pass as `inputSchema` to MCP SDK's `server.registerTool()` when the\n * request schema is a ZodObject.\n * - {@link TOOL_INPUT_SCHEMAS}: `toolName → full Zod schema` map for\n * custom tools whose request schema is a union/intersection and cannot\n * be represented as a raw shape without weakening validation.\n * - {@link TOOL_RESPONSE_SCHEMAS}: `toolName → full Zod response schema`\n * map for response validation and compliance tooling.\n * - {@link customToolFor}: sugar for registering a single custom tool\n * with type-safe `handler` params derived from the schema's shape.\n * - {@link customToolForSchema}: same sugar for full Zod schemas.\n \n ```ts\n * import { createAdcpServer } from '@adcp/sdk/server/legacy/v5';\n * import { TOOL_INPUT_SHAPES, customToolFor } from '@adcp/sdk/schemas';\n \n createAdcpServer({\n * customTools: {\n * creative_approval: customToolFor(\n * 'creative_approval',\n * 'Accept a buyer creative for approval.',\n * TOOL_INPUT_SHAPES.creative_approval,\n * async (args, extra) => { ... },\n * ),\n * },\n * ...,\n * });\n * ```\n /\n\nimport type { z } from 'zod';\nimport as schemas from '../types/schemas.generated';\nimport { TOOL_REQUEST_SCHEMAS } from '../utils/tool-request-schemas';\nimport type { KnownToolRequestSchemas } from '../utils/tool-request-schemas';\nimport {\n getToolSchemaDocument,\n type ResolvedToolSchemaDocument,\n type ResponseVariant,\n} from '../validation/schema-loader';\nimport { resolveAdcpVersion } from '../utils/adcp-version-config';\n\nexport * from '../types/schemas.generated';\nexport { BiddingPolicySchema } from '../validation/bidding-policy';\nexport { CanonicalBudgetAllocationSchema } from '../validation/budget-allocation';\nexport { TOOL_REQUEST_SCHEMAS } from '../utils/tool-request-schemas';\nexport { TOOL_RESPONSE_SCHEMAS } from '../utils/response-schemas';\nexport {\n SyncCreativesItemSchema,\n SyncCreativesSuccessStrictSchema,\n SyncCreativesResponseStrictSchema,\n SyncCreativesActionSchema,\n} from '../validation/sync-creatives';\nexport type { SyncCreativesItem, SyncCreativesSuccessStrict } from '../validation/sync-creatives';\n\nexport interface ToolSchemaLookupOptions {\n /** AdCP release/minor/legacy alias resolved through the bundled schema loader. /\n adcpVersion?: string;\n}\n\nexport interface ToolResponseSchemaLookupOptions extends ToolSchemaLookupOptions {\n /* Response arm to retrieve. Defaults to the synchronous response schema. /\n variant?: ResponseVariant;\n}\n\nexport type VersionedToolSchema = ResolvedToolSchemaDocument;\n\n/* Retrieve the protocol-authored request JSON Schema for a specific AdCP release. /\nexport function getToolInputSchema(\n toolName: string,\n options: ToolSchemaLookupOptions = {}\n): VersionedToolSchema \| undefined {\n return getToolSchemaDocument(toolName, 'request', resolveAdcpVersion(options.adcpVersion));\n}\n\n/* Retrieve a protocol-authored response JSON Schema for a specific AdCP release. /\nexport function getToolResponseSchema(\n toolName: string,\n options: ToolResponseSchemaLookupOptions = {}\n): VersionedToolSchema \| undefined {\n return getToolSchemaDocument(toolName, options.variant ?? 'sync', resolveAdcpVersion(options.adcpVersion));\n}\n\ntype InputShape = Record<string, z.ZodType>;\ntype InputSchema = z.ZodType;\ntype ShapeOf<T> = T extends { shape: infer TShape extends InputShape } ? TShape : never;\ntype ToolInputShapes = {\n [K in keyof KnownToolRequestSchemas]: ShapeOf<KnownToolRequestSchemas[K]>;\n} & {\n creative_approval: typeof schemas.CreativeApprovalRequestSchema.shape;\n search_brands: typeof schemas.SearchBrandsRequestSchema.shape;\n verify_brand_claims: typeof schemas.VerifyBrandClaimsRequestBulkSchema.shape;\n} & {\n readonly [toolName: string]: Readonly<InputShape> \| undefined;\n};\n\ntype ToolInputSchemas = {\n [K in keyof KnownToolRequestSchemas]: KnownToolRequestSchemas[K];\n} & {\n creative_approval: typeof schemas.CreativeApprovalRequestSchema;\n search_brands: typeof schemas.SearchBrandsRequestSchema;\n verify_brand_claim: typeof schemas.VerifyBrandClaimRequestSchema;\n verify_brand_claims: typeof schemas.VerifyBrandClaimsRequestBulkSchema;\n} & {\n readonly [toolName: string]: InputSchema \| undefined;\n};\n\nfunction shapeOf<T extends { shape?: InputShape }>(s: T \| undefined): T['shape'] \| undefined {\n const candidate = s?.shape;\n return candidate && typeof candidate === 'object' ? candidate : undefined;\n}\n\n/\n Map of every known AdCP tool name to its Zod input shape — i.e., the\n * `.shape` of its request schema, ready to pass as `inputSchema` to MCP\n * SDK's `server.registerTool()`.\n \n Superset of {@link TOOL_REQUEST_SCHEMAS}: covers every tool already\n * registered with the framework (get_products, create_media_buy,\n * sync_catalogs, check_governance, comply_test_controller, all five\n * _collection_list tools, validate_property_delivery, acquire_rights,\n et al.) PLUS shape-compatible custom surfaces such as `creative_approval`,\n * `search_brands`, and `verify_brand_claims` so sellers don't have to\n * hand-author shapes for those either.\n \n `verify_brand_claim` is intentionally not present here: its request schema\n * is an envelope intersected with a claim-variant union, so use\n * {@link TOOL_INPUT_SCHEMAS} with {@link customToolForSchema} to preserve the\n * discriminated union at validation time.\n \n Known tool names retain exact `.shape` field types for IDE completion and\n * handler inference. Arbitrary string lookups return `undefined` until callers\n * narrow the tool name to a known key.\n \n If a future AdCP release adds a new tool with a generated request\n * schema, add its entry here (or to `TOOL_REQUEST_SCHEMAS` if it's\n * framework-registrable) — CI's `ci:schema-check` catches missing\n * map entries by diffing against the generated schemas.\n /\nexport const TOOL_INPUT_SHAPES = Object.freeze({\n ...Object.fromEntries(\n Object.entries(TOOL_REQUEST_SCHEMAS).map(([k, s]) => {\n const shape = shapeOf(s);\n if (!shape) {\n throw new Error(\n `TOOL_REQUEST_SCHEMAS[\"${k}\"] has no .shape — schema must be a ZodObject (use merge() not and())`\n );\n }\n return [k, shape] as const;\n })\n ),\n creative_approval: schemas.CreativeApprovalRequestSchema.shape,\n search_brands: schemas.SearchBrandsRequestSchema.shape,\n verify_brand_claims: schemas.VerifyBrandClaimsRequestBulkSchema.shape,\n}) as Readonly<ToolInputShapes>;\n\n/\n Map of known AdCP tool names to their full generated Zod request schemas.\n \n Prefer {@link TOOL_INPUT_SHAPES} when registering a shape-compatible tool\n * with `registerTool()`. Use this map for union/intersection request schemas,\n * notably `verify_brand_claim`, where a raw shape would lose the correlation\n * between `claim_type` and the corresponding `claim` payload.\n /\nexport const TOOL_INPUT_SCHEMAS = Object.freeze({\n ...TOOL_REQUEST_SCHEMAS,\n creative_approval: schemas.CreativeApprovalRequestSchema,\n search_brands: schemas.SearchBrandsRequestSchema,\n verify_brand_claim: schemas.VerifyBrandClaimRequestSchema,\n verify_brand_claims: schemas.VerifyBrandClaimsRequestBulkSchema,\n}) as Readonly<ToolInputSchemas>;\n\n/\n Register a custom tool with MCP-compatible `inputSchema` + handler\n * wiring. Returns an object shaped for\n * `AdcpServerConfig.customTools[name]` — pass it straight through.\n \n Why it exists: sellers adding tools outside `AdcpToolMap` have to\n * publish an `inputSchema` via `tools/list` (MCP spec requirement). Doing\n * that by hand means authoring a Zod shape that matches the generated\n * AdCP spec schema — easy to drift silently. Using this helper guarantees\n * the advertised shape is the same shape the SDK validates the request\n * against.\n /\nexport function customToolFor<TShape extends InputShape>(\n name: string,\n description: string,\n inputSchema: TShape,\n handler: (args: z.input<z.ZodObject<TShape>>, extra?: unknown) => unknown \| Promise<unknown>\n): {\n description: string;\n inputSchema: TShape;\n handler: (args: z.input<z.ZodObject<TShape>>, extra?: unknown) => unknown \| Promise<unknown>;\n} {\n // `name` participates in the return contract's narrowing only indirectly\n // (via the caller's key when spread into `customTools`). Callers retain\n // it as a parameter so future stricter registration (logging, metrics,\n // schema-registry lookups) can be added without an API break.\n void name;\n return { description, inputSchema, handler };\n}\n\n/\n Register a custom tool whose MCP `inputSchema` is a full Zod schema rather\n * than a raw shape. Use this for request schemas with top-level unions or\n * intersections, where `.shape` would either be unavailable or would weaken\n * runtime validation.\n */\nexport function customToolForSchema<TSchema extends InputSchema>(\n name: string,\n description: string,\n inputSchema: TSchema,\n handler: (args: z.input<TSchema>, extra?: unknown) => unknown \| Promise<unknown>\n): {\n description: string;\n inputSchema: TSchema;\n handler: (args: z.input<TSchema>, extra?: unknown) => unknown \| Promise<unknown>;\n} {\n void name;\n return { description, inputSchema, handler };\n}\n"],"mappings":"AA2CA,YAAY,aAAa;AACzB,SAAS,4BAA4B;AAErC;AAAA,EACE;AAAA,OAGK;AACP,SAAS,0BAA0B;AAEnC,cAAc;AACd,SAAS,2BAA2B;AACpC,SAAS,uCAAuC;AAChD,SAAS,wBAAAA,6BAA4B;AACrC,SAAS,6BAA6B;AACtC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAgBA,SAAS,mBACd,UACA,UAAmC,CAAC,GACH;AACjC,SAAO,sBAAsB,UAAU,WAAW,mBAAmB,QAAQ,WAAW,CAAC;AAC3F;AAGO,SAAS,sBACd,UACA,UAA2C,CAAC,GACX;AACjC,SAAO,sBAAsB,UAAU,QAAQ,WAAW,QAAQ,mBAAmB,QAAQ,WAAW,CAAC;AAC3G;AA0BA,SAAS,QAA0C,GAA0C;AAC3F,QAAM,YAAY,GAAG;AACrB,SAAO,aAAa,OAAO,cAAc,WAAW,YAAY;AAClE;AA6BO,MAAM,oBAAoB,OAAO,OAAO;AAAA,EAC7C,GAAG,OAAO;AAAA,IACR,OAAO,QAAQ,oBAAoB,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM;AACnD,YAAM,QAAQ,QAAQ,CAAC;AACvB,UAAI,CAAC,OAAO;AACV,cAAM,IAAI;AAAA,UACR,yBAAyB,CAAC;AAAA,QAC5B;AAAA,MACF;AACA,aAAO,CAAC,GAAG,KAAK;AAAA,IAClB,CAAC;AAAA,EACH;AAAA,EACA,mBAAmB,QAAQ,8BAA8B;AAAA,EACzD,eAAe,QAAQ,0BAA0B;AAAA,EACjD,qBAAqB,QAAQ,mCAAmC;AAClE,CAAC;AAUM,MAAM,qBAAqB,OAAO,OAAO;AAAA,EAC9C,GAAG;AAAA,EACH,mBAAmB,QAAQ;AAAA,EAC3B,eAAe,QAAQ;AAAA,EACvB,oBAAoB,QAAQ;AAAA,EAC5B,qBAAqB,QAAQ;AAC/B,CAAC;AAcM,SAAS,cACd,MACA,aACA,aACA,SAKA;AAKA,OAAK;AACL,SAAO,EAAE,aAAa,aAAa,QAAQ;AAC7C;AAQO,SAAS,oBACd,MACA,aACA,aACA,SAKA;AACA,OAAK;AACL,SAAO,EAAE,aAAa,aAAa,QAAQ;AAC7C;","names":["TOOL_REQUEST_SCHEMAS"]}
1	+ {"version":3,"sources":["../../../src/lib/schemas/index.ts"],"sourcesContent":["/*\n Consolidated schema exports for MCP tool registration.\n \n The generated Zod schemas in `../types/schemas.generated` cover every\n * AdCP tool — the framework-registered {@link AdcpToolMap} tools AND\n * tools like `creative_approval`, `search_brands`, and brand verification\n * tasks that ship as `customTools` extensions because the spec models them\n * outside the SDK's framework-registered surface.\n \n This module re-exports the generated schemas plus two convenience\n * helpers for the `customTools` registration path:\n \n - {@link TOOL_INPUT_SHAPES}: `toolName → raw Zod shape` map, ready to\n * pass as `inputSchema` to MCP SDK's `server.registerTool()` when the\n * request schema is a ZodObject.\n * - {@link TOOL_INPUT_SCHEMAS}: `toolName → full Zod schema` map for\n * custom tools whose request schema is a union/intersection and cannot\n * be represented as a raw shape without weakening validation.\n * - {@link TOOL_RESPONSE_SCHEMAS}: `toolName → full Zod response schema`\n * map for response validation and compliance tooling.\n * - {@link customToolFor}: sugar for registering a single custom tool\n * with type-safe `handler` params derived from the schema's shape.\n * - {@link customToolForSchema}: same sugar for full Zod schemas.\n \n ```ts\n * import { createAdcpServer } from '@adcp/sdk/server/legacy/v5';\n * import { TOOL_INPUT_SHAPES, customToolFor } from '@adcp/sdk/schemas';\n \n createAdcpServer({\n * customTools: {\n * creative_approval: customToolFor(\n * 'creative_approval',\n * 'Accept a buyer creative for approval.',\n * TOOL_INPUT_SHAPES.creative_approval,\n * async (args, extra) => { ... },\n * ),\n * },\n * ...,\n * });\n * ```\n /\n\nimport { z } from 'zod';\nimport as schemas from '../types/schemas.generated';\nimport { GetProductsRequest_FieldsValues } from '../types/inline-enums.generated';\nimport type { CanonicalGetProductsRequest } from '../v2/projection/creative-delivery';\nimport { TOOL_REQUEST_SCHEMAS } from '../utils/tool-request-schemas';\nimport type { KnownToolRequestSchemas } from '../utils/tool-request-schemas';\nimport {\n getToolSchemaDocument,\n type ResolvedToolSchemaDocument,\n type ResponseVariant,\n} from '../validation/schema-loader';\nimport { resolveAdcpVersion } from '../utils/adcp-version-config';\n\nexport * from '../types/schemas.generated';\n\ntype LooseObjectSchemaFor<T extends object> = z.ZodObject<\n {\n [K in keyof T]-?: undefined extends T[K]\n ? z.ZodOptional<z.ZodType<Exclude<T[K], undefined>, Exclude<T[K], undefined>>>\n : z.ZodType<T[K], T[K]>;\n },\n z.core.$loose\n> &\n z.ZodType<T & Record<string, unknown>, T & Record<string, unknown>>;\n\n/** Wire-compatible request schema, including the legacy `format_ids` selector. /\nexport const LegacyGetProductsRequestSchema = schemas.GetProductsRequestSchema;\n\ntype CanonicalGetProductsField = NonNullable<CanonicalGetProductsRequest['fields']>[number];\nconst canonicalGetProductsFields = GetProductsRequest_FieldsValues.filter(\n (field): field is CanonicalGetProductsField => field !== 'format_ids'\n) as [CanonicalGetProductsField, ...CanonicalGetProductsField[]];\n\n/* Primary request schema; legacy `format_ids` selection is rejected. /\nexport const GetProductsRequestSchema = schemas.GetProductsRequestSchema.safeExtend({\n fields: z.array(z.enum(canonicalGetProductsFields)).optional(),\n}) as unknown as LooseObjectSchemaFor<CanonicalGetProductsRequest>;\n\nexport { BiddingPolicySchema } from '../validation/bidding-policy';\nexport { CanonicalBudgetAllocationSchema } from '../validation/budget-allocation';\nexport { TOOL_REQUEST_SCHEMAS } from '../utils/tool-request-schemas';\nexport { TOOL_RESPONSE_SCHEMAS } from '../utils/response-schemas';\nexport {\n SyncCreativesItemSchema,\n SyncCreativesSuccessStrictSchema,\n SyncCreativesResponseStrictSchema,\n SyncCreativesActionSchema,\n} from '../validation/sync-creatives';\nexport type { SyncCreativesItem, SyncCreativesSuccessStrict } from '../validation/sync-creatives';\n\nexport interface ToolSchemaLookupOptions {\n /* AdCP release/minor/legacy alias resolved through the bundled schema loader. /\n adcpVersion?: string;\n}\n\nexport interface ToolResponseSchemaLookupOptions extends ToolSchemaLookupOptions {\n /* Response arm to retrieve. Defaults to the synchronous response schema. /\n variant?: ResponseVariant;\n}\n\nexport type VersionedToolSchema = ResolvedToolSchemaDocument;\n\n/* Retrieve the protocol-authored request JSON Schema for a specific AdCP release. /\nexport function getToolInputSchema(\n toolName: string,\n options: ToolSchemaLookupOptions = {}\n): VersionedToolSchema \| undefined {\n return getToolSchemaDocument(toolName, 'request', resolveAdcpVersion(options.adcpVersion));\n}\n\n/* Retrieve a protocol-authored response JSON Schema for a specific AdCP release. /\nexport function getToolResponseSchema(\n toolName: string,\n options: ToolResponseSchemaLookupOptions = {}\n): VersionedToolSchema \| undefined {\n return getToolSchemaDocument(toolName, options.variant ?? 'sync', resolveAdcpVersion(options.adcpVersion));\n}\n\ntype InputShape = Record<string, z.ZodType>;\ntype InputSchema = z.ZodType;\ntype ShapeOf<T> = T extends { shape: infer TShape extends InputShape } ? TShape : never;\ntype ToolInputShapes = {\n [K in keyof KnownToolRequestSchemas]: ShapeOf<KnownToolRequestSchemas[K]>;\n} & {\n creative_approval: typeof schemas.CreativeApprovalRequestSchema.shape;\n search_brands: typeof schemas.SearchBrandsRequestSchema.shape;\n verify_brand_claims: typeof schemas.VerifyBrandClaimsRequestBulkSchema.shape;\n} & {\n readonly [toolName: string]: Readonly<InputShape> \| undefined;\n};\n\ntype ToolInputSchemas = {\n [K in keyof KnownToolRequestSchemas]: KnownToolRequestSchemas[K];\n} & {\n creative_approval: typeof schemas.CreativeApprovalRequestSchema;\n search_brands: typeof schemas.SearchBrandsRequestSchema;\n verify_brand_claim: typeof schemas.VerifyBrandClaimRequestSchema;\n verify_brand_claims: typeof schemas.VerifyBrandClaimsRequestBulkSchema;\n} & {\n readonly [toolName: string]: InputSchema \| undefined;\n};\n\nfunction shapeOf<T extends { shape?: InputShape }>(s: T \| undefined): T['shape'] \| undefined {\n const candidate = s?.shape;\n return candidate && typeof candidate === 'object' ? candidate : undefined;\n}\n\n/\n Map of every known AdCP tool name to its Zod input shape — i.e., the\n * `.shape` of its request schema, ready to pass as `inputSchema` to MCP\n * SDK's `server.registerTool()`.\n \n Superset of {@link TOOL_REQUEST_SCHEMAS}: covers every tool already\n * registered with the framework (get_products, create_media_buy,\n * sync_catalogs, check_governance, comply_test_controller, all five\n * _collection_list tools, validate_property_delivery, acquire_rights,\n et al.) PLUS shape-compatible custom surfaces such as `creative_approval`,\n * `search_brands`, and `verify_brand_claims` so sellers don't have to\n * hand-author shapes for those either.\n \n `verify_brand_claim` is intentionally not present here: its request schema\n * is an envelope intersected with a claim-variant union, so use\n * {@link TOOL_INPUT_SCHEMAS} with {@link customToolForSchema} to preserve the\n * discriminated union at validation time.\n \n Known tool names retain exact `.shape` field types for IDE completion and\n * handler inference. Arbitrary string lookups return `undefined` until callers\n * narrow the tool name to a known key.\n \n If a future AdCP release adds a new tool with a generated request\n * schema, add its entry here (or to `TOOL_REQUEST_SCHEMAS` if it's\n * framework-registrable) — CI's `ci:schema-check` catches missing\n * map entries by diffing against the generated schemas.\n /\nexport const TOOL_INPUT_SHAPES = Object.freeze({\n ...Object.fromEntries(\n Object.entries(TOOL_REQUEST_SCHEMAS).map(([k, s]) => {\n const shape = shapeOf(s);\n if (!shape) {\n throw new Error(\n `TOOL_REQUEST_SCHEMAS[\"${k}\"] has no .shape — schema must be a ZodObject (use merge() not and())`\n );\n }\n return [k, shape] as const;\n })\n ),\n creative_approval: schemas.CreativeApprovalRequestSchema.shape,\n search_brands: schemas.SearchBrandsRequestSchema.shape,\n verify_brand_claims: schemas.VerifyBrandClaimsRequestBulkSchema.shape,\n}) as Readonly<ToolInputShapes>;\n\n/\n Map of known AdCP tool names to their full generated Zod request schemas.\n \n Prefer {@link TOOL_INPUT_SHAPES} when registering a shape-compatible tool\n * with `registerTool()`. Use this map for union/intersection request schemas,\n * notably `verify_brand_claim`, where a raw shape would lose the correlation\n * between `claim_type` and the corresponding `claim` payload.\n /\nexport const TOOL_INPUT_SCHEMAS = Object.freeze({\n ...TOOL_REQUEST_SCHEMAS,\n creative_approval: schemas.CreativeApprovalRequestSchema,\n search_brands: schemas.SearchBrandsRequestSchema,\n verify_brand_claim: schemas.VerifyBrandClaimRequestSchema,\n verify_brand_claims: schemas.VerifyBrandClaimsRequestBulkSchema,\n}) as Readonly<ToolInputSchemas>;\n\n/\n Register a custom tool with MCP-compatible `inputSchema` + handler\n * wiring. Returns an object shaped for\n * `AdcpServerConfig.customTools[name]` — pass it straight through.\n \n Why it exists: sellers adding tools outside `AdcpToolMap` have to\n * publish an `inputSchema` via `tools/list` (MCP spec requirement). Doing\n * that by hand means authoring a Zod shape that matches the generated\n * AdCP spec schema — easy to drift silently. Using this helper guarantees\n * the advertised shape is the same shape the SDK validates the request\n * against.\n /\nexport function customToolFor<TShape extends InputShape>(\n name: string,\n description: string,\n inputSchema: TShape,\n handler: (args: z.input<z.ZodObject<TShape>>, extra?: unknown) => unknown \| Promise<unknown>\n): {\n description: string;\n inputSchema: TShape;\n handler: (args: z.input<z.ZodObject<TShape>>, extra?: unknown) => unknown \| Promise<unknown>;\n} {\n // `name` participates in the return contract's narrowing only indirectly\n // (via the caller's key when spread into `customTools`). Callers retain\n // it as a parameter so future stricter registration (logging, metrics,\n // schema-registry lookups) can be added without an API break.\n void name;\n return { description, inputSchema, handler };\n}\n\n/\n Register a custom tool whose MCP `inputSchema` is a full Zod schema rather\n * than a raw shape. Use this for request schemas with top-level unions or\n * intersections, where `.shape` would either be unavailable or would weaken\n * runtime validation.\n */\nexport function customToolForSchema<TSchema extends InputSchema>(\n name: string,\n description: string,\n inputSchema: TSchema,\n handler: (args: z.input<TSchema>, extra?: unknown) => unknown \| Promise<unknown>\n): {\n description: string;\n inputSchema: TSchema;\n handler: (args: z.input<TSchema>, extra?: unknown) => unknown \| Promise<unknown>;\n} {\n void name;\n return { description, inputSchema, handler };\n}\n"],"mappings":"AA0CA,SAAS,SAAS;AAClB,YAAY,aAAa;AACzB,SAAS,uCAAuC;AAEhD,SAAS,4BAA4B;AAErC;AAAA,EACE;AAAA,OAGK;AACP,SAAS,0BAA0B;AAEnC,cAAc;AAaP,MAAM,iCAAiC,QAAQ;AAGtD,MAAM,6BAA6B,gCAAgC;AAAA,EACjE,CAAC,UAA8C,UAAU;AAC3D;AAGO,MAAM,2BAA2B,QAAQ,yBAAyB,WAAW;AAAA,EAClF,QAAQ,EAAE,MAAM,EAAE,KAAK,0BAA0B,CAAC,EAAE,SAAS;AAC/D,CAAC;AAED,SAAS,2BAA2B;AACpC,SAAS,uCAAuC;AAChD,SAAS,wBAAAA,6BAA4B;AACrC,SAAS,6BAA6B;AACtC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAgBA,SAAS,mBACd,UACA,UAAmC,CAAC,GACH;AACjC,SAAO,sBAAsB,UAAU,WAAW,mBAAmB,QAAQ,WAAW,CAAC;AAC3F;AAGO,SAAS,sBACd,UACA,UAA2C,CAAC,GACX;AACjC,SAAO,sBAAsB,UAAU,QAAQ,WAAW,QAAQ,mBAAmB,QAAQ,WAAW,CAAC;AAC3G;AA0BA,SAAS,QAA0C,GAA0C;AAC3F,QAAM,YAAY,GAAG;AACrB,SAAO,aAAa,OAAO,cAAc,WAAW,YAAY;AAClE;AA6BO,MAAM,oBAAoB,OAAO,OAAO;AAAA,EAC7C,GAAG,OAAO;AAAA,IACR,OAAO,QAAQ,oBAAoB,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM;AACnD,YAAM,QAAQ,QAAQ,CAAC;AACvB,UAAI,CAAC,OAAO;AACV,cAAM,IAAI;AAAA,UACR,yBAAyB,CAAC;AAAA,QAC5B;AAAA,MACF;AACA,aAAO,CAAC,GAAG,KAAK;AAAA,IAClB,CAAC;AAAA,EACH;AAAA,EACA,mBAAmB,QAAQ,8BAA8B;AAAA,EACzD,eAAe,QAAQ,0BAA0B;AAAA,EACjD,qBAAqB,QAAQ,mCAAmC;AAClE,CAAC;AAUM,MAAM,qBAAqB,OAAO,OAAO;AAAA,EAC9C,GAAG;AAAA,EACH,mBAAmB,QAAQ;AAAA,EAC3B,eAAe,QAAQ;AAAA,EACvB,oBAAoB,QAAQ;AAAA,EAC5B,qBAAqB,QAAQ;AAC/B,CAAC;AAcM,SAAS,cACd,MACA,aACA,aACA,SAKA;AAKA,OAAK;AACL,SAAO,EAAE,aAAa,aAAa,QAAQ;AAC7C;AAQO,SAAS,oBACd,MACA,aACA,aACA,SAKA;AACA,OAAK;AACL,SAAO,EAAE,aAAa,aAAa,QAAQ;AAC7C;","names":["TOOL_REQUEST_SCHEMAS"]}